Test fixes for new exception handler

Author: tolyo

@types/core/compile/compile.d.ts

@@ -126,11 +126,11 @@ export class CompileProvider {
     | ((
         $injector: ng.InjectorService,
         $interpolate: any,
-        $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+        $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
         $controller: any,
-        $rootScope: import("../scope/scope.js").Scope,
+        $rootScope: ng.Scope,
         $sce: any,
         $animate: ng.AnimateService,
       ) => (

@types/directive/bind/bind.d.ts

@@ -1,7 +1,7 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngBindDirective(): import("../../interface.ts").Directive;
+export function ngBindDirective(): ng.Directive;
 /**
  * @returns {import('../../interface.ts').Directive}
  */

@types/directive/include/include.d.ts

@@ -3,15 +3,15 @@
  * @param {ng.TemplateRequestService} $templateRequest
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {ng.AnimateService} $animate
- * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @returns {ng.Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: ng.TemplateRequestService,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: ng.AnimateService,
-  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.ts").Directive;
+  $exceptionHandler: ng.ExceptionHandlerService,
+): ng.Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

@types/directive/model/model.d.ts

@@ -49,20 +49,20 @@ export class NgModelController {
   static $nonscope: boolean;
   static $inject: string[];
   /**
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
-   * @param {import('../../core/compile/attributes.js').Attributes} $attr
+   * @param {ng.Scope} $scope
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   * @param {ng.Attributes} $attr
    * @param {Element} $element
-   * @param {import("../../core/parse/interface.ts").ParseService} $parse
+   * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
-    $scope: import("../../core/scope/scope.js").Scope,
-    $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-    $attr: import("../../core/compile/attributes.js").Attributes,
+    $scope: ng.Scope,
+    $exceptionHandler: ng.ExceptionHandlerService,
+    $attr: ng.Attributes,
     $element: Element,
-    $parse: import("../../core/parse/interface.ts").ParseService,
+    $parse: ng.ParseService,
     $animate: ng.AnimateService,
     $interpolate: any,
   );
@@ -123,21 +123,21 @@ export class NgModelController {
   $$parsedNgModelAssign: (context: any, value: any) => any;
   /**
    * @type {import("../../core/parse/interface.ts").CompiledExpression |
-   *        (function(import("../../core/scope/scope.js").Scope): any)}
+   *        (function(ng.Scope): any)}
    */
   $$ngModelGet:
     | import("../../core/parse/interface.ts").CompiledExpression
-    | ((arg0: import("../../core/scope/scope.js").Scope) => any);
+    | ((arg0: ng.Scope) => any);
   $$ngModelSet: (context: any, value: any) => any;
   $$pendingDebounce: number;
   $$parserValid: boolean;
   /** @type {string} */
   $$parserName: string;
   /** @type {number} */
   $$currentValidationRunId: number;
-  /** @type {import('../../core/scope/scope.js').Scope} */
-  $$scope: import("../../core/scope/scope.js").Scope;
-  $$attr: import("../../core/compile/attributes.js").Attributes;
+  /** @type {ng.Scope} */
+  $$scope: ng.Scope;
+  $$attr: ng.Attributes;
   $$element: Element;
   $$animate: import("../../interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;

@types/directive/options/options.d.ts

@@ -1,13 +1,13 @@
 /**
  *
  * @param {ng.CompileService} $compile
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 export function ngOptionsDirective(
   $compile: ng.CompileService,
-  $parse: import("../../core/parse/interface.ts").ParseService,
-): import("../../interface.ts").Directive;
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace ngOptionsDirective {
   let $inject: string[];
 }

@types/router/url/url-service.d.ts

@@ -60,10 +60,7 @@ export class UrlService {
   getHash(): string;
   $get: (
     | string
-    | ((
-        $location: import("../../services/location/location.js").Location,
-        $rootScope: import("../../core/scope/scope.js").Scope,
-      ) => UrlService)
+    | (($location: ng.LocationService, $rootScope: ng.Scope) => UrlService)
   )[];
   /**
    * @returns {string}

@types/services/exception/exception-handler.d.ts

@@ -1,58 +1,56 @@
 /**
- * Handles uncaught exceptions thrown in AngularTS expressions.
+ * Unified exception handler used throughout AngularTS.
  *
- * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
- * You can override this behavior to provide custom exception handling—such as reporting errors
- * to a backend server, or altering the log level used.
+ * This service receives uncaught exceptions from both synchronous and asynchronous operations.
+ * Its purpose is to provide a central point through which the framework
+ * surfaces errors.
  *
- * ## Default Behavior
+ * By default, `$exceptionHandler` simply rethrows the exception. This ensures fail-fast
+ * behavior, making errors visible immediately in development and in unit tests.
+ * Applications may override this service to introduce custom error handling.
  *
- * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
- * The default implementation logs the error using `$log.error(exception, cause)`.
- *
- * ## Custom Implementation
- *
- * You can override the default `$exceptionHandler` by providing your own factory. This allows you to:
- * - Log errors to a remote server
- * - Change the log level (e.g., from `error` to `warn`)
- * - Trigger custom error-handling workflows
- *
- * ### Example: Overriding `$exceptionHandler`
+ * ### Example: Custom `$exceptionHandler`
  *
  * ```js
  * angular
- *   .module('exceptionOverwrite', [])
- *   .factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
- *     return function myExceptionHandler(exception, cause) {
- *       logErrorsToBackend(exception, cause);
- *       $log.warn(exception, cause); // Use warn instead of error
+ *   .module('app')
+ *   .factory('$exceptionHandler', function(myLogger) {
+ *     return function handleError(error) {
+ *       myLogger.capture(error);
+ *       // Rethrow to preserve fail-fast behavior:
+ *       throw error;
  *     };
- *   }]);
+ *   });
  * ```
- * - You may also manually invoke the exception handler:
+ *
+ * IMPORTANT: custom implementation should always rethrow the error as the framework assumes that `$exceptionHandler` always does the throwing.
+ *
+ * ### Manual Invocation
+ *
+ * You can invoke the exception handler directly when catching errors in your own code:
  *
  * ```js
  * try {
- *   // Some code that might throw
- * } catch (e) {
- *   $exceptionHandler(e, 'optional context');
+ *   riskyOperation();
+ * } catch (err) {
+ *   $exceptionHandler(err);
  * }
  * ```
  *
  * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
-/** @typedef {import('../log/interface.ts').LogService} LogService */
-/** @typedef {import("./interface.ts").ErrorHandler}  ErrorHandler */
 /**
- * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
- * Can be overridden to implement custom error-handling logic.
+ * Provider for the `$exceptionHandler` service.
+ *
+ * The default implementation rethrows exceptions, enabling strict fail-fast behavior.
+ * Applications may replace the handler via by setting `errorHandler`property or by providing their own
+ * `$exceptionHandler` factory.
  */
 export class ExceptionHandlerProvider {
-  /** @type {LogService} */
-  log: LogService;
-  /** @type {ErrorHandler} */
-  errorHandler: ErrorHandler;
-  $get: (string | (($log: LogService) => ErrorHandler))[];
+  /** @type {ng.ExceptionHandlerService} */
+  errorHandler: ng.ExceptionHandlerService;
+  /**
+   * @returns {ng.ExceptionHandlerService}
+   */
+  $get(): ng.ExceptionHandlerService;
 }
-export type LogService = import("../log/interface.ts").LogService;
-export type ErrorHandler = import("./interface.ts").ErrorHandler;

@types/services/exception/interface.d.ts

@@ -2,6 +2,5 @@
  * A callback type for handling errors.
  *
  * @param exception - The exception associated with the error.
- * @param [cause] - Optional information about the context in which the error was thrown.
  */
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type ErrorHandler = (exception: Error) => void;

@types/shared/dom.d.ts

@@ -106,11 +106,11 @@ export function getScope(element: Element): ng.Scope;
  * Set scope for a given element.
  *
  * @param {Element|Node|ChildNode} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
 export function setScope(
   element: Element | Node | ChildNode,
-  scope: import("../core/scope/scope.js").Scope,
+  scope: ng.Scope,
 ): void;
 /**
  * Gets isolate scope for a given element.
@@ -123,23 +123,20 @@ export function getIsolateScope(element: Element): any;
  * Set isolate scope for a given element.
  *
  * @param {Element} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
-export function setIsolateScope(
-  element: Element,
-  scope: import("../core/scope/scope.js").Scope,
-): void;
+export function setIsolateScope(element: Element, scope: ng.Scope): void;
 /**
  * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
  *
  * @param {Element} element - The DOM element to get data from.
  * @param {string} [name] - Controller name.
- * @returns {import("../core/scope/scope.js").Scope|undefined} - The retrieved data
+ * @returns {ng.Scope|undefined} - The retrieved data
  */
 export function getController(
   element: Element,
   name?: string,
-): import("../core/scope/scope.js").Scope | undefined;
+): ng.Scope | undefined;
 /**
  *
  * @param {Node} element