@allstak/angular 0.1.0

package/fesm2022/allstak-angular.mjs

@@ -0,0 +1,740 @@
+import { AllStak } from '@allstak/js';
+export { AllStak, Scope, Session, SessionTracker, Span, WebVitalsModule, consoleIntegration, databaseIntegration, dedupeIntegration, defineIntegration, eventFiltersIntegration, httpClientIntegration, inboundFiltersIntegration, isWebVitalsSupported } from '@allstak/js';
+import * as i0 from '@angular/core';
+import { Injectable, Optional, Input, Directive, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, ErrorHandler, APP_INITIALIZER, inject, InjectionToken, NgModule } from '@angular/core';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/router';
+import { NavigationStart, NavigationEnd, NavigationCancel, NavigationError } from '@angular/router';
+
+// AUTO-GENERATED by scripts/gen-version.mjs — do not edit by hand.
+const SDK_NAME = 'allstak-angular';
+const SDK_VERSION = "0.1.0";
+
+/**
+ * Initialize the AllStak SDK for an Angular application.
+ *
+ * This is a thin shim over `AllStak.init` from `@allstak/js` that stamps the
+ * wrapper identity (`sdkName: 'allstak-angular'`, `sdkVersion`) so the backend
+ * can tell Angular traffic apart from plain JS traffic. Everything else —
+ * buffering, sampling, session health, offline queue, PII scrubbing — is
+ * delegated to the underlying core client.
+ *
+ * Call this once at app boot in `main.ts`, BEFORE `bootstrapApplication(...)`
+ * (standalone) or `platformBrowserDynamic().bootstrapModule(...)` (NgModule),
+ * so the global `ErrorHandler` and router instrumentation see a live client:
+ *
+ *   import { init } from '@allstak/angular';
+ *
+ *   init({
+ *     apiKey: environment.allstakApiKey,
+ *     environment: environment.production ? 'production' : 'development',
+ *   });
+ *
+ *   bootstrapApplication(AppComponent, appConfig);
+ */
+function init(config) {
+    return AllStak.init({
+        ...config,
+        sdkName: config.sdkName ?? SDK_NAME,
+        sdkVersion: config.sdkVersion ?? SDK_VERSION,
+    });
+}
+
+const DEFAULT_OPTIONS = {
+    logErrors: true,
+};
+/**
+ * Unwrap the common Angular/zone.js error envelopes so we capture the real
+ * underlying error rather than the wrapper:
+ *
+ *   - Angular wraps errors thrown during change detection as
+ *     `{ ngOriginalError }` / `{ originalError }`.
+ *   - `HttpErrorResponse` carries the server payload on `.error`.
+ *   - DOM `ErrorEvent` carries the real error on `.error`.
+ *   - Rejected promises may surface as `{ rejection }`.
+ */
+function defaultExtractor(error) {
+    if (error && typeof error === 'object') {
+        const candidate = error;
+        // PromiseRejectionEvent-style wrapping from zone.js.
+        if ('rejection' in candidate && candidate['rejection'] != null) {
+            return defaultExtractor(candidate['rejection']);
+        }
+        // Angular wraps the thrown value during change detection.
+        if ('ngOriginalError' in candidate && candidate['ngOriginalError'] != null) {
+            return defaultExtractor(candidate['ngOriginalError']);
+        }
+        if ('originalError' in candidate && candidate['originalError'] != null) {
+            return defaultExtractor(candidate['originalError']);
+        }
+        // DOM ErrorEvent / HttpErrorResponse expose the real error on `.error`.
+        if ('error' in candidate && candidate['error'] instanceof Error) {
+            return candidate['error'];
+        }
+    }
+    return error;
+}
+/** Coerce any extracted value into an `Error` so `captureException` is happy. */
+function toError(value) {
+    if (value instanceof Error)
+        return value;
+    if (typeof value === 'string')
+        return new Error(value);
+    try {
+        return new Error(JSON.stringify(value));
+    }
+    catch {
+        return new Error(String(value));
+    }
+}
+/**
+ * AllStak's implementation of Angular's `ErrorHandler`. Captures every error
+ * routed through Angular's global error handling — uncaught render/lifecycle
+ * errors, change-detection errors, and (when zone.js is present) unhandled
+ * promise rejections.
+ *
+ * Wired manually as `{ provide: ErrorHandler, useValue: createErrorHandler() }`
+ * or via {@link provideAllStakErrorHandler}.
+ */
+class AllStakErrorHandler {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    handleError(error) {
+        const extracted = this.options.extractor
+            ? this.options.extractor(error, defaultExtractor)
+            : defaultExtractor(error);
+        const err = toError(extracted);
+        try {
+            AllStak.captureException(err, { framework: 'angular' });
+        }
+        catch {
+            // Never let our handler break the host's error path.
+        }
+        if (this.options.logErrors !== false) {
+            // Preserve Angular's default of surfacing the original (pre-unwrap)
+            // value so stack traces and zone context stay intact in the console.
+            // eslint-disable-next-line no-console
+            console.error(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined }] });
+/**
+ * Factory returning an Angular `ErrorHandler` that forwards to
+ * `AllStak.captureException`.
+ *
+ * Standalone (`app.config.ts`):
+ *
+ *   import { ErrorHandler } from '@angular/core';
+ *   import { createErrorHandler } from '@allstak/angular';
+ *
+ *   export const appConfig = {
+ *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],
+ *   };
+ *
+ * NgModule (`AppModule`):
+ *
+ *   @NgModule({
+ *     providers: [{ provide: ErrorHandler, useValue: createErrorHandler() }],
+ *   })
+ *   export class AppModule {}
+ */
+function createErrorHandler(options) {
+    return new AllStakErrorHandler(options);
+}
+
+const KNOWN_METHODS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'HEAD',
+    'OPTIONS',
+]);
+/** Normalise an Angular request method into the core method union. */
+function normalizeMethod(method) {
+    const upper = method.toUpperCase();
+    return (KNOWN_METHODS.has(upper) ? upper : 'GET');
+}
+/** Split an outbound URL into `host` + `path`, tolerating relative URLs. */
+function splitUrl(url) {
+    try {
+        const base = typeof window !== 'undefined' && window.location
+            ? window.location.origin
+            : 'http://localhost';
+        const parsed = new URL(url, base);
+        return { host: parsed.host, path: parsed.pathname + parsed.search };
+    }
+    catch {
+        return { host: '', path: url };
+    }
+}
+/**
+ * Open a span + record an outbound request for a single `HttpRequest`, and
+ * return the lifecycle hooks the interceptor (class or functional) uses to
+ * finish it. Shared so the class-based and functional interceptors stay
+ * behaviourally identical.
+ */
+function instrumentRequest(req) {
+    const startedAt = Date.now();
+    const method = normalizeMethod(req.method);
+    const { host, path } = splitUrl(req.urlWithParams);
+    let span = null;
+    try {
+        span = AllStak.startSpan('http.client', {
+            op: 'http.client',
+            description: `${req.method} ${req.urlWithParams}`,
+            attributes: {
+                'allstak.origin': 'auto.http.angular',
+                'http.method': req.method,
+                'http.url': req.urlWithParams,
+            },
+        });
+    }
+    catch {
+        // Never block the request on observability errors.
+    }
+    const finish = (statusCode, status) => {
+        const durationMs = Date.now() - startedAt;
+        try {
+            span?.setMeasurement('http.duration_ms', durationMs);
+            span?.finish(status);
+        }
+        catch {
+            // ignore — span may already be finished
+        }
+        try {
+            const item = {
+                direction: 'outbound',
+                method,
+                host,
+                path,
+                statusCode,
+                durationMs,
+            };
+            AllStak.captureRequest(item);
+        }
+        catch {
+            // ignore — request recording is best-effort
+        }
+    };
+    return {
+        onResponse(statusCode) {
+            finish(statusCode, statusCode >= 400 ? 'error' : 'ok');
+        },
+        onError(error) {
+            const statusCode = error instanceof HttpErrorResponse ? error.status : 0;
+            finish(statusCode, 'error');
+        },
+    };
+}
+/**
+ * Class-based `HttpInterceptor` that records every outbound HTTP request and
+ * opens a `http.client` span around it. Register in the DI-token style used by
+ * NgModule apps and standalone apps that opt into `withInterceptorsFromDi()`:
+ *
+ *   import { HTTP_INTERCEPTORS } from '@angular/common/http';
+ *   import { AllStakHttpInterceptor } from '@allstak/angular';
+ *
+ *   providers: [
+ *     { provide: HTTP_INTERCEPTORS, useClass: AllStakHttpInterceptor, multi: true },
+ *   ]
+ *
+ * The interceptor never mutates the request and never swallows errors — it
+ * only observes the stream.
+ */
+class AllStakHttpInterceptor {
+    intercept(req, next) {
+        const hooks = instrumentRequest(req);
+        return new Observable((subscriber) => {
+            const sub = next.handle(req).subscribe({
+                next: (event) => {
+                    if (event instanceof HttpResponse) {
+                        hooks.onResponse(event.status);
+                    }
+                    subscriber.next(event);
+                },
+                error: (error) => {
+                    hooks.onError(error);
+                    subscriber.error(error);
+                },
+                complete: () => subscriber.complete(),
+            });
+            return () => sub.unsubscribe();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakHttpInterceptor, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Functional `HttpInterceptor` for standalone apps using
+ * `provideHttpClient(withInterceptors([allStakHttpInterceptor]))`.
+ *
+ * Behaviourally identical to {@link AllStakHttpInterceptor}.
+ */
+function allStakHttpInterceptor(req, next) {
+    const hooks = instrumentRequest(req);
+    return new Observable((subscriber) => {
+        const sub = next(req).subscribe({
+            next: (event) => {
+                if (event instanceof HttpResponse) {
+                    hooks.onResponse(event.status);
+                }
+                subscriber.next(event);
+            },
+            error: (error) => {
+                hooks.onError(error);
+                subscriber.error(error);
+            },
+            complete: () => subscriber.complete(),
+        });
+        return () => sub.unsubscribe();
+    });
+}
+
+/**
+ * Router-aware navigation instrumentation.
+ *
+ * `TraceService` subscribes to Angular `Router` events and opens a
+ * `navigation` span per route change — `NavigationStart` opens it,
+ * `NavigationEnd` finishes it `ok`, and `NavigationCancel` / `NavigationError`
+ * finish it `error`. A navigation breadcrumb is recorded alongside each span.
+ *
+ * Because Angular only constructs a service when something injects it, the
+ * service must be *force-instantiated* for its Router subscription to run.
+ * Use {@link provideAllStakRouterInstrumentation} (standalone) or inject it in
+ * your `AppComponent` constructor (NgModule) — see those helpers for wiring.
+ *
+ * `Router` is `@Optional()` so apps without `@angular/router` (which is an
+ * optional peer dependency) can still construct the service without error; it
+ * simply becomes a no-op.
+ */
+class TraceService {
+    router;
+    activeNavSpan = null;
+    subscription = null;
+    constructor(router) {
+        this.router = router;
+        if (!this.router)
+            return;
+        this.subscription = this.router.events.subscribe((event) => {
+            this.handleEvent(event);
+        });
+    }
+    handleEvent(event) {
+        try {
+            if (event instanceof NavigationStart) {
+                this.onNavigationStart(event.url);
+            }
+            else if (event instanceof NavigationEnd) {
+                this.finishActive('ok');
+            }
+            else if (event instanceof NavigationCancel ||
+                event instanceof NavigationError) {
+                this.finishActive('error');
+                if (event instanceof NavigationError) {
+                    AllStak.captureException(event.error instanceof Error
+                        ? event.error
+                        : new Error(String(event.error)), { framework: 'angular', source: '@angular/router' });
+                }
+            }
+        }
+        catch {
+            // ignore — never block navigation on observability errors
+        }
+    }
+    onNavigationStart(url) {
+        // A new navigation supersedes any span still open from a redirect chain.
+        this.finishActive('ok');
+        AllStak.addBreadcrumb({
+            type: 'navigation',
+            message: url,
+            level: 'info',
+            data: { url },
+        });
+        this.activeNavSpan = AllStak.startSpan('navigation', {
+            op: 'navigation',
+            description: url,
+            attributes: {
+                'allstak.origin': 'auto.navigation.angular',
+                'route.url': url,
+            },
+        });
+    }
+    finishActive(status) {
+        if (!this.activeNavSpan)
+            return;
+        try {
+            this.activeNavSpan.finish(status);
+        }
+        catch {
+            // ignore — span may already be finished
+        }
+        finally {
+            this.activeNavSpan = null;
+        }
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+        this.finishActive('ok');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TraceService, deps: [{ token: i1.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TraceService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TraceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.Router, decorators: [{
+                    type: Optional
+                }] }] });
+
+/**
+ * `[trace]` template directive for component render timing.
+ *
+ *   <app-checkout trace="checkout"></app-checkout>
+ *
+ * Opens a `ui.angular.init` span when the host component initialises
+ * (`ngOnInit`) and finishes it once the component's view has been fully
+ * initialised (`ngAfterViewInit`). The span is named after the directive's
+ * `trace` value — required, because component class names are not reliable in
+ * minified production builds.
+ *
+ * Standalone components import the directive directly; module-based apps get
+ * it via {@link AllStakTraceModule}.
+ */
+class TraceDirective {
+    /**
+     * Human-readable name for the traced component. Used as the span
+     * description. Required so spans stay meaningful after minification.
+     */
+    componentName = '';
+    span = null;
+    ngOnInit() {
+        const name = this.componentName || 'unnamed';
+        try {
+            this.span = AllStak.startSpan('ui.angular.init', {
+                op: 'ui.angular.init',
+                description: name,
+                attributes: {
+                    'allstak.origin': 'auto.ui.angular',
+                    'angular.component': name,
+                },
+            });
+        }
+        catch {
+            // Never let render tracing break a component.
+        }
+    }
+    ngAfterViewInit() {
+        try {
+            this.span?.finish('ok');
+        }
+        catch {
+            // ignore — span may already be finished
+        }
+        finally {
+            this.span = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TraceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TraceDirective, isStandalone: true, selector: "[trace]", inputs: { componentName: ["trace", "componentName"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TraceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[trace]',
+                    standalone: true,
+                }]
+        }], propDecorators: { componentName: [{
+                type: Input,
+                args: ['trace']
+            }] } });
+
+/**
+ * Class decorator that instruments a component's init lifecycle. Wraps
+ * `ngOnInit` so a `ui.angular.init` span is opened on init and finished on
+ * `ngAfterViewInit` (or immediately after `ngOnInit` if the component has no
+ * `ngAfterViewInit`).
+ *
+ *   @TraceClassDecorator({ name: 'CheckoutComponent' })
+ *   @Component({ ... })
+ *   export class CheckoutComponent implements OnInit {}
+ */
+function TraceClassDecorator(options) {
+    return function (target) {
+        const proto = target.prototype;
+        const SPAN_KEY = '__allstak_trace_class_span__';
+        const originalOnInit = proto.ngOnInit;
+        const originalAfterViewInit = proto.ngAfterViewInit;
+        proto.ngOnInit = function () {
+            try {
+                this[SPAN_KEY] = AllStak.startSpan('ui.angular.init', {
+                    op: 'ui.angular.init',
+                    description: options.name,
+                    attributes: {
+                        'allstak.origin': 'auto.ui.angular',
+                        'angular.component': options.name,
+                    },
+                });
+            }
+            catch {
+                // ignore
+            }
+            originalOnInit?.call(this);
+            // If there is no ngAfterViewInit, close the span right after init.
+            if (!originalAfterViewInit && !proto.ngAfterViewInit) {
+                finishSpan(this[SPAN_KEY]);
+                this[SPAN_KEY] = undefined;
+            }
+        };
+        proto.ngAfterViewInit = function () {
+            originalAfterViewInit?.call(this);
+            finishSpan(this[SPAN_KEY]);
+            this[SPAN_KEY] = undefined;
+        };
+        return target;
+    };
+}
+/** Alias for the alternate naming. */
+const TraceClass = TraceClassDecorator;
+/**
+ * Method decorator emitting a point-in-time `ui.angular.[hook]` span around a
+ * single lifecycle method (e.g. `ngOnInit`, `ngOnChanges`, `ngAfterViewInit`).
+ *
+ *   class Foo {
+ *     @TraceMethodDecorator({ name: 'Foo.ngOnInit' })
+ *     ngOnInit() {}
+ *   }
+ */
+function TraceMethodDecorator(options) {
+    return function (_target, propertyKey, descriptor) {
+        const original = descriptor.value;
+        descriptor.value = function (...args) {
+            let span = null;
+            try {
+                span = AllStak.startSpan(`ui.angular.${propertyKey}`, {
+                    op: `ui.angular.${propertyKey}`,
+                    description: options.name,
+                    attributes: {
+                        'allstak.origin': 'auto.ui.angular',
+                        'angular.hook': propertyKey,
+                    },
+                });
+            }
+            catch {
+                // ignore
+            }
+            try {
+                return original?.apply(this, args);
+            }
+            finally {
+                finishSpan(span ?? undefined);
+            }
+        };
+        return descriptor;
+    };
+}
+/** Alias for the alternate naming. */
+const TraceMethod = TraceMethodDecorator;
+function finishSpan(span) {
+    try {
+        span?.finish('ok');
+    }
+    catch {
+        // ignore — span may already be finished
+    }
+}
+
+/**
+ * Bootstrap the AllStak SDK from a standalone app's `appConfig.providers`.
+ *
+ *   import { provideAllStak } from '@allstak/angular';
+ *
+ *   export const appConfig: ApplicationConfig = {
+ *     providers: [
+ *       provideAllStak({ apiKey: environment.allstakApiKey }),
+ *     ],
+ *   };
+ *
+ * This calls {@link init} during DI bootstrap. For the global `ErrorHandler`
+ * to catch errors thrown *during bootstrap itself*, prefer calling `init(...)`
+ * directly in `main.ts` before `bootstrapApplication`; this provider is the
+ * convenient alternative for apps that initialise inside the DI graph.
+ */
+function provideAllStak(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            multi: true,
+            useValue: () => {
+                init(config);
+            },
+        },
+    ]);
+}
+/**
+ * Provide the AllStak `ErrorHandler` (overriding Angular's default) so every
+ * error routed through Angular's global error handling is captured.
+ *
+ *   providers: [provideAllStakErrorHandler()]
+ *
+ * Equivalent to `{ provide: ErrorHandler, useValue: createErrorHandler() }`.
+ */
+function provideAllStakErrorHandler(options) {
+    return { provide: ErrorHandler, useValue: createErrorHandler(options) };
+}
+/**
+ * Register and force-instantiate {@link TraceService} so its Router
+ * subscription runs and a navigation span opens per route change.
+ *
+ *   providers: [provideRouter(routes), provideAllStakRouterInstrumentation()]
+ *
+ * `TraceService` is `providedIn: 'root'`, but Angular only constructs a
+ * service when something injects it. The `APP_INITIALIZER` below injects it
+ * during bootstrap, guaranteeing the subscription is live before the first
+ * navigation completes.
+ */
+function provideAllStakRouterInstrumentation() {
+    return makeEnvironmentProviders([
+        TraceService,
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: () => {
+                // Force-instantiate the service; the factory itself is a no-op.
+                inject(TraceService);
+                return () => undefined;
+            },
+        },
+    ]);
+}
+
+/** DI token carrying the config passed to {@link AllStakModule.forRoot}. */
+const ALLSTAK_CONFIG = new InjectionToken('ALLSTAK_CONFIG');
+/**
+ * NgModule that exposes {@link TraceDirective} for module-based apps (or
+ * standalone components that prefer NgModule-style `imports`):
+ *
+ *   @NgModule({ imports: [AllStakTraceModule] })
+ *   export class AppModule {}
+ *
+ *   <app-checkout trace="checkout"></app-checkout>
+ *
+ * `TraceDirective` is a standalone directive, so it is imported (not declared)
+ * and re-exported.
+ */
+class AllStakTraceModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakTraceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AllStakTraceModule, imports: [TraceDirective], exports: [TraceDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakTraceModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakTraceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [TraceDirective],
+                    exports: [TraceDirective],
+                }]
+        }] });
+/**
+ * Root NgModule for module-based Angular apps.
+ *
+ *   import { AllStakModule } from '@allstak/angular';
+ *
+ *   @NgModule({
+ *     imports: [
+ *       BrowserModule,
+ *       AllStakModule.forRoot({ apiKey: environment.allstakApiKey }),
+ *     ],
+ *   })
+ *   export class AppModule {}
+ *
+ * `forRoot(config)`:
+ *   - calls {@link init} during bootstrap (via `APP_INITIALIZER`);
+ *   - overrides the global `ErrorHandler` with the AllStak handler;
+ *   - force-instantiates {@link TraceService} so router navigation spans open;
+ *   - exposes {@link TraceDirective} via {@link AllStakTraceModule}.
+ *
+ * Call `forRoot` exactly once, in your root module. Feature modules that only
+ * need the `[trace]` directive can import {@link AllStakTraceModule} directly.
+ */
+class AllStakModule {
+    // Inject TraceService here so importing the module force-instantiates it and
+    // its Router subscription runs. `@Optional` keeps router-less apps working.
+    constructor(_trace) { }
+    static forRoot(config) {
+        return {
+            ngModule: AllStakModule,
+            providers: [
+                { provide: ALLSTAK_CONFIG, useValue: config },
+                { provide: ErrorHandler, useValue: createErrorHandler() },
+                TraceService,
+                {
+                    provide: APP_INITIALIZER,
+                    multi: true,
+                    useFactory: appInitializerFactory,
+                    deps: [ALLSTAK_CONFIG, TraceService],
+                },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakModule, deps: [{ token: TraceService, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AllStakModule, imports: [AllStakTraceModule], exports: [AllStakTraceModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakModule, imports: [AllStakTraceModule, AllStakTraceModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AllStakModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AllStakTraceModule],
+                    exports: [AllStakTraceModule],
+                }]
+        }], ctorParameters: () => [{ type: TraceService, decorators: [{
+                    type: Optional
+                }] }] });
+/**
+ * `APP_INITIALIZER` factory: initialises the SDK from the injected config and
+ * touches `TraceService` so it is constructed (its constructor wires the
+ * Router subscription). Declared as a named function so ng-packagr's partial
+ * compiler can statically reference it (no arrow-in-decorator-metadata error).
+ */
+function appInitializerFactory(config, 
+// TraceService is injected via `deps` purely to force its construction.
+_trace) {
+    return () => {
+        init(config);
+    };
+}
+
+/**
+ * AllStak for Angular.
+ *
+ * Public surface:
+ *   - `init`                              — bootstrap (delegates to @allstak/js with Angular tagging)
+ *   - `createErrorHandler` / `AllStakErrorHandler` — Angular `ErrorHandler` forwarding to captureException
+ *   - `AllStakHttpInterceptor` / `allStakHttpInterceptor` — records outbound requests + opens spans
+ *   - `TraceService`                      — Router-aware navigation span instrumentation
+ *   - `TraceDirective` / `AllStakTraceModule` — `[trace]` component render-timing directive
+ *   - `TraceClassDecorator` / `TraceMethodDecorator` — lifecycle-span decorators
+ *   - `provideAllStak` / `provideAllStakErrorHandler` / `provideAllStakRouterInstrumentation`
+ *                                          — standalone provider functions
+ *   - `AllStakModule.forRoot(config)`     — NgModule registration for module-based apps
+ *   - re-exports                          — every top-level @allstak/js export
+ */
+// Bootstrap.
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ALLSTAK_CONFIG, AllStakErrorHandler, AllStakHttpInterceptor, AllStakModule, AllStakTraceModule, SDK_NAME, SDK_VERSION, TraceClass, TraceClassDecorator, TraceDirective, TraceMethod, TraceMethodDecorator, TraceService, allStakHttpInterceptor, appInitializerFactory, createErrorHandler, init, provideAllStak, provideAllStakErrorHandler, provideAllStakRouterInstrumentation };
+//# sourceMappingURL=allstak-angular.mjs.map