@gravito/ripple 3.1.0 → 4.0.1

package/dist/core/src/events/observability/StreamWorkerMetrics.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Worker Pool Metrics Recorder for OpenTelemetry integration.
+ *
+ * Tracks Worker Pool statistics and emits OpenTelemetry metrics.
+ *
+ * @internal
+ */
+import type { Meter } from '@opentelemetry/api';
+/**
+ * Worker job status for metrics.
+ */
+export declare enum WorkerJobStatus {
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+/**
+ * Stream Worker Metrics Recorder.
+ *
+ * Collects and records metrics related to Worker Pool execution:
+ * - Pool size and utilization
+ * - Job execution duration
+ * - Job success/failure counts
+ * - Queue depth
+ */
+export declare class StreamWorkerMetrics {
+    private meter;
+    private jobDurationHistogram?;
+    private jobCounterCompleted?;
+    constructor(meter: Meter);
+    /**
+     * Initialize OpenTelemetry metrics.
+     */
+    private initializeMetrics;
+    /**
+     * Record job execution duration.
+     *
+     * @param durationSeconds - Duration in seconds
+     * @param status - Job status (completed or failed)
+     * @param queue - Queue name
+     */
+    recordJobDuration(durationSeconds: number, status: WorkerJobStatus, queue?: string): void;
+    /**
+     * Record pool size change.
+     *
+     * @param poolSize - Current pool size
+     * @param callback - Optional callback to fetch pool size dynamically
+     */
+    setPoolSizeProvider(callback: () => number): void;
+    private poolSizeCallback?;
+    /**
+     * Get current pool size.
+     */
+    getPoolSize(): number;
+    /**
+     * Record queue depth change.
+     *
+     * @param depth - Current queue depth
+     * @param callback - Optional callback to fetch queue depth dynamically
+     */
+    setQueueDepthProvider(callback: () => number): void;
+    private queueDepthCallback?;
+    /**
+     * Get current queue depth.
+     */
+    getQueueDepth(): number;
+}
+/**
+ * Worker Metrics Recorder interface for dependency injection.
+ */
+export interface WorkerMetricsRecorder {
+    recordJobDuration(durationSeconds: number, status: WorkerJobStatus, queue?: string): void;
+    setPoolSizeProvider(callback: () => number): void;
+    setQueueDepthProvider(callback: () => number): void;
+    getPoolSize(): number;
+    getQueueDepth(): number;
+}

package/dist/core/src/events/observability/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @public
+ */
+export { EventMetrics } from './EventMetrics';
+/**
+ * @public
+ */
+export { EventTracer } from './EventTracer';
+/**
+ * @public
+ */
+export { EventTracing, type EventTracingConfig, getEventTracing } from './EventTracing';
+/**
+ * @public
+ */
+export { type ObservabilityConfig, ObservableHookManager } from './ObservableHookManager';
+/**
+ * @public
+ */
+export { OTelEventMetrics, type QueueDepthCallback } from './OTelEventMetrics';
+/**
+ * @public
+ */
+export { StreamWorkerMetrics, WorkerJobStatus, type WorkerMetricsRecorder, } from './StreamWorkerMetrics';

package/dist/core/src/events/observability/metrics-types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Minimal metric types for event observability.
+ * Avoids importing @gravito/monitor from core to prevent circular dependency.
+ * Runtime implementations are provided by @gravito/monitor MetricsRegistry.
+ *
+ * @internal
+ */
+export interface EventMetricCounter {
+    inc(labels: Record<string, string>): void;
+}
+export interface EventMetricGauge {
+    set(value: number, labels: Record<string, string>): void;
+}
+export interface EventMetricHistogram {
+    observe(value: number, labels: Record<string, string>): void;
+}

package/dist/core/src/events/types.d.ts

@@ -0,0 +1,134 @@
+import type { ActionCallback } from '../HookManager';
+import type { BackpressureConfig } from './BackpressureManager';
+import type { EventOptions } from './EventOptions';
+/**
+ * Event task for priority queue processing.
+ * @internal
+ */
+export interface EventTask {
+    /**
+     * Unique identifier for this event task.
+     */
+    id: string;
+    /**
+     * Event hook name.
+     */
+    hook: string;
+    /**
+     * Event payload/arguments.
+     */
+    args: unknown;
+    /**
+     * Event options.
+     */
+    options: EventOptions;
+    /**
+     * Callbacks to execute for this event.
+     */
+    callbacks: ActionCallback[];
+    /**
+     * Timestamp when the event was created.
+     */
+    createdAt: number;
+    /**
+     * Timestamp when the event was enqueued (added to the queue).
+     * Used for priority escalation calculations.
+     * @internal
+     */
+    enqueuedAt: number;
+    /**
+     * Partition key for ordering (if applicable).
+     */
+    partitionKey?: string;
+    /**
+     * Number of retry attempts made.
+     * @internal
+     */
+    retryCount?: number;
+    /**
+     * Timestamp when the event first failed.
+     * @internal
+     */
+    firstFailedAt?: number;
+    /**
+     * Last error encountered.
+     * @internal
+     */
+    lastError?: Error;
+}
+/**
+ * Strategy for handling backpressure when the queue is full.
+ */
+export type BackpressureStrategy = 'reject' | 'drop-oldest' | 'drop-newest' | 'ignore';
+/**
+ * Configuration for the event priority queue.
+ */
+export interface EventQueueConfig {
+    /**
+     * Maximum number of pending events in the queue.
+     * If exceeded, the backpressure strategy is applied.
+     * @default undefined (unbounded)
+     */
+    maxSize?: number;
+    /**
+     * Strategy to use when the queue is full.
+     * - 'reject': Throw an error (default)
+     * - 'drop-oldest': Drop the oldest lowest-priority event
+     * - 'drop-newest': Drop the incoming event
+     * - 'ignore': Silently drop the incoming event
+     * @default 'reject'
+     */
+    strategy?: BackpressureStrategy;
+    /**
+     * Advanced backpressure management configuration.
+     * When enabled, provides state-based flow control with multi-strategy support.
+     * If not provided, falls back to simple strategy-based backpressure.
+     * @default undefined (disabled, uses simple strategy)
+     */
+    backpressure?: BackpressureConfig;
+}
+/**
+ * Multi-priority queue depth snapshot (FS-103)
+ * Represents the current queue depth for each priority level.
+ * @internal
+ */
+export interface MultiPriorityQueueDepth {
+    /** Queue depth for CRITICAL priority events */
+    critical: number;
+    /** Queue depth for HIGH priority events */
+    high: number;
+    /** Queue depth for NORMAL priority events */
+    normal: number;
+    /** Queue depth for LOW priority events */
+    low: number;
+    /** Total queue depth across all priorities */
+    total: number;
+}
+/**
+ * Window adjustment record for backpressure feedback (FS-103)
+ * Records when and why the aggregation window was adjusted.
+ * @internal
+ */
+export interface WindowAdjustment {
+    /** Timestamp of the adjustment */
+    timestamp: number;
+    /** Previous window size in milliseconds */
+    from: number;
+    /** New window size in milliseconds */
+    to: number;
+    /** Backpressure state that triggered the adjustment */
+    reason: string;
+}
+/**
+ * Dead letter queue routing decision (FS-103)
+ * Determines whether an event should be routed to the DLQ.
+ * @internal
+ */
+export interface DeadLetterDecision {
+    /** Whether the event should be routed to DLQ */
+    shouldRoute: boolean;
+    /** Reason for the decision (if applicable) */
+    reason?: string;
+    /** Suggested retry strategy */
+    retryStrategy?: 'immediate' | 'delayed' | 'dlq-only';
+}

package/dist/core/src/exceptions/CircularDependencyException.d.ts

@@ -0,0 +1,9 @@
+import type { ServiceKey } from '../Container';
+/**
+ * CircularDependencyException - Thrown when the container detects an infinite loop.
+ *
+ * @module @gravito/core
+ */
+export declare class CircularDependencyException extends Error {
+    constructor(key: ServiceKey, stack: ServiceKey[]);
+}

package/dist/core/src/exceptions/index.d.ts

@@ -1,5 +1,6 @@
 export * from './AuthenticationException';
 export * from './AuthorizationException';
+export * from './CircularDependencyException';
 export * from './GravitoException';
 export * from './HttpException';
 export * from './ModelNotFoundException';

package/dist/core/src/health/HealthProvider.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview HealthProvider - Cloud-native health checks
+ *
+ * Provides liveness and readiness probes for Kubernetes and cloud deployments
+ *
+ * @module @gravito/core/health
+ * @since 2.2.0
+ */
+import type { Container } from '../Container';
+import type { PlanetCore } from '../PlanetCore';
+import { ServiceProvider } from '../ServiceProvider';
+/**
+ * Health check result
+ * @public
+ */
+export interface HealthCheckResult {
+    /** Health status */
+    status: 'healthy' | 'unhealthy';
+    /** Optional message */
+    message?: string;
+}
+/**
+ * Health check function interface
+ * @public
+ */
+export interface HealthCheck {
+    /** Unique name for this check */
+    name: string;
+    /** Check function that returns health status */
+    check(): Promise<HealthCheckResult>;
+}
+/**
+ * HealthProvider - Provides /health/liveness and /health/readiness endpoints
+ *
+ * - Liveness: Always returns 200 OK (just checks if server is running)
+ * - Readiness: Returns 200 if all checks are healthy, 503 otherwise
+ *
+ * @public
+ */
+export declare class HealthProvider extends ServiceProvider {
+    private checks;
+    register(container: Container): void;
+    /**
+     * Register a health check
+     *
+     * @param check - The health check to register
+     *
+     * @example
+     * ```typescript
+     * const health = core.container.make<HealthProvider>('health')
+     * health.registerCheck({
+     *   name: 'database',
+     *   check: async () => {
+     *     try {
+     *       await db.ping()
+     *       return { status: 'healthy' }
+     *     } catch {
+     *       return { status: 'unhealthy', message: 'DB unreachable' }
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    registerCheck(check: HealthCheck): void;
+    boot(core: PlanetCore): void;
+}
+export default HealthProvider;

package/dist/core/src/http/types.d.ts

@@ -57,6 +57,13 @@ export interface GravitoVariables {
      * Cookie jar for managing response cookies
      */
     cookieJar?: unknown;
+    /**
+     * Middleware scope tracking for Orbit isolation
+     * Tracks which Orbit/scope this request belongs to
+     * Used to prevent cross-Orbit middleware contamination
+     * @since 2.3.0
+     */
+    middlewareScope?: string;
     /** @deprecated Use ctx.route() instead */
     route?: unknown;
     [key: string]: unknown;
@@ -85,6 +92,20 @@ export interface GravitoRequest {
     readonly method: string;
     /** Request path without query string */
     readonly path: string;
+    /**
+     * Route pattern (e.g., /users/:id) for the matched route
+     *
+     * This provides the parameterized route pattern instead of the concrete path,
+     * which is critical for preventing high cardinality issues in metrics systems.
+     *
+     * @example
+     * ```typescript
+     * // For request: GET /users/123
+     * ctx.req.path          // => "/users/123"
+     * ctx.req.routePattern  // => "/users/:id"
+     * ```
+     */
+    readonly routePattern?: string;
     /**
      * Get a route parameter value
      * @param name - Parameter name (e.g., 'id' for route '/users/:id')
@@ -291,6 +312,25 @@ export interface GravitoContext<V extends GravitoVariables = GravitoVariables> {
      * ```
      */
     readonly native: unknown;
+    /**
+     * Access the RequestScopeManager for this request
+     * Services resolved through this manager are scoped to the HTTP request lifetime.
+     */
+    requestScope(): any;
+    /**
+     * Resolve or create a request-scoped service
+     *
+     * @param key - Service key (string or symbol)
+     * @param factory - Factory function to create the service if not cached
+     * @returns The cached or newly created service instance
+     *
+     * @example
+     * ```typescript
+     * // Subsequent calls in the same request return the same instance
+     * const cache = ctx.scoped('product:cache', () => new RequestProductCache())
+     * ```
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
 }
 /**
  * Next function for middleware chain

package/dist/core/src/index.d.ts

@@ -17,16 +17,32 @@ export type { AdapterConfig, AdapterFactory, HttpAdapter, RouteDefinition } from
 export { isHttpAdapter } from './adapters/types';
 export type { ContentfulStatusCode, GravitoContext, GravitoErrorHandler, GravitoHandler, GravitoMiddleware, GravitoNext, GravitoNotFoundHandler, GravitoRequest, GravitoVariables, HttpMethod, StatusCode, ValidationTarget, } from './http/types';
 export { Application, type ApplicationConfig } from './Application';
+export { type CommandHandler, CommandKernel } from './CommandKernel';
 export { ConfigManager } from './ConfigManager';
-export { Container, type Factory } from './Container';
+export { Container, type Factory, type ServiceKey, type ServiceMap } from './Container';
+export { RequestScopeManager } from './Container/RequestScopeManager';
+export { RequestScopeMetrics, RequestScopeMetricsCollector, type RequestScopeObserver, } from './Container/RequestScopeMetrics';
+export { registerQueueCommands } from './cli/queue-commands';
 export { codeFromStatus, ErrorHandler, type ErrorHandlerDeps, messageFromStatus, } from './ErrorHandler';
 export { EventManager } from './EventManager';
+export { cleanupRequestScopeOnError, detectRequestScopeLeaks, extractRequestScopeErrorContext, RequestScopeCleanupError, type RequestScopeErrorContext, withRequestScopeCleanup, } from './error-handling/RequestScopeErrorContext';
+export type { CircuitBreakerOptions, DLQEntry, DLQFilter, EventBackend, EventOptions, EventTask, } from './events';
+export { CircuitBreaker, CircuitBreakerState, DEFAULT_EVENT_OPTIONS, DeadLetterQueue, EventPriorityQueue, } from './events';
+export type { EventTracingConfig, ObservabilityConfig, QueueDepthCallback, } from './events/observability';
+export { EventMetrics, EventTracer, EventTracing, getEventTracing, ObservableHookManager, OTelEventMetrics, } from './events/observability';
+export { type DashboardSnapshot, type ErrorStats, type JobEvent, QueueDashboard, type QueueDashboardConfig, type QueueMetrics, type WorkerMetrics as QueueWorkerMetrics, } from './observability/QueueDashboard';
 export * from './exceptions';
 export { type GlobalErrorHandlersMode, type GlobalProcessErrorHandlerContext, type GlobalProcessErrorKind, type RegisterGlobalErrorHandlersOptions, registerGlobalErrorHandlers, } from './GlobalErrorHandlers';
 export { type GravitoManifest, GravitoServer } from './GravitoServer';
-export type { ActionCallback, FilterCallback } from './HookManager';
-export { HookManager } from './HookManager';
-export * from './helpers';
+export type { ActionCallback, FilterCallback, ListenerInfo, ListenerOptions } from './HookManager';
+export { HookManager, type HookManagerConfig } from './HookManager';
+export type { HealthCheck, HealthCheckResult } from './health/HealthProvider';
+export { HealthProvider } from './health/HealthProvider';
+export type { DumpOptions } from './helpers';
+export { Arr, abort, abortIf, abortUnless, app, blank, config, DumpDieError, dd, dump, env, filled, hasApp, logger, router, Str, setApp, tap, throwIf, throwUnless, value, } from './helpers';
+export * from './helpers/data';
+export * from './helpers/errors';
+export * from './helpers/response';
 export { CookieJar, type CookieOptions } from './http/CookieJar';
 export { deleteCookie, getCookie, setCookie } from './http/cookie';
 export { type BodySizeLimitOptions, bodySizeLimit } from './http/middleware/BodySizeLimit';
@@ -35,12 +51,17 @@ export { type CsrfOptions, csrfProtection, getCsrfToken } from './http/middlewar
 export { createHeaderGate, type HeaderTokenGateOptions, type RequireHeaderTokenOptions, requireHeaderToken, } from './http/middleware/HeaderTokenGate';
 export { type HstsOptions, type SecurityHeadersOptions, securityHeaders, } from './http/middleware/SecurityHeaders';
 export { ThrottleRequests } from './http/middleware/ThrottleRequests';
+export * as instrumentation from './instrumentation';
+export { DEFAULT_CONFIG as OTEL_DEFAULT_CONFIG, getMeter, getOpenTelemetrySDK, getTracer as getOtelTracer, isOpenTelemetryInitialized, type MetricsConfig as OtelMetricsConfig, type MetricsExporter, type OpenTelemetryConfig, type OpenTelemetrySDK, OTEL_ENV_VARS, resetOpenTelemetry, setupOpenTelemetry, shutdownOpenTelemetry, type TracingConfig as OtelTracingConfig, type TracingExporter, } from './instrumentation';
 export type { Listener, ShouldQueue } from './Listener';
 export type { Logger } from './Logger';
 export { ConsoleLogger } from './Logger';
 export { type CacheService, type ErrorHandlerContext, type GravitoConfig, type GravitoOrbit, PlanetCore, type ViewService, } from './PlanetCore';
+export { RequestContext, type RequestContextData, } from './RequestContext';
 export { Route } from './Route';
 export { type ControllerClass, FORM_REQUEST_SYMBOL, type FormRequestClass, type FormRequestLike, RouteGroup, type RouteHandler, type RouteOptions, Router, } from './Router';
+export type { DLQManagerFilter, DLQRecord, DLQStats, RetryPolicy } from './reliability';
+export { DeadLetterQueueManager, getDefaultRetryPolicy, getPresetRetryPolicy, RetryEngine, } from './reliability';
 export { ServiceProvider } from './ServiceProvider';
 export { Encrypter, type EncrypterOptions } from './security/Encrypter';
 export type { Channel, ShouldBroadcast } from './types/events';

package/dist/core/src/instrumentation/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @gravito/core - Instrumentation Module
+ *
+ * 提供 OpenTelemetry SDK 集成功能，包括分佈式追蹤與指標收集。
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   setupOpenTelemetry,
+ *   getOpenTelemetrySDK,
+ *   getTracer,
+ *   getMeter
+ * } from '@gravito/core'
+ *
+ * // 初始化 SDK
+ * await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   tracing: { enabled: true, exporter: 'jaeger' },
+ *   metrics: { enabled: true, exporter: 'prometheus' }
+ * })
+ *
+ * // 獲取 Tracer
+ * const tracer = await getTracer('my-module')
+ * const span = tracer.startSpan('my-operation')
+ *
+ * // 獲取 Meter
+ * const meter = await getMeter('my-module')
+ * const counter = meter.createCounter('request_count')
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { getMeter, getOpenTelemetrySDK, getTracer, isOpenTelemetryInitialized, resetOpenTelemetry, setupOpenTelemetry, shutdownOpenTelemetry, } from './opentelemetry';
+export type { MetricsConfig, MetricsExporter, OpenTelemetryConfig, OpenTelemetrySDK, TracingConfig, TracingExporter, } from './types';
+export { DEFAULT_CONFIG, OTEL_ENV_VARS } from './types';

package/dist/core/src/instrumentation/opentelemetry.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @gravito/core - OpenTelemetry SDK 集成
+ *
+ * 提供 OpenTelemetry 的初始化、配置與管理功能。
+ * 支援動態導入以實現可選依賴的優雅降級。
+ *
+ * @example
+ * ```typescript
+ * import { setupOpenTelemetry } from '@gravito/core'
+ *
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   serviceVersion: '1.0.0',
+ *   tracing: {
+ *     enabled: true,
+ *     exporter: 'jaeger',
+ *     samplingRate: 0.1
+ *   },
+ *   metrics: {
+ *     enabled: true,
+ *     exporter: 'prometheus',
+ *     prometheusPort: 9090
+ *   }
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type MetricsConfig, type OpenTelemetryConfig, type OpenTelemetrySDK, type TracingConfig } from './types';
+export type { MetricsConfig, OpenTelemetryConfig, OpenTelemetrySDK, TracingConfig };
+/**
+ * 初始化 OpenTelemetry SDK
+ *
+ * @param userConfig - 用戶配置
+ * @returns OpenTelemetry SDK 實例或 null（如果禁用或初始化失敗）
+ *
+ * @example
+ * ```typescript
+ * // 基本用法
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service'
+ * })
+ *
+ * // 完整配置
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   serviceVersion: '2.0.0',
+ *   environment: 'production',
+ *   tracing: {
+ *     enabled: true,
+ *     exporter: 'jaeger',
+ *     jaegerEndpoint: 'http://jaeger:14268/api/traces',
+ *     samplingRate: 0.1
+ *   },
+ *   metrics: {
+ *     enabled: true,
+ *     exporter: 'prometheus',
+ *     prometheusPort: 9090
+ *   }
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function setupOpenTelemetry(userConfig?: OpenTelemetryConfig): Promise<OpenTelemetrySDK | null>;
+/**
+ * 獲取全局 OpenTelemetry SDK 實例
+ *
+ * @returns SDK 實例或 null
+ *
+ * @example
+ * ```typescript
+ * const sdk = getOpenTelemetrySDK()
+ * if (sdk) {
+ *   console.log('Service:', sdk.serviceName)
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function getOpenTelemetrySDK(): OpenTelemetrySDK | null;
+/**
+ * 檢查 OpenTelemetry 是否已初始化
+ *
+ * @returns 初始化狀態
+ *
+ * @public
+ */
+export declare function isOpenTelemetryInitialized(): boolean;
+/**
+ * 關閉 OpenTelemetry SDK
+ *
+ * 應在應用程序關閉時調用，確保所有 spans 和 metrics 都被導出。
+ *
+ * @example
+ * ```typescript
+ * // 在應用程序退出前
+ * process.on('SIGTERM', async () => {
+ *   await shutdownOpenTelemetry()
+ *   process.exit(0)
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function shutdownOpenTelemetry(): Promise<void>;
+/**
+ * 重置 OpenTelemetry SDK（主要用於測試）
+ *
+ * 關閉現有 SDK 並重置所有狀態，允許重新初始化。
+ *
+ * @internal
+ */
+export declare function resetOpenTelemetry(): Promise<void>;
+/**
+ * 獲取 Tracer 實例
+ *
+ * @param name - Tracer 名稱（預設：@gravito/core）
+ * @param version - Tracer 版本
+ * @returns Tracer 實例
+ *
+ * @example
+ * ```typescript
+ * const tracer = getTracer('my-module')
+ * const span = tracer.startSpan('my-operation')
+ * // ... 執行操作
+ * span.end()
+ * ```
+ *
+ * @public
+ */
+export declare function getTracer(name?: string, version?: string): Promise<import("@opentelemetry/api").Tracer | {
+    startSpan: () => {
+        end: () => void;
+        setAttribute: () => void;
+        setStatus: () => void;
+        recordException: () => void;
+        addEvent: () => void;
+        isRecording: () => boolean;
+    };
+    startActiveSpan: (_name: string, fn: (span: any) => any) => any;
+}>;
+/**
+ * 獲取 Meter 實例
+ *
+ * @param name - Meter 名稱（預設：@gravito/core）
+ * @param version - Meter 版本
+ * @returns Meter 實例
+ *
+ * @example
+ * ```typescript
+ * const meter = getMeter('my-module')
+ * const counter = meter.createCounter('my_counter')
+ * counter.add(1, { key: 'value' })
+ * ```
+ *
+ * @public
+ */
+export declare function getMeter(name?: string, version?: string): Promise<import("@opentelemetry/api").Meter | {
+    createCounter: () => {
+        add: () => void;
+    };
+    createHistogram: () => {
+        record: () => void;
+    };
+    createUpDownCounter: () => {
+        add: () => void;
+    };
+    createObservableCounter: () => {
+        addCallback: () => void;
+    };
+    createObservableGauge: () => {
+        addCallback: () => void;
+    };
+    createObservableUpDownCounter: () => {
+        addCallback: () => void;
+    };
+}>;