@runtimescope/collector 0.10.0 → 0.10.2

package/dist/index.d.ts

@@ -915,10 +915,23 @@ declare class SqliteStore {
     addEvent(event: RuntimeEvent, project: string): void;
     flush(): void;
     saveSession(info: SessionInfoExtended): void;
+    /**
+     * Read every session record stored for a project. Used by the in-memory
+     * EventStore at startup to rehydrate the session→projectId map after a
+     * crash, so post-recovery `?project_id=...` queries return the right rows.
+     * Each row is returned as a `SessionInfo` shape compatible with EventStore.
+     */
+    getStoredSessions(project: string): SessionInfoExtended[];
     updateSessionDisconnected(sessionId: string, disconnectedAt: number): void;
     saveSessionMetrics(sessionId: string, project: string, metrics: unknown, label?: string): void;
     /** Remove oldest snapshots for a session beyond the retention limit */
     private pruneSnapshots;
+    /**
+     * Return the most recent `limit` events for a project, in chronological
+     * order (oldest-first). Used at startup to warm the in-memory ring buffer
+     * so MCP tools see recent activity immediately after a collector restart.
+     */
+    getRecentEvents(project: string, limit: number): RuntimeEvent[];
     getEvents(filter: HistoricalFilter): RuntimeEvent[];
     getEventCount(filter: HistoricalFilter): number;
     getSessions(project: string, limit?: number): SessionInfoExtended[];
@@ -929,6 +942,16 @@ declare class SqliteStore {
     private migrateSessionMetrics;
     deleteOldEvents(beforeTimestamp: number): number;
     vacuum(): void;
+    /**
+     * Atomically copy the live database to `targetPath` using SQLite's
+     * `VACUUM INTO`. The destination is a self-contained, defragmented copy of
+     * the DB at the moment the statement runs — no readers are blocked beyond
+     * the duration of the copy, and the WAL/journal contents are folded in.
+     * The target file must not already exist; SQLite refuses to overwrite.
+     *
+     * Returns the size in bytes of the resulting file.
+     */
+    snapshotTo(targetPath: string): number;
     close(): void;
 }
 
@@ -973,12 +996,36 @@ declare class EventStore {
     setRedactor(redactor: Redactor): void;
     get eventCount(): number;
     setSqliteStore(store: SqliteStore, project: string): void;
+    /**
+     * Pre-load recent events from a SqliteStore into the in-memory ring buffer.
+     * Used at collector startup to make MCP tools immediately useful after a
+     * restart — without this, the buffer is empty until the SDK reconnects and
+     * generates new traffic.
+     *
+     * Also rehydrates the session→projectId map from SqliteStore's `sessions`
+     * table. Without this, queries filtered by `project_id` after a crash
+     * return nothing because the in-memory map is empty: events are tagged
+     * by sessionId, and matchesProjectId() looks up the session record to
+     * find the project. (Pre-fix: only sessions whose `session` event happens
+     * to be in the warmed window got rehydrated, which is rare in long runs.)
+     *
+     * Does NOT propagate to SqliteStore (we just read FROM it). Ring-buffer
+     * eviction handles overflow naturally if multiple projects are warmed.
+     */
+    warmFromSqlite(sqliteStore: SqliteStore, project: string, limit: number): void;
     onEvent(callback: (event: RuntimeEvent) => void): void;
     removeEventListener(callback: (event: RuntimeEvent) => void): void;
     addEvent(event: RuntimeEvent): void;
     getNetworkRequests(filter?: NetworkFilter): NetworkEvent[];
     getConsoleMessages(filter?: ConsoleFilter): ConsoleEvent[];
     getSessionInfo(): SessionInfo[];
+    /**
+     * Fast O(sessions) event count for a specific projectId. Callers that just
+     * want to know "have any events arrived for project X yet?" should use this
+     * instead of `getAllEvents(..., projectId).length`, which allocates and
+     * filters the entire 10K-event ring buffer on every call.
+     */
+    eventCountForProject(projectId: string): number;
     markDisconnected(sessionId: string): void;
     getEventTimeline(filter?: TimelineFilter): RuntimeEvent[];
     getAllEvents(sinceSeconds?: number, sessionId?: string, projectId?: string): RuntimeEvent[];
@@ -1175,6 +1222,166 @@ declare function isValidProjectId(id: string): boolean;
  */
 declare function getOrCreateProjectId(projectManager: ProjectManager, appName: string): string;
 
+/**
+ * Minimal Prometheus-compatible metrics registry. Zero dependencies — the
+ * exposition format is small enough that pulling in `prom-client` would be
+ * heavier than just emitting the text ourselves.
+ *
+ * Two metric kinds are supported:
+ *   - Counter (monotonic) for things like total events, dropped events.
+ *   - Gauge (point-in-time) for things like current sessions connected,
+ *     ring-buffer occupancy. Gauges accept a `collect` callback so they
+ *     compute their value at scrape time rather than tracking state.
+ *
+ * Spec reference: https://prometheus.io/docs/instrumenting/exposition_formats/
+ */
+type LabelValues = Record<string, string>;
+interface Sample {
+    labels: LabelValues;
+    value: number;
+}
+declare abstract class Metric {
+    readonly name: string;
+    readonly help: string;
+    readonly labelNames: string[];
+    constructor(name: string, help: string, labelNames?: string[]);
+    abstract type(): 'counter' | 'gauge';
+    abstract collect(): Sample[];
+}
+declare class Counter extends Metric {
+    private values;
+    type(): 'counter';
+    inc(value?: number, labels?: LabelValues): void;
+    reset(): void;
+    collect(): Sample[];
+}
+declare class Gauge extends Metric {
+    private values;
+    private collectFn;
+    type(): 'gauge';
+    /**
+     * Set a fixed value for the given label set. Per the Prometheus spec, gauges
+     * may take any numeric value including +Inf / -Inf / NaN — the renderer
+     * handles formatting. Only actually-not-a-number inputs (`undefined`, etc.)
+     * are silently dropped.
+     */
+    set(value: number, labels?: LabelValues): void;
+    /**
+     * Compute the gauge dynamically at scrape time. Useful for things like
+     * "currently-connected sessions" where caching a stale value is wrong.
+     * Mutually exclusive with `set()` — last writer wins.
+     */
+    setCollect(fn: () => number | Sample[]): void;
+    collect(): Sample[];
+}
+declare class MetricsRegistry {
+    private metrics;
+    counter(name: string, help: string, labelNames?: string[]): Counter;
+    gauge(name: string, help: string, labelNames?: string[]): Gauge;
+    /** Serialize every registered metric in Prometheus exposition format. */
+    render(): string;
+}
+
+/**
+ * OpenTelemetry exporter — one-way bridge from RuntimeScope events to OTLP/HTTP.
+ *
+ * Each RuntimeScope event maps to one OTel signal:
+ *   - `network`     → trace span (HTTP client, kind=CLIENT)
+ *   - `database`    → trace span (DB client, kind=CLIENT)
+ *   - `render`      → trace span (kind=INTERNAL, attr `react.component`)
+ *   - `console`     → log record. `level=error` is severity=ERROR, with the
+ *                     stack trace as an `exception.stacktrace` attribute.
+ *   - `performance` → gauge metric (Web Vitals: LCP / FCP / CLS / INP / TTFB).
+ *
+ * State, session, ui-interaction, dom_snapshot, custom, navigation, and recon
+ * events have no clean OTel mapping and are skipped — downstream tools can
+ * still see everything via the RuntimeScope HTTP API directly.
+ *
+ * Session = trace. All events for one `sessionId` share a deterministic 16-byte
+ * trace ID derived from `sha256(sessionId)`, so a downstream OTel UI groups
+ * them. Span IDs are random per event.
+ *
+ * Wire format is OTLP/HTTP with JSON encoding — chosen specifically because it
+ * needs no Protobuf compiler, no deps, and is supported by every modern
+ * collector (otel-collector, Honeycomb refinery, Vector, Datadog, Tempo, etc.).
+ *
+ * Configuration is opt-in via env vars:
+ *   - RUNTIMESCOPE_OTEL_ENDPOINT       — e.g. "http://localhost:4318" (no path)
+ *   - RUNTIMESCOPE_OTEL_HEADERS        — "k1=v1,k2=v2" — for bearer tokens etc.
+ *   - RUNTIMESCOPE_OTEL_SERVICE_NAME   — defaults to "runtimescope-collector"
+ *
+ * Failure semantics: best-effort. We batch in memory, flush on a timer or
+ * size threshold, and drop on POST failure (logging at most once per failure).
+ * If the OTel endpoint is down, RuntimeScope itself is unaffected — that's
+ * the whole point of running this as a sidecar exporter.
+ */
+
+interface OtelExporterOptions {
+    /** Base URL of the OTel collector — no path. e.g. "http://localhost:4318". */
+    endpoint: string;
+    /** `service.name` resource attribute. Default "runtimescope-collector". */
+    serviceName?: string;
+    /** `service.namespace` resource attribute — useful for projectId. */
+    serviceNamespace?: string;
+    /** Extra HTTP headers (auth tokens, tenant IDs, etc.). */
+    headers?: Record<string, string>;
+    /** Force flush after this many milliseconds even if the buffer is small. Default 10s. */
+    flushIntervalMs?: number;
+    /** Force flush once we've accumulated this many signals. Default 1000. */
+    maxBatchSize?: number;
+}
+declare class OtelExporter {
+    private spans;
+    private logs;
+    private metrics;
+    private flushTimer;
+    private closed;
+    private lastFailureLog;
+    private readonly endpoint;
+    private readonly serviceName;
+    private readonly serviceNamespace;
+    private readonly headers;
+    private readonly maxBatchSize;
+    constructor(options: OtelExporterOptions);
+    /** Convert a RuntimeScope event to its OTel signal(s) and buffer. */
+    ingest(event: RuntimeEvent): void;
+    /** POST any buffered signals to the OTLP endpoint. */
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private networkToSpan;
+    private databaseToSpan;
+    /**
+     * Render events bundle multiple component profiles in one event. We emit
+     * one span per profile so the OTel UI can show each component's render
+     * timing independently — sharing the same trace via the sessionId.
+     */
+    private renderToSpans;
+    /**
+     * `console` events with `level: 'error'` carry stack traces; we surface them
+     * via OTel's exception attributes so log-search backends can show them
+     * inline. Lower-severity console events become plain log records.
+     */
+    private consoleToLog;
+    private performanceToMetric;
+    private resourceAttributes;
+    private wrapSpans;
+    private wrapLogs;
+    private wrapMetrics;
+    private send;
+    /** Rate-limit failure logs to once every 60s — don't spam stderr. */
+    private logFailure;
+}
+/**
+ * Build a deterministic 16-byte trace ID from the sessionId so every event
+ * for one session belongs to the same trace in the downstream UI.
+ */
+declare function traceIdFromSession(sessionId: string): string;
+declare function randomSpanId(): string;
+/** Parse `RUNTIMESCOPE_OTEL_HEADERS="k1=v1,k2=v2"` into a header map. */
+declare function parseOtelHeaders(raw: string | undefined): Record<string, string>;
+/** Build options from environment variables. Returns null if OTel is not configured. */
+declare function otelOptionsFromEnv(): OtelExporterOptions | null;
+
 interface RateLimitConfig {
     maxEventsPerSecond?: number;
     maxEventsPerMinute?: number;
@@ -1212,6 +1419,22 @@ declare function loadTlsOptions(config: TlsConfig): SecureContextOptions;
  */
 declare function resolveTlsConfig(): TlsConfig | null;
 
+interface SnapshotResult {
+    /** Absolute path to the snapshot directory. */
+    path: string;
+    /** ISO-like timestamp embedded in the directory name. */
+    timestamp: string;
+    /** Per-project sizes + event counts. */
+    projects: {
+        name: string;
+        sqliteBytes: number;
+        walBytes: number;
+        eventCount: number;
+    }[];
+    /** Total bytes written across all projects. */
+    totalBytes: number;
+}
+
 interface CollectorServerOptions {
     port?: number;
     host?: string;
@@ -1222,6 +1445,13 @@ interface CollectorServerOptions {
     authManager?: AuthManager;
     rateLimits?: RateLimitConfig;
     tls?: TlsConfig;
+    /**
+     * Optional OpenTelemetry exporter config. When set (or when
+     * `RUNTIMESCOPE_OTEL_ENDPOINT` is in the environment), every event the
+     * store accepts is converted into an OTLP signal and shipped to the
+     * configured endpoint. Failures are logged but never break ingestion.
+     */
+    otel?: OtelExporterOptions;
 }
 declare class CollectorServer {
     private wss;
@@ -1233,6 +1463,12 @@ declare class CollectorServer {
     private pendingHandshakes;
     private pendingCommands;
     private sqliteStores;
+    private wals;
+    private ready;
+    private metrics;
+    private startedAt;
+    private counters;
+    private otelExporter;
     private connectCallbacks;
     private disconnectCallbacks;
     private pruneTimer;
@@ -1240,6 +1476,8 @@ declare class CollectorServer {
     private tlsConfig;
     private pmStore;
     constructor(options?: CollectorServerOptions);
+    /** Public access to the metrics registry — HttpServer renders this at /metrics. */
+    getMetricsRegistry(): MetricsRegistry;
     getStore(): EventStore;
     getPort(): number | null;
     getClientCount(): number;
@@ -1251,10 +1489,55 @@ declare class CollectorServer {
     setPmStore(pmStore: PmStoreLike | null): void;
     onConnect(cb: (sessionId: string, projectName: string, projectId?: string) => void): void;
     onDisconnect(cb: (sessionId: string, projectName: string, projectId?: string) => void): void;
+    /** True after start() finishes recovery. False during startup or after stop(). */
+    isReady(): boolean;
+    /**
+     * Snapshot every project's SQLite DB and WAL into a fresh directory under
+     * `<runtimescope-root>/snapshots/<ISO>/`. Atomic via SQLite's `VACUUM INTO`;
+     * non-blocking for ongoing event ingestion (the live DB keeps accepting
+     * writes during the copy).
+     *
+     * Returns metadata for the admin endpoint to serialize.
+     */
+    createSnapshot(): SnapshotResult;
     start(options?: CollectorServerOptions): Promise<void>;
+    /**
+     * On collector startup, for each known project:
+     *   1. Replay any sealed/active WAL files into SqliteStore (mirror of the
+     *      lazy recovery in `ensureWal`, but proactive — handles the case where
+     *      a crashed project never reconnects).
+     *   2. Warm the in-memory ring buffer with recent events from SqliteStore so
+     *      MCP tools see history immediately, not just events from the next
+     *      session that connects.
+     *
+     * Runs synchronously — better-sqlite3 is sync — so callers can `await
+     * collector.start()` and trust the buffer is hot when it returns.
+     */
+    private runStartupRecovery;
     private tryStart;
     private handleStartError;
     private ensureSqliteStore;
+    private walDirFor;
+    /**
+     * Open (or return) the WAL for a project. Every event ingested for this
+     * project is first appended + fsync'd here before being pushed to the ring
+     * buffer and SqliteStore, so a crash between receipt and SqliteStore flush
+     * doesn't lose acknowledged events.
+     */
+    private ensureWal;
+    /**
+     * Replay any sealed or non-empty active WAL files into SqliteStore, then
+     * delete them. Called lazily the first time a project's WAL is opened — if
+     * the prior collector crashed mid-batch, those events survive in the WAL
+     * and we'd otherwise leave them stranded on disk forever.
+     */
+    private recoverWalForProject;
+    /**
+     * Rotate the project's WAL, flush SqliteStore so the rotated file's events
+     * are persisted, then delete the sealed file. Called when the active file
+     * has grown past its rotate threshold.
+     */
+    private checkpointWal;
     /** Catch runtime errors on the WSS so an unhandled error doesn't crash the process */
     private setupPersistentErrorHandler;
     /** Ping all connected clients every 15s — terminate those that don't respond */
@@ -1404,6 +1687,85 @@ interface MigrationResult {
  */
 declare function migrateProjectIds(projectManager: ProjectManager, pmStore?: MigratablePmStore | null): MigrationResult;
 
+/**
+ * Write-ahead log for the collector. One WAL directory per project, holding
+ * an append-only JSONL file (`active.jsonl`) plus zero or more sealed files
+ * that have been rotated out. The durability contract is:
+ *
+ *   append(events) + commit() → events are on disk (fsync'd).
+ *
+ * `append` buffers into the OS file table (a plain `write` syscall); `commit`
+ * calls `fsync` to force the bytes to stable storage. Callers should batch
+ * appends within a single SDK message and call `commit` once per batch.
+ *
+ * On rotation, the active file is renamed to `sealed-<ts>-<seq>.jsonl` and a
+ * fresh active file is opened. Sealed files stay on disk until the collector
+ * confirms the corresponding events are durable in SqliteStore, at which
+ * point they're safe to delete.
+ *
+ * On crash + restart, any remaining sealed or active files are evidence of
+ * events that may not have reached SqliteStore. Replay feeds them back into
+ * the store path, then deletes the WAL files.
+ */
+
+interface WalOptions {
+    /** Directory to hold WAL files — created if missing. */
+    dir: string;
+    /** Rotate the active file once it grows past this size in bytes. */
+    rotateSizeBytes?: number;
+}
+declare class Wal {
+    private dir;
+    private rotateSize;
+    private fd;
+    private activeSize;
+    private seq;
+    private closed;
+    constructor(options: WalOptions);
+    private openActive;
+    private activePath;
+    /**
+     * Buffer events into the active file. Not durable yet — must be followed by
+     * `commit()` before the caller treats the events as persisted.
+     */
+    append(events: RuntimeEvent[]): void;
+    /** fsync the active file. Durability contract: returns only after bytes are on stable storage. */
+    commit(): void;
+    /** True if the active file has exceeded the rotate threshold. */
+    shouldRotate(): boolean;
+    /**
+     * Rotate the active file: fsync, close, rename to `sealed-<ts>-<seq>.jsonl`,
+     * then open a fresh active file. Returns the sealed path so the caller can
+     * schedule deletion after confirming persistence elsewhere.
+     */
+    rotate(): string | null;
+    /** Remove a sealed file once its events are durable in the downstream store. */
+    static deleteSealed(path: string): void;
+    /** List sealed files in this WAL's directory, sorted oldest-first. */
+    listSealed(): string[];
+    /**
+     * Parse a WAL file back into its events, skipping any corrupt or truncated
+     * trailing line. A crash mid-append can leave a partial line; the parser
+     * tolerates it because fsync had never completed for that line, which means
+     * the event was never treated as durable.
+     */
+    static readFile(path: string): RuntimeEvent[];
+    /**
+     * List the WAL files that need recovery for a project: any sealed files
+     * plus the active file if it has content. Returned in ingestion order
+     * (sealed oldest-first, then active last).
+     */
+    static listRecoveryFiles(dir: string): string[];
+    close(): void;
+    /**
+     * Copy the active file (post-fsync) and any sealed files into `targetDir`.
+     * Returns the total bytes copied. Used by snapshot endpoints — pairing the
+     * SQLite snapshot with the WAL means a restore captures any events that
+     * hadn't yet been drained into SQLite at snapshot time.
+     */
+    snapshotTo(targetDir: string): number;
+}
+
 declare function isSqliteAvailable(): boolean;
 
 declare class ApiDiscoveryEngine {
@@ -1578,7 +1940,17 @@ interface PmWorkspace {
  * events from that key.
  */
 interface PmApiKey {
+    /**
+     * Raw secret. Populated ONLY by `createApiKey()`'s return value — the caller
+     * must store it on the spot. Every subsequent read (list/get) returns this
+     * field as an empty string; the server stores a SHA-256 hash, not the
+     * plaintext, so there is no way to recover it later.
+     */
     key: string;
+    /** User-visible identifier — first ~11 chars of the raw token, e.g. "tk_9f2a1c3b". Safe to log. */
+    keyPrefix: string;
+    /** Last 4 chars of the raw token — for visual confirmation ("...a4f1"). */
+    keyLast4: string;
     workspaceId: string;
     label: string;
     createdAt: number;
@@ -1806,8 +2178,26 @@ declare class PmStore {
     setProjectWorkspace(projectId: string, workspaceId: string): void;
     createApiKey(workspaceId: string, label: string, expiresAt?: number): PmApiKey;
     listApiKeys(workspaceId: string): PmApiKey[];
-    revokeApiKey(key: string): void;
-    getWorkspaceByApiKey(key: string): PmWorkspace | null;
+    /** Revoke by the public prefix (what the dashboard shows), not the raw secret. */
+    revokeApiKey(prefix: string): void;
+    /** Look up an API key's workspace by its public prefix. Used for per-workspace authorization on the revoke route. */
+    findApiKeyByPrefix(prefix: string): PmApiKey | null;
+    /**
+     * True if any non-revoked workspace API key exists. The HTTP auth gate uses
+     * this to enforce auth whenever workspace keys are in play, even when the
+     * global AuthManager has no keys configured. Without this check, a user who
+     * creates a workspace key expecting it to gate access gets no auth at all
+     * (the H5 bypass).
+     */
+    hasActiveApiKeys(): boolean;
+    /**
+     * Given a runtime projectId (proj_xxx), return the workspaceId it belongs to,
+     * or null if the projectId isn't registered with any PM project. Used to
+     * enforce per-workspace isolation on event-read routes — the caller can only
+     * query events from runtime projects owned by their workspace.
+     */
+    getWorkspaceIdByRuntimeProjectId(runtimeProjectId: string): string | null;
+    getWorkspaceByApiKey(rawKey: string): PmWorkspace | null;
     private mapProjectRow;
     createTask(task: PmTask): PmTask;
     updateTask(id: string, updates: Partial<PmTask>): void;
@@ -1978,6 +2368,10 @@ declare class HttpServer {
     private connectedSessionsGetter;
     private pmStore;
     private projectManager;
+    private isReadyGetter;
+    private snapshotFn;
+    private lastSnapshotAt;
+    private renderMetricsFn;
     constructor(store: EventStore, processMonitor?: ProcessMonitor, options?: {
         authManager?: AuthManager;
         allowedOrigins?: string[];
@@ -1989,6 +2383,37 @@ declare class HttpServer {
             projectName: string;
         }[];
         projectManager?: ProjectManager;
+        /**
+         * Returns true once the collector has finished startup recovery
+         * (WAL replay + ring-buffer warm). Drives the `/readyz` probe — load
+         * balancers and attach-mode detection should wait for ready before
+         * routing traffic.
+         */
+        isReady?: () => boolean;
+        /**
+         * Called by `POST /api/v1/admin/snapshot`. Implementations should copy
+         * every project's SQLite + WAL into a fresh directory and return a
+         * manifest. Admin-only on the route side; rate-limited to prevent
+         * snapshot loops.
+         */
+        createSnapshot?: () => {
+            path: string;
+            timestamp: string;
+            projects: {
+                name: string;
+                sqliteBytes: number;
+                walBytes: number;
+                eventCount: number;
+            }[];
+            totalBytes: number;
+        };
+        /**
+         * Returns the Prometheus exposition body for `GET /metrics`. Public
+         * (no auth) so a Prometheus scraper can hit it without configuring a
+         * bearer token — that's the standard pattern. Opt out via the
+         * `RUNTIMESCOPE_DISABLE_METRICS=1` env var.
+         */
+        renderMetrics?: () => string;
     });
     private registerRoutes;
     /**
@@ -1996,6 +2421,21 @@ declare class HttpServer {
      * Tries multiple locations for monorepo and installed-package scenarios.
      */
     private resolveSdkPath;
+    getPort(): number;
+    /**
+     * Validate the `project_id` query parameter against the caller's workspace.
+     *
+     * Returns:
+     *   - `string`  — the caller is authorized; pass to store.
+     *   - `undefined` — caller is admin and didn't specify a project_id (all projects allowed).
+     *   - `false`   — not authorized (a 400 or 403 response has already been written); the handler must return immediately.
+     *
+     * Callers with a workspace-scoped token MUST provide `project_id`, and it
+     * must resolve to a PM project in the caller's workspace. Runtime projectIds
+     * without a PM record (never registered via setup_project) fall through to
+     * admin-only; workspace-scoped callers get 403.
+     */
+    private authorizeProjectIdParam;
     start(options?: HttpServerOptions): Promise<void>;
     private tryStart;
     stop(): Promise<void>;
@@ -2051,4 +2491,4 @@ declare function parseProcessList(): ProcessInfo[];
 /** Get RSS memory in MB for a given PID. Cross-platform. */
 declare function getProcessMemoryMB(pid: number): number;
 
-export { type ApiChangeRecord, type ApiContract, type ApiContractField, ApiDiscoveryEngine, type ApiEndpoint, type ApiEndpointHealth, type ApiKeyEntry, type AuthConfig, type AuthInfo, AuthManager, BUILT_IN_RULES, type BackgroundSpriteSheet, type BaseEvent, type BuildMeta, type BuildStatus, type CSSArchitecture, type CSSCustomProperty, type CapexClassification, type CapexSummary, type CaptureConfig, CollectorServer, type CollectorServerOptions, type ColorToken, type CommandResponse, type ComputedStyleEntry, ConnectionManager, type ConsoleEvent, type ConsoleFilter, type ConsoleLevel, type CustomEvent, type CustomEventFilter, DataBrowser, type DatabaseConnectionConfig, type DatabaseEvent, type DatabaseFilter, type DatabaseOperation, type DatabaseSchema, type DatabaseSource, type DeployLog, type DetectedBuildTool, type DetectedFramework, type DetectedHosting, type DetectedIssue, type DetectedMetaFramework, type DetectedUILibrary, type DevProcess, type DevProcessType, type DomSnapshotEvent, type ElementSnapshotNode, type EventBatchPayload, EventStore, type EventType, type FontFaceInfo, type FontUsage, type FormFieldInfo, type GitCommit, type GitFileChange, type GitFileStatus, type GitStatus, type GlobalConfig, type GraphQLOperation, type HandshakePayload, type HeadingInfo, type HistoricalFilter, HttpServer, type HttpServerOptions, type IconFontInfo, type ImageAsset, type IndexSuggestion, InfraConnector, type InfraOverview, type InfrastructureConfig, type InlineSVGAsset, type InteractiveElementInfo, type IssueSeverity, type LandmarkInfo, type LayoutNode, type ManagedConnection, type MaskSpriteSheet, type MemoryFile, type MetricDelta, type NavigationEvent, type NetworkEvent, type NetworkFilter, type NormalizedQueryStats, type PerformanceEvent, type PerformanceFilter, type PerformanceMetricName, type PmApiKey, type PmCapexEntry, type PmNote, type PmProject, type PmSession, PmStore, type PmStoreIndexSource, type PmTask, type PmWorkspace, type PortUsage, type ProcessInfo, ProcessMonitor, type ProjectConfig, ProjectDiscovery, ProjectManager, type ProjectPhase, type ProjectStatus, type RateLimitConfig, type ReadOptions, type ReadResult, type ReconAccessibilityEvent, type ReconAssetInventoryEvent, type ReconComputedStylesEvent, type ReconDesignTokensEvent, type ReconElementSnapshotEvent, type ReconEventType, type ReconFilter, type ReconFontsEvent, type ReconLayoutTreeEvent, type ReconMetadataEvent, type RedactionRule, Redactor, type RedactorConfig, type RenderComponentProfile, type RenderEvent, type RenderFilter, RingBuffer, type RulesFiles, type RuntimeEvent, type RuntimeLog, type RuntimeScopeProjectConfig, type SVGSpriteSymbol, type SchemaColumn, type SchemaForeignKey, type SchemaIndex, SchemaIntrospector, type SchemaTable, type SdkEntry, type ServerCommand, type ServerMetricName, type ServiceInfo, type SessionDiffResult, type SessionEvent, type SessionInfo, type SessionInfoExtended, SessionManager, type SessionMetrics, SessionRateLimiter, type SessionSnapshot, type SessionStats, type SpacingValue, type SpriteFrame, SqliteStore, type SqliteStoreOptions, type StateEvent, type StateFilter, type TaskPriority, type TaskSource, type TaskStatus, type TechStackDetection, type TimelineFilter, type TlsConfig, type ToolResponse, type TypographyToken, type UIInteractionAction, type UIInteractionEvent, type UIInteractionFilter, type UserContext, type WSMessage, type WebVitalRating, type WorkType, type WriteOptions, type WriteResult, aggregateQueryStats, calculateActiveMinutes, calculateCostMicrodollars, compareSessions, detectIssues, detectN1Queries, detectOverfetching, detectSlowQueries, findPidsInDirectory, generateApiKey, generateProjectId, getListenPorts, getOrCreateProjectId, getPidsOnPort, getProcessCwd, getProcessMemoryMB, isSqliteAvailable, isValidProjectId, loadTlsOptions, migrateProjectIds, parseProcessList, parseSessionJsonl, readProjectConfig, resolveProjectAppNames, resolveTlsConfig, scaffoldProjectConfig, suggestIndexes, writeProjectConfig };
+export { type ApiChangeRecord, type ApiContract, type ApiContractField, ApiDiscoveryEngine, type ApiEndpoint, type ApiEndpointHealth, type ApiKeyEntry, type AuthConfig, type AuthInfo, AuthManager, BUILT_IN_RULES, type BackgroundSpriteSheet, type BaseEvent, type BuildMeta, type BuildStatus, type CSSArchitecture, type CSSCustomProperty, type CapexClassification, type CapexSummary, type CaptureConfig, CollectorServer, type CollectorServerOptions, type ColorToken, type CommandResponse, type ComputedStyleEntry, ConnectionManager, type ConsoleEvent, type ConsoleFilter, type ConsoleLevel, Counter, type CustomEvent, type CustomEventFilter, DataBrowser, type DatabaseConnectionConfig, type DatabaseEvent, type DatabaseFilter, type DatabaseOperation, type DatabaseSchema, type DatabaseSource, type DeployLog, type DetectedBuildTool, type DetectedFramework, type DetectedHosting, type DetectedIssue, type DetectedMetaFramework, type DetectedUILibrary, type DevProcess, type DevProcessType, type DomSnapshotEvent, type ElementSnapshotNode, type EventBatchPayload, EventStore, type EventType, type FontFaceInfo, type FontUsage, type FormFieldInfo, Gauge, type GitCommit, type GitFileChange, type GitFileStatus, type GitStatus, type GlobalConfig, type GraphQLOperation, type HandshakePayload, type HeadingInfo, type HistoricalFilter, HttpServer, type HttpServerOptions, type IconFontInfo, type ImageAsset, type IndexSuggestion, InfraConnector, type InfraOverview, type InfrastructureConfig, type InlineSVGAsset, type InteractiveElementInfo, type IssueSeverity, type LabelValues, type LandmarkInfo, type LayoutNode, type ManagedConnection, type MaskSpriteSheet, type MemoryFile, type MetricDelta, MetricsRegistry, type NavigationEvent, type NetworkEvent, type NetworkFilter, type NormalizedQueryStats, OtelExporter, type OtelExporterOptions, type PerformanceEvent, type PerformanceFilter, type PerformanceMetricName, type PmApiKey, type PmCapexEntry, type PmNote, type PmProject, type PmSession, PmStore, type PmStoreIndexSource, type PmTask, type PmWorkspace, type PortUsage, type ProcessInfo, ProcessMonitor, type ProjectConfig, ProjectDiscovery, ProjectManager, type ProjectPhase, type ProjectStatus, type RateLimitConfig, type ReadOptions, type ReadResult, type ReconAccessibilityEvent, type ReconAssetInventoryEvent, type ReconComputedStylesEvent, type ReconDesignTokensEvent, type ReconElementSnapshotEvent, type ReconEventType, type ReconFilter, type ReconFontsEvent, type ReconLayoutTreeEvent, type ReconMetadataEvent, type RedactionRule, Redactor, type RedactorConfig, type RenderComponentProfile, type RenderEvent, type RenderFilter, RingBuffer, type RulesFiles, type RuntimeEvent, type RuntimeLog, type RuntimeScopeProjectConfig, type SVGSpriteSymbol, type SchemaColumn, type SchemaForeignKey, type SchemaIndex, SchemaIntrospector, type SchemaTable, type SdkEntry, type ServerCommand, type ServerMetricName, type ServiceInfo, type SessionDiffResult, type SessionEvent, type SessionInfo, type SessionInfoExtended, SessionManager, type SessionMetrics, SessionRateLimiter, type SessionSnapshot, type SessionStats, type SnapshotResult, type SpacingValue, type SpriteFrame, SqliteStore, type SqliteStoreOptions, type StateEvent, type StateFilter, type TaskPriority, type TaskSource, type TaskStatus, type TechStackDetection, type TimelineFilter, type TlsConfig, type ToolResponse, type TypographyToken, type UIInteractionAction, type UIInteractionEvent, type UIInteractionFilter, type UserContext, type WSMessage, Wal, type WalOptions, type WebVitalRating, type WorkType, type WriteOptions, type WriteResult, aggregateQueryStats, calculateActiveMinutes, calculateCostMicrodollars, compareSessions, detectIssues, detectN1Queries, detectOverfetching, detectSlowQueries, findPidsInDirectory, generateApiKey, generateProjectId, getListenPorts, getOrCreateProjectId, getPidsOnPort, getProcessCwd, getProcessMemoryMB, isSqliteAvailable, isValidProjectId, loadTlsOptions, migrateProjectIds, otelOptionsFromEnv, parseOtelHeaders, parseProcessList, parseSessionJsonl, randomSpanId, readProjectConfig, resolveProjectAppNames, resolveTlsConfig, scaffoldProjectConfig, suggestIndexes, traceIdFromSession, writeProjectConfig };

package/dist/index.js

@@ -2,8 +2,12 @@ import {
   AuthManager,
   BUILT_IN_RULES,
   CollectorServer,
+  Counter,
   EventStore,
+  Gauge,
   HttpServer,
+  MetricsRegistry,
+  OtelExporter,
   PmStore,
   ProjectDiscovery,
   ProjectManager,
@@ -12,6 +16,7 @@ import {
   SessionManager,
   SessionRateLimiter,
   SqliteStore,
+  Wal,
   calculateActiveMinutes,
   calculateCostMicrodollars,
   findPidsInDirectory,
@@ -26,14 +31,18 @@ import {
   isValidProjectId,
   loadTlsOptions,
   migrateProjectIds,
+  otelOptionsFromEnv,
+  parseOtelHeaders,
   parseProcessList,
   parseSessionJsonl,
+  randomSpanId,
   readProjectConfig,
   resolveProjectAppNames,
   resolveTlsConfig,
   scaffoldProjectConfig,
+  traceIdFromSession,
   writeProjectConfig
-} from "./chunk-WWFIEANS.js";
+} from "./chunk-M2V4EFJY.js";
 import {
   __require
 } from "./chunk-UP2VWCW5.js";
@@ -2036,10 +2045,14 @@ export {
   BUILT_IN_RULES,
   CollectorServer,
   ConnectionManager,
+  Counter,
   DataBrowser,
   EventStore,
+  Gauge,
   HttpServer,
   InfraConnector,
+  MetricsRegistry,
+  OtelExporter,
   PmStore,
   ProcessMonitor,
   ProjectDiscovery,
@@ -2050,6 +2063,7 @@ export {
   SessionManager,
   SessionRateLimiter,
   SqliteStore,
+  Wal,
   aggregateQueryStats,
   calculateActiveMinutes,
   calculateCostMicrodollars,
@@ -2070,13 +2084,17 @@ export {
   isValidProjectId,
   loadTlsOptions,
   migrateProjectIds,
+  otelOptionsFromEnv,
+  parseOtelHeaders,
   parseProcessList,
   parseSessionJsonl,
+  randomSpanId,
   readProjectConfig,
   resolveProjectAppNames,
   resolveTlsConfig,
   scaffoldProjectConfig,
   suggestIndexes,
+  traceIdFromSession,
   writeProjectConfig
 };
 //# sourceMappingURL=index.js.map