teraprox-core-sdk 0.3.3 → 0.3.5

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as CoreService, H as HttpController, T as ToastService } from './federation-UNcGnNB-.js';
-export { D as DevAutoLogin, F as FederatedBridge, M as MatchingObjectSubscription, R as ReducersBundle, a as ReducersBundleConfig, b as RemoteManifest, c as RemoteMenuItem, d as RemoteMenuSection, S as StandaloneProvider, e as ToastOptions, f as createReducersBundle } from './federation-UNcGnNB-.js';
+import { C as CoreService, T as ToastService, I as IObservabilityPort, H as HttpController, a as InteractionPayload, V as VitalsPayload, B as BreadcrumbPayload } from './federation-Bhx0XhSP.js';
+export { D as DevAutoLogin, F as FederatedBridge, M as MatchingObjectSubscription, R as ReducersBundle, b as ReducersBundleConfig, c as RemoteManifest, d as RemoteMenuItem, e as RemoteMenuSection, S as StandaloneProvider, f as ToastOptions, g as createReducersBundle } from './federation-Bhx0XhSP.js';
 import * as React from 'react';
 import { Dispatch } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -34,8 +34,134 @@ interface NavigationConfig {
 }
 type NavigateFn = (path: string | number, config?: NavigationConfig, pageName?: string) => void;
 
+type StatusSolicitacao = 'PENDENTE' | 'APROVADO' | 'REPROVADO' | 'CANCELADO' | 'EM_EXECUCAO';
+interface SolicitacaoDeServico {
+    id: string | number;
+    status: StatusSolicitacao;
+    dataDeAbertura: string;
+    descricaoDoProblema: string;
+    solicitante: {
+        id: string | number;
+        nome: string;
+    };
+    recurso?: {
+        id: string | number;
+        nome: string;
+    };
+    recursoNome?: string;
+    prioridade?: 'BAIXA' | 'MEDIA' | 'ALTA' | 'URGENTE';
+    setor?: string;
+    equipamento?: string;
+}
+
 declare const CoreServiceContext: React.Context<CoreService | null>;
 
+declare class FetchHttpAdapter implements HttpController {
+    private endpoint;
+    constructor(endpoint: string);
+    private request;
+    get(path?: string): Promise<any>;
+    post(path?: string, data?: any): Promise<any>;
+    put(path?: string, data?: any): Promise<any>;
+    patch(path?: string, data?: any): Promise<any>;
+    delete(path?: string, id?: string | number): Promise<any>;
+    deleteSimple(path?: string): Promise<any>;
+    save(path?: string, data?: any): Promise<any>;
+    read(path?: string, id?: string | number): Promise<any>;
+    readAll(path?: string): Promise<any>;
+    readAllwithPage(path?: string): Promise<any>;
+    bulkDelete(path?: string): Promise<any>;
+}
+declare class CoreServiceBuilder {
+    private _toast;
+    private _httpEndpoint?;
+    private _rtdbConfig?;
+    private _hostedByCore;
+    private _observability;
+    private _tracing;
+    withToast(toast: ToastService): this;
+    withHttpEndpoint(url: string): this;
+    withRtdbConfig(config: any): this;
+    setHostedByCore(hosted: boolean): this;
+    withObservability(observability: IObservabilityPort): this;
+    /**
+     * Ativa Distributed Tracing W3C nos controllers HTTP.
+     * Quando habilitado, `createController` retorna `TracingHttpAdapter` em vez de `FetchHttpAdapter`.
+     * O header `traceparent` é injetado em todas as requisições automaticamente.
+     */
+    withTracing(enabled?: boolean): this;
+    build(): CoreService;
+}
+
+declare class NullToastService implements ToastService {
+    success(message: string): void;
+    warning(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+}
+declare class NullHttpController implements HttpController {
+    private logAndResolve;
+    get(path?: string): Promise<never[]>;
+    post(path?: string): Promise<never[]>;
+    put(path?: string): Promise<never[]>;
+    patch(path?: string): Promise<never[]>;
+    delete(path?: string, id?: string | number): Promise<never[]>;
+    deleteSimple(path?: string): Promise<never[]>;
+    save(path?: string): Promise<never[]>;
+    read(path?: string, id?: string | number): Promise<never[]>;
+    readAll(path?: string): Promise<never[]>;
+    readAllwithPage(path?: string): Promise<never[]>;
+    bulkDelete(path?: string): Promise<never[]>;
+}
+declare const NullCoreService: CoreService;
+
+/**
+ * Null Object Pattern — implementação fallback de `IObservabilityPort`.
+ * Apenas loga no console; substitua pela implementação real (Datadog/Sentry/Grafana)
+ * via `CoreServiceBuilder.withObservability()` no host.
+ */
+declare class NullObservabilityAdapter implements IObservabilityPort {
+    trackInteraction(payload: InteractionPayload): void;
+    captureVitals(payload: VitalsPayload): void;
+    logBreadcrumb(payload: BreadcrumbPayload): void;
+}
+
+/**
+ * Decorator de HTTP que implementa Distributed Tracing via W3C TraceContext.
+ *
+ * - Gera um `trace-id` único por instância (cobre todos os spans de um contexto/controller).
+ * - Gera um `span-id` único por requisição HTTP.
+ * - Injeta o header `traceparent` em todas as chamadas: GET, POST, PUT, PATCH, DELETE, etc.
+ * - Mesclado com quaisquer `extraHeaders` já presentes na chamada.
+ *
+ * Uso via CoreServiceBuilder:
+ * ```ts
+ * new CoreServiceBuilder()
+ *   .withHttpEndpoint(process.env.REACT_APP_END_POINT)
+ *   .withTracing()
+ *   .build()
+ * ```
+ */
+declare class TracingHttpAdapter implements HttpController {
+    private readonly endpoint;
+    /** Identificador único desta cadeia de spans — compartilhado por todas as reqs do controller. */
+    private readonly traceId;
+    constructor(endpoint: string);
+    private mergeHeaders;
+    private request;
+    get(path?: string): Promise<any>;
+    post(path?: string, data?: any, extraHeaders?: Record<string, string>): Promise<any>;
+    put(path?: string, data?: any, extraHeaders?: Record<string, string>): Promise<any>;
+    patch(path?: string, data?: any, extraHeaders?: Record<string, string>): Promise<any>;
+    delete(path?: string, id?: string | number, extraHeaders?: Record<string, string>): Promise<any>;
+    deleteSimple(path?: string, extraHeaders?: Record<string, string>): Promise<any>;
+    save(path?: string, data?: any, extraHeaders?: Record<string, string>): Promise<any>;
+    read(path?: string, id?: string | number, extraHeaders?: Record<string, string>): Promise<any>;
+    readAll(path?: string, extraHeaders?: Record<string, string>): Promise<any>;
+    readAllwithPage(path?: string): Promise<any>;
+    bulkDelete(path?: string, ids?: (string | number)[], extraHeaders?: Record<string, string>): Promise<any>;
+}
+
 declare function useCoreService(): CoreService;
 
 declare function useHttpController(context: string, baseEndPoint?: string): HttpController;
@@ -80,6 +206,16 @@ interface NavigatorConfig {
  */
 declare function useNavigator(config: NavigatorConfig): NavigateFn;
 
+/**
+ * Atalho para acessar o Port de observabilidade via React context.
+ * Retorna a implementação real (quando fornecida pelo host) ou o NullObservabilityAdapter.
+ *
+ * @example
+ * const obs = useObservability()
+ * obs.logBreadcrumb({ category: 'action', message: 'Solicitação aprovada', data: { id } })
+ */
+declare function useObservability(): IObservabilityPort;
+
 interface FetchDataReturn<T = any> {
     data: T | null;
     loading: boolean;
@@ -198,6 +334,36 @@ declare const _default: redux.Reducer<PickerState>;
 
 declare function pickTextColorBasedOnBgColorAdvanced(bgColor: string, lightColor: string, darkColor: string): string;
 
+/**
+ * Instala PerformanceObserver para LCP e CLS automaticamente no bootstrap do módulo.
+ * Fallback silencioso em ambientes que não suportam a API (Node, browsers antigos).
+ *
+ * @param observability - Implementação de IObservabilityPort para receber as métricas.
+ */
+declare function initWebVitals(observability: IObservabilityPort): void;
+
+/**
+ * Utilitários de Distributed Tracing seguindo a especificação W3C TraceContext.
+ * https://www.w3.org/TR/trace-context/
+ */
+/**
+ * Gera um trace-id de 128 bits (32 chars hex) conforme W3C TraceContext.
+ * Usado uma vez por instância de adapter — identifica toda a cadeia de spans de um contexto.
+ */
+declare function generateTraceId(): string;
+/**
+ * Gera um span-id de 64 bits (16 chars hex) conforme W3C TraceContext.
+ * Chamado a cada requisição HTTP — identifica um span individual.
+ */
+declare function generateSpanId(): string;
+/**
+ * Monta o header `traceparent` no formato W3C:
+ * `{version}-{traceId}-{spanId}-{flags}`
+ *
+ * Flags: `01` = sampled (enviado ao coletor), `00` = não-amostrado.
+ */
+declare function buildTraceparent(traceId: string, spanId: string, sampled?: boolean): string;
+
 /**
  * Formats a date for display in Brazilian format.
  * Corresponds to the duplicated dateUtils.js in SGM/SGP/Services/default/.
@@ -219,4 +385,4 @@ declare function removeAccents(str: string): string;
 declare function slugify(str: string): string;
 declare function isBlank(str: string | null | undefined): boolean;
 
-export { CoreService, CoreServiceContext, HttpController, type NavigateFn, type NavigationConfig, type Notification, type NotificationState, RecursoDisplayer, ToastService, addDays, _default$1 as branchLevelReducer, capitalize, clearBranchLevelForm, clearPicker, daysBetween, formatDate, formatDateTime, isBlank, isDateAfter, isDateBefore, pickTextColorBasedOnBgColorAdvanced, _default as pickerReducer, populateToEdit, removeAccents, setColor, setExcludeLevels, setHaveComponente, setLevel, setLevels, setNome, setPickerContext, setPickerItems, setPickerSelected, setPickerVisible, slugify, toISOString, truncate, useAnexoUpload, useCoreService, useFetchData, useFormStorage, useHttpController, useMatchingObject, useNavigator, useNotifications, usePostData, useSmartSearch, useToast, useValidation };
+export { BreadcrumbPayload, CoreService, CoreServiceBuilder, CoreServiceContext, FetchHttpAdapter, HttpController, IObservabilityPort, InteractionPayload, type NavigateFn, type NavigationConfig, type Notification, type NotificationState, NullCoreService, NullHttpController, NullObservabilityAdapter, NullToastService, RecursoDisplayer, type SolicitacaoDeServico, type StatusSolicitacao, ToastService, TracingHttpAdapter, VitalsPayload, addDays, _default$1 as branchLevelReducer, buildTraceparent, capitalize, clearBranchLevelForm, clearPicker, daysBetween, formatDate, formatDateTime, generateSpanId, generateTraceId, initWebVitals, isBlank, isDateAfter, isDateBefore, pickTextColorBasedOnBgColorAdvanced, _default as pickerReducer, populateToEdit, removeAccents, setColor, setExcludeLevels, setHaveComponente, setLevel, setLevels, setNome, setPickerContext, setPickerItems, setPickerSelected, setPickerVisible, slugify, toISOString, truncate, useAnexoUpload, useCoreService, useFetchData, useFormStorage, useHttpController, useMatchingObject, useNavigator, useNotifications, useObservability, usePostData, useSmartSearch, useToast, useValidation };

package/dist/index.js

@@ -30,13 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CoreServiceBuilder: () => CoreServiceBuilder,
   CoreServiceContext: () => CoreServiceContext,
   DevAutoLogin: () => DevAutoLogin,
   FederatedBridge: () => FederatedBridge,
+  FetchHttpAdapter: () => FetchHttpAdapter,
+  NullCoreService: () => NullCoreService,
+  NullHttpController: () => NullHttpController,
+  NullObservabilityAdapter: () => NullObservabilityAdapter,
+  NullToastService: () => NullToastService,
   RecursoDisplayer: () => RecursoDisplayer_default,
   StandaloneProvider: () => StandaloneProvider,
+  TracingHttpAdapter: () => TracingHttpAdapter,
   addDays: () => addDays,
   branchLevelReducer: () => branchLevelReducer_default,
+  buildTraceparent: () => buildTraceparent,
   capitalize: () => capitalize,
   clearBranchLevelForm: () => clearBranchLevelForm,
   clearPicker: () => clearPicker,
@@ -44,6 +52,9 @@ __export(index_exports, {
   daysBetween: () => daysBetween,
   formatDate: () => formatDate,
   formatDateTime: () => formatDateTime,
+  generateSpanId: () => generateSpanId,
+  generateTraceId: () => generateTraceId,
+  initWebVitals: () => initWebVitals,
   isBlank: () => isBlank,
   isDateAfter: () => isDateAfter,
   isDateBefore: () => isDateBefore,
@@ -72,6 +83,7 @@ __export(index_exports, {
   useMatchingObject: () => useMatchingObject,
   useNavigator: () => useNavigator,
   useNotifications: () => useNotifications,
+  useObservability: () => useObservability,
   usePostData: () => usePostData,
   useSmartSearch: () => useSmartSearch,
   useToast: () => useToast,
@@ -83,14 +95,308 @@ module.exports = __toCommonJS(index_exports);
 var import_react = require("react");
 var CoreServiceContext = (0, import_react.createContext)(null);
 
+// src/adapters/null/NullObservabilityAdapter.ts
+var NullObservabilityAdapter = class {
+  trackInteraction(payload) {
+    var _a;
+    console.info(`[Observability] INTERACTION: ${payload.name}`, (_a = payload.properties) != null ? _a : {});
+  }
+  captureVitals(payload) {
+    var _a, _b;
+    const unit = (_a = payload.unit) != null ? _a : "";
+    console.info(`[Observability] VITAL: ${payload.name} = ${payload.value}${unit}`, (_b = payload.meta) != null ? _b : {});
+  }
+  logBreadcrumb(payload) {
+    var _a;
+    console.info(`[Observability] BREADCRUMB [${payload.category}]: ${payload.message}`, (_a = payload.data) != null ? _a : {});
+  }
+};
+
+// src/adapters/null/NullObjectAdapters.ts
+var NullToastService = class {
+  success(message) {
+    console.log(`[Toast Fallback] SUCCESS: ${message}`);
+  }
+  warning(message) {
+    console.warn(`[Toast Fallback] WARNING: ${message}`);
+  }
+  error(message) {
+    console.error(`[Toast Fallback] ERROR: ${message}`);
+  }
+  info(message) {
+    console.info(`[Toast Fallback] INFO: ${message}`);
+  }
+};
+var NullHttpController = class {
+  logAndResolve(method, path) {
+    console.warn(`[Http Fallback] MOCK ${method} requisitado para ${path} (Nenhum adapter injetado)`);
+    return Promise.resolve([]);
+  }
+  get(path) {
+    return this.logAndResolve("GET", path);
+  }
+  post(path) {
+    return this.logAndResolve("POST", path);
+  }
+  put(path) {
+    return this.logAndResolve("PUT", path);
+  }
+  patch(path) {
+    return this.logAndResolve("PATCH", path);
+  }
+  delete(path, id) {
+    return this.logAndResolve("DELETE", `${path}/${id}`);
+  }
+  deleteSimple(path) {
+    return this.logAndResolve("DELETE", path);
+  }
+  save(path) {
+    return this.logAndResolve("SAVE", path);
+  }
+  read(path, id) {
+    return this.logAndResolve("READ", `${path}/${id}`);
+  }
+  readAll(path) {
+    return this.logAndResolve("READ_ALL", path);
+  }
+  readAllwithPage(path) {
+    return this.logAndResolve("READ_ALL_PAGE", path);
+  }
+  bulkDelete(path) {
+    return this.logAndResolve("BULK_DELETE", path);
+  }
+};
+var NullCoreService = {
+  toast: new NullToastService(),
+  createController: (context) => {
+    console.warn(`[CoreService Fallback] createController chamado para "${context}" sem Adapter. Usando NullHttpController.`);
+    return new NullHttpController();
+  },
+  subscribe: (mo) => console.log(`[CoreService Fallback] Inscri\xE7\xE3o simulada RTDB: ${mo.context}`),
+  unsubscribe: (mo) => console.log(`[CoreService Fallback] Desinscri\xE7\xE3o simulada RTDB: ${mo.context}`),
+  subscribeEvent: (evt) => console.log(`[CoreService Fallback] Inscri\xE7\xE3o Evento: ${evt}`),
+  unsubscribeEvent: (evt) => console.log(`[CoreService Fallback] Desinscri\xE7\xE3o Evento: ${evt}`),
+  handleLogout: () => console.log(`[CoreService Fallback] Realizando logout...`),
+  hostedByCore: false,
+  observability: new NullObservabilityAdapter()
+};
+
+// src/utils/tracing.ts
+function toHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return toHex(bytes);
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return toHex(bytes);
+}
+function buildTraceparent(traceId, spanId, sampled = true) {
+  return `00-${traceId}-${spanId}-${sampled ? "01" : "00"}`;
+}
+
+// src/adapters/TracingHttpAdapter.ts
+var TracingHttpAdapter = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.traceId = generateTraceId();
+  }
+  mergeHeaders(extraHeaders, withContentType = false) {
+    const spanId = generateSpanId();
+    const headers = {
+      traceparent: buildTraceparent(this.traceId, spanId),
+      ...extraHeaders
+    };
+    if (withContentType && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  async request(method, extraPath, data, extraHeaders) {
+    const url = extraPath ? `${this.endpoint}/${extraPath}` : this.endpoint;
+    const isFormData = data instanceof FormData;
+    const headers = this.mergeHeaders(extraHeaders, data !== void 0 && !isFormData);
+    try {
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: data !== void 0 ? isFormData ? data : JSON.stringify(data) : void 0
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return await res.json();
+    } catch (e) {
+      console.warn(`[TracingHttpAdapter] Falha ao fazer ${method} para ${url}:`, e);
+      return [];
+    }
+  }
+  get(path) {
+    return this.request("GET", path || "");
+  }
+  post(path, data, extraHeaders) {
+    return this.request("POST", path || "", data, extraHeaders);
+  }
+  put(path, data, extraHeaders) {
+    return this.request("PUT", path || "", data, extraHeaders);
+  }
+  patch(path, data, extraHeaders) {
+    return this.request("PATCH", path || "", data, extraHeaders);
+  }
+  delete(path, id, extraHeaders) {
+    return this.request("DELETE", `${path || ""}/${id}`, void 0, extraHeaders);
+  }
+  deleteSimple(path, extraHeaders) {
+    return this.request("DELETE", path || "", void 0, extraHeaders);
+  }
+  save(path, data, extraHeaders) {
+    return this.request("POST", path || "", data, extraHeaders);
+  }
+  read(path, id, extraHeaders) {
+    return this.request("GET", `${path || ""}/${id}`, void 0, extraHeaders);
+  }
+  readAll(path, extraHeaders) {
+    return this.request("GET", path || "", void 0, extraHeaders);
+  }
+  readAllwithPage(path) {
+    return this.request("GET", path || "");
+  }
+  bulkDelete(path, ids, extraHeaders) {
+    return this.request("DELETE", path || "", ids, extraHeaders);
+  }
+};
+
+// src/factories/CoreServiceBuilder.ts
+var FetchHttpAdapter = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  async request(method, extraPath, data) {
+    const url = extraPath ? `${this.endpoint}/${extraPath}` : this.endpoint;
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: data ? { "Content-Type": "application/json" } : void 0,
+        body: data ? JSON.stringify(data) : void 0
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return await res.json();
+    } catch (e) {
+      console.warn(`[FetchHttpAdapter] Falha ao fazer ${method} para ${url}:`, e);
+      return [];
+    }
+  }
+  get(path) {
+    return this.request("GET", path || "");
+  }
+  post(path, data) {
+    return this.request("POST", path || "", data);
+  }
+  put(path, data) {
+    return this.request("PUT", path || "", data);
+  }
+  patch(path, data) {
+    return this.request("PATCH", path || "", data);
+  }
+  delete(path, id) {
+    return this.request("DELETE", `${path || ""}/${id}`);
+  }
+  deleteSimple(path) {
+    return this.request("DELETE", path || "");
+  }
+  save(path, data) {
+    return this.request("POST", path || "", data);
+  }
+  read(path, id) {
+    return this.request("GET", `${path || ""}/${id}`);
+  }
+  readAll(path) {
+    return this.request("GET", path || "");
+  }
+  readAllwithPage(path) {
+    return this.request("GET", path || "");
+  }
+  bulkDelete(path) {
+    return this.request("DELETE", path || "");
+  }
+};
+var CoreServiceBuilder = class {
+  constructor() {
+    this._toast = new NullToastService();
+    this._hostedByCore = false;
+    this._observability = new NullObservabilityAdapter();
+    this._tracing = false;
+  }
+  withToast(toast) {
+    this._toast = toast;
+    return this;
+  }
+  withHttpEndpoint(url) {
+    this._httpEndpoint = url;
+    return this;
+  }
+  withRtdbConfig(config) {
+    this._rtdbConfig = config;
+    return this;
+  }
+  setHostedByCore(hosted) {
+    this._hostedByCore = hosted;
+    return this;
+  }
+  withObservability(observability) {
+    this._observability = observability;
+    return this;
+  }
+  /**
+   * Ativa Distributed Tracing W3C nos controllers HTTP.
+   * Quando habilitado, `createController` retorna `TracingHttpAdapter` em vez de `FetchHttpAdapter`.
+   * O header `traceparent` é injetado em todas as requisições automaticamente.
+   */
+  withTracing(enabled = true) {
+    this._tracing = enabled;
+    return this;
+  }
+  build() {
+    return {
+      toast: this._toast,
+      createController: (context, baseEndPoint) => {
+        const endpoint = baseEndPoint != null ? baseEndPoint : this._httpEndpoint ? `${this._httpEndpoint}/${context}` : null;
+        if (!endpoint) {
+          console.warn(`[CoreServiceBuilder] HttpEndpoint nulo para "${context}". Usando NullHttpController.`);
+          return new NullHttpController();
+        }
+        return this._tracing ? new TracingHttpAdapter(endpoint) : new FetchHttpAdapter(endpoint);
+      },
+      subscribe: (mo) => {
+        console.log(`[CoreServiceBuilder RTDB] Subscribe > ${mo.context}`);
+      },
+      unsubscribe: (mo) => {
+        console.log(`[CoreServiceBuilder RTDB] Unsubscribe > ${mo.context}`);
+      },
+      subscribeEvent: (evt) => {
+      },
+      unsubscribeEvent: (evt) => {
+      },
+      handleLogout: () => console.log("Logout invocado no Standalone mode"),
+      hostedByCore: this._hostedByCore,
+      observability: this._observability
+    };
+  }
+};
+
 // src/hooks/useCoreService.ts
 var import_react2 = require("react");
 function useCoreService() {
   const ctx = (0, import_react2.useContext)(CoreServiceContext);
   if (!ctx) {
-    throw new Error(
-      "useCoreService must be used within a CoreServiceProvider. Are you running outside Core (standalone mode)?"
-    );
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        "[useCoreService] rodando sem Provider. O SDK ativou os Fallbacks (Null Object Pattern)."
+      );
+    }
+    return NullCoreService;
   }
   return ctx;
 }
@@ -191,6 +497,11 @@ function useNavigator(config) {
   );
 }
 
+// src/hooks/useObservability.ts
+function useObservability() {
+  return useCoreService().observability;
+}
+
 // src/hooks/useFetchData.ts
 var import_react6 = require("react");
 function useFetchData() {
@@ -1246,6 +1557,39 @@ var {
 } = pickerSlice.actions;
 var pickerReducer_default = pickerSlice.reducer;
 
+// src/utils/webVitals.ts
+function initWebVitals(observability) {
+  if (typeof PerformanceObserver === "undefined") return;
+  try {
+    const lcpObserver = new PerformanceObserver((list) => {
+      const entries = list.getEntries();
+      if (!entries.length) return;
+      const last = entries[entries.length - 1];
+      observability.captureVitals({ name: "LCP", value: Math.round(last.startTime), unit: "ms" });
+    });
+    lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+  } catch (_) {
+  }
+  try {
+    let clsValue = 0;
+    const clsObserver = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const ls = entry;
+        if (!ls.hadRecentInput && typeof ls.value === "number") {
+          clsValue += ls.value;
+        }
+      }
+      observability.captureVitals({
+        name: "CLS",
+        value: parseFloat(clsValue.toFixed(4)),
+        unit: "score"
+      });
+    });
+    clsObserver.observe({ type: "layout-shift", buffered: true });
+  } catch (_) {
+  }
+}
+
 // src/utils/dateUtils.ts
 var import_dayjs = __toESM(require("dayjs"));
 function formatDate(date, format = "DD/MM/YYYY") {
@@ -1559,7 +1903,8 @@ function StandaloneProvider({ createController, addToast, firebaseConfig, emulat
       },
       handleLogout: () => {
       },
-      hostedByCore: false
+      hostedByCore: false,
+      observability: new NullObservabilityAdapter()
     }),
     [createController, toast, subscribe, unsubscribe]
   );
@@ -1578,14 +1923,14 @@ var DEFAULT_DEV_USER = {
   lastName: "User",
   token: "dev-standalone-token",
   email: "dev@teraprox.local",
-  id: "dev-user-id",
+  id: "1",
   role: "admin",
   user: "devuser",
   userName: "devuser",
   setor: "Desenvolvimento",
-  userSetor: { setorId: "dev-setor-id" },
+  userSetor: { setorId: "1" },
   companyName: "Dev Company",
-  companyId: "dev-company-id",
+  companyId: "1",
   filters: []
 };
 function DevAutoLogin({ actions, devUser, children }) {
@@ -1606,13 +1951,21 @@ function DevAutoLogin({ actions, devUser, children }) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CoreServiceBuilder,
   CoreServiceContext,
   DevAutoLogin,
   FederatedBridge,
+  FetchHttpAdapter,
+  NullCoreService,
+  NullHttpController,
+  NullObservabilityAdapter,
+  NullToastService,
   RecursoDisplayer,
   StandaloneProvider,
+  TracingHttpAdapter,
   addDays,
   branchLevelReducer,
+  buildTraceparent,
   capitalize,
   clearBranchLevelForm,
   clearPicker,
@@ -1620,6 +1973,9 @@ function DevAutoLogin({ actions, devUser, children }) {
   daysBetween,
   formatDate,
   formatDateTime,
+  generateSpanId,
+  generateTraceId,
+  initWebVitals,
   isBlank,
   isDateAfter,
   isDateBefore,
@@ -1648,6 +2004,7 @@ function DevAutoLogin({ actions, devUser, children }) {
   useMatchingObject,
   useNavigator,
   useNotifications,
+  useObservability,
   usePostData,
   useSmartSearch,
   useToast,