@sincpro/mobile 0.3.1 → 0.4.1

package/dist/infrastructure/context_manager/stack_context_manager.d.ts

@@ -0,0 +1,39 @@
+import { Context } from "./context";
+/**
+ * Hermes-compatible context manager.
+ *
+ * Hermes (React Native JS engine) has no AsyncLocalStorage and no native
+ * Promise hooks, so automatic async context propagation is not possible.
+ * This manager uses an explicit stack instead:
+ *
+ * - with(ctx, fn)   — pushes ctx, calls fn synchronously, pops on return.
+ *                     Works correctly for synchronous code and for sequential
+ *                     await chains (where each await resolves before the next
+ *                     call starts).
+ *
+ * - push(ctx) / pop() — manual variant used by before/after interceptor hooks
+ *                     so the context stays active across async boundaries
+ *                     (the push in before() and the pop in after() bracket the
+ *                     entire async method execution, not just the sync part).
+ *
+ * Known limitation: concurrent branches (Promise.all with independent contexts)
+ * share the top of stack. For mobile single-user sequential flows this is
+ * acceptable — document it, never hide it.
+ */
+export declare class StackContextManager {
+    private _stack;
+    active(): Context;
+    with<T>(ctx: Context, fn: () => T): T;
+    /**
+     * Push a context explicitly. Must be paired with pop().
+     * Use when you need the context to survive past a synchronous return,
+     * i.e. inside before/after interceptor hooks for async methods.
+     */
+    push(ctx: Context): void;
+    /**
+     * Pop the top context. Never pops the root — safe to call on empty stacks.
+     */
+    pop(): void;
+    /** @internal — test and framework init use only */
+    reset(): void;
+}

package/dist/infrastructure/context_manager/stack_context_manager.js

@@ -0,0 +1,56 @@
+import { Context } from "./context";
+/**
+ * Hermes-compatible context manager.
+ *
+ * Hermes (React Native JS engine) has no AsyncLocalStorage and no native
+ * Promise hooks, so automatic async context propagation is not possible.
+ * This manager uses an explicit stack instead:
+ *
+ * - with(ctx, fn)   — pushes ctx, calls fn synchronously, pops on return.
+ *                     Works correctly for synchronous code and for sequential
+ *                     await chains (where each await resolves before the next
+ *                     call starts).
+ *
+ * - push(ctx) / pop() — manual variant used by before/after interceptor hooks
+ *                     so the context stays active across async boundaries
+ *                     (the push in before() and the pop in after() bracket the
+ *                     entire async method execution, not just the sync part).
+ *
+ * Known limitation: concurrent branches (Promise.all with independent contexts)
+ * share the top of stack. For mobile single-user sequential flows this is
+ * acceptable — document it, never hide it.
+ */
+export class StackContextManager {
+    _stack = [Context.ROOT];
+    active() {
+        return this._stack[this._stack.length - 1] ?? Context.ROOT;
+    }
+    with(ctx, fn) {
+        this._stack.push(ctx);
+        try {
+            return fn();
+        }
+        finally {
+            this._stack.pop();
+        }
+    }
+    /**
+     * Push a context explicitly. Must be paired with pop().
+     * Use when you need the context to survive past a synchronous return,
+     * i.e. inside before/after interceptor hooks for async methods.
+     */
+    push(ctx) {
+        this._stack.push(ctx);
+    }
+    /**
+     * Pop the top context. Never pops the root — safe to call on empty stacks.
+     */
+    pop() {
+        if (this._stack.length > 1)
+            this._stack.pop();
+    }
+    /** @internal — test and framework init use only */
+    reset() {
+        this._stack = [Context.ROOT];
+    }
+}

package/dist/infrastructure/database/connector.js

@@ -4,7 +4,16 @@ import { openDatabaseAsync, openDatabaseSync, } from "expo-sqlite";
 export const DB_NAME = "distribution.db";
 let dbInstance = null;
 const dbLock = new Mutex();
-const SKIP_LOG_TABLES = ["event_queue", "dead_letter_queue"];
+// Telemetry/queue tables are excluded from query logging: logging their
+// mutations would feed the log pipeline its own writes — and a failing
+// telemetry insert logs at ERROR (always remote), which tries to insert again,
+// amplifying under exactly the offline/full conditions where inserts fail.
+const SKIP_LOG_TABLES = [
+    "event_queue",
+    "dead_letter_queue",
+    "telemetry_queue",
+    "spans_queue",
+];
 function shouldLogQuery(query) {
     const lowerQuery = query.toLowerCase();
     return !SKIP_LOG_TABLES.some((table) => lowerQuery.includes(table));

package/dist/infrastructure/interceptor/index.d.ts

@@ -0,0 +1,4 @@
+export type { InterceptorHooks, MethodCall } from "./intercept";
+export { interceptClass, interceptFunction, interceptInstance } from "./intercept";
+export type { Logger } from "./logging_hooks";
+export { loggingHooks } from "./logging_hooks";

package/dist/infrastructure/interceptor/index.js

@@ -0,0 +1,2 @@
+export { interceptClass, interceptFunction, interceptInstance } from "./intercept";
+export { loggingHooks } from "./logging_hooks";

package/dist/infrastructure/interceptor/intercept.d.ts

@@ -0,0 +1,57 @@
+export interface MethodCall {
+    className: string;
+    methodName: string;
+    args: unknown[];
+}
+export interface InterceptorHooks {
+    before?: (call: MethodCall) => void;
+    after?: (call: MethodCall, result: unknown) => void;
+    onError?: (call: MethodCall, error: unknown) => void;
+}
+/**
+ * Mutates the class prototype so every instance is automatically traced.
+ * Use when the class is instantiated multiple times, or as the implementation
+ * behind a class decorator.
+ *
+ * ```ts
+ * interceptClass(CustomerService, otelHooks());
+ * // all CustomerService instances are now traced
+ *
+ * // as a decorator:
+ * function Traced(hooks: InterceptorHooks) {
+ *   return <T extends new (...args: never[]) => object>(target: T) =>
+ *     interceptClass(target, hooks);
+ * }
+ * @Traced(otelHooks())
+ * class OrderService { ... }
+ * ```
+ *
+ * Throws if called twice on the same class — hooks stack silently otherwise.
+ * Getters, setters, and the constructor are never wrapped.
+ */
+export declare function interceptClass<T extends new (...args: never[]) => object>(target: T, hooks: InterceptorHooks): T;
+/**
+ * Wraps a standalone function. Use for module-level functions or factory outputs.
+ *
+ * ```ts
+ * export const fetchOrders = interceptFunction(rawFetchOrders, otelHooks());
+ * ```
+ *
+ * `MethodCall.className` is empty for standalone functions; `methodName` is the
+ * function's `.name` (or `"anonymous"` if unnamed).
+ */
+export declare function interceptFunction<T extends (...args: never[]) => unknown>(fn: T, hooks: InterceptorHooks): T;
+/**
+ * Wraps a single live instance via Proxy without touching the class prototype.
+ * Use for singletons exported directly (e.g. `dbCursor`, `distributionWorkflows`).
+ *
+ * ```ts
+ * export const dbCursor = interceptInstance(new DBCursor(), otelHooks());
+ * // only this exported instance is traced; other DBCursor instances are unaffected
+ * ```
+ *
+ * Hooks contract: `before` fires before the call; `after` fires on success with
+ * the resolved value; `onError` fires on throw or rejection — the error is always
+ * re-thrown after `onError` completes.
+ */
+export declare function interceptInstance<T extends object>(instance: T, hooks: InterceptorHooks): T;

package/dist/infrastructure/interceptor/intercept.js

@@ -0,0 +1,112 @@
+function isPlainFunction(descriptor) {
+    if (!descriptor)
+        return false;
+    if (typeof descriptor.value !== "function")
+        return false;
+    if (descriptor.get || descriptor.set)
+        return false;
+    return true;
+}
+function wrap(original, className, methodName, hooks) {
+    return function wrapped(...args) {
+        const call = { className, methodName, args };
+        hooks.before?.(call);
+        try {
+            const result = original.apply(this, args);
+            if (result instanceof Promise) {
+                return result.then((value) => {
+                    hooks.after?.(call, value);
+                    return value;
+                }, (error) => {
+                    hooks.onError?.(call, error);
+                    throw error;
+                });
+            }
+            hooks.after?.(call, result);
+            return result;
+        }
+        catch (error) {
+            hooks.onError?.(call, error);
+            throw error;
+        }
+    };
+}
+const INTERCEPTED = Symbol("sincpro.intercepted");
+function ownMethodNames(prototype) {
+    return Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+}
+/**
+ * Mutates the class prototype so every instance is automatically traced.
+ * Use when the class is instantiated multiple times, or as the implementation
+ * behind a class decorator.
+ *
+ * ```ts
+ * interceptClass(CustomerService, otelHooks());
+ * // all CustomerService instances are now traced
+ *
+ * // as a decorator:
+ * function Traced(hooks: InterceptorHooks) {
+ *   return <T extends new (...args: never[]) => object>(target: T) =>
+ *     interceptClass(target, hooks);
+ * }
+ * @Traced(otelHooks())
+ * class OrderService { ... }
+ * ```
+ *
+ * Throws if called twice on the same class — hooks stack silently otherwise.
+ * Getters, setters, and the constructor are never wrapped.
+ */
+export function interceptClass(target, hooks) {
+    if (target[INTERCEPTED]) {
+        throw new Error(`interceptClass: ${target.name} is already intercepted`);
+    }
+    const prototype = target.prototype;
+    for (const methodName of ownMethodNames(prototype)) {
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+        if (!isPlainFunction(descriptor))
+            continue;
+        const original = descriptor.value;
+        descriptor.value = wrap(original, target.name, methodName, hooks);
+        Object.defineProperty(prototype, methodName, descriptor);
+    }
+    Object.defineProperty(target, INTERCEPTED, { value: true, enumerable: false });
+    return target;
+}
+/**
+ * Wraps a standalone function. Use for module-level functions or factory outputs.
+ *
+ * ```ts
+ * export const fetchOrders = interceptFunction(rawFetchOrders, otelHooks());
+ * ```
+ *
+ * `MethodCall.className` is empty for standalone functions; `methodName` is the
+ * function's `.name` (or `"anonymous"` if unnamed).
+ */
+export function interceptFunction(fn, hooks) {
+    return wrap(fn, "", fn.name || "anonymous", hooks);
+}
+/**
+ * Wraps a single live instance via Proxy without touching the class prototype.
+ * Use for singletons exported directly (e.g. `dbCursor`, `distributionWorkflows`).
+ *
+ * ```ts
+ * export const dbCursor = interceptInstance(new DBCursor(), otelHooks());
+ * // only this exported instance is traced; other DBCursor instances are unaffected
+ * ```
+ *
+ * Hooks contract: `before` fires before the call; `after` fires on success with
+ * the resolved value; `onError` fires on throw or rejection — the error is always
+ * re-thrown after `onError` completes.
+ */
+export function interceptInstance(instance, hooks) {
+    const className = instance.constructor?.name ?? "Object";
+    return new Proxy(instance, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value !== "function" || typeof prop === "symbol") {
+                return value;
+            }
+            return wrap(value, className, prop, hooks).bind(target);
+        },
+    });
+}

package/dist/infrastructure/interceptor/logging_hooks.d.ts

@@ -0,0 +1,22 @@
+import type { InterceptorHooks } from "./intercept";
+/** Minimal logger contract — compatible with the framework's ILogger and any custom logger. */
+export interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * Produces `InterceptorHooks` that log every method call through the given logger.
+ *
+ * - `before`  → debug: method entry with class and method name
+ * - `after`   → info:  method exited successfully
+ * - `onError` → error: method threw or rejected, includes the error
+ *
+ * Args and return values are intentionally not logged to avoid leaking sensitive data.
+ *
+ * ```ts
+ * interceptClass(DistributionWorkflowsImp, loggingHooks(loggerUseCases));
+ * interceptInstance(dbCursor, loggingHooks(loggerRepositories));
+ * ```
+ */
+export declare function loggingHooks(logger: Logger): InterceptorHooks;

package/dist/infrastructure/interceptor/logging_hooks.js

@@ -0,0 +1,27 @@
+/**
+ * Produces `InterceptorHooks` that log every method call through the given logger.
+ *
+ * - `before`  → debug: method entry with class and method name
+ * - `after`   → info:  method exited successfully
+ * - `onError` → error: method threw or rejected, includes the error
+ *
+ * Args and return values are intentionally not logged to avoid leaking sensitive data.
+ *
+ * ```ts
+ * interceptClass(DistributionWorkflowsImp, loggingHooks(loggerUseCases));
+ * interceptInstance(dbCursor, loggingHooks(loggerRepositories));
+ * ```
+ */
+export function loggingHooks(logger) {
+    return {
+        before(call) {
+            logger.debug(`→ ${call.className}.${call.methodName}`);
+        },
+        after(call) {
+            logger.info(`✓ ${call.className}.${call.methodName}`);
+        },
+        onError(call, error) {
+            logger.error(`✗ ${call.className}.${call.methodName}`, error);
+        },
+    };
+}

package/dist/infrastructure/logger.d.ts

@@ -5,21 +5,16 @@ interface ILogger {
     warn(...args: LoggerArgs): void;
     error(...args: LoggerArgs): void;
 }
-declare enum ELogLevel {
-    DEBUG = "DEBUG",
-    INFO = "INFO",
-    WARN = "WARN",
-    ERROR = "ERROR"
-}
-declare enum EApplicationLogger {
-    GLOBAL = "GLOBAL",
-    ODOO_CLIENT = "ODOO_CLIENT",
-    ADAPTER = "ADAPTER",
-    REPOSITORIES = "REPOSITORIES",
-    USE_CASES = "USE_CASES",
-    QUEUE_PROCESSOR = "EVENT_BUS",
-    CRON_JOBS = "CRON_JOBS"
-}
+declare const EApplicationLogger: {
+    readonly GLOBAL: "GLOBAL";
+    readonly ODOO_CLIENT: "ODOO_CLIENT";
+    readonly ADAPTER: "ADAPTER";
+    readonly REPOSITORIES: "REPOSITORIES";
+    readonly USE_CASES: "USE_CASES";
+    readonly QUEUE_PROCESSOR: "EVENT_BUS";
+    readonly CRON_JOBS: "CRON_JOBS";
+};
+type EApplicationLogger = (typeof EApplicationLogger)[keyof typeof EApplicationLogger];
 /**
  * Production flag - manually toggle to disable all logs
  * Set to true to disable logging, false to enable
@@ -28,7 +23,7 @@ export declare const IS_PRODUCTION = false;
 /**
  * Global log level for the application.
  */
-export declare const LOG_LEVEL = ELogLevel.INFO;
+export declare const LOG_LEVEL: "INFO";
 /**
  * Configuration for enabling or disabling logs for specific application contexts.
  */

package/dist/infrastructure/logger.js

@@ -1,3 +1,5 @@
+import { getLokiClient } from "./telemetry/logging/loki_registry";
+import { activeTraceLabel } from "./telemetry/tracing/active_span";
 // ANSI color codes for terminal output
 const Colors = {
     Reset: "\x1b[0m",
@@ -15,23 +17,21 @@ const Colors = {
     BrightYellow: "\x1b[93m",
     White: "\x1b[37m",
 };
-var ELogLevel;
-(function (ELogLevel) {
-    ELogLevel["DEBUG"] = "DEBUG";
-    ELogLevel["INFO"] = "INFO";
-    ELogLevel["WARN"] = "WARN";
-    ELogLevel["ERROR"] = "ERROR";
-})(ELogLevel || (ELogLevel = {}));
-var EApplicationLogger;
-(function (EApplicationLogger) {
-    EApplicationLogger["GLOBAL"] = "GLOBAL";
-    EApplicationLogger["ODOO_CLIENT"] = "ODOO_CLIENT";
-    EApplicationLogger["ADAPTER"] = "ADAPTER";
-    EApplicationLogger["REPOSITORIES"] = "REPOSITORIES";
-    EApplicationLogger["USE_CASES"] = "USE_CASES";
-    EApplicationLogger["QUEUE_PROCESSOR"] = "EVENT_BUS";
-    EApplicationLogger["CRON_JOBS"] = "CRON_JOBS";
-})(EApplicationLogger || (EApplicationLogger = {}));
+const ELogLevel = {
+    DEBUG: "DEBUG",
+    INFO: "INFO",
+    WARN: "WARN",
+    ERROR: "ERROR",
+};
+const EApplicationLogger = {
+    GLOBAL: "GLOBAL",
+    ODOO_CLIENT: "ODOO_CLIENT",
+    ADAPTER: "ADAPTER",
+    REPOSITORIES: "REPOSITORIES",
+    USE_CASES: "USE_CASES",
+    QUEUE_PROCESSOR: "EVENT_BUS",
+    CRON_JOBS: "CRON_JOBS",
+};
 /**
  * Color mapping for each logger context
  */
@@ -93,6 +93,9 @@ class BaseLogger {
         if (this.shouldLog(level)) {
             this.output(method, level, args);
         }
+        // Remote push is independent of console filters — IS_PRODUCTION and ENABLED_LOGS
+        // control console verbosity, not what reaches Loki in production.
+        this.pushRemote(level, args);
     }
     shouldLog(level) {
         if (IS_PRODUCTION)
@@ -105,17 +108,57 @@ class BaseLogger {
             return false;
         return true;
     }
+    /**
+     * Remote logging filter — intentionally decoupled from console config.
+     * ERROR and WARN always reach Loki (production incidents must be observable).
+     * INFO reaches Loki only for enabled contexts (avoids noise from disabled ones).
+     * DEBUG never goes remote (too verbose for a push store).
+     * IS_PRODUCTION does NOT gate this — it controls the console, not telemetry.
+     */
+    shouldLogRemote(level) {
+        if (level === ELogLevel.ERROR || level === ELogLevel.WARN)
+            return true;
+        if (level === ELogLevel.INFO)
+            return ENABLED_LOGS[this.context];
+        return false;
+    }
+    pushRemote(level, args) {
+        if (!this.shouldLogRemote(level))
+            return;
+        const client = getLokiClient();
+        if (!client)
+            return;
+        // Include context in the message so logs are filterable in Grafana
+        // without needing a high-cardinality label: `{app="..."} |= "[USE_CASES]"`
+        const prefix = this.context !== EApplicationLogger.GLOBAL ? `[${this.context}] ` : "";
+        const lvl = level.toLowerCase();
+        const traceLabel = activeTraceLabel();
+        queueMicrotask(() => client.push(lvl, prefix + this.serialize(args) + traceLabel));
+    }
     output(method, level, args) {
         const timestamp = new Date().toISOString();
         const contextColor = this.getContextColor();
         if (this.contextPrefix) {
-            // Colorear todo el mensaje con el color del contexto
             method(`${Colors.Gray}${timestamp}${Colors.Reset}`, `${contextColor}${this.contextPrefix}`, ...args, Colors.Reset);
         }
         else {
             method(`${Colors.Gray}${timestamp}${Colors.Reset}`, ...args);
         }
     }
+    serialize(args) {
+        const MAX = 2048;
+        const msg = args
+            .map((a) => {
+            try {
+                return typeof a === "string" ? a : JSON.stringify(a);
+            }
+            catch {
+                return "[unserializable]";
+            }
+        })
+            .join(" ");
+        return msg.length > MAX ? `${msg.slice(0, MAX)}…` : msg;
+    }
     debug(...args) {
         this.log(ELogLevel.DEBUG, console.debug, args);
     }

package/dist/infrastructure/telemetry/buffer_registry.d.ts

@@ -0,0 +1,15 @@
+import type { LogQueueRepository } from "./logging/log_queue_repository";
+import type { SpanQueueRepository } from "./tracing/span_queue_repository";
+import type { TelemetryBufferStats } from "./types";
+/** @internal — wired by initTelemetry so consumers can inspect buffer pressure. */
+export declare function _registerBuffers(logQueue: LogQueueRepository | null, spanQueue: SpanQueueRepository | null): void;
+/** @internal — test use only. */
+export declare function _resetBuffers(): void;
+/**
+ * Current size and drop pressure of the telemetry buffers.
+ *
+ * Use this to surface offline backlog in dashboards or health checks — a high
+ * `dropped` count means the device has been offline long enough to lose data.
+ * Returns null buffers when the corresponding signal is disabled.
+ */
+export declare function bufferStats(): Promise<TelemetryBufferStats>;

package/dist/infrastructure/telemetry/buffer_registry.js

@@ -0,0 +1,26 @@
+let _logQueue = null;
+let _spanQueue = null;
+/** @internal — wired by initTelemetry so consumers can inspect buffer pressure. */
+export function _registerBuffers(logQueue, spanQueue) {
+    _logQueue = logQueue;
+    _spanQueue = spanQueue;
+}
+/** @internal — test use only. */
+export function _resetBuffers() {
+    _logQueue = null;
+    _spanQueue = null;
+}
+/**
+ * Current size and drop pressure of the telemetry buffers.
+ *
+ * Use this to surface offline backlog in dashboards or health checks — a high
+ * `dropped` count means the device has been offline long enough to lose data.
+ * Returns null buffers when the corresponding signal is disabled.
+ */
+export async function bufferStats() {
+    const [logs, spans] = await Promise.all([
+        _logQueue?.stats() ?? Promise.resolve(null),
+        _spanQueue?.stats() ?? Promise.resolve(null),
+    ]);
+    return { logs, spans };
+}

package/dist/infrastructure/telemetry/connectivity_state.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Self-correcting online/offline flag for the telemetry pipeline.
+ *
+ * The framework does NOT depend on the app's connectivity cron — that is
+ * client-specific and optional. Instead this flag is corrected from two cheap,
+ * always-available sources:
+ *   - the outcome of each delivery attempt (success → online, network failure → offline)
+ *   - optional connectivity events, when the host app emits them
+ *
+ * It exists to skip delivery attempts while known-offline (avoiding hung HTTP
+ * and wasted work); the send timeout in the HTTP clients is the backstop when
+ * the flag is optimistically wrong.
+ */
+export declare class ConnectivityState {
+    private online;
+    constructor(initiallyOnline?: boolean);
+    isOnline(): boolean;
+    markOnline(): void;
+    markOffline(): void;
+}

package/dist/infrastructure/telemetry/connectivity_state.js

@@ -0,0 +1,28 @@
+/**
+ * Self-correcting online/offline flag for the telemetry pipeline.
+ *
+ * The framework does NOT depend on the app's connectivity cron — that is
+ * client-specific and optional. Instead this flag is corrected from two cheap,
+ * always-available sources:
+ *   - the outcome of each delivery attempt (success → online, network failure → offline)
+ *   - optional connectivity events, when the host app emits them
+ *
+ * It exists to skip delivery attempts while known-offline (avoiding hung HTTP
+ * and wasted work); the send timeout in the HTTP clients is the backstop when
+ * the flag is optimistically wrong.
+ */
+export class ConnectivityState {
+    online;
+    constructor(initiallyOnline = true) {
+        this.online = initiallyOnline;
+    }
+    isOnline() {
+        return this.online;
+    }
+    markOnline() {
+        this.online = true;
+    }
+    markOffline() {
+        this.online = false;
+    }
+}

package/dist/infrastructure/telemetry/context_keys.d.ts

@@ -0,0 +1,7 @@
+import type { Context as OtelContext } from "@opentelemetry/api";
+/**
+ * Key under which the active OTel Context (carrying the current Span) is
+ * stored inside the framework Context. Shared between tracing_hooks (writes)
+ * and active_span (reads) so both sides reference the same Symbol.
+ */
+export declare const OTEL_CTX_KEY: import("../context_manager/context_key").ContextKey<OtelContext>;

package/dist/infrastructure/telemetry/context_keys.js

@@ -0,0 +1,7 @@
+import { createContextKey } from "../context_manager/index";
+/**
+ * Key under which the active OTel Context (carrying the current Span) is
+ * stored inside the framework Context. Shared between tracing_hooks (writes)
+ * and active_span (reads) so both sides reference the same Symbol.
+ */
+export const OTEL_CTX_KEY = createContextKey("sincpro.telemetry.otel_context");

package/dist/infrastructure/telemetry/fetch_with_timeout.d.ts

@@ -0,0 +1,8 @@
+/** Default send timeout — fail fast instead of hanging when the network is flaky/offline. */
+export declare const DEFAULT_SEND_TIMEOUT_MS = 4000;
+/**
+ * `fetch` with a hard timeout via AbortController. On timeout the request is
+ * aborted and the returned promise rejects, so an offline/slow network never
+ * blocks the telemetry pipeline indefinitely.
+ */
+export declare function fetchWithTimeout(input: string, init: RequestInit, timeoutMs?: number): Promise<Response>;

package/dist/infrastructure/telemetry/fetch_with_timeout.js

@@ -0,0 +1,17 @@
+/** Default send timeout — fail fast instead of hanging when the network is flaky/offline. */
+export const DEFAULT_SEND_TIMEOUT_MS = 4000;
+/**
+ * `fetch` with a hard timeout via AbortController. On timeout the request is
+ * aborted and the returned promise rejects, so an offline/slow network never
+ * blocks the telemetry pipeline indefinitely.
+ */
+export async function fetchWithTimeout(input, init, timeoutMs = DEFAULT_SEND_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(input, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}