static-injector 6.0.3 → 6.1.0

package/index.js

@@ -24,9 +24,11 @@ __export(import_exports, {
   ChangeDetectionSchedulerImpl: () => ChangeDetectionSchedulerImpl,
   DecoratorFlags: () => DecoratorFlags,
   EnvironmentInjector: () => EnvironmentInjector,
+  ErrorHandler: () => ErrorHandler,
   INJECTOR_SCOPE: () => INJECTOR_SCOPE,
+  INTERNAL_APPLICATION_ERROR_HANDLER: () => INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject: () => Inject,
-  InjectFlags: () => InjectFlags,
+  Injectable: () => Injectable,
   InjectionToken: () => InjectionToken,
   Injector: () => Injector,
   InternalInjectFlags: () => InternalInjectFlags,
@@ -37,8 +39,10 @@ __export(import_exports, {
   NullInjector: () => NullInjector,
   Optional: () => Optional,
   PROVIDED_ZONELESS: () => PROVIDED_ZONELESS,
+  PendingTasks: () => PendingTasks,
+  PendingTasksInternal: () => PendingTasksInternal,
   R3Injector: () => R3Injector,
-  ResourceStatus: () => ResourceStatus,
+  RetrievingInjector: () => RetrievingInjector,
   RootStaticInjectOptions: () => RootStaticInjectOptions,
   SCHEDULE_IN_ROOT_ZONE: () => SCHEDULE_IN_ROOT_ZONE,
   SOURCE: () => SOURCE,
@@ -56,7 +60,7 @@ __export(import_exports, {
   convertToBitFlags: () => convertToBitFlags,
   createInjector: () => createInjector2,
   createRootInjector: () => createRootInjector,
-  effect: () => effect2,
+  effect: () => effect,
   formatError: () => formatError,
   getCurrentInjector: () => getCurrentInjector,
   getInheritedInjectableDef: () => getInheritedInjectableDef,
@@ -74,11 +78,9 @@ __export(import_exports, {
   resource: () => resource,
   setCurrentInjector: () => setCurrentInjector,
   signal: () => signal,
-  untracked: () => untracked,
+  untracked: () => untracked2,
   ɵEffectScheduler: () => EffectScheduler,
-  ɵMicrotaskEffectScheduler: () => MicrotaskEffectScheduler,
   ɵSIGNAL: () => SIGNAL,
-  ɵmicrotaskEffect: () => microtaskEffect,
   ɵunwrapWritableSignal: () => ɵunwrapWritableSignal,
   ɵɵdefineInjectable: () => ɵɵdefineInjectable,
   ɵɵdefineInjector: () => ɵɵdefineInjector,
@@ -100,8 +102,11 @@ var RuntimeError = class extends Error {
     this.code = code;
   }
 };
+function formatRuntimeErrorCode(code) {
+  return `NG0${Math.abs(code)}`;
+}
 function formatRuntimeError(code, message) {
-  const fullCode = `NG0${Math.abs(code)}`;
+  const fullCode = formatRuntimeErrorCode(code);
   const errorMessage = `${fullCode}${message ? ": " + message : ""}`;
   if (false) {
   }
@@ -113,6 +118,15 @@ function getFactoryDef(type, throwNotFound) {
   return () => new type();
 }
 
+// src/import/render3/errors_di.ts
+function throwCyclicDependencyError(token, path) {
+  throw new RuntimeError(-200 /* CYCLIC_DI_DEPENDENCY */, token);
+}
+function throwProviderNotFoundError(token, injectorName) {
+  const errorMessage = void 0;
+  throw new RuntimeError(-201 /* PROVIDER_NOT_FOUND */, errorMessage);
+}
+
 // src/import/util/property.ts
 function getClosureSafeProperty(objWithPropertyToExtract) {
   for (const key in objWithPropertyToExtract) {
@@ -120,16 +134,12 @@ function getClosureSafeProperty(objWithPropertyToExtract) {
       return key;
     }
   }
-  throw Error("Could not find renamed property on target object.");
+  throw Error("");
 }
 
 // src/import/render3/fields.ts
-var NG_FACTORY_DEF = getClosureSafeProperty({
-  ɵfac: getClosureSafeProperty
-});
-var NG_ENV_ID = getClosureSafeProperty({
-  __NG_ENV_ID__: getClosureSafeProperty
-});
+var NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
+var NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
 
 // src/import/util/empty.ts
 var EMPTY_ARRAY = [];
@@ -160,9 +170,7 @@ function stringify(token) {
 }
 
 // src/import/di/forward_ref.ts
-var __forward_ref__ = getClosureSafeProperty({
-  __forward_ref__: getClosureSafeProperty
-});
+var __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
 function forwardRef(forwardRefFn) {
   forwardRefFn.__forward_ref__ = forwardRef;
   forwardRefFn.toString = function() {
@@ -190,20 +198,16 @@ function ɵɵdefineInjector(options) {
   return { providers: options.providers || [], imports: options.imports || [] };
 }
 function getInjectableDef(type) {
-  return getOwnDefinition(type, NG_PROV_DEF) || {
-    token: type,
-    factory: () => new type(),
-    ...type.injectOptions
-  };
+  return getOwnDefinition(type, NG_PROV_DEF) || { token: type, factory: () => new type(), ...type.injectOptions };
 }
 function isInjectable(type) {
   return getInjectableDef(type) !== null;
 }
 function getOwnDefinition(type, field) {
-  return type.hasOwnProperty(field) ? type[field] : null;
+  return type.hasOwnProperty(field) && type[field] || null;
 }
 function getInheritedInjectableDef(type) {
-  const def = type && (type[NG_PROV_DEF] || null);
+  const def = type?.[NG_PROV_DEF] ?? null;
   if (def) {
     return def;
   } else {
@@ -211,14 +215,10 @@ function getInheritedInjectableDef(type) {
   }
 }
 function getInjectorDef(type) {
-  return type && (type.hasOwnProperty(NG_INJ_DEF) || false) ? type[NG_INJ_DEF] : null;
+  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
 }
-var NG_PROV_DEF = getClosureSafeProperty({
-  ɵprov: getClosureSafeProperty
-});
-var NG_INJ_DEF = getClosureSafeProperty({
-  ɵinj: getClosureSafeProperty
-});
+var NG_PROV_DEF = getClosureSafeProperty({ ɵprov: getClosureSafeProperty });
+var NG_INJ_DEF = getClosureSafeProperty({ ɵinj: getClosureSafeProperty });
 
 // src/import/di/injection_token.ts
 var InjectionToken = class {
@@ -257,29 +257,18 @@ var InjectionToken = class {
 // src/import/di/initializer_token.ts
 var ENVIRONMENT_INITIALIZER = new InjectionToken("");
 
-// src/import/render3/errors_di.ts
-function throwProviderNotFoundError(token, injectorName) {
-  const errorMessage = null;
-  throw new RuntimeError(-201 /* PROVIDER_NOT_FOUND */, errorMessage);
-}
-
 // src/import/di/interface/injector.ts
 var DecoratorFlags = /* @__PURE__ */ ((DecoratorFlags2) => {
   DecoratorFlags2[DecoratorFlags2["Inject"] = -1] = "Inject";
   return DecoratorFlags2;
 })(DecoratorFlags || {});
-var InjectFlags = /* @__PURE__ */ ((InjectFlags2) => {
-  InjectFlags2[InjectFlags2["Default"] = 0] = "Default";
-  InjectFlags2[InjectFlags2["Self"] = 2] = "Self";
-  InjectFlags2[InjectFlags2["SkipSelf"] = 4] = "SkipSelf";
-  InjectFlags2[InjectFlags2["Optional"] = 8] = "Optional";
-  return InjectFlags2;
-})(InjectFlags || {});
 var InternalInjectFlags = /* @__PURE__ */ ((InternalInjectFlags2) => {
   InternalInjectFlags2[InternalInjectFlags2["Default"] = 0] = "Default";
+  InternalInjectFlags2[InternalInjectFlags2["Host"] = 1] = "Host";
   InternalInjectFlags2[InternalInjectFlags2["Self"] = 2] = "Self";
   InternalInjectFlags2[InternalInjectFlags2["SkipSelf"] = 4] = "SkipSelf";
   InternalInjectFlags2[InternalInjectFlags2["Optional"] = 8] = "Optional";
+  InternalInjectFlags2[InternalInjectFlags2["ForPipe"] = 16] = "ForPipe";
   return InternalInjectFlags2;
 })(InternalInjectFlags || {});
 
@@ -303,15 +292,7 @@ function injectRootLimpMode(token, notFoundValue, flags) {
   throwProviderNotFoundError(token, "Injector");
 }
 
-// src/import/di/injector_compatibility.ts
-var _THROW_IF_NOT_FOUND = {};
-var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
-var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
-var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-var NG_TOKEN_PATH = "ngTokenPath";
-var NEW_LINE = /\n/gm;
-var NO_NEW_LINE = "ɵ";
-var SOURCE = "__source";
+// src/primitives/di/src/injector.ts
 var _currentInjector = void 0;
 function getCurrentInjector() {
   return _currentInjector;
@@ -321,31 +302,75 @@ function setCurrentInjector(injector) {
   _currentInjector = injector;
   return former;
 }
+
+// src/primitives/di/src/not_found.ts
+var NOT_FOUND = Symbol("NotFound");
+var NotFoundError = class extends Error {
+  name = "ɵNotFound";
+  constructor(message) {
+    super(message);
+  }
+};
+function isNotFound(e) {
+  return e === NOT_FOUND || e?.name === "ɵNotFound";
+}
+
+// src/import/di/injector_compatibility.ts
+var _THROW_IF_NOT_FOUND = {};
+var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
+var RetrievingInjector = class {
+  constructor(injector) {
+    this.injector = injector;
+  }
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0 /* Default */;
+    try {
+      return this.injector.get(
+        token,
+        // When a dependency is requested with an optional flag, DI returns null as the default value.
+        flags & 8 /* Optional */ ? null : THROW_IF_NOT_FOUND,
+        flags
+      );
+    } catch (e) {
+      if (isNotFound(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+};
+var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
+var NG_TOKEN_PATH = "ngTokenPath";
+var NEW_LINE = /\n/gm;
+var NO_NEW_LINE = "ɵ";
+var SOURCE = "__source";
 function injectInjectorOnly(token, flags = 0 /* Default */) {
-  if (_currentInjector === void 0) {
-    throw new RuntimeError(-203 /* MISSING_INJECTION_CONTEXT */, null);
-  } else if (_currentInjector === null) {
+  const currentInjector = getCurrentInjector();
+  if (currentInjector === void 0) {
+    throw new RuntimeError(-203 /* MISSING_INJECTION_CONTEXT */, void 0);
+  } else if (currentInjector === null) {
     return injectRootLimpMode(token, void 0, flags);
   } else {
-    const value = _currentInjector.get(
-      token,
-      flags & 8 /* Optional */ ? null : void 0,
-      flags
-    );
+    const options = convertToInjectOptions(flags);
+    const value = currentInjector.retrieve(token, options);
+    if (isNotFound(value)) {
+      if (options.optional) {
+        return null;
+      }
+      throw value;
+    }
     return value;
   }
 }
 function ɵɵinject(token, flags = 0 /* Default */) {
-  return (getInjectImplementation() || injectInjectorOnly)(
-    resolveForwardRef(token),
-    flags
-  );
+  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
 }
 function ɵɵinvalidFactoryDep(index) {
-  throw new RuntimeError(202 /* INVALID_FACTORY_DEPENDENCY */, null);
+  throw new RuntimeError(202 /* INVALID_FACTORY_DEPENDENCY */, void 0);
 }
-function inject(token, flags = 0 /* Default */) {
-  return ɵɵinject(token, convertToBitFlags(flags));
+function inject(token, options) {
+  return ɵɵinject(token, convertToBitFlags(options));
 }
 function convertToBitFlags(flags) {
   if (typeof flags === "undefined" || typeof flags === "number") {
@@ -354,13 +379,21 @@ function convertToBitFlags(flags) {
   return 0 /* Default */ | // comment to force a line break in the formatter
   (flags.optional && 8 /* Optional */) | 0 | (flags.self && 2 /* Self */) | (flags.skipSelf && 4 /* SkipSelf */);
 }
+function convertToInjectOptions(flags) {
+  return {
+    optional: !!(flags & 8 /* Optional */),
+    host: !!(flags & 1 /* Host */),
+    self: !!(flags & 2 /* Self */),
+    skipSelf: !!(flags & 4 /* SkipSelf */)
+  };
+}
 function injectArgs(types) {
   const args = [];
   for (let i = 0; i < types.length; i++) {
     const arg = resolveForwardRef(types[i]);
     if (Array.isArray(arg)) {
       if (arg.length === 0) {
-        throw new RuntimeError(900 /* INVALID_DIFFER_INPUT */, null);
+        throw new RuntimeError(900 /* INVALID_DIFFER_INPUT */, void 0);
       }
       let type = void 0;
       let flags = 0 /* Default */;
@@ -397,12 +430,7 @@ function catchInjectorError(e, token, injectorErrorName, source) {
   if (token[SOURCE]) {
     tokenPath.unshift(token[SOURCE]);
   }
-  e.message = formatError(
-    "\n" + e.message,
-    tokenPath,
-    injectorErrorName,
-    source
-  );
+  e.message = formatError("\n" + e.message, tokenPath, injectorErrorName, source);
   e[NG_TOKEN_PATH] = tokenPath;
   e[NG_TEMP_TOKEN_PATH] = null;
   throw e;
@@ -417,17 +445,12 @@ function formatError(text, obj, injectorErrorName, source = null) {
     for (const key in obj) {
       if (obj.hasOwnProperty(key)) {
         const value = obj[key];
-        parts.push(
-          key + ":" + (typeof value === "string" ? JSON.stringify(value) : stringify(value))
-        );
+        parts.push(key + ":" + (typeof value === "string" ? JSON.stringify(value) : stringify(value)));
       }
     }
     context = `{${parts.join(", ")}}`;
   }
-  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(
-    NEW_LINE,
-    "\n  "
-  )}`;
+  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
 }
 
 // src/import/di/injector_token.ts
@@ -446,10 +469,7 @@ var INJECTOR_DEF_TYPES = new InjectionToken("");
 var NullInjector = class {
   get(token, notFoundValue = THROW_IF_NOT_FOUND) {
     if (notFoundValue === THROW_IF_NOT_FOUND) {
-      const error = new Error(
-        `NullInjectorError: No provider for ${stringify(token)}!`
-      );
-      error.name = "NullInjectorError";
+      const error = new NotFoundError(`NullInjectorError: No provider for ${stringify(token)}!`);
       throw error;
     }
     return notFoundValue;
@@ -457,32 +477,6 @@ var NullInjector = class {
 };
 
 // src/import/di/provider_collection.ts
-function importProvidersFrom(...sources) {
-  return {
-    ɵproviders: internalImportProvidersFrom(true, sources),
-    ɵfromNgModule: true
-  };
-}
-function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
-  const providersOut = [];
-  const dedup = /* @__PURE__ */ new Set();
-  let injectorTypesWithProviders;
-  const collectProviders = (provider) => {
-    providersOut.push(provider);
-  };
-  if (injectorTypesWithProviders !== void 0) {
-    processInjectorTypesWithProviders(
-      injectorTypesWithProviders,
-      collectProviders
-    );
-  }
-  return providersOut;
-}
-function processInjectorTypesWithProviders(typesWithProviders, visitor) {
-  for (let i = 0; i < typesWithProviders.length; i++) {
-    const { ngModule, providers } = typesWithProviders[i];
-  }
-}
 var USE_VALUE = getClosureSafeProperty({
   provide: String,
   useValue: getClosureSafeProperty
@@ -521,23 +515,16 @@ var R3Injector = class extends EnvironmentInjector {
     this.parent = parent;
     this.source = source;
     this.scopes = scopes;
-    forEachSingleProvider(
-      providers,
-      (provider) => this.processProvider(provider)
-    );
+    forEachSingleProvider(providers, (provider) => this.processProvider(provider));
     this.records.set(INJECTOR, makeRecord(void 0, this));
     if (scopes.has("environment")) {
       this.records.set(EnvironmentInjector, makeRecord(void 0, this));
     }
-    const record = this.records.get(
-      INJECTOR_SCOPE
-    );
+    const record = this.records.get(INJECTOR_SCOPE);
     if (record != null && typeof record.value === "string") {
       this.scopes.add(record.value);
     }
-    this.injectorDefTypes = new Set(
-      this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, 2 /* Self */)
-    );
+    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));
   }
   /**
    * Map of tokens to records which contain the instances of those tokens.
@@ -558,6 +545,22 @@ var R3Injector = class extends EnvironmentInjector {
   }
   _destroyed = false;
   injectorDefTypes;
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0 /* Default */;
+    try {
+      return this.get(
+        token,
+        // When a dependency is requested with an optional flag, DI returns null as the default value.
+        THROW_IF_NOT_FOUND,
+        flags
+      );
+    } catch (e) {
+      if (isNotFound(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
   /**
    * Destroy the injector and release references to every instance or provider associated with it.
    *
@@ -600,12 +603,12 @@ var R3Injector = class extends EnvironmentInjector {
       setInjectImplementation(previousInjectImplementation);
     }
   }
-  get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = 0 /* Default */) {
+  get(token, notFoundValue = THROW_IF_NOT_FOUND, options) {
     assertNotDestroyed(this);
     if (token.hasOwnProperty(NG_ENV_ID)) {
       return token[NG_ENV_ID](this);
     }
-    flags = convertToBitFlags(flags);
+    const flags = convertToBitFlags(options);
     if (false) {
     }
     const previousInjector = setCurrentInjector(this);
@@ -618,10 +621,7 @@ var R3Injector = class extends EnvironmentInjector {
           if (def && this.injectableDefInScope(def)) {
             if (false) {
             }
-            record = makeRecord(
-              injectableDefOrInjectorDefFactory(token),
-              NOT_YET
-            );
+            record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
           } else {
             record = null;
           }
@@ -635,7 +635,7 @@ var R3Injector = class extends EnvironmentInjector {
       notFoundValue = flags & 8 /* Optional */ && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
       return nextInjector.get(token, notFoundValue);
     } catch (e) {
-      if (e.name === "NullInjectorError") {
+      if (isNotFound(e)) {
         const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
         path.unshift(stringify(token));
         if (previousInjector) {
@@ -658,11 +658,7 @@ var R3Injector = class extends EnvironmentInjector {
     if (false) {
     }
     try {
-      const initializers = this.get(
-        ENVIRONMENT_INITIALIZER,
-        EMPTY_ARRAY,
-        2 /* Self */
-      );
+      const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, { self: true });
       if (false) {
       }
       for (const initializer of initializers) {
@@ -710,7 +706,8 @@ var R3Injector = class extends EnvironmentInjector {
   }
   hydrate(token, record) {
     try {
-      if (false) {
+      if (record.value === CIRCULAR) {
+        throwCyclicDependencyError(stringify(token));
       } else if (record.value === NOT_YET) {
         record.value = CIRCULAR;
         if (false) {
@@ -750,17 +747,17 @@ function injectableDefOrInjectorDefFactory(token) {
     return factory;
   }
   if (token instanceof InjectionToken) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, null);
+    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
   }
   if (token instanceof Function) {
     return getUndecoratedInjectableFactory(token);
   }
-  throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, null);
+  throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
 }
 function getUndecoratedInjectableFactory(token) {
   const paramLength = token.length;
   if (paramLength > 0) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, null);
+    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
   }
   const inheritedInjectableDef = getInheritedInjectableDef(token);
   if (inheritedInjectableDef !== null) {
@@ -792,9 +789,7 @@ function providerToFactory(provider, ngModuleType, providers) {
     } else if (isExistingProvider(provider)) {
       factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));
     } else {
-      const classRef = resolveForwardRef(
-        provider && (provider.useClass || provider.provide)
-      );
+      const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
       if (false) {
       }
       if (hasDeps(provider)) {
@@ -808,7 +803,7 @@ function providerToFactory(provider, ngModuleType, providers) {
 }
 function assertNotDestroyed(injector) {
   if (injector.destroyed) {
-    throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, null);
+    throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, void 0);
   }
 }
 function makeRecord(factory, value, multi = false) {
@@ -825,7 +820,7 @@ function hasOnDestroy(value) {
   return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
 }
 function couldBeInjectableType(value) {
-  return typeof value === "function" || typeof value === "object" && value instanceof InjectionToken;
+  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
 }
 function forEachSingleProvider(providers, fn) {
   for (const provider of providers) {
@@ -878,10 +873,7 @@ var Inject = attachInjectFlag(
 var Optional = (
   // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
   // tslint:disable-next-line: no-toplevel-property-access
-  attachInjectFlag(
-    makeParamDecorator("Optional"),
-    8 /* Optional */
-  )
+  attachInjectFlag(makeParamDecorator("Optional"), 8 /* Optional */)
 );
 var Self = (
   // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
@@ -891,35 +883,19 @@ var Self = (
 var SkipSelf = (
   // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
   // tslint:disable-next-line: no-toplevel-property-access
-  attachInjectFlag(
-    makeParamDecorator("SkipSelf"),
-    4 /* SkipSelf */
-  )
+  attachInjectFlag(makeParamDecorator("SkipSelf"), 4 /* SkipSelf */)
 );
 
 // src/import/di/create_injector.ts
 function createInjector(defType, parent = null, additionalProviders = null, name) {
-  const injector = createInjectorWithoutInjectorInstances(
-    defType,
-    parent,
-    additionalProviders,
-    name
-  );
+  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
   injector.resolveInjectorInitializers();
   return injector;
 }
 function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
-  const providers = [
-    additionalProviders || EMPTY_ARRAY,
-    importProvidersFrom(defType)
-  ];
+  const providers = [additionalProviders || EMPTY_ARRAY];
   name = name || (typeof defType === "object" ? void 0 : stringify(defType));
-  return new R3Injector(
-    providers,
-    parent || getNullInjector(),
-    name || null,
-    scopes
-  );
+  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }
 
 // src/import/di/injector.ts
@@ -965,6 +941,7 @@ function defaultEquals(a, b) {
 var activeConsumer = null;
 var inNotificationPhase = false;
 var epoch = 1;
+var postProducerCreatedFn = null;
 var SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
 function setActiveConsumer(consumer) {
   const prev = activeConsumer;
@@ -974,9 +951,6 @@ function setActiveConsumer(consumer) {
 function getActiveConsumer() {
   return activeConsumer;
 }
-function isInNotificationPhase() {
-  return inNotificationPhase;
-}
 var REACTIVE_NODE = {
   version: 0,
   lastCleanEpoch: 0,
@@ -1000,9 +974,7 @@ var REACTIVE_NODE = {
 };
 function producerAccessed(node) {
   if (inNotificationPhase) {
-    throw new Error(
-      false ? `Assertion error: signal read during notification phase` : ""
-    );
+    throw new Error(false ? `Assertion error: signal read during notification phase` : "");
   }
   if (activeConsumer === null) {
     return;
@@ -1013,10 +985,7 @@ function producerAccessed(node) {
   if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
     if (consumerIsLive(activeConsumer)) {
       const staleProducer = activeConsumer.producerNode[idx];
-      producerRemoveLiveConsumerAtIndex(
-        staleProducer,
-        activeConsumer.producerIndexOfThis[idx]
-      );
+      producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
     }
   }
   if (activeConsumer.producerNode[idx] !== node) {
@@ -1081,10 +1050,7 @@ function consumerAfterComputation(node, prevConsumer) {
   }
   if (consumerIsLive(node)) {
     for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(
-        node.producerNode[i],
-        node.producerIndexOfThis[i]
-      );
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
     }
   }
   while (node.producerNode.length > node.nextProducerIndex) {
@@ -1112,10 +1078,7 @@ function consumerDestroy(node) {
   assertConsumerNode(node);
   if (consumerIsLive(node)) {
     for (let i = 0; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(
-        node.producerNode[i],
-        node.producerIndexOfThis[i]
-      );
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
     }
   }
   node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length = 0;
@@ -1127,11 +1090,7 @@ function producerAddLiveConsumer(node, consumer, indexOfThis) {
   assertProducerNode(node);
   if (node.liveConsumerNode.length === 0 && isConsumerNode(node)) {
     for (let i = 0; i < node.producerNode.length; i++) {
-      node.producerIndexOfThis[i] = producerAddLiveConsumer(
-        node.producerNode[i],
-        node,
-        i
-      );
+      node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
     }
   }
   node.liveConsumerIndexOfThis.push(indexOfThis);
@@ -1140,16 +1099,11 @@ function producerAddLiveConsumer(node, consumer, indexOfThis) {
 function producerRemoveLiveConsumerAtIndex(node, idx) {
   assertProducerNode(node);
   if (false) {
-    throw new Error(
-      `Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`
-    );
+    throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
   }
   if (node.liveConsumerNode.length === 1 && isConsumerNode(node)) {
     for (let i = 0; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(
-        node.producerNode[i],
-        node.producerIndexOfThis[i]
-      );
+      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
     }
   }
   const lastIdx = node.liveConsumerNode.length - 1;
@@ -1179,11 +1133,17 @@ function assertProducerNode(node) {
 function isConsumerNode(node) {
   return node.producerNode !== void 0;
 }
+function runPostProducerCreatedFn(node) {
+  postProducerCreatedFn?.(node);
+}
 
 // src/primitives/signals/src/computed.ts
-function createComputed(computation) {
+function createComputed(computation, equal) {
   const node = Object.create(COMPUTED_NODE);
   node.computation = computation;
+  if (equal !== void 0) {
+    node.equal = equal;
+  }
   const computed2 = () => {
     producerUpdateValueVersion(node);
     producerAccessed(node);
@@ -1193,6 +1153,11 @@ function createComputed(computation) {
     return node.value;
   };
   computed2[SIGNAL] = node;
+  if (false) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    computed2.toString = () => `[Computed${debugName}: ${node.value}]`;
+  }
+  runPostProducerCreatedFn(node);
   return computed2;
 }
 var UNSET = /* @__PURE__ */ Symbol("UNSET");
@@ -1210,7 +1175,7 @@ var COMPUTED_NODE = /* @__PURE__ */ (() => ({
   },
   producerRecomputeValue(node) {
     if (node.value === COMPUTING) {
-      throw new Error("Detected cycle in computations.");
+      throw new Error(false ? "Detected cycle in computations." : "");
     }
     const oldValue = node.value;
     node.value = COMPUTING;
@@ -1247,15 +1212,26 @@ function throwInvalidWriteToSignalError(node) {
 
 // src/primitives/signals/src/signal.ts
 var postSignalSetFn = null;
-function createSignal(initialValue) {
+function createSignal(initialValue, equal) {
   const node = Object.create(SIGNAL_NODE);
   node.value = initialValue;
-  const getter = () => {
-    producerAccessed(node);
-    return node.value;
-  };
+  if (equal !== void 0) {
+    node.equal = equal;
+  }
+  const getter = () => signalGetFn(node);
   getter[SIGNAL] = node;
-  return getter;
+  if (false) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
+  }
+  runPostProducerCreatedFn(node);
+  const set = (newValue) => signalSetFn(node, newValue);
+  const update = (updateFn) => signalUpdateFn(node, updateFn);
+  return [getter, set, update];
+}
+function signalGetFn(node) {
+  producerAccessed(node);
+  return node.value;
 }
 function signalSetFn(node, newValue) {
   if (!producerUpdatesAllowed()) {
@@ -1282,7 +1258,7 @@ function signalValueChanged(node) {
   node.version++;
   producerIncrementEpoch();
   producerNotifyConsumers(node);
-  postSignalSetFn?.();
+  postSignalSetFn?.(node);
 }
 
 // src/primitives/signals/src/linked_signal.ts
@@ -1303,6 +1279,11 @@ function createLinkedSignal(sourceFn, computationFn, equalityFn) {
   };
   const getter = linkedSignalGetter;
   getter[SIGNAL] = node;
+  if (false) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;
+  }
+  runPostProducerCreatedFn(node);
   return getter;
 }
 function linkedSignalSetFn(node, newValue) {
@@ -1321,12 +1302,13 @@ var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => ({
   dirty: true,
   error: null,
   equal: defaultEquals,
+  kind: "linkedSignal",
   producerMustRecompute(node) {
     return node.value === UNSET || node.value === COMPUTING;
   },
   producerRecomputeValue(node) {
     if (node.value === COMPUTING) {
-      throw new Error("Detected cycle in computations.");
+      throw new Error(false ? "Detected cycle in computations." : "");
     }
     const oldValue = node.value;
     node.value = COMPUTING;
@@ -1355,75 +1337,15 @@ var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => ({
   }
 }))();
 
-// src/primitives/signals/src/watch.ts
-function createWatch(fn, schedule, allowSignalWrites) {
-  const node = Object.create(WATCH_NODE);
-  if (allowSignalWrites) {
-    node.consumerAllowSignalWrites = true;
-  }
-  node.fn = fn;
-  node.schedule = schedule;
-  const registerOnCleanup = (cleanupFn) => {
-    node.cleanupFn = cleanupFn;
-  };
-  function isWatchNodeDestroyed(node2) {
-    return node2.fn === null && node2.schedule === null;
-  }
-  function destroyWatchNode(node2) {
-    if (!isWatchNodeDestroyed(node2)) {
-      consumerDestroy(node2);
-      node2.cleanupFn();
-      node2.fn = null;
-      node2.schedule = null;
-      node2.cleanupFn = NOOP_CLEANUP_FN;
-    }
+// src/primitives/signals/src/untracked.ts
+function untracked(nonReactiveReadsFn) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    return nonReactiveReadsFn();
+  } finally {
+    setActiveConsumer(prevConsumer);
   }
-  const run = () => {
-    if (node.fn === null) {
-      return;
-    }
-    if (isInNotificationPhase()) {
-      throw new Error(
-        `Schedulers cannot synchronously execute watches while scheduling.`
-      );
-    }
-    node.dirty = false;
-    if (node.hasRun && !consumerPollProducersForChange(node)) {
-      return;
-    }
-    node.hasRun = true;
-    const prevConsumer = consumerBeforeComputation(node);
-    try {
-      node.cleanupFn();
-      node.cleanupFn = NOOP_CLEANUP_FN;
-      node.fn(registerOnCleanup);
-    } finally {
-      consumerAfterComputation(node, prevConsumer);
-    }
-  };
-  node.ref = {
-    notify: () => consumerMarkDirty(node),
-    run,
-    cleanup: () => node.cleanupFn(),
-    destroy: () => destroyWatchNode(node),
-    [SIGNAL]: node
-  };
-  return node.ref;
 }
-var NOOP_CLEANUP_FN = () => {
-};
-var WATCH_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  consumerIsAlwaysLive: true,
-  consumerAllowSignalWrites: false,
-  consumerMarkedDirty: (node) => {
-    if (node.schedule !== null) {
-      node.schedule(node.ref);
-    }
-  },
-  hasRun: false,
-  cleanupFn: NOOP_CLEANUP_FN
-}))();
 
 // src/import/render3/reactivity/api.ts
 function isSignal(value) {
@@ -1432,10 +1354,7 @@ function isSignal(value) {
 
 // src/import/render3/reactivity/computed.ts
 function computed(computation, options) {
-  const getter = createComputed(computation);
-  if (options?.equal) {
-    getter[SIGNAL].equal = options.equal;
-  }
+  const getter = createComputed(computation, options?.equal);
   if (false) {
   }
   return getter;
@@ -1446,16 +1365,12 @@ function ɵunwrapWritableSignal(value) {
   return null;
 }
 function signal(initialValue, options) {
-  const signalFn = createSignal(initialValue);
+  const [get, set, update] = createSignal(initialValue, options?.equal);
+  const signalFn = get;
   const node = signalFn[SIGNAL];
-  if (options?.equal) {
-    node.equal = options.equal;
-  }
-  signalFn.set = (newValue) => signalSetFn(node, newValue);
-  signalFn.update = (updateFn) => signalUpdateFn(node, updateFn);
-  signalFn.asReadonly = signalAsReadonlyFn.bind(
-    signalFn
-  );
+  signalFn.set = set;
+  signalFn.update = update;
+  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
   if (false) {
   }
   return signalFn;
@@ -1474,18 +1389,10 @@ function signalAsReadonlyFn() {
 var identityFn = (v) => v;
 function linkedSignal(optionsOrComputation, options) {
   if (typeof optionsOrComputation === "function") {
-    const getter = createLinkedSignal(
-      optionsOrComputation,
-      identityFn,
-      options?.equal
-    );
+    const getter = createLinkedSignal(optionsOrComputation, identityFn, options?.equal);
     return upgradeLinkedSignalGetter(getter);
   } else {
-    const getter = createLinkedSignal(
-      optionsOrComputation.source,
-      optionsOrComputation.computation,
-      optionsOrComputation.equal
-    );
+    const getter = createLinkedSignal(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);
     return upgradeLinkedSignalGetter(getter);
   }
 }
@@ -1496,39 +1403,19 @@ function upgradeLinkedSignalGetter(getter) {
   const upgradedGetter = getter;
   upgradedGetter.set = (newValue) => linkedSignalSetFn(node, newValue);
   upgradedGetter.update = (updateFn) => linkedSignalUpdateFn(node, updateFn);
-  upgradedGetter.asReadonly = signalAsReadonlyFn.bind(
-    getter
-  );
+  upgradedGetter.asReadonly = signalAsReadonlyFn.bind(getter);
   return upgradedGetter;
 }
 
 // src/import/render3/reactivity/untracked.ts
-function untracked(nonReactiveReadsFn) {
-  const prevConsumer = setActiveConsumer(null);
-  try {
-    return nonReactiveReadsFn();
-  } finally {
-    setActiveConsumer(prevConsumer);
-  }
+function untracked2(nonReactiveReadsFn) {
+  return untracked(nonReactiveReadsFn);
 }
 
 // src/import/render3/reactivity/asserts.ts
 function assertNotInReactiveContext(debugFn, extraContext) {
   if (getActiveConsumer() !== null) {
-    throw new RuntimeError(
-      -602 /* ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT */,
-      null
-    );
-  }
-}
-
-// src/import/di/contextual.ts
-function isInInjectionContext() {
-  return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
-}
-function assertInInjectionContext(debugFn) {
-  if (!isInInjectionContext()) {
-    throw new RuntimeError(-203 /* MISSING_INJECTION_CONTEXT */, null);
+    throw new RuntimeError(-602 /* ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT */, void 0);
   }
 }
 
@@ -1569,20 +1456,10 @@ var NotificationSource = /* @__PURE__ */ ((NotificationSource2) => {
 })(NotificationSource || {});
 var ChangeDetectionScheduler = class {
 };
-var ZONELESS_ENABLED = new InjectionToken(
-  false ? "Zoneless enabled" : "",
-  { providedIn: "root", factory: () => false }
-);
-var PROVIDED_ZONELESS = new InjectionToken(
-  false ? "Zoneless provided" : "",
-  { providedIn: "root", factory: () => false }
-);
-var ZONELESS_SCHEDULER_DISABLED = new InjectionToken(
-  false ? "scheduler disabled" : ""
-);
-var SCHEDULE_IN_ROOT_ZONE = new InjectionToken(
-  false ? "run changes outside zone in root" : ""
-);
+var ZONELESS_ENABLED = new InjectionToken("", { providedIn: "root", factory: () => false });
+var PROVIDED_ZONELESS = new InjectionToken("", { providedIn: "root", factory: () => false });
+var ZONELESS_SCHEDULER_DISABLED = new InjectionToken("");
+var SCHEDULE_IN_ROOT_ZONE = new InjectionToken("");
 
 // src/import/render3/reactivity/root_effect_scheduler.ts
 var EffectScheduler = class _EffectScheduler {
@@ -1597,10 +1474,17 @@ var EffectScheduler = class _EffectScheduler {
   );
 };
 var ZoneAwareEffectScheduler = class {
-  queuedEffectCount = 0;
+  dirtyEffectCount = 0;
   queues = /* @__PURE__ */ new Map();
-  schedule(handle) {
+  add(handle) {
     this.enqueue(handle);
+    this.schedule(handle);
+  }
+  schedule(handle) {
+    if (!handle.dirty) {
+      return;
+    }
+    this.dirtyEffectCount++;
   }
   remove(handle) {
     const zone = handle.zone;
@@ -1609,7 +1493,9 @@ var ZoneAwareEffectScheduler = class {
       return;
     }
     queue.delete(handle);
-    this.queuedEffectCount--;
+    if (handle.dirty) {
+      this.dirtyEffectCount--;
+    }
   }
   enqueue(handle) {
     const zone = handle.zone;
@@ -1620,7 +1506,6 @@ var ZoneAwareEffectScheduler = class {
     if (queue.has(handle)) {
       return;
     }
-    this.queuedEffectCount++;
     queue.add(handle);
   }
   /**
@@ -1630,224 +1515,35 @@ var ZoneAwareEffectScheduler = class {
    * ordering guarantee between effects scheduled in different zones.
    */
   flush() {
-    while (this.queuedEffectCount > 0) {
+    while (this.dirtyEffectCount > 0) {
+      let ranOneEffect = false;
       for (const [zone, queue] of this.queues) {
         if (zone === null) {
-          this.flushQueue(queue);
+          ranOneEffect ||= this.flushQueue(queue);
         } else {
-          zone.run(() => this.flushQueue(queue));
+          ranOneEffect ||= zone.run(() => this.flushQueue(queue));
         }
       }
+      if (!ranOneEffect) {
+        this.dirtyEffectCount = 0;
+      }
     }
   }
   flushQueue(queue) {
+    let ranOneEffect = false;
     for (const handle of queue) {
-      queue.delete(handle);
-      this.queuedEffectCount--;
-      handle.run();
-    }
-  }
-};
-
-// src/import/render3/reactivity/patch.ts
-var USE_MICROTASK_EFFECT_BY_DEFAULT = false;
-
-// src/import/error_handler.ts
-var ErrorHandler = class {
-  /**
-   * @internal
-   */
-  _console = console;
-  handleError(error) {
-    this._console.error("ERROR", error);
-  }
-};
-
-// src/import/pending_tasks.ts
-var import_rxjs = require("rxjs");
-var PendingTasksInternal = class _PendingTasksInternal {
-  taskId = 0;
-  pendingTasks = /* @__PURE__ */ new Set();
-  get _hasPendingTasks() {
-    return this.hasPendingTasks.value;
-  }
-  hasPendingTasks = new import_rxjs.BehaviorSubject(false);
-  add() {
-    if (!this._hasPendingTasks) {
-      this.hasPendingTasks.next(true);
-    }
-    const taskId = this.taskId++;
-    this.pendingTasks.add(taskId);
-    return taskId;
-  }
-  has(taskId) {
-    return this.pendingTasks.has(taskId);
-  }
-  remove(taskId) {
-    this.pendingTasks.delete(taskId);
-    if (this.pendingTasks.size === 0 && this._hasPendingTasks) {
-      this.hasPendingTasks.next(false);
-    }
-  }
-  ngOnDestroy() {
-    this.pendingTasks.clear();
-    if (this._hasPendingTasks) {
-      this.hasPendingTasks.next(false);
-    }
-  }
-  /** @nocollapse */
-  static ɵprov = (
-    /** @pureOrBreakMyCode */
-    /* @__PURE__ */ ɵɵdefineInjectable({
-      token: _PendingTasksInternal,
-      providedIn: "root",
-      factory: () => new _PendingTasksInternal()
-    })
-  );
-};
-var PendingTasks = class _PendingTasks {
-  internalPendingTasks = inject(PendingTasksInternal);
-  scheduler = inject(ChangeDetectionScheduler);
-  /**
-   * Adds a new task that should block application's stability.
-   * @returns A cleanup function that removes a task when called.
-   */
-  add() {
-    const taskId = this.internalPendingTasks.add();
-    return () => {
-      if (!this.internalPendingTasks.has(taskId)) {
-        return;
-      }
-      this.scheduler.notify(11 /* PendingTaskRemoved */);
-      this.internalPendingTasks.remove(taskId);
-    };
-  }
-  /**
-   * Runs an asynchronous function and blocks the application's stability until the function completes.
-   *
-   * ```ts
-   * pendingTasks.run(async () => {
-   *   const userData = await fetch('/api/user');
-   *   this.userData.set(userData);
-   * });
-   * ```
-   *
-   * Application stability is at least delayed until the next tick after the `run` method resolves
-   * so it is safe to make additional updates to application state that would require UI synchronization:
-   *
-   * ```ts
-   * const userData = await pendingTasks.run(() => fetch('/api/user'));
-   * this.userData.set(userData);
-   * ```
-   *
-   * @param fn The asynchronous function to execute
-   */
-  async run(fn) {
-    const removeTask = this.add();
-    try {
-      return await fn();
-    } finally {
-      removeTask();
-    }
-  }
-  /** @nocollapse */
-  static ɵprov = (
-    /** @pureOrBreakMyCode */
-    /* @__PURE__ */ ɵɵdefineInjectable({
-      token: _PendingTasks,
-      providedIn: "root",
-      factory: () => new _PendingTasks()
-    })
-  );
-};
-
-// src/import/render3/reactivity/microtask_effect.ts
-var MicrotaskEffectScheduler = class _MicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
-  pendingTasks = inject(PendingTasksInternal);
-  taskId = null;
-  schedule(effect3) {
-    super.schedule(effect3);
-    if (this.taskId === null) {
-      this.taskId = this.pendingTasks.add();
-      queueMicrotask(() => this.flush());
-    }
-  }
-  flush() {
-    try {
-      super.flush();
-    } finally {
-      if (this.taskId !== null) {
-        this.pendingTasks.remove(this.taskId);
-        this.taskId = null;
+      if (!handle.dirty) {
+        continue;
       }
+      this.dirtyEffectCount--;
+      ranOneEffect = true;
+      handle.run();
     }
+    return ranOneEffect;
   }
-  /** @nocollapse */
-  static ɵprov = (
-    /** @pureOrBreakMyCode */
-    /* @__PURE__ */ ɵɵdefineInjectable({
-      token: _MicrotaskEffectScheduler,
-      providedIn: "root",
-      factory: () => new _MicrotaskEffectScheduler()
-    })
-  );
 };
-var EffectHandle = class {
-  constructor(scheduler, effectFn, zone, destroyRef, injector, allowSignalWrites) {
-    this.scheduler = scheduler;
-    this.effectFn = effectFn;
-    this.zone = zone;
-    this.injector = injector;
-    this.watcher = createWatch(
-      (onCleanup) => this.runEffect(onCleanup),
-      () => this.schedule(),
-      allowSignalWrites
-    );
-    this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
-  }
-  unregisterOnDestroy;
-  watcher;
-  runEffect(onCleanup) {
-    try {
-      this.effectFn(onCleanup);
-    } catch (err) {
-      const errorHandler = this.injector.get(ErrorHandler, null, {
-        optional: true
-      });
-      errorHandler?.handleError(err);
-    }
-  }
-  run() {
-    this.watcher.run();
-  }
-  schedule() {
-    this.scheduler.schedule(this);
-  }
-  destroy() {
-    this.watcher.destroy();
-    this.unregisterOnDestroy?.();
-  }
-};
-function effect() {
-}
-function microtaskEffect(effectFn, options) {
-  !options?.injector && assertInInjectionContext(effect);
-  const injector = options?.injector ?? inject(Injector);
-  const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-  const handle = new EffectHandle(
-    injector.get(MicrotaskEffectScheduler),
-    effectFn,
-    true ? null : (void 0).current,
-    destroyRef,
-    injector,
-    options?.allowSignalWrites ?? false
-  );
-  handle.watcher.notify();
-  return handle;
-}
 
 // src/import/render3/reactivity/effect.ts
-var useMicrotaskEffectsByDefault = USE_MICROTASK_EFFECT_BY_DEFAULT;
 var EffectRefImpl = class {
   [SIGNAL];
   constructor(node) {
@@ -1857,20 +1553,12 @@ var EffectRefImpl = class {
     this[SIGNAL].destroy();
   }
 };
-function effect2(effectFn, options) {
-  if (useMicrotaskEffectsByDefault) {
-    if (false) {
-      throw new Error(
-        `Cannot use 'forceRoot' option with microtask effects on`
-      );
-    }
-    return microtaskEffect(effectFn, options);
+function effect(effectFn, options) {
+  if (false) {
+    assertInInjectionContext(effect);
   }
-  !options?.injector && assertInInjectionContext(effect2);
   if (false) {
-    console.warn(
-      `The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`
-    );
+    console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);
   }
   const injector = options?.injector ?? inject(Injector);
   const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
@@ -1897,9 +1585,7 @@ var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
   run() {
     this.dirty = false;
     if (false) {
-      throw new Error(
-        `Schedulers cannot synchronously execute watches while scheduling.`
-      );
+      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
     }
     if (this.hasRun && !consumerPollProducersForChange(this)) {
       return;
@@ -1918,12 +1604,14 @@ var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
     if (!this.cleanupFns?.length) {
       return;
     }
+    const prevConsumer = setActiveConsumer(null);
     try {
       while (this.cleanupFns.length) {
         this.cleanupFns.pop()();
       }
     } finally {
       this.cleanupFns = [];
+      setActiveConsumer(prevConsumer);
     }
   }
 }))();
@@ -1946,7 +1634,7 @@ function createRootEffect(fn, scheduler, notifier) {
   node.scheduler = scheduler;
   node.notifier = notifier;
   node.zone = false ? (void 0).current : null;
-  node.scheduler.schedule(node);
+  node.scheduler.add(node);
   node.notifier.notify(12 /* RootEffect */);
   return node;
 }
@@ -2000,27 +1688,148 @@ var ChangeDetectionSchedulerImpl = class {
   }
 };
 
-// src/import/resource/api.ts
-var ResourceStatus = /* @__PURE__ */ ((ResourceStatus2) => {
-  ResourceStatus2[ResourceStatus2["Idle"] = 0] = "Idle";
-  ResourceStatus2[ResourceStatus2["Error"] = 1] = "Error";
-  ResourceStatus2[ResourceStatus2["Loading"] = 2] = "Loading";
-  ResourceStatus2[ResourceStatus2["Reloading"] = 3] = "Reloading";
-  ResourceStatus2[ResourceStatus2["Resolved"] = 4] = "Resolved";
-  ResourceStatus2[ResourceStatus2["Local"] = 5] = "Local";
-  return ResourceStatus2;
-})(ResourceStatus || {});
+// src/import/pending_tasks.ts
+var import_rxjs = require("rxjs");
+
+// 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("", {
+  providedIn: "root",
+  factory: () => {
+    const injector = inject(EnvironmentInjector);
+    let userErrorHandler;
+    return (e) => {
+      userErrorHandler ??= injector.get(ErrorHandler);
+      userErrorHandler.handleError(e);
+    };
+  }
+});
+
+// src/import/pending_tasks.ts
+var PendingTasksInternal = class _PendingTasksInternal {
+  taskId = 0;
+  pendingTasks = /* @__PURE__ */ new Set();
+  destroyed = false;
+  pendingTask = new import_rxjs.BehaviorSubject(false);
+  get hasPendingTasks() {
+    return this.destroyed ? false : this.pendingTask.value;
+  }
+  /**
+   * In case the service is about to be destroyed, return a self-completing observable.
+   * Otherwise, return the observable that emits the current state of pending tasks.
+   */
+  get hasPendingTasksObservable() {
+    if (this.destroyed) {
+      return new import_rxjs.Observable((subscriber) => {
+        subscriber.next(false);
+        subscriber.complete();
+      });
+    }
+    return this.pendingTask;
+  }
+  add() {
+    if (!this.hasPendingTasks && !this.destroyed) {
+      this.pendingTask.next(true);
+    }
+    const taskId = this.taskId++;
+    this.pendingTasks.add(taskId);
+    return taskId;
+  }
+  has(taskId) {
+    return this.pendingTasks.has(taskId);
+  }
+  remove(taskId) {
+    this.pendingTasks.delete(taskId);
+    if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+  }
+  ngOnDestroy() {
+    this.pendingTasks.clear();
+    if (this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+    this.destroyed = true;
+    this.pendingTask.unsubscribe();
+  }
+  /** @nocollapse */
+  static ɵprov = (
+    /** @pureOrBreakMyCode */
+    /* @__PURE__ */ ɵɵdefineInjectable({
+      token: _PendingTasksInternal,
+      providedIn: "root",
+      factory: () => new _PendingTasksInternal()
+    })
+  );
+};
+var PendingTasks = class _PendingTasks {
+  internalPendingTasks = inject(PendingTasksInternal);
+  scheduler = inject(ChangeDetectionScheduler);
+  errorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
+  /**
+   * Adds a new task that should block application's stability.
+   * @returns A cleanup function that removes a task when called.
+   */
+  add() {
+    const taskId = this.internalPendingTasks.add();
+    return () => {
+      if (!this.internalPendingTasks.has(taskId)) {
+        return;
+      }
+      this.scheduler.notify(11 /* PendingTaskRemoved */);
+      this.internalPendingTasks.remove(taskId);
+    };
+  }
+  /**
+   * Runs an asynchronous function and blocks the application's stability until the function completes.
+   *
+   * ```ts
+   * pendingTasks.run(async () => {
+   *   const userData = await fetch('/api/user');
+   *   this.userData.set(userData);
+   * });
+   * ```
+   *
+   * @param fn The asynchronous function to execute
+   * @developerPreview 19.0
+   */
+  run(fn) {
+    const removeTask = this.add();
+    fn().catch(this.errorHandler).finally(removeTask);
+  }
+  /** @nocollapse */
+  static ɵprov = (
+    /** @pureOrBreakMyCode */
+    /* @__PURE__ */ ɵɵdefineInjectable({
+      token: _PendingTasks,
+      providedIn: "root",
+      factory: () => new _PendingTasks()
+    })
+  );
+};
 
 // src/import/resource/resource.ts
+var RESOURCE_VALUE_THROWS_ERRORS_DEFAULT = true;
 function resource(options) {
-  options?.injector || assertInInjectionContext(resource);
-  const request = options.request ?? (() => null);
+  if (false) {
+  }
+  const oldNameForParams = options.request;
+  const params = options.params ?? oldNameForParams ?? (() => null);
   return new ResourceImpl(
-    request,
+    params,
     getLoader(options),
     options.defaultValue,
     options.equal ? wrapEqualityFn(options.equal) : void 0,
-    options.injector ?? inject(Injector)
+    options.injector ?? inject(Injector),
+    RESOURCE_VALUE_THROWS_ERRORS_DEFAULT
   );
 }
 var BaseWritableResource = class {
@@ -2031,13 +1840,15 @@ var BaseWritableResource = class {
     this.value.update = this.update.bind(this);
     this.value.asReadonly = signalAsReadonlyFn;
   }
+  isError = computed(() => this.status() === "error");
   update(updateFn) {
-    this.set(updateFn(untracked(this.value)));
+    this.set(updateFn(untracked2(this.value)));
   }
-  isLoading = computed(
-    () => this.status() === 2 /* Loading */ || this.status() === 3 /* Reloading */
-  );
+  isLoading = computed(() => this.status() === "loading" || this.status() === "reloading");
   hasValue() {
+    if (this.isError()) {
+      return false;
+    }
     return this.value() !== void 0;
   }
   asReadonly() {
@@ -2045,20 +1856,32 @@ var BaseWritableResource = class {
   }
 };
 var ResourceImpl = class extends BaseWritableResource {
-  constructor(request, loaderFn, defaultValue, equal, injector) {
+  constructor(request, loaderFn, defaultValue, equal, injector, throwErrorsFromValue = RESOURCE_VALUE_THROWS_ERRORS_DEFAULT) {
     super(
       // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a
       // `WritableSignal` that delegates to `ResourceImpl.set`.
       computed(
         () => {
           const streamValue = this.state().stream?.();
-          return streamValue && isResolved(streamValue) ? streamValue.value : this.defaultValue;
+          if (!streamValue) {
+            return defaultValue;
+          }
+          if (this.state().status === "loading" && this.error()) {
+            return defaultValue;
+          }
+          if (!isResolved(streamValue)) {
+            if (throwErrorsFromValue) {
+              throw new ResourceValueError(this.error());
+            } else {
+              return defaultValue;
+            }
+          }
+          return streamValue.value;
         },
         { equal }
       )
     );
     this.loaderFn = loaderFn;
-    this.defaultValue = defaultValue;
     this.equal = equal;
     this.extRequest = linkedSignal({
       source: request,
@@ -2069,12 +1892,12 @@ var ResourceImpl = class extends BaseWritableResource {
       source: this.extRequest,
       // Compute the state of the resource given a change in status.
       computation: (extRequest, previous) => {
-        const status = extRequest.request === void 0 ? 0 /* Idle */ : 2 /* Loading */;
+        const status = extRequest.request === void 0 ? "idle" : "loading";
         if (!previous) {
           return {
             extRequest,
             status,
-            previousStatus: 0 /* Idle */,
+            previousStatus: "idle",
             stream: void 0
           };
         } else {
@@ -2088,12 +1911,12 @@ var ResourceImpl = class extends BaseWritableResource {
         }
       }
     });
-    this.effectRef = effect2(this.loadEffect.bind(this), {
+    this.effectRef = effect(this.loadEffect.bind(this), {
       injector,
       manualCleanup: true
     });
     this.pendingTasks = injector.get(PendingTasks);
-    injector.get(DestroyRef).onDestroy(() => this.destroy());
+    this.unregisterOnDestroy = injector.get(DestroyRef).onDestroy(() => this.destroy());
   }
   pendingTasks;
   /**
@@ -2109,6 +1932,7 @@ var ResourceImpl = class extends BaseWritableResource {
   pendingController;
   resolvePendingTask = void 0;
   destroyed = false;
+  unregisterOnDestroy;
   status = computed(() => projectStatusOfState(this.state()));
   error = computed(() => {
     const stream = this.state().stream?.();
@@ -2121,55 +1945,55 @@ var ResourceImpl = class extends BaseWritableResource {
     if (this.destroyed) {
       return;
     }
-    const current = untracked(this.value);
-    const state = untracked(this.state);
-    if (state.status === 5 /* Local */ && (this.equal ? this.equal(current, value) : current === value)) {
+    const current = untracked2(this.value);
+    const state = untracked2(this.state);
+    if (state.status === "local" && (this.equal ? this.equal(current, value) : current === value)) {
       return;
     }
     this.state.set({
       extRequest: state.extRequest,
-      status: 5 /* Local */,
-      previousStatus: 5 /* Local */,
+      status: "local",
+      previousStatus: "local",
       stream: signal({ value })
     });
     this.abortInProgressLoad();
   }
   reload() {
-    const { status } = untracked(this.state);
-    if (status === 0 /* Idle */ || status === 2 /* Loading */) {
+    const { status } = untracked2(this.state);
+    if (status === "idle" || status === "loading") {
       return false;
     }
-    this.extRequest.update(({ request, reload }) => ({
-      request,
-      reload: reload + 1
-    }));
+    this.extRequest.update(({ request, reload }) => ({ request, reload: reload + 1 }));
     return true;
   }
   destroy() {
     this.destroyed = true;
+    this.unregisterOnDestroy();
     this.effectRef.destroy();
     this.abortInProgressLoad();
     this.state.set({
       extRequest: { request: void 0, reload: 0 },
-      status: 0 /* Idle */,
-      previousStatus: 0 /* Idle */,
+      status: "idle",
+      previousStatus: "idle",
       stream: void 0
     });
   }
   async loadEffect() {
     const extRequest = this.extRequest();
-    const { status: currentStatus, previousStatus } = untracked(this.state);
+    const { status: currentStatus, previousStatus } = untracked2(this.state);
     if (extRequest.request === void 0) {
       return;
-    } else if (currentStatus !== 2 /* Loading */) {
+    } else if (currentStatus !== "loading") {
       return;
     }
     this.abortInProgressLoad();
     let resolvePendingTask = this.resolvePendingTask = this.pendingTasks.add();
     const { signal: abortSignal } = this.pendingController = new AbortController();
     try {
-      const stream = await untracked(
+      const stream = await untracked2(
         () => this.loaderFn({
+          params: extRequest.request,
+          // TODO(alxhub): cleanup after g3 removal of `request` alias.
           request: extRequest.request,
           abortSignal,
           previous: {
@@ -2177,24 +2001,24 @@ var ResourceImpl = class extends BaseWritableResource {
           }
         })
       );
-      if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {
+      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
         return;
       }
       this.state.set({
         extRequest,
-        status: 4 /* Resolved */,
-        previousStatus: 4 /* Resolved */,
+        status: "resolved",
+        previousStatus: "resolved",
         stream
       });
     } catch (err) {
-      if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {
+      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
         return;
       }
       this.state.set({
         extRequest,
-        status: 4 /* Resolved */,
-        previousStatus: 1 /* Error */,
-        stream: signal({ error: err })
+        status: "resolved",
+        previousStatus: "error",
+        stream: signal({ error: encapsulateResourceError(err) })
       });
     } finally {
       resolvePendingTask?.();
@@ -2202,7 +2026,7 @@ var ResourceImpl = class extends BaseWritableResource {
     }
   }
   abortInProgressLoad() {
-    untracked(() => this.pendingController?.abort());
+    untracked2(() => this.pendingController?.abort());
     this.pendingController = void 0;
     this.resolvePendingTask?.();
     this.resolvePendingTask = void 0;
@@ -2219,7 +2043,7 @@ function getLoader(options) {
     try {
       return signal({ value: await options.loader(params) });
     } catch (err) {
-      return signal({ error: err });
+      return signal({ error: encapsulateResourceError(err) });
     }
   };
 }
@@ -2228,10 +2052,10 @@ function isStreamingResourceOptions(options) {
 }
 function projectStatusOfState(state) {
   switch (state.status) {
-    case 2 /* Loading */:
-      return state.extRequest.reload === 0 ? 2 /* Loading */ : 3 /* Reloading */;
-    case 4 /* Resolved */:
-      return isResolved(untracked(state.stream)) ? 4 /* Resolved */ : 1 /* Error */;
+    case "loading":
+      return state.extRequest.reload === 0 ? "loading" : "reloading";
+    case "resolved":
+      return isResolved(state.stream()) ? "resolved" : "error";
     default:
       return state.status;
   }
@@ -2239,8 +2063,28 @@ function projectStatusOfState(state) {
 function isResolved(state) {
   return state.error === void 0;
 }
+function encapsulateResourceError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new ResourceWrappedError(error);
+}
+var ResourceValueError = class extends Error {
+  constructor(error) {
+    super(error.message, { cause: error });
+  }
+};
+var ResourceWrappedError = class extends Error {
+  constructor(error) {
+    super(String(error), { cause: error });
+  }
+};
 
 // src/import/index.ts
+function Injectable(args) {
+  return (constructor) => {
+  };
+}
 var StaticInjectOptions = class {
   static injectOptions;
 };
@@ -2250,12 +2094,7 @@ var RootStaticInjectOptions = class {
   };
 };
 function createInjector2(options) {
-  return new R3Injector(
-    options.providers,
-    options.parent ?? getNullInjector(),
-    options.name ?? "",
-    options.scopes ?? /* @__PURE__ */ new Set([])
-  );
+  return new R3Injector(options.providers, options.parent ?? getNullInjector(), options.name ?? "", options.scopes ?? /* @__PURE__ */ new Set([]));
 }
 function createRootInjector(options) {
   return new R3Injector(
@@ -2268,7 +2107,7 @@ function createRootInjector(options) {
     ],
     getNullInjector(),
     options.name ?? "",
-    options.scopes ?? /* @__PURE__ */ new Set([])
+    options.scopes ?? /* @__PURE__ */ new Set(["environment"])
   );
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -2277,9 +2116,11 @@ function createRootInjector(options) {
   ChangeDetectionSchedulerImpl,
   DecoratorFlags,
   EnvironmentInjector,
+  ErrorHandler,
   INJECTOR_SCOPE,
+  INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject,
-  InjectFlags,
+  Injectable,
   InjectionToken,
   Injector,
   InternalInjectFlags,
@@ -2290,8 +2131,10 @@ function createRootInjector(options) {
   NullInjector,
   Optional,
   PROVIDED_ZONELESS,
+  PendingTasks,
+  PendingTasksInternal,
   R3Injector,
-  ResourceStatus,
+  RetrievingInjector,
   RootStaticInjectOptions,
   SCHEDULE_IN_ROOT_ZONE,
   SOURCE,
@@ -2329,9 +2172,7 @@ function createRootInjector(options) {
   signal,
   untracked,
   ɵEffectScheduler,
-  ɵMicrotaskEffectScheduler,
   ɵSIGNAL,
-  ɵmicrotaskEffect,
   ɵunwrapWritableSignal,
   ɵɵdefineInjectable,
   ɵɵdefineInjector,