@indesad/observability-angular 0.0.0-stage → 1.1.1

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @indesad/observability-angular
+
+SDK de navegador para IndeFlow Observabilidad. Captura errores no controlados y los envía a IndeFlow con
+navegador, sistema operativo, URL, release y la secuencia de clics y páginas previa al error.
+No depende de Angular: sirve igual en React, Vue o JavaScript puro.
+
+## Instalación
+
+Paquete oficial de INDESAD en npm:
+
+```bash
+npm install @indesad/observability-angular@1.1.1
+```
+
+## Uso en Angular
+
+```ts
+// app.config.ts
+import { ApplicationConfig, ErrorHandler } from '@angular/core';
+import { createIndeFlowObservabilityClient, IndeFlowErrorHandler } from '@indesad/observability-angular';
+
+export const observability = createIndeFlowObservabilityClient({
+  sourceToken: 'if_obs_...',      // token de la fuente: Proyecto → Observabilidad → fuente → Tokens
+  environment: 'production',
+  release: 'mi-app@1.4.0'
+});
+
+export const appConfig: ApplicationConfig = {
+  providers: [{ provide: ErrorHandler, useValue: new IndeFlowErrorHandler(observability) }]
+};
+```
+
+## Uso sin Angular
+
+```ts
+import { createIndeFlowObservabilityClient } from '@indesad/observability-angular';
+
+const observability = createIndeFlowObservabilityClient({ sourceToken: 'if_obs_...', release: 'mi-app@1.4.0' });
+
+try { riesgoso(); } catch (error) { observability.captureException(error); }
+```
+
+## Opciones
+
+| Opción | Por defecto | Qué hace |
+| --- | --- | --- |
+| `sourceToken` | — | Token de la fuente. Si llega después del arranque, usa `client.configure({ sourceToken })`. |
+| `ingestEndpoint` | `https://api.indeflow.app/api/v1/ingest/events` | Destino de los eventos. |
+| `environment` | `production` | Ambiente informado en cada evento. |
+| `release` | `1.0.0` | Versión de tu app; permite saber en qué release apareció un error. |
+| `sampleRate` | `1.0` | Fracción de errores enviados. |
+| `captureInteractions` | `true` | Registra clics, campos tocados y páginas visitadas del último minuto. |
+| `queueCapacity` | `100` | Eventos en espera; al llenarse se descartan sin afectar a la app. |
+
+## Privacidad
+
+- Nunca se envía el valor de un campo: solo qué campo se tocó.
+- De los clics se envía el control (`button#guardar`) y la etiqueta visible solo de botones, enlaces, pestañas y
+  elementos de menú; nunca el contenido de tablas, textos o formularios.
+- Para excluir una zona completa: `class="block-replay"` o el atributo `data-block-replay`.
+- De la navegación se envía la ruta, sin parámetros de consulta.
+- El SDK nunca lanza errores ni bloquea la interfaz: si IndeFlow no responde, el evento se pierde en silencio.
+
+## Trazas HTTP
+
+`handleHttpRequestTrace` y `handleHttpResponseError` agregan la cabecera W3C `traceparent` y reportan respuestas 5xx.
+Úsalos desde un interceptor HTTP si quieres correlacionar el error del navegador con el de tu API.

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+import type { IndeFlowAngularOptions, IndeFlowBrowserEvent } from './types';
+import type { IndeFlowSessionReplay } from './replay';
+export declare const DEFAULT_INGEST_ENDPOINT = "https://api.indeflow.app/api/v1/ingest/events";
+export declare class IndeFlowBrowserClient {
+    private options;
+    private breadcrumbs;
+    private queue;
+    private isFlushing;
+    private droppedEvents;
+    private enqueuedEvents;
+    private interactionTrail;
+    constructor(options: IndeFlowAngularOptions);
+    /** Update settings that arrive after startup (for example a token fetched at runtime). Flushes anything queued. */
+    configure(update: Partial<IndeFlowAngularOptions>): void;
+    get isConfigured(): boolean;
+    /** Clicks, field focus and navigation recorded by the trail travel with every captured error. */
+    attachInteractionTrail(trail: IndeFlowSessionReplay | null): void;
+    private collectBreadcrumbs;
+    get droppedCount(): number;
+    get enqueuedCount(): number;
+    addBreadcrumb(category: string, message: string, level?: 'info' | 'warning' | 'error', data?: Record<string, string>): void;
+    captureException(error: unknown, additionalContext?: Partial<IndeFlowBrowserEvent>): void;
+    private resolveCulprit;
+    private detectBrowser;
+    private detectOs;
+    private scheduleFlush;
+    private flushQueue;
+}

package/dist/error-handler.d.ts

@@ -0,0 +1,10 @@
+import { IndeFlowBrowserClient } from './client';
+export interface ErrorHandlerInterface {
+    handleError(error: unknown): void;
+}
+export declare class IndeFlowErrorHandler implements ErrorHandlerInterface {
+    private client;
+    constructor(client: IndeFlowBrowserClient);
+    handleError(error: unknown): void;
+}
+export declare function initGlobalErrorListeners(client: IndeFlowBrowserClient): () => void;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './types';
+export * from './client';
+export * from './error-handler';
+export * from './interceptor';
+export * from './replay';
+import { IndeFlowBrowserClient } from './client';
+import type { IndeFlowAngularOptions } from './types';
+export declare const SDK_VERSION = "1.1.1";
+/**
+ * Creates the client, listens for uncaught errors and (unless captureInteractions is false)
+ * records the trail of clicks and navigation that is attached to each error.
+ */
+export declare function createIndeFlowObservabilityClient(options: IndeFlowAngularOptions): IndeFlowBrowserClient;

package/dist/index.js

@@ -0,0 +1,449 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// packages/angular/observability-angular/src/client.ts
+var DEFAULT_INGEST_ENDPOINT = "https://api.indeflow.app/api/v1/ingest/events";
+var IndeFlowBrowserClient = class {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "breadcrumbs", []);
+    __publicField(this, "queue", []);
+    __publicField(this, "isFlushing", false);
+    __publicField(this, "droppedEvents", 0);
+    __publicField(this, "enqueuedEvents", 0);
+    __publicField(this, "interactionTrail", null);
+    this.options = {
+      ingestEndpoint: options.ingestEndpoint || DEFAULT_INGEST_ENDPOINT,
+      sourceToken: options.sourceToken || "",
+      environment: options.environment || "production",
+      release: options.release || "1.0.0",
+      sampleRate: options.sampleRate ?? 1,
+      maxBreadcrumbs: options.maxBreadcrumbs ?? 25,
+      queueCapacity: options.queueCapacity ?? 100,
+      maskAllInputs: options.maskAllInputs ?? true,
+      enableHttpTracking: options.enableHttpTracking ?? true,
+      enableRoutingTracking: options.enableRoutingTracking ?? true,
+      captureInteractions: options.captureInteractions ?? true
+    };
+  }
+  /** Update settings that arrive after startup (for example a token fetched at runtime). Flushes anything queued. */
+  configure(update) {
+    for (const [key, value] of Object.entries(update)) {
+      if (value !== void 0 && value !== null && value !== "") {
+        this.options[key] = value;
+      }
+    }
+    if (this.queue.length > 0) this.scheduleFlush();
+  }
+  get isConfigured() {
+    return !!this.options.sourceToken;
+  }
+  /** Clicks, field focus and navigation recorded by the trail travel with every captured error. */
+  attachInteractionTrail(trail) {
+    this.interactionTrail = trail;
+  }
+  collectBreadcrumbs() {
+    const merged = [...this.breadcrumbs];
+    if (this.interactionTrail) {
+      for (const step of this.interactionTrail.getTrail(60)) {
+        merged.push({ timestampUtc: new Date(step.timestamp).toISOString(), category: step.category, message: step.message, level: "info" });
+      }
+    }
+    merged.sort((a, b) => a.timestampUtc.localeCompare(b.timestampUtc));
+    return merged.slice(-40);
+  }
+  get droppedCount() {
+    return this.droppedEvents;
+  }
+  get enqueuedCount() {
+    return this.enqueuedEvents;
+  }
+  addBreadcrumb(category, message, level = "info", data) {
+    if (this.breadcrumbs.length >= this.options.maxBreadcrumbs) {
+      this.breadcrumbs.shift();
+    }
+    this.breadcrumbs.push({
+      timestampUtc: (/* @__PURE__ */ new Date()).toISOString(),
+      category,
+      message,
+      level,
+      data
+    });
+  }
+  captureException(error, additionalContext) {
+    if (Math.random() > this.options.sampleRate) return;
+    try {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const eventId = `evt_js_${Math.random().toString(36).substring(2, 10)}${Date.now().toString(36)}`;
+      const stack = err.stack || "";
+      const culprit = this.resolveCulprit(stack) || err.name;
+      const event = {
+        eventId,
+        timestampUtc: (/* @__PURE__ */ new Date()).toISOString(),
+        platform: "angular",
+        runtime: "V8 / Browser",
+        level: "error",
+        exceptionType: err.name || "Error",
+        culprit,
+        message: err.message || "Unknown javascript error",
+        stackTrace: stack,
+        tags: {
+          runtime: "browser",
+          angular: "true"
+        },
+        breadcrumbs: this.collectBreadcrumbs(),
+        environment: this.options.environment,
+        release: this.options.release,
+        url: typeof window !== "undefined" ? window.location?.href || "/" : "/",
+        deviceBrowser: this.detectBrowser(),
+        deviceOs: this.detectOs(),
+        viewport: typeof window !== "undefined" ? `${window.innerWidth}x${window.innerHeight}` : void 0,
+        ...additionalContext
+      };
+      if (this.queue.length >= this.options.queueCapacity) {
+        this.droppedEvents++;
+        return;
+      }
+      this.queue.push(event);
+      this.enqueuedEvents++;
+      this.scheduleFlush();
+    } catch {
+    }
+  }
+  resolveCulprit(stack) {
+    if (!stack) return "unknown";
+    const lines = stack.split("\n");
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line && !line.includes("observability-angular") && !line.includes("zone.js")) {
+        return line.replace(/^at\s+/, "").trim();
+      }
+    }
+    return lines[1] ? lines[1].trim() : "window.onerror";
+  }
+  detectBrowser() {
+    if (typeof navigator === "undefined") return "Node / SSR";
+    const ua = navigator.userAgent;
+    const version = (pattern) => {
+      const m = ua.match(pattern);
+      return m ? ` ${m[1]}` : "";
+    };
+    if (ua.includes("Edg/")) return `Edge${version(/Edg\/(\d+)/)}`;
+    if (ua.includes("OPR/")) return `Opera${version(/OPR\/(\d+)/)}`;
+    if (ua.includes("Firefox/")) return `Firefox${version(/Firefox\/(\d+)/)}`;
+    if (ua.includes("Chrome/")) return `Chrome${version(/Chrome\/(\d+)/)}`;
+    if (ua.includes("Safari/")) return `Safari${version(/Version\/(\d+)/)}`;
+    return "Browser";
+  }
+  detectOs() {
+    if (typeof navigator === "undefined") return "Server";
+    const ua = navigator.userAgent;
+    const mobile = /Mobi|Android|iPhone|iPad/.test(ua) ? " (mobile)" : "";
+    if (ua.includes("Android")) return `Android${mobile}`;
+    if (ua.includes("iPhone") || ua.includes("iPad")) return `iOS${mobile}`;
+    if (ua.includes("Windows")) return "Windows";
+    if (ua.includes("Mac")) return "macOS";
+    if (ua.includes("Linux")) return "Linux";
+    return "Unknown OS";
+  }
+  scheduleFlush() {
+    if (this.isFlushing) return;
+    this.isFlushing = true;
+    const defer = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => setTimeout(fn, 0);
+    defer(() => {
+      this.flushQueue().finally(() => {
+        this.isFlushing = false;
+      });
+    });
+  }
+  async flushQueue() {
+    if (this.queue.length === 0 || !this.options.sourceToken) return;
+    const eventsToSend = this.queue.splice(0, 25);
+    const body = JSON.stringify(eventsToSend.length === 1 ? eventsToSend[0] : eventsToSend);
+    try {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" && eventsToSend.length === 1) {
+        const blob = new Blob([body], { type: "application/json" });
+      }
+      if (typeof fetch === "function") {
+        await fetch(this.options.ingestEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-IndeFlow-Source-Token": this.options.sourceToken
+          },
+          body,
+          keepalive: true
+        });
+      }
+    } catch {
+    }
+  }
+};
+
+// packages/angular/observability-angular/src/error-handler.ts
+var IndeFlowErrorHandler = class {
+  constructor(client) {
+    __publicField(this, "client");
+    this.client = client;
+  }
+  handleError(error) {
+    try {
+      this.client.captureException(error);
+    } catch {
+    }
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(error);
+    }
+  }
+};
+function initGlobalErrorListeners(client) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const isHttpResponse = (value) => typeof value === "object" && value !== null && !(value instanceof Error) && typeof value.status === "number" && "url" in value;
+  const isResizeObserverNotice = (message) => typeof message === "string" && message.includes("ResizeObserver loop");
+  const onErrorHandler = (event) => {
+    if (isHttpResponse(event.error) || isResizeObserverNotice(event.message)) return;
+    client.captureException(event.error || event.message, {
+      culprit: event.filename ? `${event.filename}:${event.lineno}:${event.colno}` : "window.onerror",
+      message: event.message || "Uncaught error"
+    });
+  };
+  const onUnhandledRejection = (event) => {
+    if (isHttpResponse(event.reason)) return;
+    client.captureException(event.reason, {
+      culprit: "UnhandledPromiseRejection",
+      message: event.reason instanceof Error ? event.reason.message : String(event.reason)
+    });
+  };
+  window.addEventListener("error", onErrorHandler);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onErrorHandler);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+
+// packages/angular/observability-angular/src/interceptor.ts
+function generateW3CTraceparent() {
+  const bytes = new Uint8Array(24);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 24; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  const toHex = (buf) => Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const traceId = toHex(bytes.slice(0, 16));
+  const spanId = toHex(bytes.slice(16, 24));
+  const traceparent = `00-${traceId}-${spanId}-01`;
+  return { traceparent, traceId, spanId };
+}
+function handleHttpRequestTrace(client, req) {
+  const { traceparent, traceId, spanId } = generateW3CTraceparent();
+  const headers = req.headers.set("traceparent", traceparent);
+  const cloned = req.clone({ headers });
+  client.addBreadcrumb("http", `${req.method.toUpperCase()} ${req.url}`, "info", {
+    traceId,
+    spanId
+  });
+  return { req: cloned, traceId, spanId };
+}
+function handleHttpResponseError(client, req, status, statusText, errorBody, traceId, spanId) {
+  const isServerError = status >= 500 || status === 0;
+  const level = isServerError ? "error" : "warning";
+  client.addBreadcrumb("http", `${req.method.toUpperCase()} ${req.url} [${status} ${statusText}]`, level, {
+    status: String(status),
+    statusText,
+    traceId: traceId || ""
+  });
+  if (isServerError) {
+    const errorMsg = `HTTP ${req.method.toUpperCase()} ${req.url} failed with status ${status}: ${statusText}`;
+    client.captureException(new Error(errorMsg), {
+      culprit: `${req.method.toUpperCase()} ${req.url}`,
+      message: errorMsg,
+      level: "error",
+      httpMethod: req.method,
+      httpStatusCode: status,
+      traceId,
+      spanId
+    });
+  }
+}
+
+// packages/angular/observability-angular/src/replay.ts
+var CONTROL_SELECTOR = 'button, a, [role="button"], [role="tab"], [role="menuitem"], [role="link"], [role="option"], summary, label, input[type="submit"], input[type="button"]';
+var IndeFlowSessionReplay = class {
+  constructor(options = {}) {
+    __publicField(this, "buffer", []);
+    __publicField(this, "sessionId");
+    __publicField(this, "maxDurationMs");
+    __publicField(this, "maskAllInputs");
+    __publicField(this, "blockSelector");
+    __publicField(this, "captureControlLabels");
+    __publicField(this, "isRecording", false);
+    __publicField(this, "cleanupListeners", []);
+    this.sessionId = `rep_${Math.random().toString(36).substring(2, 10)}_${Date.now().toString(36)}`;
+    this.maxDurationMs = (options.maxBufferDurationSeconds ?? 60) * 1e3;
+    this.maskAllInputs = options.maskAllInputs ?? true;
+    this.blockSelector = options.blockSelector ?? ".if-block, [data-if-block], .block-replay, [data-block-replay]";
+    this.captureControlLabels = options.captureControlLabels ?? true;
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  start() {
+    if (this.isRecording || typeof window === "undefined") return;
+    this.isRecording = true;
+    this.recordEvent({
+      timestamp: Date.now(),
+      type: "snapshot",
+      data: {
+        url: window.location?.href || "/",
+        viewport: `${window.innerWidth}x${window.innerHeight}`,
+        title: document.title
+      }
+    });
+    const clickHandler = (e) => {
+      const target = e.target;
+      if (!target || this.isBlocked(target)) return;
+      const control = target.closest ? target.closest(CONTROL_SELECTOR) : null;
+      const el = control ?? target;
+      this.recordEvent({
+        timestamp: Date.now(),
+        type: "click",
+        target: this.describe(el),
+        data: { text: control && this.captureControlLabels ? this.controlLabel(control) : "" }
+      });
+    };
+    const inputHandler = (e) => {
+      const target = e.target;
+      if (!target) return;
+      const type = (target.getAttribute("type") || "").toLowerCase();
+      const isPassword = type === "password";
+      const isSensitiveName = /card|cvc|cvv|pass|token|secret|pin/i.test(target.name || target.id || "");
+      const value = isPassword || isSensitiveName || this.maskAllInputs ? "***" : target.value ? target.value.substring(0, 50) : "";
+      const inputTarget = `${target.tagName.toLowerCase()}${target.id ? "#" + target.id : target.name ? `[name=${target.name}]` : ""}`;
+      const last = this.buffer[this.buffer.length - 1];
+      if (last && last.type === "input" && last.target === inputTarget) {
+        last.timestamp = Date.now();
+        return;
+      }
+      this.recordEvent({
+        timestamp: Date.now(),
+        type: "input",
+        target: inputTarget,
+        data: {
+          inputType: type,
+          maskedValue: value
+        }
+      });
+    };
+    let lastPath = window.location?.pathname || "/";
+    const navigationHandler = () => {
+      const path = window.location?.pathname || "/";
+      if (path === lastPath) return;
+      lastPath = path;
+      this.recordEvent({ timestamp: Date.now(), type: "navigation", data: { to: path } });
+    };
+    const navigationPoll = setInterval(navigationHandler, 1e3);
+    window.addEventListener("click", clickHandler, { capture: true, passive: true });
+    window.addEventListener("input", inputHandler, { capture: true, passive: true });
+    window.addEventListener("popstate", navigationHandler);
+    this.cleanupListeners.push(() => {
+      clearInterval(navigationPoll);
+      window.removeEventListener("click", clickHandler, { capture: true });
+      window.removeEventListener("input", inputHandler, { capture: true });
+      window.removeEventListener("popstate", navigationHandler);
+    });
+  }
+  describe(el) {
+    const tag = el.tagName.toLowerCase();
+    const id = el.id ? `#${el.id}` : "";
+    const testId = el.getAttribute("data-testid") || el.getAttribute("data-test");
+    const role = el.getAttribute("role");
+    const name = !id && el.getAttribute("name") ? `[name=${el.getAttribute("name")}]` : "";
+    return `${tag}${id}${name}${role ? `[role=${role}]` : ""}${testId ? `[testid=${testId}]` : ""}`.substring(0, 120);
+  }
+  controlLabel(el) {
+    const raw = el.getAttribute("aria-label") || el.getAttribute("title") || el.value || el.innerText || "";
+    return raw.replace(/\s+/g, " ").trim().substring(0, 40);
+  }
+  stop() {
+    this.isRecording = false;
+    for (const cleanup of this.cleanupListeners) {
+      cleanup();
+    }
+    this.cleanupListeners = [];
+  }
+  recordEvent(event) {
+    const now = Date.now();
+    this.buffer.push(event);
+    const cutoff = now - this.maxDurationMs;
+    while (this.buffer.length > 0 && this.buffer[0].timestamp < cutoff) {
+      this.buffer.shift();
+    }
+  }
+  getRecentEvents(secondsBeforeNow = 30) {
+    const cutoff = Date.now() - secondsBeforeNow * 1e3;
+    return this.buffer.filter((e) => e.timestamp >= cutoff);
+  }
+  getAllEvents() {
+    return [...this.buffer];
+  }
+  /** The recent trail as readable steps, ready to travel inside the error event. */
+  getTrail(secondsBeforeNow = 60) {
+    return this.getRecentEvents(secondsBeforeNow).map((e) => {
+      if (e.type === "click") {
+        const label = e.data && typeof e.data["text"] === "string" && e.data["text"] ? ` "${e.data["text"]}"` : "";
+        return { timestamp: e.timestamp, category: "ui.click", message: `${e.target || "element"}${label}` };
+      }
+      if (e.type === "input") {
+        return { timestamp: e.timestamp, category: "ui.input", message: `${e.target || "field"} (value hidden)` };
+      }
+      if (e.type === "navigation") {
+        return { timestamp: e.timestamp, category: "navigation", message: String(e.data && e.data["to"] || "/") };
+      }
+      if (e.type === "snapshot") {
+        const url = String(e.data && e.data["url"] || "/").split("?")[0];
+        return { timestamp: e.timestamp, category: "page", message: `${url} ${String(e.data && e.data["viewport"] || "")}`.trim() };
+      }
+      return { timestamp: e.timestamp, category: e.type, message: e.target || e.type };
+    });
+  }
+  isBlocked(el) {
+    if (el.matches && el.matches(this.blockSelector)) return true;
+    if (el.closest && el.closest(this.blockSelector)) return true;
+    return false;
+  }
+};
+
+// packages/angular/observability-angular/src/index.ts
+var SDK_VERSION = "1.1.1";
+function createIndeFlowObservabilityClient(options) {
+  const client = new IndeFlowBrowserClient(options);
+  if (typeof window !== "undefined") {
+    initGlobalErrorListeners(client);
+    if (options.captureInteractions !== false) {
+      const trail = new IndeFlowSessionReplay({ maskAllInputs: options.maskAllInputs ?? true });
+      trail.start();
+      client.attachInteractionTrail(trail);
+    }
+  }
+  return client;
+}
+export {
+  DEFAULT_INGEST_ENDPOINT,
+  IndeFlowBrowserClient,
+  IndeFlowErrorHandler,
+  IndeFlowSessionReplay,
+  SDK_VERSION,
+  createIndeFlowObservabilityClient,
+  generateW3CTraceparent,
+  handleHttpRequestTrace,
+  handleHttpResponseError,
+  initGlobalErrorListeners
+};

package/dist/interceptor.d.ts

@@ -0,0 +1,26 @@
+import { IndeFlowBrowserClient } from './client';
+export declare function generateW3CTraceparent(): {
+    traceparent: string;
+    traceId: string;
+    spanId: string;
+};
+export interface HttpRequestLike {
+    url: string;
+    method: string;
+    headers: {
+        set(name: string, value: string): HttpRequestLike['headers'];
+        get?(name: string): string | null;
+    };
+    clone(update: {
+        headers: HttpRequestLike['headers'];
+    }): HttpRequestLike;
+}
+export declare function handleHttpRequestTrace(client: IndeFlowBrowserClient, req: HttpRequestLike): {
+    req: HttpRequestLike;
+    traceId: string;
+    spanId: string;
+};
+export declare function handleHttpResponseError(client: IndeFlowBrowserClient, req: {
+    method: string;
+    url: string;
+}, status: number, statusText: string, errorBody?: unknown, traceId?: string, spanId?: string): void;

package/dist/replay.d.ts

@@ -0,0 +1,40 @@
+export interface ReplayOptions {
+    maskAllInputs?: boolean;
+    blockSelector?: string;
+    maxBufferDurationSeconds?: number;
+    sampleRate?: number;
+    /** Capture the visible label of buttons, links, tabs and menu items (never of inputs or free content). Default true. */
+    captureControlLabels?: boolean;
+}
+export interface ReplayEvent {
+    timestamp: number;
+    type: 'snapshot' | 'mutation' | 'click' | 'input' | 'navigation' | 'error';
+    target?: string;
+    data?: Record<string, unknown>;
+}
+export declare class IndeFlowSessionReplay {
+    private buffer;
+    private sessionId;
+    private maxDurationMs;
+    private maskAllInputs;
+    private blockSelector;
+    private captureControlLabels;
+    private isRecording;
+    private cleanupListeners;
+    constructor(options?: ReplayOptions);
+    get currentSessionId(): string;
+    start(): void;
+    private describe;
+    private controlLabel;
+    stop(): void;
+    recordEvent(event: ReplayEvent): void;
+    getRecentEvents(secondsBeforeNow?: number): ReplayEvent[];
+    getAllEvents(): ReplayEvent[];
+    /** The recent trail as readable steps, ready to travel inside the error event. */
+    getTrail(secondsBeforeNow?: number): Array<{
+        timestamp: number;
+        category: string;
+        message: string;
+    }>;
+    private isBlocked;
+}

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+export interface IndeFlowAngularOptions {
+    /** Defaults to https://api.indeflow.app/api/v1/ingest/events */
+    ingestEndpoint?: string;
+    sourceToken: string;
+    environment?: string;
+    release?: string;
+    sampleRate?: number;
+    maxBreadcrumbs?: number;
+    queueCapacity?: number;
+    maskAllInputs?: boolean;
+    enableHttpTracking?: boolean;
+    enableRoutingTracking?: boolean;
+    /** Record the sequence of clicks, fields touched and pages visited before an error. Default true. */
+    captureInteractions?: boolean;
+}
+export interface IndeFlowBreadcrumb {
+    timestampUtc: string;
+    category: string;
+    message: string;
+    level?: 'info' | 'warning' | 'error';
+    data?: Record<string, string>;
+}
+export interface IndeFlowBrowserEvent {
+    eventId: string;
+    timestampUtc: string;
+    platform: string;
+    runtime: string;
+    level: 'error' | 'warning' | 'info';
+    exceptionType: string;
+    culprit: string;
+    message: string;
+    stackTrace?: string;
+    tags: Record<string, string>;
+    breadcrumbs: IndeFlowBreadcrumb[];
+    traceId?: string;
+    spanId?: string;
+    environment: string;
+    release?: string;
+    url: string;
+    deviceBrowser?: string;
+    deviceOs?: string;
+    viewport?: string;
+    userIdentifierMasked?: string;
+    httpMethod?: string;
+    httpStatusCode?: number;
+    durationMs?: number;
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@indesad/observability-angular",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "description": "Official Angular & Browser Observability SDK for IndeFlow with fail-open error handling, W3C trace propagation and private source maps support.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "author": "INDESAD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/INDESAD/IndeFlow.git",
+    "directory": "packages/angular/observability-angular"
+  },
+  "homepage": "https://indeflow.app",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}