@runtimescope/collector 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,1356 @@
+import { SecureContextOptions } from 'node:tls';
+
+type EventType = 'network' | 'console' | 'session' | 'state' | 'render' | 'dom_snapshot' | 'performance' | 'database' | 'recon_metadata' | 'recon_design_tokens' | 'recon_fonts' | 'recon_layout_tree' | 'recon_accessibility' | 'recon_computed_styles' | 'recon_element_snapshot' | 'recon_asset_inventory';
+interface BaseEvent {
+    eventId: string;
+    sessionId: string;
+    timestamp: number;
+    eventType: EventType;
+}
+interface GraphQLOperation {
+    type: 'query' | 'mutation' | 'subscription';
+    name: string;
+}
+interface NetworkEvent extends BaseEvent {
+    eventType: 'network';
+    url: string;
+    method: string;
+    status: number;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    requestBodySize: number;
+    responseBodySize: number;
+    duration: number;
+    ttfb: number;
+    graphqlOperation?: GraphQLOperation;
+    requestBody?: string;
+    responseBody?: string;
+    errorPhase?: 'error' | 'abort' | 'timeout';
+    errorMessage?: string;
+    source?: 'fetch' | 'xhr' | 'node-http' | 'node-https';
+}
+type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'trace';
+interface ConsoleEvent extends BaseEvent {
+    eventType: 'console';
+    level: ConsoleLevel;
+    message: string;
+    args: unknown[];
+    stackTrace?: string;
+    sourceFile?: string;
+}
+interface BuildMeta {
+    gitCommit?: string;
+    gitBranch?: string;
+    buildTime?: string;
+    deployId?: string;
+}
+interface SessionEvent extends BaseEvent {
+    eventType: 'session';
+    appName: string;
+    connectedAt: number;
+    sdkVersion: string;
+    buildMeta?: BuildMeta;
+}
+interface StateEvent extends BaseEvent {
+    eventType: 'state';
+    storeId: string;
+    library: 'zustand' | 'redux' | 'unknown';
+    phase: 'init' | 'update';
+    state: unknown;
+    previousState?: unknown;
+    diff?: Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+    action?: {
+        type: string;
+        payload?: unknown;
+    };
+    stackTrace?: string;
+}
+interface RenderComponentProfile {
+    componentName: string;
+    renderCount: number;
+    totalDuration: number;
+    avgDuration: number;
+    lastRenderPhase: 'mount' | 'update' | 'unmount';
+    lastRenderCause?: 'props' | 'state' | 'context' | 'parent' | 'unknown';
+    renderVelocity: number;
+    suspicious: boolean;
+}
+interface RenderEvent extends BaseEvent {
+    eventType: 'render';
+    profiles: RenderComponentProfile[];
+    snapshotWindowMs: number;
+    totalRenders: number;
+    suspiciousComponents: string[];
+}
+interface DomSnapshotEvent extends BaseEvent {
+    eventType: 'dom_snapshot';
+    html: string;
+    url: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    scrollPosition: {
+        x: number;
+        y: number;
+    };
+    elementCount: number;
+    truncated: boolean;
+}
+type WebVitalRating = 'good' | 'needs-improvement' | 'poor';
+type ServerMetricName = 'memory.rss' | 'memory.heapUsed' | 'memory.heapTotal' | 'memory.external' | 'eventloop.lag.mean' | 'eventloop.lag.p99' | 'eventloop.lag.max' | 'gc.pause.major' | 'gc.pause.minor' | 'cpu.user' | 'cpu.system' | 'handles.active' | 'requests.active';
+type PerformanceMetricName = 'LCP' | 'FCP' | 'CLS' | 'TTFB' | 'FID' | 'INP' | ServerMetricName;
+interface PerformanceEvent extends BaseEvent {
+    eventType: 'performance';
+    metricName: PerformanceMetricName;
+    value: number;
+    rating?: WebVitalRating;
+    unit?: 'bytes' | 'ms' | 'percent' | 'count' | 'score';
+    element?: string;
+    entries?: unknown[];
+}
+type DatabaseOperation = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'OTHER';
+type DatabaseSource = 'prisma' | 'drizzle' | 'knex' | 'pg' | 'mysql2' | 'better-sqlite3' | 'generic';
+interface DatabaseEvent extends BaseEvent {
+    eventType: 'database';
+    query: string;
+    normalizedQuery: string;
+    duration: number;
+    rowsReturned?: number;
+    rowsAffected?: number;
+    tablesAccessed: string[];
+    operation: DatabaseOperation;
+    source: DatabaseSource;
+    stackTrace?: string;
+    label?: string;
+    error?: string;
+    params?: string;
+}
+type DetectedFramework = 'react' | 'vue' | 'angular' | 'svelte' | 'solid' | 'preact' | 'htmx' | 'unknown';
+type DetectedMetaFramework = 'nextjs' | 'nuxt' | 'sveltekit' | 'remix' | 'astro' | 'gatsby' | 'unknown';
+type DetectedUILibrary = 'tailwind' | 'mui' | 'chakra' | 'shadcn' | 'bootstrap' | 'antd' | 'radix' | 'unknown';
+type DetectedBuildTool = 'webpack' | 'vite' | 'turbopack' | 'esbuild' | 'parcel' | 'rollup' | 'unknown';
+type DetectedHosting = 'vercel' | 'netlify' | 'cloudflare' | 'aws' | 'firebase' | 'railway' | 'unknown';
+interface TechStackDetection {
+    name: string;
+    confidence: 'high' | 'medium' | 'low';
+    version?: string;
+    evidence: string[];
+}
+interface ReconMetadataEvent extends BaseEvent {
+    eventType: 'recon_metadata';
+    url: string;
+    title: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    documentLang?: string;
+    metaTags: Record<string, string>;
+    techStack: {
+        framework: TechStackDetection;
+        metaFramework?: TechStackDetection;
+        uiLibrary?: TechStackDetection;
+        buildTool?: TechStackDetection;
+        hosting?: TechStackDetection;
+        stateManagement?: TechStackDetection;
+        additional: TechStackDetection[];
+    };
+    externalStylesheets: {
+        href: string;
+        crossOrigin: boolean;
+    }[];
+    externalScripts: {
+        src: string;
+        async: boolean;
+        defer: boolean;
+        type?: string;
+    }[];
+    preloads: {
+        href: string;
+        as: string;
+    }[];
+}
+interface CSSCustomProperty {
+    name: string;
+    value: string;
+    source: string;
+}
+interface ColorToken {
+    value: string;
+    hex: string;
+    usageCount: number;
+    properties: string[];
+    sampleSelectors: string[];
+}
+interface TypographyToken {
+    fontFamily: string;
+    fontSize: string;
+    fontWeight: string;
+    lineHeight: string;
+    letterSpacing: string;
+    usageCount: number;
+    sampleSelectors: string[];
+}
+interface SpacingValue {
+    value: string;
+    pixels: number;
+    usageCount: number;
+    properties: string[];
+}
+type CSSArchitecture = 'tailwind' | 'css-modules' | 'styled-components' | 'css-in-js' | 'bem' | 'atomic' | 'vanilla' | 'unknown';
+interface ReconDesignTokensEvent extends BaseEvent {
+    eventType: 'recon_design_tokens';
+    url: string;
+    customProperties: CSSCustomProperty[];
+    colors: ColorToken[];
+    typography: TypographyToken[];
+    spacing: SpacingValue[];
+    borderRadii: {
+        value: string;
+        usageCount: number;
+    }[];
+    boxShadows: {
+        value: string;
+        usageCount: number;
+    }[];
+    cssArchitecture: CSSArchitecture;
+    classNamingPatterns: string[];
+    sampleClassNames: string[];
+}
+interface FontFaceInfo {
+    family: string;
+    weight: string;
+    style: string;
+    src: string;
+    display?: string;
+    unicodeRange?: string;
+}
+interface FontUsage {
+    family: string;
+    weight: string;
+    style: string;
+    usageCount: number;
+    sampleSelectors: string[];
+}
+interface ReconFontsEvent extends BaseEvent {
+    eventType: 'recon_fonts';
+    url: string;
+    fontFaces: FontFaceInfo[];
+    fontsUsed: FontUsage[];
+    iconFonts: {
+        family: string;
+        glyphsUsed: {
+            codepoint: string;
+            selector: string;
+        }[];
+    }[];
+    loadingStrategy: string;
+}
+interface LayoutNode {
+    tag: string;
+    id?: string;
+    classList: string[];
+    role?: string;
+    ariaLabel?: string;
+    dataAttributes: Record<string, string>;
+    boundingRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    display: string;
+    position: string;
+    flexDirection?: string;
+    justifyContent?: string;
+    alignItems?: string;
+    flexWrap?: string;
+    gap?: string;
+    gridTemplateColumns?: string;
+    gridTemplateRows?: string;
+    overflow?: string;
+    zIndex?: string;
+    opacity?: string;
+    children: LayoutNode[];
+    childCount: number;
+    textContent?: string;
+}
+interface ReconLayoutTreeEvent extends BaseEvent {
+    eventType: 'recon_layout_tree';
+    url: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    scrollHeight: number;
+    rootSelector?: string;
+    tree: LayoutNode;
+    totalElements: number;
+    maxDepth: number;
+}
+interface HeadingInfo {
+    level: number;
+    text: string;
+    selector: string;
+}
+interface LandmarkInfo {
+    role: string;
+    label?: string;
+    selector: string;
+}
+interface FormFieldInfo {
+    tag: string;
+    type?: string;
+    name?: string;
+    label?: string;
+    required: boolean;
+    ariaDescribedBy?: string;
+    selector: string;
+}
+interface InteractiveElementInfo {
+    tag: string;
+    role?: string;
+    text: string;
+    ariaLabel?: string;
+    href?: string;
+    tabIndex?: number;
+    selector: string;
+}
+interface ReconAccessibilityEvent extends BaseEvent {
+    eventType: 'recon_accessibility';
+    url: string;
+    headings: HeadingInfo[];
+    landmarks: LandmarkInfo[];
+    formFields: FormFieldInfo[];
+    links: InteractiveElementInfo[];
+    buttons: InteractiveElementInfo[];
+    images: {
+        src: string;
+        alt: string;
+        hasAlt: boolean;
+        selector: string;
+    }[];
+    issues: string[];
+}
+interface ComputedStyleEntry {
+    selector: string;
+    matchCount: number;
+    styles: Record<string, string>;
+    variations?: {
+        property: string;
+        values: {
+            value: string;
+            count: number;
+        }[];
+    }[];
+}
+interface ReconComputedStylesEvent extends BaseEvent {
+    eventType: 'recon_computed_styles';
+    url: string;
+    selector: string;
+    propertyFilter?: string[];
+    entries: ComputedStyleEntry[];
+}
+interface ElementSnapshotNode {
+    tag: string;
+    id?: string;
+    classList: string[];
+    attributes: Record<string, string>;
+    textContent?: string;
+    boundingRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    computedStyles: Record<string, string>;
+    children: ElementSnapshotNode[];
+}
+interface ReconElementSnapshotEvent extends BaseEvent {
+    eventType: 'recon_element_snapshot';
+    url: string;
+    selector: string;
+    depth: number;
+    root: ElementSnapshotNode;
+    totalNodes: number;
+}
+interface ImageAsset {
+    src: string;
+    alt?: string;
+    width: number;
+    height: number;
+    naturalWidth?: number;
+    naturalHeight?: number;
+    format?: string;
+    loading?: string;
+    selector: string;
+}
+interface SpriteFrame {
+    selector: string;
+    cropX: number;
+    cropY: number;
+    cropWidth: number;
+    cropHeight: number;
+    extractedDataUrl?: string;
+}
+interface BackgroundSpriteSheet {
+    sheetUrl: string;
+    sheetWidth?: number;
+    sheetHeight?: number;
+    frames: SpriteFrame[];
+}
+interface SVGSpriteSymbol {
+    id: string;
+    viewBox?: string;
+    paths: string;
+    referencedBy: string[];
+}
+interface IconFontInfo {
+    fontFamily: string;
+    fontFaceUrl?: string;
+    glyphs: {
+        codepoint: string;
+        pseudoElement: string;
+        selector: string;
+        renderedSize: number;
+    }[];
+}
+interface InlineSVGAsset {
+    selector: string;
+    viewBox?: string;
+    width?: number;
+    height?: number;
+    source: string;
+}
+interface MaskSpriteSheet {
+    sheetUrl: string;
+    sheetWidth?: number;
+    sheetHeight?: number;
+    frames: SpriteFrame[];
+}
+interface ReconAssetInventoryEvent extends BaseEvent {
+    eventType: 'recon_asset_inventory';
+    url: string;
+    images: ImageAsset[];
+    inlineSVGs: InlineSVGAsset[];
+    svgSprites: SVGSpriteSymbol[];
+    backgroundSprites: BackgroundSpriteSheet[];
+    maskSprites: MaskSpriteSheet[];
+    iconFonts: IconFontInfo[];
+    totalAssets: number;
+}
+interface ReconFilter {
+    reconType?: ReconEventType;
+    sinceSeconds?: number;
+    sessionId?: string;
+    url?: string;
+}
+type ReconEventType = 'recon_metadata' | 'recon_design_tokens' | 'recon_fonts' | 'recon_layout_tree' | 'recon_accessibility' | 'recon_computed_styles' | 'recon_element_snapshot' | 'recon_asset_inventory';
+type RuntimeEvent = NetworkEvent | ConsoleEvent | SessionEvent | StateEvent | RenderEvent | DomSnapshotEvent | PerformanceEvent | DatabaseEvent | ReconMetadataEvent | ReconDesignTokensEvent | ReconFontsEvent | ReconLayoutTreeEvent | ReconAccessibilityEvent | ReconComputedStylesEvent | ReconElementSnapshotEvent | ReconAssetInventoryEvent;
+interface NetworkFilter {
+    sinceSeconds?: number;
+    urlPattern?: string;
+    status?: number;
+    method?: string;
+    sessionId?: string;
+}
+interface ConsoleFilter {
+    level?: string;
+    sinceSeconds?: number;
+    search?: string;
+    sessionId?: string;
+}
+interface StateFilter {
+    storeId?: string;
+    sinceSeconds?: number;
+    sessionId?: string;
+}
+interface RenderFilter {
+    componentName?: string;
+    sinceSeconds?: number;
+    sessionId?: string;
+}
+interface PerformanceFilter {
+    metricName?: string;
+    sinceSeconds?: number;
+    sessionId?: string;
+}
+interface DatabaseFilter {
+    sinceSeconds?: number;
+    table?: string;
+    minDurationMs?: number;
+    search?: string;
+    operation?: DatabaseOperation;
+    source?: DatabaseSource;
+    sessionId?: string;
+}
+interface HistoricalFilter {
+    project?: string;
+    sessionId?: string;
+    eventTypes?: EventType[];
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+    endpoint?: string;
+    component?: string;
+    storeId?: string;
+}
+interface ToolResponse<T = unknown> {
+    summary: string;
+    data: T;
+    issues: string[];
+    metadata: {
+        timeRange: {
+            from: number;
+            to: number;
+        };
+        eventCount: number;
+        sessionId: string | null;
+    };
+}
+interface SessionInfo {
+    sessionId: string;
+    appName: string;
+    connectedAt: number;
+    sdkVersion: string;
+    eventCount: number;
+    isConnected: boolean;
+}
+interface SessionInfoExtended extends SessionInfo {
+    project: string;
+    disconnectedAt?: number;
+    buildMeta?: BuildMeta;
+}
+interface SessionMetrics {
+    sessionId: string;
+    project: string;
+    connectedAt: number;
+    disconnectedAt: number;
+    totalEvents: number;
+    errorCount: number;
+    endpoints: Record<string, {
+        avgLatency: number;
+        errorRate: number;
+        callCount: number;
+    }>;
+    components: Record<string, {
+        renderCount: number;
+        avgDuration: number;
+    }>;
+    stores: Record<string, {
+        updateCount: number;
+    }>;
+    webVitals: Record<string, {
+        value: number;
+        rating: WebVitalRating;
+    }>;
+    queries: Record<string, {
+        avgDuration: number;
+        callCount: number;
+    }>;
+}
+interface MetricDelta {
+    key: string;
+    before: number;
+    after: number;
+    delta: number;
+    percentChange: number;
+    classification: 'regression' | 'improvement' | 'unchanged';
+}
+interface SessionDiffResult {
+    sessionA: string;
+    sessionB: string;
+    endpointDeltas: MetricDelta[];
+    componentDeltas: MetricDelta[];
+    storeDeltas: MetricDelta[];
+    webVitalDeltas: MetricDelta[];
+    queryDeltas: MetricDelta[];
+    overallDelta: {
+        errorCountDelta: number;
+        totalEventsDelta: number;
+    };
+}
+interface SessionSnapshot {
+    sessionId: string;
+    project: string;
+    snapshotPath?: string;
+    metrics: SessionMetrics;
+    buildMeta?: BuildMeta;
+    createdAt: number;
+}
+interface WSMessage {
+    type: 'event' | 'handshake' | 'heartbeat' | 'command' | 'command_response';
+    payload: unknown;
+    timestamp: number;
+    sessionId: string;
+}
+interface HandshakePayload {
+    appName: string;
+    sdkVersion: string;
+    sessionId: string;
+    authToken?: string;
+}
+interface EventBatchPayload {
+    events: RuntimeEvent[];
+}
+type ServerCommand = {
+    command: 'capture_dom_snapshot';
+    requestId: string;
+    params?: {
+        maxSize?: number;
+    };
+} | {
+    command: 'capture_performance_metrics';
+    requestId: string;
+} | {
+    command: 'clear_renders';
+    requestId: string;
+} | {
+    command: 'recon_scan';
+    requestId: string;
+    params?: {
+        categories?: ReconEventType[];
+    };
+} | {
+    command: 'recon_computed_styles';
+    requestId: string;
+    params: {
+        selector: string;
+        properties?: string[];
+    };
+} | {
+    command: 'recon_element_snapshot';
+    requestId: string;
+    params: {
+        selector: string;
+        depth?: number;
+    };
+} | {
+    command: 'recon_layout_tree';
+    requestId: string;
+    params?: {
+        selector?: string;
+        maxDepth?: number;
+    };
+};
+interface CommandResponse {
+    type: 'command_response';
+    requestId: string;
+    command: string;
+    payload: unknown;
+    timestamp: number;
+    sessionId: string;
+}
+interface TimelineFilter {
+    sinceSeconds?: number;
+    eventTypes?: EventType[];
+    sessionId?: string;
+}
+type IssueSeverity = 'high' | 'medium' | 'low';
+interface DetectedIssue {
+    id: string;
+    pattern: string;
+    severity: IssueSeverity;
+    title: string;
+    description: string;
+    evidence: string[];
+    suggestion?: string;
+}
+interface AuthInfo {
+    type: 'bearer' | 'basic' | 'api_key' | 'cookie' | 'none';
+    headerName?: string;
+}
+interface ApiContractField {
+    path: string;
+    type: string;
+    nullable: boolean;
+    example?: unknown;
+}
+interface ApiContract {
+    requestFields?: ApiContractField[];
+    responseFields: ApiContractField[];
+    sampleCount: number;
+}
+interface ApiEndpoint {
+    normalizedPath: string;
+    method: string;
+    baseUrl: string;
+    service: string;
+    callCount: number;
+    firstSeen: number;
+    lastSeen: number;
+    auth: AuthInfo;
+    contract?: ApiContract;
+    graphqlOperation?: GraphQLOperation;
+}
+interface ApiEndpointHealth {
+    normalizedPath: string;
+    method: string;
+    service: string;
+    callCount: number;
+    successRate: number;
+    avgLatency: number;
+    p50Latency: number;
+    p95Latency: number;
+    errorRate: number;
+    errorCodes: Record<number, number>;
+}
+interface ServiceInfo {
+    name: string;
+    baseUrl: string;
+    endpointCount: number;
+    totalCalls: number;
+    avgLatency: number;
+    errorRate: number;
+    auth: AuthInfo;
+    detectedPlatform?: string;
+}
+interface ApiChangeRecord {
+    normalizedPath: string;
+    method: string;
+    changeType: 'added' | 'removed' | 'modified';
+    fieldChanges?: {
+        path: string;
+        change: 'added' | 'removed' | 'type_changed';
+        oldType?: string;
+        newType?: string;
+    }[];
+}
+interface NormalizedQueryStats {
+    normalizedQuery: string;
+    tables: string[];
+    operation: DatabaseOperation;
+    callCount: number;
+    avgDuration: number;
+    maxDuration: number;
+    p95Duration: number;
+    totalDuration: number;
+    avgRowsReturned: number;
+}
+interface IndexSuggestion {
+    table: string;
+    columns: string[];
+    reason: string;
+    estimatedImpact: 'high' | 'medium' | 'low';
+    queryPattern: string;
+}
+interface DatabaseConnectionConfig {
+    id: string;
+    type: 'postgres' | 'mysql' | 'sqlite';
+    connectionString?: string;
+    label?: string;
+    projectRef?: string;
+    serviceKey?: string;
+}
+interface SchemaColumn {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: string;
+    isPrimaryKey: boolean;
+}
+interface SchemaForeignKey {
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+}
+interface SchemaIndex {
+    name: string;
+    columns: string[];
+    unique: boolean;
+}
+interface SchemaTable {
+    name: string;
+    columns: SchemaColumn[];
+    foreignKeys: SchemaForeignKey[];
+    indexes: SchemaIndex[];
+    rowCount?: number;
+}
+interface DatabaseSchema {
+    connectionId: string;
+    tables: SchemaTable[];
+    fetchedAt: number;
+}
+type DevProcessType = 'next' | 'vite' | 'webpack' | 'wrangler' | 'prisma' | 'docker' | 'postgres' | 'mysql' | 'redis' | 'node' | 'bun' | 'deno' | 'python' | 'unknown';
+interface DevProcess {
+    pid: number;
+    command: string;
+    type: DevProcessType;
+    cpuPercent: number;
+    memoryMB: number;
+    ports: number[];
+    cwd?: string;
+    project?: string;
+    uptime?: number;
+    isOrphaned: boolean;
+}
+interface PortUsage {
+    port: number;
+    pid: number;
+    process: string;
+    type: DevProcessType;
+    project?: string;
+}
+interface DeployLog {
+    id: string;
+    platform: string;
+    project: string;
+    status: 'building' | 'ready' | 'error' | 'canceled';
+    url?: string;
+    branch?: string;
+    commit?: string;
+    createdAt: number;
+    readyAt?: number;
+    errorMessage?: string;
+}
+interface RuntimeLog {
+    timestamp: number;
+    level: 'info' | 'warn' | 'error' | 'debug';
+    message: string;
+    source?: string;
+    platform: string;
+}
+interface BuildStatus {
+    platform: string;
+    project: string;
+    latestDeployId: string;
+    status: 'building' | 'ready' | 'error' | 'canceled';
+    url?: string;
+    lastDeployed: number;
+}
+interface InfraOverview {
+    project: string;
+    platforms: {
+        name: string;
+        configured: boolean;
+        deployCount: number;
+        lastDeploy?: number;
+        status?: string;
+    }[];
+    detectedFromTraffic: string[];
+}
+
+interface SqliteStoreOptions {
+    dbPath: string;
+    walMode?: boolean;
+    flushIntervalMs?: number;
+    batchSize?: number;
+}
+declare class SqliteStore {
+    private db;
+    private writeBuffer;
+    private flushTimer;
+    private readonly batchSize;
+    private insertEventStmt;
+    private insertSessionStmt;
+    private updateSessionDisconnectedStmt;
+    constructor(options: SqliteStoreOptions);
+    private createSchema;
+    addEvent(event: RuntimeEvent, project: string): void;
+    flush(): void;
+    saveSession(info: SessionInfoExtended): void;
+    updateSessionDisconnected(sessionId: string, disconnectedAt: number): void;
+    saveSessionMetrics(sessionId: string, project: string, metrics: unknown): void;
+    getEvents(filter: HistoricalFilter): RuntimeEvent[];
+    getEventCount(filter: HistoricalFilter): number;
+    getSessions(project: string, limit?: number): SessionInfoExtended[];
+    getSessionMetrics(sessionId: string): unknown | null;
+    getEventsByType(project: string, eventType: EventType, sinceMs?: number): RuntimeEvent[];
+    deleteOldEvents(beforeTimestamp: number): number;
+    vacuum(): void;
+    close(): void;
+}
+
+interface RedactionRule {
+    name: string;
+    pattern: RegExp;
+    replacement: string;
+}
+interface RedactorConfig {
+    enabled?: boolean;
+    useBuiltIn?: boolean;
+    rules?: RedactionRule[];
+    /** Redact JSON object keys matching these patterns (case-insensitive). */
+    sensitiveKeys?: string[];
+}
+/** Built-in patterns for common secret/PII formats. */
+declare const BUILT_IN_RULES: RedactionRule[];
+declare class Redactor {
+    private rules;
+    private sensitiveKeyPattern;
+    private enabled;
+    constructor(config?: RedactorConfig);
+    isEnabled(): boolean;
+    /** Apply all redaction rules to a string value. */
+    redactString(value: string): string;
+    /**
+     * Deep-walk an event and redact all string fields.
+     * Returns a new event object (does not mutate the original).
+     */
+    redactEvent(event: RuntimeEvent): RuntimeEvent;
+    private deepRedact;
+}
+
+declare class EventStore {
+    private buffer;
+    private sessions;
+    private sqliteStore;
+    private currentProject;
+    private onEventCallbacks;
+    private redactor;
+    constructor(capacity?: number);
+    setRedactor(redactor: Redactor): void;
+    get eventCount(): number;
+    setSqliteStore(store: SqliteStore, project: string): 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[];
+    markDisconnected(sessionId: string): void;
+    getEventTimeline(filter?: TimelineFilter): RuntimeEvent[];
+    getAllEvents(sinceSeconds?: number, sessionId?: string): RuntimeEvent[];
+    getSessionIdsForProject(appName: string): string[];
+    getStateEvents(filter?: StateFilter): StateEvent[];
+    getRenderEvents(filter?: RenderFilter): RenderEvent[];
+    getPerformanceMetrics(filter?: PerformanceFilter): PerformanceEvent[];
+    getDatabaseEvents(filter?: DatabaseFilter): DatabaseEvent[];
+    private getLatestReconEvent;
+    private getReconEvents;
+    getReconMetadata(filter?: ReconFilter): ReconMetadataEvent | null;
+    getReconDesignTokens(filter?: ReconFilter): ReconDesignTokensEvent | null;
+    getReconFonts(filter?: ReconFilter): ReconFontsEvent | null;
+    getReconLayoutTree(filter?: ReconFilter): ReconLayoutTreeEvent | null;
+    getReconAccessibility(filter?: ReconFilter): ReconAccessibilityEvent | null;
+    getReconComputedStyles(filter?: ReconFilter): ReconComputedStylesEvent[];
+    getReconElementSnapshots(filter?: ReconFilter): ReconElementSnapshotEvent[];
+    getReconAssetInventory(filter?: ReconFilter): ReconAssetInventoryEvent | null;
+    clear(): {
+        clearedCount: number;
+    };
+}
+
+interface ApiKeyEntry {
+    key: string;
+    label: string;
+    project?: string;
+    createdAt: number;
+}
+interface AuthConfig {
+    enabled: boolean;
+    apiKeys: ApiKeyEntry[];
+}
+declare class AuthManager {
+    private keys;
+    private enabled;
+    constructor(config?: Partial<AuthConfig>);
+    isEnabled(): boolean;
+    /** Validate an API key. Returns the entry if valid, null if invalid. */
+    validate(key: string | undefined): ApiKeyEntry | null;
+    /** Check if request is authorized. Returns true if auth is disabled or key is valid. */
+    isAuthorized(key: string | undefined): boolean;
+    /** Extract bearer token from Authorization header value. */
+    static extractBearer(header: string | undefined): string | undefined;
+    /** Constant-time string comparison to prevent timing attacks. */
+    private safeCompare;
+}
+/** Generate a cryptographically secure API key (64 hex chars = 32 bytes). */
+declare function generateApiKey(label: string, project?: string): ApiKeyEntry;
+
+interface GlobalConfig {
+    defaultPort: number;
+    bufferSize: number;
+    httpPort: number;
+    /** Authentication configuration */
+    auth?: {
+        enabled: boolean;
+        apiKeys: ApiKeyEntry[];
+    };
+    /** TLS certificate paths */
+    tls?: {
+        certPath: string;
+        keyPath: string;
+        caPath?: string;
+    };
+    /** CORS allowed origins (defaults to '*' when not set) */
+    corsOrigins?: string[];
+    /** Rate limiting configuration */
+    rateLimits?: {
+        maxEventsPerSecond?: number;
+        maxEventsPerMinute?: number;
+    };
+    /** Payload redaction configuration */
+    redaction?: {
+        enabled: boolean;
+        rules?: {
+            name: string;
+            pattern: string;
+            replacement: string;
+        }[];
+    };
+}
+interface ProjectConfig {
+    name: string;
+    createdAt: string;
+    sdkVersion?: string;
+    settings: {
+        bufferSize?: number;
+        retentionDays?: number;
+    };
+}
+interface InfrastructureConfig {
+    project?: string;
+    databases?: Record<string, {
+        type: string;
+        connection_string?: string;
+        project_ref?: string;
+        service_key?: string;
+        label?: string;
+    }>;
+    deployments?: Record<string, {
+        platform: string;
+        project_id?: string;
+        team_id?: string;
+        worker_name?: string;
+        account_id?: string;
+    }>;
+    services?: Record<string, string>;
+}
+declare class ProjectManager {
+    private readonly baseDir;
+    constructor(baseDir?: string);
+    get rootDir(): string;
+    getProjectDir(projectName: string): string;
+    getProjectDbPath(projectName: string): string;
+    getSessionsDir(projectName: string): string;
+    getSessionSnapshotPath(projectName: string, sessionId: string, timestamp: number): string;
+    ensureGlobalDir(): void;
+    ensureProjectDir(projectName: string): void;
+    getGlobalConfig(): GlobalConfig;
+    saveGlobalConfig(config: GlobalConfig): void;
+    getProjectConfig(projectName: string): ProjectConfig | null;
+    saveProjectConfig(projectName: string, config: ProjectConfig): void;
+    getInfrastructureConfig(projectName: string): InfrastructureConfig | null;
+    getClaudeInstructions(projectName: string): string | null;
+    listProjects(): string[];
+    projectExists(projectName: string): boolean;
+    resolveEnvVars(value: string): string;
+    private mkdirp;
+    private readJson;
+    private writeJson;
+    private resolveConfigEnvVars;
+    /**
+     * Minimal YAML parser for simple infrastructure config files.
+     * Handles flat key-value pairs and one level of nesting.
+     * For full YAML support, install js-yaml.
+     */
+    private parseSimpleYaml;
+}
+
+interface RateLimitConfig {
+    maxEventsPerSecond?: number;
+    maxEventsPerMinute?: number;
+}
+declare class SessionRateLimiter {
+    private windows;
+    private maxPerSecond;
+    private maxPerMinute;
+    private _droppedTotal;
+    constructor(config?: RateLimitConfig);
+    get droppedTotal(): number;
+    isEnabled(): boolean;
+    /** Returns true if the event should be accepted, false if rate-limited. */
+    allow(sessionId: string): boolean;
+    /** Allow a batch of N events. Returns the number accepted. */
+    allowBatch(sessionId: string, count: number): number;
+    /** Remove tracking for sessions that haven't been seen in maxAgeMs. */
+    prune(maxAgeMs?: number): void;
+    private maybeWarn;
+}
+
+interface TlsConfig {
+    certPath: string;
+    keyPath: string;
+    caPath?: string;
+}
+/**
+ * Load TLS certificate files and return options suitable for
+ * https.createServer() or tls.createSecureContext().
+ */
+declare function loadTlsOptions(config: TlsConfig): SecureContextOptions;
+/**
+ * Resolve TLS config from environment variables.
+ * Returns null if TLS is not configured.
+ */
+declare function resolveTlsConfig(): TlsConfig | null;
+
+interface CollectorServerOptions {
+    port?: number;
+    host?: string;
+    bufferSize?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    projectManager?: ProjectManager;
+    authManager?: AuthManager;
+    rateLimits?: RateLimitConfig;
+    tls?: TlsConfig;
+}
+declare class CollectorServer {
+    private wss;
+    private store;
+    private projectManager;
+    private authManager;
+    private rateLimiter;
+    private clients;
+    private pendingHandshakes;
+    private pendingCommands;
+    private sqliteStores;
+    private disconnectCallbacks;
+    private pruneTimer;
+    private tlsConfig;
+    constructor(options?: CollectorServerOptions);
+    getStore(): EventStore;
+    getPort(): number | null;
+    getClientCount(): number;
+    getProjectManager(): ProjectManager | null;
+    getSqliteStore(projectName: string): SqliteStore | undefined;
+    getSqliteStores(): Map<string, SqliteStore>;
+    getRateLimiter(): SessionRateLimiter;
+    onDisconnect(cb: (sessionId: string, projectName: string) => void): void;
+    start(options?: CollectorServerOptions): Promise<void>;
+    private tryStart;
+    private handleStartError;
+    private ensureSqliteStore;
+    private setupConnectionHandler;
+    private handleMessage;
+    /** Find the WebSocket for a given sessionId */
+    private findWsBySessionId;
+    /** Get the first connected session ID (for single-app use) */
+    getFirstSessionId(): string | undefined;
+    /** Get the project name for a session */
+    getProjectForSession(sessionId: string): string | undefined;
+    /** Send a command to the SDK and await the response */
+    sendCommand(sessionId: string, command: {
+        command: string;
+        requestId: string;
+        params?: Record<string, unknown>;
+    }, timeoutMs?: number): Promise<unknown>;
+    stop(): void;
+}
+
+/**
+ * Fixed-size circular buffer. When full, new items overwrite the oldest.
+ * Optimized for append-heavy workloads with periodic filtered scans.
+ */
+declare class RingBuffer<T> {
+    private capacity;
+    private buffer;
+    private head;
+    private _count;
+    constructor(capacity: number);
+    get count(): number;
+    push(item: T): void;
+    /** Returns all items from oldest to newest. */
+    toArray(): T[];
+    /** Returns matching items from newest to oldest (most recent first). */
+    query(predicate: (item: T) => boolean): T[];
+    clear(): void;
+}
+
+/**
+ * Runs all pattern detectors against a set of events and returns
+ * prioritized issues sorted by severity (high → medium → low).
+ */
+declare function detectIssues(events: RuntimeEvent[]): DetectedIssue[];
+
+declare class ApiDiscoveryEngine {
+    private endpoints;
+    private store;
+    constructor(store: EventStore);
+    rebuild(): void;
+    private ingestEvent;
+    private refineEndpoints;
+    getCatalog(filter?: {
+        service?: string;
+        minCalls?: number;
+    }): ApiEndpoint[];
+    getHealth(filter?: {
+        endpoint?: string;
+        sinceSeconds?: number;
+    }): ApiEndpointHealth[];
+    getDocumentation(filter?: {
+        service?: string;
+        format?: string;
+    }): string;
+    getServiceMap(): ServiceInfo[];
+    getApiChanges(sessionA: string, sessionB: string): ApiChangeRecord[];
+    private buildCatalogFromEvents;
+    detectIssues(): DetectedIssue[];
+}
+
+declare function aggregateQueryStats(events: DatabaseEvent[]): NormalizedQueryStats[];
+declare function detectN1Queries(events: DatabaseEvent[]): DetectedIssue[];
+declare function detectSlowQueries(events: DatabaseEvent[], thresholdMs?: number): DetectedIssue[];
+declare function suggestIndexes(events: DatabaseEvent[]): IndexSuggestion[];
+declare function detectOverfetching(events: DatabaseEvent[]): DetectedIssue[];
+
+interface ManagedConnection {
+    config: DatabaseConnectionConfig;
+    client: unknown;
+    isHealthy: boolean;
+    lastChecked: number;
+}
+declare class ConnectionManager {
+    private connections;
+    addConnection(config: DatabaseConnectionConfig): Promise<void>;
+    getConnection(id: string): ManagedConnection | undefined;
+    listConnections(): {
+        id: string;
+        type: string;
+        label?: string;
+        isHealthy: boolean;
+    }[];
+    healthCheck(id: string): Promise<boolean>;
+    closeConnection(id: string): Promise<void>;
+    closeAll(): Promise<void>;
+    private dynamicRequire;
+    private createClient;
+}
+
+declare class SchemaIntrospector {
+    introspect(connection: ManagedConnection, tableName?: string): Promise<DatabaseSchema>;
+    private introspectPostgres;
+    private introspectMysql;
+    private introspectSqlite;
+}
+
+interface ReadOptions {
+    table: string;
+    limit?: number;
+    offset?: number;
+    where?: string;
+    orderBy?: string;
+}
+interface ReadResult {
+    rows: Record<string, unknown>[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface WriteOptions {
+    table: string;
+    operation: 'insert' | 'update' | 'delete';
+    data?: Record<string, unknown>;
+    where?: string;
+}
+interface WriteResult {
+    success: boolean;
+    affectedRows: number;
+    error?: string;
+}
+declare class DataBrowser {
+    read(connection: ManagedConnection, options: ReadOptions): Promise<ReadResult>;
+    write(connection: ManagedConnection, options: WriteOptions): Promise<WriteResult>;
+    private assertLocalhost;
+    private readPostgres;
+    private writePostgres;
+    private readMysql;
+    private writeMysql;
+    private readSqlite;
+    private writeSqlite;
+}
+
+declare class ProcessMonitor {
+    private store;
+    private scanInterval;
+    private processes;
+    private lastActivity;
+    constructor(store: EventStore);
+    start(intervalMs?: number): void;
+    stop(): void;
+    scan(): void;
+    getProcesses(filter?: {
+        project?: string;
+        type?: DevProcessType;
+    }): DevProcess[];
+    killProcess(pid: number, signal?: 'SIGTERM' | 'SIGKILL'): {
+        success: boolean;
+        error?: string;
+    };
+    getPortUsage(port?: number): PortUsage[];
+    detectIssues(): DetectedIssue[];
+}
+
+declare class InfraConnector {
+    private store;
+    private clients;
+    constructor(store: EventStore);
+    loadFromConfig(projectManager: ProjectManager, projectName: string): void;
+    getDeployLogs(project: string, platform?: string, deployId?: string): Promise<DeployLog[]>;
+    getRuntimeLogs(project: string, opts?: {
+        platform?: string;
+        since?: number;
+        level?: string;
+    }): Promise<RuntimeLog[]>;
+    getBuildStatus(project: string): Promise<BuildStatus[]>;
+    getInfraOverview(project?: string): InfraOverview[];
+}
+
+declare class SessionManager {
+    private projectManager;
+    private sqliteStores;
+    private store;
+    constructor(projectManager: ProjectManager, sqliteStores: Map<string, SqliteStore>, store: EventStore);
+    computeMetrics(sessionId: string, project: string, events: RuntimeEvent[]): SessionMetrics;
+    createSnapshot(sessionId: string, project: string): SessionSnapshot;
+    getSessionHistory(project: string, limit?: number): SessionSnapshot[];
+}
+
+declare function compareSessions(metricsA: SessionMetrics, metricsB: SessionMetrics): SessionDiffResult;
+
+interface HttpServerOptions {
+    port?: number;
+    host?: string;
+    authManager?: AuthManager;
+    allowedOrigins?: string[];
+    tls?: TlsConfig;
+}
+declare class HttpServer {
+    private server;
+    private wss;
+    private store;
+    private processMonitor;
+    private authManager;
+    private allowedOrigins;
+    private dashboardClients;
+    private eventListener;
+    private routes;
+    private sdkBundlePath;
+    private activePort;
+    private startedAt;
+    constructor(store: EventStore, processMonitor?: ProcessMonitor, options?: {
+        authManager?: AuthManager;
+        allowedOrigins?: string[];
+    });
+    private registerRoutes;
+    /**
+     * Resolve the SDK IIFE bundle path.
+     * Tries multiple locations for monorepo and installed-package scenarios.
+     */
+    private resolveSdkPath;
+    start(options?: HttpServerOptions): Promise<void>;
+    private tryStart;
+    stop(): Promise<void>;
+    broadcastEvent(event: RuntimeEvent): void;
+    private handleRequest;
+    private setCorsHeaders;
+    private json;
+}
+
+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, CollectorServer, type CollectorServerOptions, type ColorToken, type CommandResponse, type ComputedStyleEntry, ConnectionManager, type ConsoleEvent, type ConsoleFilter, type ConsoleLevel, 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 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 MetricDelta, type NetworkEvent, type NetworkFilter, type NormalizedQueryStats, type PerformanceEvent, type PerformanceFilter, type PerformanceMetricName, type PortUsage, ProcessMonitor, type ProjectConfig, ProjectManager, 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 RuntimeEvent, type RuntimeLog, type SVGSpriteSymbol, type SchemaColumn, type SchemaForeignKey, type SchemaIndex, SchemaIntrospector, type SchemaTable, type ServerCommand, type ServerMetricName, type ServiceInfo, type SessionDiffResult, type SessionEvent, type SessionInfo, type SessionInfoExtended, SessionManager, type SessionMetrics, SessionRateLimiter, type SessionSnapshot, type SpacingValue, type SpriteFrame, SqliteStore, type SqliteStoreOptions, type StateEvent, type StateFilter, type TechStackDetection, type TimelineFilter, type TlsConfig, type ToolResponse, type TypographyToken, type WSMessage, type WebVitalRating, type WriteOptions, type WriteResult, aggregateQueryStats, compareSessions, detectIssues, detectN1Queries, detectOverfetching, detectSlowQueries, generateApiKey, loadTlsOptions, resolveTlsConfig, suggestIndexes };