@flotrace/runtime-core 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,1465 @@
+/**
+ * Types for @flotrace/runtime package
+ * These mirror the shared types from the extension but are standalone
+ * to avoid importing from the extension package.
+ */
+/**
+ * Serialized value for safe transmission over WebSocket
+ */
+type SerializedValue = null | boolean | number | string | SerializedValue[] | {
+    [key: string]: SerializedValue;
+} | {
+    __type: 'function';
+    name?: string;
+} | {
+    __type: 'undefined';
+} | {
+    __type: 'symbol';
+    description?: string;
+} | {
+    __type: 'circular';
+} | {
+    __type: 'truncated';
+    originalType: string;
+    length?: number;
+};
+/**
+ * Messages sent from runtime to extension
+ */
+type RuntimeMessage = RuntimeReadyMessage | RuntimeRenderMessage | RuntimePropsUpdateMessage | RuntimeNodePropsMessage | RuntimeZustandUpdateMessage | RuntimeReduxUpdateMessage | RuntimeRouterUpdateMessage | RuntimeContextUpdateMessage | RuntimeDisconnectMessage | RuntimeTreeSnapshotMessage | RuntimeTreeDiffMessage | RuntimeNodeHooksMessage | RuntimeNodeEffectsMessage | RuntimeDetailedRenderReasonMessage | RuntimeTimelineEventMessage | RuntimeTanStackQueryUpdateMessage | RuntimeRenderTriggerMessage | RuntimeRenderCascadeMessage | RuntimePropDrillingMessage | RuntimeActionStateMessage | RuntimeOptimisticDiffMessage | RuntimeNextjsContextMessage | RuntimeRscPayloadMessage | RuntimeHydrationEventMessage | RuntimeNetworkRequestMessage | RuntimeLocalStateCorrelationMessage | RuntimePongMessage;
+interface RuntimeReadyMessage {
+    type: 'runtime:ready';
+    appName?: string;
+    reactVersion?: string;
+    appUrl?: string;
+    /** 'web' | 'ios' | 'android'. Populated by the adapter. Desktop uses it for badges
+     *  and to disambiguate multi-app sessions (one iOS + one Android from the same monorepo). */
+    platform?: 'web' | 'ios' | 'android';
+    /** Stable app identifier. Pairs with platform to disambiguate simultaneous clients. */
+    appId?: string;
+    /** App version — shown in the desktop connection panel for diagnostic purposes. */
+    appVersion?: string;
+}
+interface RuntimeRenderMessage {
+    type: 'runtime:render';
+    componentName: string;
+    filePath?: string;
+    phase: 'mount' | 'update';
+    actualDuration: number;
+    baseDuration: number;
+    timestamp: number;
+    instanceId?: string;
+}
+interface RuntimePropsUpdateMessage {
+    type: 'runtime:props';
+    componentName: string;
+    instanceId?: string;
+    props: Record<string, SerializedValue>;
+    changedKeys?: string[];
+    timestamp: number;
+}
+interface RuntimeNodePropsMessage {
+    type: 'runtime:nodeProps';
+    /** Path-based node ID (e.g., "App-0/Dashboard-0/Card-2") */
+    nodeId: string;
+    /** Serialized props from fiber.memoizedProps */
+    props: Record<string, SerializedValue>;
+    timestamp: number;
+}
+interface RuntimeZustandUpdateMessage {
+    type: 'runtime:zustand';
+    storeName: string;
+    state: Record<string, SerializedValue>;
+    changedKeys: string[];
+    /** Per-request causal correlation: each entry maps a requestId to the specific store keys
+     *  whose values came from that fetch response (WeakMap causal correlation). */
+    correlatedRequests?: Array<{
+        requestId: string;
+        storeKeys: string[];
+    }>;
+    timestamp: number;
+}
+interface RuntimeReduxUpdateMessage {
+    type: 'runtime:redux';
+    /** Current state snapshot */
+    state: Record<string, SerializedValue>;
+    /** Keys that changed */
+    changedKeys: string[];
+    /** Per-request causal correlation: each entry maps a requestId to the specific store keys
+     *  whose values came from that fetch response (WeakMap causal correlation). */
+    correlatedRequests?: Array<{
+        requestId: string;
+        storeKeys: string[];
+    }>;
+    timestamp: number;
+}
+interface RuntimeRouterUpdateMessage {
+    type: 'runtime:router';
+    pathname: string;
+    params: Record<string, string>;
+    searchParams: Record<string, string>;
+    timestamp: number;
+}
+interface RuntimeContextUpdateMessage {
+    type: 'runtime:context';
+    contextName: string;
+    value: SerializedValue;
+    consumers?: string[];
+    timestamp: number;
+}
+interface RuntimeDisconnectMessage {
+    type: 'runtime:disconnect';
+    reason?: string;
+}
+/**
+ * Heartbeat response. The desktop pings every few seconds; the runtime replies
+ * with a pong so the server can detect native-crash scenarios where the JS
+ * thread is frozen but the socket is still technically open.
+ */
+interface RuntimePongMessage {
+    type: 'runtime:pong';
+    timestamp: number;
+}
+interface RuntimeTreeSnapshotMessage {
+    type: 'runtime:treeSnapshot';
+    /** Full component tree from fiber traversal */
+    tree: LiveTreeNode;
+    /** Timestamp when snapshot was taken */
+    timestamp: number;
+}
+/**
+ * Incremental tree diff — sent instead of a full snapshot when the tree
+ * structure hasn't changed dramatically. Reduces WebSocket payload by ~80-95%
+ * compared to sending the full tree every time.
+ *
+ * The extension reconstructs the full tree by applying diffs to its cached copy.
+ * A full snapshot is sent every FULL_SNAPSHOT_INTERVAL (10) diffs to prevent drift,
+ * and whenever the extension detects a sequence gap.
+ */
+interface RuntimeTreeDiffMessage {
+    type: 'runtime:treeDiff';
+    /** Monotonic sequence number — extension uses this to detect missed diffs */
+    seq: number;
+    /** Nodes added since last snapshot (includes parentId for tree insertion) */
+    added: Array<LiveTreeNode & {
+        parentId: string;
+    }>;
+    /** Node IDs removed since last snapshot */
+    removed: string[];
+    /** Nodes whose mutable fields changed (renderDuration, renderPhase, renderReason) */
+    updated: Array<{
+        id: string;
+        renderDuration?: number;
+        renderPhase?: 'mount' | 'update';
+        renderReason?: 'mount' | 'props-changed' | 'state-or-context' | 'parent';
+    }>;
+    timestamp: number;
+}
+/**
+ * React Compiler memoization status for a component.
+ * Detected by checking for the React Compiler memo cache sentinel in fiber state.
+ * Mirrors the CompilerStatus type in src/shared/liveMessages.ts.
+ */
+type CompilerStatus = 'compiled' | 'manual' | 'unoptimized' | 'de-opted';
+/**
+ * A node in the live component tree captured from React fiber tree.
+ * Path-based IDs ensure stability across snapshots for React Flow animations.
+ */
+interface LiveTreeNode {
+    /** Path-based ID: "App-0/Dashboard-0/Card-2" (component name + child index among same-type siblings) */
+    id: string;
+    /** Component display name */
+    name: string;
+    /** Child components (host elements like div/span are filtered out) */
+    children: LiveTreeNode[];
+    /** Serialized props (functions filtered, values truncated) */
+    props?: Record<string, SerializedValue>;
+    /** Fiber tag: 0=Function, 1=Class, 11=ForwardRef, 14=Memo, 15=SimpleMemo */
+    fiberTag: number;
+    /** Mount on first render, update on re-render */
+    renderPhase?: 'mount' | 'update';
+    /** Render duration in ms (from Profiler) */
+    renderDuration?: number;
+    /** Source file path from _debugSource (dev mode only) */
+    filePath?: string;
+    /** Source line number from _debugSource (dev mode only) */
+    lineNumber?: number;
+    /** Why this component rendered (detected via fiber.alternate props comparison) */
+    renderReason?: 'mount' | 'props-changed' | 'state-or-context' | 'parent';
+    /** True if this component is a framework/library wrapper (Next.js, React Router, etc.) */
+    isFramework?: boolean;
+    /** React key prop (only string keys, used to differentiate same-name siblings in search) */
+    reactKey?: string;
+    /** TanStack Query hashes observed by this component (detected from useRef → QueryObserver) */
+    queryHashes?: string[];
+    /** Number of hooks in this component (counted from memoizedState linked list) */
+    hookCount?: number;
+    /** True if any hook is useContext (indicates data may come from context, not just props) */
+    hasContextHook?: boolean;
+    /** True if a useTransition hook on this component currently has isPending=true */
+    isTransitionPending?: boolean;
+    /** True if this component is currently rendering inside a Suspense fallback branch */
+    isSuspenseFallback?: boolean;
+    /** React Compiler memoization status (undefined = not analyzed / compiler not detected) */
+    compilerStatus?: CompilerStatus;
+    /** True if this is detected as a Next.js Server Component (heuristic) */
+    isServerComponent?: boolean;
+    /** True if this is the first client component below a server component boundary */
+    isClientBoundary?: boolean;
+    /** True if this component is from a third-party library, not user-defined code */
+    isLibrary?: boolean;
+    /** Short display label for the library source (e.g. 'framer', 'fontawesome', 'sonner') */
+    libraryName?: string;
+}
+/**
+ * Enhanced render reason with specific prop/state/context changes.
+ */
+type DetailedRenderReasonType = 'mount' | 'props-changed' | 'state-changed' | 'context-changed' | 'parent-render' | 'force-update';
+interface PropChange {
+    key: string;
+    prev: SerializedValue;
+    next: SerializedValue;
+}
+type DetailedRenderReason = {
+    type: 'mount';
+} | {
+    type: 'props-changed';
+    changedProps: PropChange[];
+} | {
+    type: 'state-changed';
+    changedHookIndices: number[];
+} | {
+    type: 'context-changed';
+    contextNames: string[];
+} | {
+    type: 'parent-render';
+    parentName?: string;
+} | {
+    type: 'force-update';
+};
+/**
+ * Hook type classification — inferred from fiber.memoizedState shape.
+ */
+type HookType = 'useState' | 'useReducer' | 'useRef' | 'useMemo' | 'useCallback' | 'useEffect' | 'useLayoutEffect' | 'useInsertionEffect' | 'useContext' | 'useImperativeHandle' | 'useDebugValue' | 'useTransition' | 'useDeferredValue' | 'useId' | 'useSyncExternalStore' | 'useOptimistic' | 'useFormStatus' | 'unknown';
+/**
+ * Information about a single hook in a component's hook linked list.
+ */
+interface HookInfo {
+    /** Position in the hook linked list (0-based) */
+    index: number;
+    /** Classified hook type */
+    type: HookType;
+    /** Serialized current value (state for useState, ref.current for useRef, etc.) */
+    value: SerializedValue;
+    /** For useMemo/useCallback/useEffect: serialized dependency array */
+    deps?: SerializedValue[];
+    /** Hook name hint from _debugHookTypes if available */
+    debugLabel?: string;
+}
+/**
+ * Information about a single effect (useEffect/useLayoutEffect/useInsertionEffect).
+ */
+interface EffectInfo {
+    /** Position in the effect circular list (0-based) */
+    index: number;
+    /** Corresponding hook index in the memoizedState list */
+    hookIndex: number;
+    /** Effect type derived from tag bitmask */
+    type: 'useEffect' | 'useLayoutEffect' | 'useInsertionEffect';
+    /** Current dependency array (null = no deps, runs every render) */
+    deps: SerializedValue[] | null;
+    /** Previous dependency array from fiber.alternate */
+    prevDeps: SerializedValue[] | null;
+    /** Indices of deps that changed (triggering this effect to run) */
+    changedDepIndices: number[];
+    /** Whether this effect will execute on this render */
+    willRun: boolean;
+    /** Whether the previous effect returned a cleanup function */
+    hasCleanup: boolean;
+}
+/**
+ * Component lifecycle event types for the timeline.
+ */
+type TimelineEventType = 'mount' | 'unmount' | 'render' | 'effect-run' | 'effect-cleanup' | 'state-update' | 'props-change';
+/**
+ * A single event in a component's lifecycle timeline.
+ */
+interface TimelineEvent {
+    type: TimelineEventType;
+    timestamp: number;
+    /** Render duration in ms (for render events) */
+    duration?: number;
+    /** Additional context (e.g., which hook, which prop) */
+    detail?: SerializedValue;
+}
+interface RuntimeNodeHooksMessage {
+    type: 'runtime:nodeHooks';
+    nodeId: string;
+    hooks: HookInfo[];
+    timestamp: number;
+}
+interface RuntimeNodeEffectsMessage {
+    type: 'runtime:nodeEffects';
+    nodeId: string;
+    effects: EffectInfo[];
+    timestamp: number;
+}
+interface RuntimeDetailedRenderReasonMessage {
+    type: 'runtime:detailedRenderReason';
+    nodeId: string;
+    reason: DetailedRenderReason;
+    timestamp: number;
+}
+interface RuntimeTimelineEventMessage {
+    type: 'runtime:timelineEvent';
+    nodeId: string;
+    componentName: string;
+    event: TimelineEvent;
+}
+/** Serialized query info sent over WebSocket */
+interface TanStackQueryInfo {
+    queryKey: SerializedValue;
+    queryHash: string;
+    status: 'pending' | 'error' | 'success';
+    fetchStatus: 'idle' | 'fetching' | 'paused';
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    isInvalidated: boolean;
+    isStale: boolean;
+    isActive: boolean;
+    isDisabled: boolean;
+    failureCount: number;
+    errorMessage?: string;
+    observerCount: number;
+    /** Config values */
+    staleTime?: number;
+    gcTime?: number;
+    /** Additional config for health analysis */
+    refetchInterval?: number | false;
+    refetchOnWindowFocus?: boolean | 'always';
+    refetchOnMount?: boolean | 'always';
+    refetchOnReconnect?: boolean | 'always';
+    networkMode?: string;
+    enabled?: boolean;
+    retry?: number | boolean;
+    /** Data shape descriptor (key names + types, no values) */
+    dataShape?: SerializedValue;
+    /** Number of times query refetched but data was identical */
+    wastedRefetchCount?: number;
+    /** Total number of fetches tracked */
+    totalFetchCount?: number;
+    /** Per-query state transition history (ring buffer, max 50) */
+    events?: TanStackQueryEvent[];
+    /** requestId of the API call whose response was stored in this query's cache (WeakMap causal) */
+    correlatedRequestId?: string;
+}
+/** A state transition event for a TanStack Query */
+interface TanStackQueryEvent {
+    timestamp: number;
+    /** Status before the transition */
+    fromStatus: string;
+    /** Status after the transition */
+    toStatus: string;
+    /** Fetch status before the transition */
+    fromFetchStatus: string;
+    /** Fetch status after the transition */
+    toFetchStatus: string;
+    /** Whether the data changed during this transition */
+    dataChanged: boolean;
+}
+/** Serialized mutation info sent over WebSocket */
+interface TanStackMutationInfo {
+    mutationId: number;
+    status: 'idle' | 'pending' | 'error' | 'success';
+    isPaused: boolean;
+    submittedAt: number;
+    failureCount: number;
+    errorMessage?: string;
+    mutationKey?: SerializedValue;
+    scope?: string;
+    /** Correlation ID linking this mutation to queries it triggered */
+    lastCorrelationId?: string;
+}
+/** Mutation → query invalidation → refetch correlation event */
+interface MutationCorrelation {
+    /** Unique ID for this correlation event */
+    correlationId: string;
+    /** The mutation that triggered the cascade */
+    mutationId: number;
+    /** Mutation key (if provided) for display */
+    mutationKey?: SerializedValue;
+    /** Timestamp when mutation completed (status → 'success') */
+    mutationCompletedAt: number;
+    /** Queries that started fetching within the correlation window */
+    affectedQueries: Array<{
+        queryHash: string;
+        queryKey: SerializedValue;
+        /** When the query started fetching */
+        fetchStartedAt: number;
+        /** Latency: fetchStartedAt - mutationCompletedAt */
+        latencyMs: number;
+        /** Whether the refetch actually changed data */
+        dataChanged?: boolean;
+    }>;
+    /** Timestamp when the correlation window closed */
+    resolvedAt: number;
+}
+interface RuntimeTanStackQueryUpdateMessage {
+    type: 'runtime:tanstackQuery';
+    queries: TanStackQueryInfo[];
+    mutations: TanStackMutationInfo[];
+    /** New correlation events since last snapshot */
+    correlations?: MutationCorrelation[];
+    timestamp: number;
+}
+interface StackFrame {
+    functionName: string | null;
+    fileName: string | null;
+    lineNumber: number | null;
+    columnNumber: number | null;
+    /** false for node_modules / react-dom / react-reconciler frames */
+    isUserCode: boolean;
+}
+interface TriggerRecord {
+    triggerId: string;
+    fiberId: string;
+    componentName: string;
+    hookIndex: number;
+    hookType: 'state' | 'reducer' | 'setState' | 'forceUpdate';
+    stack: StackFrame[];
+    timestamp: number;
+    action: SerializedValue | null;
+    batchId: string | null;
+}
+type CascadeReason = 'state-update' | 'context-update' | 'props-changed' | 'parent-cascade' | 'force-update' | 'bailed-out';
+interface CascadeNode {
+    nodeId: string;
+    componentName: string;
+    reason: CascadeReason;
+    renderDuration: number;
+    subtreeDuration: number;
+    changedProps?: string[];
+    hookIndex?: number;
+    triggerId?: string;
+    children: CascadeNode[];
+    depth: number;
+    isMemoized: boolean;
+}
+type LanePriority = 'sync' | 'discrete' | 'continuous' | 'default' | 'transition' | 'deferred' | 'idle' | 'offscreen';
+interface LaneInfo {
+    priority: LanePriority;
+    lanes: number;
+    isTransition: boolean;
+    isBlocking: boolean;
+}
+interface CascadeRecord {
+    commitId: string;
+    timestamp: number;
+    totalDuration: number;
+    totalComponents: number;
+    avoidableCount: number;
+    avoidableDuration: number;
+    rootCauses: CascadeNode[];
+    lane: LaneInfo;
+    triggerIds: string[];
+}
+interface RuntimeRenderTriggerMessage {
+    type: 'runtime:renderTrigger';
+    trigger: TriggerRecord;
+}
+interface RuntimeRenderCascadeMessage {
+    type: 'runtime:renderCascade';
+    cascade: CascadeRecord;
+}
+interface PropDrillingChainNode {
+    nodeId: string;
+    componentName: string;
+    propKey: string;
+    role: 'source' | 'passthrough' | 'consumer';
+    hookCount: number;
+    hasContextHook: boolean;
+}
+interface PropDrillingChain {
+    chainId: string;
+    propName: string;
+    sourceNodeId: string;
+    sourceComponentName: string;
+    consumerNodeIds: string[];
+    consumerComponentNames: string[];
+    path: PropDrillingChainNode[];
+    depth: number;
+    passthroughCount: number;
+    severity: 'info' | 'warning' | 'critical';
+    renames: Array<{
+        atNodeId: string;
+        fromKey: string;
+        toKey: string;
+    }>;
+}
+interface RuntimePropDrillingMessage {
+    type: 'runtime:propDrilling';
+    payload: {
+        chains: PropDrillingChain[];
+        passthroughNodeIds: string[];
+        analysisTimestamp: number;
+        treeSize: number;
+    };
+}
+/** Sent whenever a useActionState or useOptimistic hook changes on any fiber */
+interface RuntimeActionStateMessage {
+    type: 'runtime:actionState';
+    nodeId: string;
+    componentName: string;
+    /** One entry per useActionState / useOptimistic hook on this fiber */
+    actions: Array<{
+        hookIndex: number;
+        hookKind: 'action' | 'optimistic';
+        isPending: boolean;
+        state: SerializedValue;
+        error?: SerializedValue;
+        pendingSince?: number;
+        durationMs?: number;
+    }>;
+    timestamp: number;
+}
+/** Sent when a useOptimistic value diverges from its underlying actual value */
+interface RuntimeOptimisticDiffMessage {
+    type: 'runtime:optimisticDiff';
+    nodeId: string;
+    componentName: string;
+    hookIndex: number;
+    optimisticValue: SerializedValue;
+    actualValue: SerializedValue;
+    timestamp: number;
+}
+/** Sent once on mount when the Next.js environment is detected */
+interface RuntimeNextjsContextMessage {
+    type: 'runtime:nextjsContext';
+    detected: boolean;
+    version?: string;
+    isAppRouter: boolean;
+    initialRoute?: string;
+    timestamp: number;
+}
+/** Sent when an RSC / Next.js data fetch is intercepted (metadata only, no values) */
+interface RuntimeRscPayloadMessage {
+    type: 'runtime:rscPayload';
+    route: string;
+    payloadSizeBytes: number;
+    cacheStatus: 'HIT' | 'MISS' | 'STALE' | 'unknown';
+    timestamp: number;
+}
+/** Sent when React hydration completes or a mismatch is detected */
+interface RuntimeHydrationEventMessage {
+    type: 'runtime:hydrationEvent';
+    kind: 'complete' | 'mismatch';
+    durationMs?: number;
+    errorMessage?: string;
+    timestamp: number;
+}
+/** Metadata for a single intercepted network request. Privacy-first: no bodies, no query params, no auth headers. */
+interface NetworkRequestEntry {
+    /** Incrementing request ID */
+    requestId: string;
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH, etc.) */
+    method: string;
+    /** URL path only — query params stripped for privacy */
+    urlPath: string;
+    /** URL host for endpoint grouping */
+    urlHost: string;
+    /** HTTP status code (0 if pending/aborted) */
+    status: number;
+    /** Request duration in ms (null if still pending) */
+    durationMs: number | null;
+    /** Response size from Content-Length header (null if unavailable) */
+    responseSizeBytes: number | null;
+    /** React component that initiated this request (if attributable) */
+    componentName?: string;
+    /** Ancestor chain of the initiating component (last 3) */
+    ancestorChain?: string[];
+    /** True if fetch was called during React render phase (anti-pattern) */
+    initiatedDuringRender: boolean;
+    /** True if fetch was called inside a useEffect callback */
+    initiatedInEffect: boolean;
+    /** Request lifecycle state */
+    state: 'pending' | 'success' | 'error' | 'aborted';
+    /** Deduplication key: `${method}:${normalizedPath}` for duplicate detection */
+    dedupeKey: string;
+    /** True if another request with same dedupeKey was made within 2s */
+    isDuplicate?: boolean;
+    /** True if this is a Next.js Server Action (POST with Next-Action header) */
+    isServerAction?: boolean;
+    /** True if this is a Next.js RSC prefetch (Next-Router-Prefetch header) */
+    isPrefetch?: boolean;
+    /** Error message if request failed */
+    errorMessage?: string;
+    /** Timestamp (Date.now()) */
+    timestamp: number;
+}
+/** Batched network request message sent to FloTrace server */
+interface RuntimeNetworkRequestMessage {
+    type: 'runtime:networkRequest';
+    requests: NetworkRequestEntry[];
+    timestamp: number;
+}
+/** Emitted when a fiber's useState/useReducer hook holds API response data (WeakMap causal) */
+interface RuntimeLocalStateCorrelationMessage {
+    type: 'runtime:localStateCorrelation';
+    requestId: string;
+    componentName: string;
+    hookIndex: number;
+    timestamp: number;
+}
+/**
+ * Messages received from extension
+ */
+type ExtensionToRuntimeMessage = {
+    type: 'ext:ping';
+} | {
+    type: 'ext:startTracking';
+    options?: TrackingOptions;
+} | {
+    type: 'ext:stopTracking';
+} | {
+    type: 'ext:requestState';
+    componentName?: string;
+} | {
+    type: 'ext:requestNodeProps';
+    nodeId: string;
+} | {
+    type: 'ext:startTreeTracking';
+} | {
+    type: 'ext:stopTreeTracking';
+} | {
+    type: 'ext:requestFullSnapshot';
+} | {
+    type: 'ext:requestNodeHooks';
+    nodeId: string;
+} | {
+    type: 'ext:requestNodeEffects';
+    nodeId: string;
+} | {
+    type: 'ext:requestDetailedRenderReason';
+    nodeId: string;
+} | {
+    type: 'ext:requestTimeline';
+    nodeId: string;
+} | {
+    type: 'ext:startNetworkCapture';
+} | {
+    type: 'ext:stopNetworkCapture';
+} | {
+    type: 'ext:startReduxTracking';
+} | {
+    type: 'ext:stopReduxTracking';
+} | {
+    type: 'ext:startRouterTracking';
+} | {
+    type: 'ext:stopRouterTracking';
+} | {
+    type: 'ext:startZustandTracking';
+} | {
+    type: 'ext:stopZustandTracking';
+} | {
+    type: 'ext:startTanstackTracking';
+} | {
+    type: 'ext:stopTanstackTracking';
+};
+interface TrackingOptions {
+    trackAllRenders?: boolean;
+    componentFilter?: string[];
+    includeProps?: boolean;
+    trackZustand?: boolean;
+    trackRedux?: boolean;
+    trackRouter?: boolean;
+    trackContext?: boolean;
+    trackTanstackQuery?: boolean;
+    trackNetwork?: boolean;
+    batchSize?: number;
+    batchDelayMs?: number;
+}
+/**
+ * FloTrace provider configuration
+ */
+interface FloTraceConfig {
+    /** WebSocket server port (default: 3457) */
+    port?: number;
+    /** App name to display in FloTrace */
+    appName?: string;
+    /** Enable/disable tracking (default: true in development) */
+    enabled?: boolean;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnect interval in ms (default: 2000) */
+    reconnectInterval?: number;
+    /** Track all renders or only specific components */
+    trackAllRenders?: boolean;
+    /** Include props in render events (default: true) */
+    includeProps?: boolean;
+    /** Track Zustand stores (default: true) */
+    trackZustand?: boolean;
+    /** Track Redux store (default: true) */
+    trackRedux?: boolean;
+    /** Track React Router (default: true) */
+    trackRouter?: boolean;
+    /** Track Context (default: true) */
+    trackContext?: boolean;
+    /** Track TanStack Query (default: true) */
+    trackTanstackQuery?: boolean;
+    /** Resolver for the app URL included in the `runtime:ready` message.
+     *  Web adapter passes `() => window.location.href`; native adapters pass undefined
+     *  (no browser URL on React Native). */
+    getAppUrl?: () => string | undefined;
+    /** Runtime platform — set by adapters. Web passes 'web'; native derives from `Platform.OS`.
+     *  Surfaced on `runtime:ready` so the desktop can badge nodes + disambiguate multi-app sessions. */
+    platform?: 'web' | 'ios' | 'android';
+    /** Stable app identifier. Used by the desktop to disambiguate simultaneously-connected
+     *  clients (e.g., one iOS + one Android from the same monorepo). */
+    appId?: string;
+    /** App version — surfaced on `runtime:ready` for diagnostic display. */
+    appVersion?: string;
+    /** WebSocket host override. Native adapter sets this to the resolved Metro host
+     *  (e.g., "10.0.2.2" on Android emulator, LAN IP for physical devices).
+     *  Defaults to '127.0.0.1' when unset. */
+    host?: string;
+    /** LAN auth token for connections to `0.0.0.0`-bound desktop servers.
+     *  Ignored for loopback (`127.0.0.1`) connections. Paste from desktop Settings. */
+    authToken?: string;
+    /** **Experimental (runtime-native only).** Default-deny filter: a component is
+     *  treated as framework unless its fiber has positive source-path evidence
+     *  (`_debugSource`, owner-chain `_debugSource`, or `_debugStack` first non-react
+     *  frame) pointing outside `node_modules`. Eliminates most per-library
+     *  wrapper-name maintenance. Default: `true` on native, `false` on web. Pass
+     *  `false` to fall back to the name-list-based framework filter. */
+    userOnlyStrict?: boolean;
+    /** Regex patterns that mark paths as user code even when they would otherwise
+     *  be hidden by strict mode (e.g. monorepo packages resolved into
+     *  `node_modules/@workspace/ui`). Only consulted when `userOnlyStrict` is on. */
+    userAllowPatterns?: RegExp[];
+}
+/** Keys that stay optional in DEFAULT_CONFIG. These are populated by adapters (web/native)
+ *  at call-time — the default object should not pretend to know a platform or LAN token. */
+type OptionalConfigKeys = 'getAppUrl' | 'platform' | 'appId' | 'appVersion' | 'host' | 'authToken' | 'userOnlyStrict' | 'userAllowPatterns';
+type ResolvedFloTraceConfig = Required<Omit<FloTraceConfig, OptionalConfigKeys>> & Pick<FloTraceConfig, OptionalConfigKeys>;
+/**
+ * Default configuration
+ */
+declare const DEFAULT_CONFIG: ResolvedFloTraceConfig;
+
+/**
+ * Fiber Tree Walker for @flotrace/runtime
+ *
+ * Captures the full React component hierarchy and sends tree snapshots
+ * to the FloTrace VS Code extension via WebSocket.
+ *
+ * Two strategies for accessing the fiber tree:
+ * 1. DevTools Hook: Wraps __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot (event-driven)
+ * 2. DOM Fallback: Finds fibers via __reactFiber$ keys on DOM elements (works without DevTools)
+ *
+ * The DOM fallback is triggered by requestTreeSnapshot() which is called
+ * from the Profiler's onRender callback - so tree walks happen after each React commit.
+ */
+
+/**
+ * Minimal fiber type - only the fields we access.
+ * React fibers are internal, so we type just what we use.
+ */
+interface Fiber$1 {
+    tag: number;
+    key: string | null;
+    type: FiberType | null;
+    child: Fiber$1 | null;
+    sibling: Fiber$1 | null;
+    return: Fiber$1 | null;
+    memoizedProps: Record<string, unknown> | null;
+    pendingProps: Record<string, unknown> | null;
+    actualDuration?: number;
+    alternate?: Fiber$1 | null;
+    stateNode?: unknown;
+    _debugSource?: {
+        fileName: string;
+        lineNumber: number;
+    } | null;
+    /** React 19+: fiber that created this fiber (owner chain). */
+    _debugOwner?: Fiber$1 | null;
+    /** React 19.1+: Error captured at JSX creation site (replaces _debugSource in React 19+). */
+    _debugStack?: {
+        stack?: string;
+    } | null;
+    /** Hook state linked list head (useState, useRef, useMemo, etc.) */
+    memoizedState: FiberHookState | null;
+    /** Effect queue (useEffect, useLayoutEffect circular list) */
+    updateQueue: FiberUpdateQueue | null;
+    /** Fiber flags (for detecting force updates, etc.) */
+    flags: number;
+    /** Pending work lanes on this fiber */
+    lanes: number;
+    /** Pending work lanes on this fiber's subtree */
+    childLanes: number;
+    /** Element type (used for context detection) */
+    elementType: unknown;
+    /** Context dependencies (React 18+) */
+    dependencies: FiberDependencies | null;
+    /** Debug hook types array (dev mode: ["useState", "useEffect", ...]) */
+    _debugHookTypes?: string[] | null;
+}
+/**
+ * Hook state linked list node from fiber.memoizedState.
+ * Each hook call creates one node in this linked list.
+ */
+interface FiberHookState {
+    memoizedState: unknown;
+    baseState: unknown;
+    baseQueue: unknown;
+    queue: {
+        pending: unknown;
+        lastRenderedReducer: ((...args: unknown[]) => unknown) | null;
+        lastRenderedState: unknown;
+        dispatch?: (...args: unknown[]) => void;
+    } | null;
+    next: FiberHookState | null;
+}
+/**
+ * Effect structure in the updateQueue circular linked list.
+ * Tag bitmask: HookHasEffect=0b0001, Insertion=0b0010, Layout=0b0100, Passive=0b1000
+ */
+interface FiberEffect {
+    tag: number;
+    create: (() => (() => void) | void) | null;
+    destroy: (() => void) | null;
+    deps: unknown[] | null;
+    next: FiberEffect | null;
+}
+interface FiberUpdateQueue {
+    lastEffect: FiberEffect | null;
+    /** Class component update queue — pending updates linked list */
+    shared?: {
+        pending?: unknown;
+    };
+    /** Lane bits for this queue */
+    lanes?: number;
+}
+interface FiberDependencies {
+    firstContext: FiberContextDependency | null;
+}
+interface FiberContextDependency {
+    context: {
+        _currentValue: unknown;
+        displayName?: string;
+    };
+    memoizedValue: unknown;
+    next: FiberContextDependency | null;
+}
+type FiberType = {
+    name?: string;
+    displayName?: string;
+    render?: {
+        name?: string;
+        displayName?: string;
+    };
+    type?: {
+        name?: string;
+        displayName?: string;
+    };
+};
+/**
+ * FiberRoot from React internals (what onCommitFiberRoot receives)
+ */
+interface FiberRoot {
+    current: Fiber$1;
+}
+/**
+ * The global hook React DevTools uses. We piggyback on it.
+ */
+interface DevToolsHook {
+    onCommitFiberRoot?: (rendererID: number, root: FiberRoot, priority?: number) => void;
+}
+declare global {
+    interface Window {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__?: DevToolsHook & Record<string, unknown>;
+    }
+    interface globalThis {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__?: DevToolsHook & Record<string, unknown>;
+    }
+}
+/** Platform-specific hooks the walker reads during descent. */
+interface FiberTreeWalkerOptions {
+    /**
+     * Per-node predicate invoked for every user-component node after it has been
+     * fully assembled. Returning true drops the node (and its descendants) from
+     * the emitted tree. Platforms use this to hide subtrees that are not visible
+     * to the user — e.g. React Native inactive screens, React `<Modal>` overlays,
+     * or lib/framework-only subtrees. Default: never prune.
+     */
+    pruneSubtree?: (node: LiveTreeNode) => boolean;
+    /**
+     * Extra component names treated as framework internals (merged with the built-in
+     * web list). Platforms use this to tag RN / React Navigation / Reanimated /
+     * Gesture Handler / Safe Area / FlashList wrappers without forking the walker.
+     */
+    frameworkComponentNames?: string[];
+    /**
+     * Extra display-name regex patterns treated as framework internals. Used for
+     * generated names that can't be enumerated exhaustively — e.g. React Native's
+     * `Animated(View)` / `Animated(Anonymous)` HOC output or `_withRef` forwardRef
+     * wrappers. Checked when the exact-name set misses.
+     */
+    frameworkComponentNamePatterns?: RegExp[];
+    /**
+     * Extra path patterns treated as framework source (merged with the built-in
+     * web list). Checked against fiber._debugSource.fileName in dev mode.
+     */
+    frameworkPathPatterns?: RegExp[];
+    /**
+     * Host-node name prefixes to skip at the host-component layer (mirror of the
+     * DOM-element filter). React Native sets this to `["RCT"]` so native host
+     * views like `RCTView`/`RCTText` don't appear in the tree.
+     */
+    hostComponentSkipPrefixes?: string[];
+    /**
+     * **Experimental.** Default-deny mode: a fiber is treated as framework
+     * unless there is positive source-path evidence that it originates from user
+     * code. Evidence resolution order (first match wins):
+     *   1. `fiber._debugSource.fileName`
+     *   2. owner-chain walk of `fiber._debugOwner._debugSource.fileName` (3 hops)
+     *   3. first non-react frame parsed from `fiber._debugStack.stack`
+     * A fiber passes iff the resolved path is defined AND does not contain
+     * `node_modules` AND matches `userAllowPatterns` when that list is set.
+     *
+     * Rationale: library code is typically published pre-transpiled so the JSX
+     * source plugin never runs on it, and `_debugSource` is absent. Flipping the
+     * default from allow-list (enumerate every wrapper) to deny-list (require
+     * user evidence) eliminates most of the per-library maintenance burden.
+     *
+     * Degrades gracefully: when strict mode is on but the runtime populates zero
+     * `_debugSource` info on any fiber (e.g. Next.js SWC without the plugin),
+     * the name-based filter remains the fallback.
+     */
+    userOnlyStrict?: boolean;
+    /**
+     * Regex patterns that explicitly mark paths as user code even when they
+     * would otherwise be hidden (e.g. a monorepo package resolved into
+     * `node_modules/@workspace/ui/dist/*`). Only consulted when `userOnlyStrict`
+     * is on. Checked BEFORE the `node_modules` deny rule.
+     */
+    userAllowPatterns?: RegExp[];
+}
+/**
+ * Request a tree snapshot using the DOM fallback approach.
+ * Called from FloTraceProvider's Profiler onRender callback after each React commit.
+ * This is the primary way to trigger tree walks when DevTools hook isn't available.
+ *
+ * When the DevTools hook strategy is active, this acts as a safety net:
+ * if no snapshot has been sent via onCommitFiberRoot within DEVTOOLS_STALE_THRESHOLD_MS,
+ * we fall back to DOM-based snapshots. This handles React 19 compatibility issues
+ * where onCommitFiberRoot may not fire reliably for all commits.
+ */
+declare function requestTreeSnapshot(): void;
+/**
+ * Force the next snapshot to be a full tree (not a diff).
+ * Called when the extension detects a sequence gap or on explicit refresh.
+ * Resets diff state so the next scheduleSnapshot sends runtime:treeSnapshot.
+ */
+declare function requestFullSnapshot(): void;
+/**
+ * Install the fiber tree walker.
+ *
+ * Strategy 1 (preferred): Hook into __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot
+ * Strategy 2 (fallback): DOM-based fiber access, triggered by requestTreeSnapshot()
+ *
+ * Tree snapshots are always sent WITHOUT props (structure only).
+ * Props are fetched on demand via getNodeProps() when the user selects a node.
+ *
+ * @returns Cleanup function to uninstall
+ */
+declare function installFiberTreeWalker(options?: FiberTreeWalkerOptions): () => void;
+/**
+ * Get serialized props for a specific node by ID.
+ * Looks up the fiber reference cached during the last tree walk and serializes
+ * its current memoizedProps. Returns null if the node is not found (e.g., unmounted).
+ */
+declare function getNodeProps(nodeId: string): Record<string, SerializedValue> | null;
+/**
+ * Get detailed render reason for a specific node by ID.
+ * Uses fiberRefMap to look up the cached fiber reference.
+ */
+declare function getDetailedRenderReason(nodeId: string): DetailedRenderReason | null;
+/**
+ * Get all hooks for a specific node by ID.
+ * Returns null if the node is not found (e.g., unmounted).
+ */
+declare function getNodeHooks(nodeId: string): HookInfo[] | null;
+/**
+ * Get all effects for a specific node by ID.
+ * Returns null if the node is not found (e.g., unmounted).
+ */
+declare function getNodeEffects(nodeId: string): EffectInfo[] | null;
+/**
+ * Get the fiberRefMap for external use (e.g., console tracker fiber attribution).
+ */
+declare function getFiberRefMap(): Map<string, Fiber$1>;
+/**
+ * Uninstall the fiber tree walker, restoring the original hook.
+ */
+declare function uninstallFiberTreeWalker(): void;
+
+/**
+ * Fiber Attribution Utilities for @flotrace/runtime
+ *
+ * Provides React fiber introspection for component attribution.
+ * Used by networkTracker to identify which component triggered a request.
+ *
+ * Works across React 18 and 19 by probing different internal property names.
+ */
+interface FiberLike {
+    type: {
+        name?: string;
+        displayName?: string;
+        type?: {
+            name?: string;
+            displayName?: string;
+        };
+        render?: {
+            name?: string;
+            displayName?: string;
+        };
+    } | ((...args: unknown[]) => unknown) | string | null;
+    return: FiberLike | null;
+    tag: number;
+}
+/**
+ * Get the currently rendering fiber across React 18 and 19.
+ *
+ * Strategy 1 (React 18): __SECRET_INTERNALS...ReactCurrentOwner.current
+ * Strategy 2 (React 19): __CLIENT_INTERNALS...owner field (renamed + flattened)
+ * Both return the fiber currently being rendered (null between renders).
+ */
+declare function getCurrentRenderingFiber(): FiberLike | null;
+/**
+ * Extract display name from a fiber node.
+ */
+declare function getComponentNameFromFiber(fiber: FiberLike): string | null;
+/**
+ * Walk up the fiber tree to build an ancestor chain of component names.
+ * Stops after 10 levels to prevent excessive traversal.
+ */
+declare function buildAncestorChain(fiber: FiberLike): string[];
+
+/**
+ * Hook Inspector for @flotrace/runtime
+ *
+ * Walks fiber.memoizedState linked list, classifies each hook by type,
+ * and serializes values for display in FloTrace.
+ *
+ * Hook classification uses a combination of:
+ * 1. fiber._debugHookTypes (available in dev builds — most reliable)
+ * 2. Shape-based inference from memoizedState structure (fallback)
+ *
+ * Shape heuristics (from React internals):
+ * - useState/useReducer: queue !== null (has dispatch/reducer)
+ * - useRef: memoizedState is { current: <value> } with single key
+ * - useMemo/useCallback: memoizedState is [computedValue, deps]
+ * - useEffect/useLayoutEffect: matched against effect circular list via tag bitmask
+ */
+
+/**
+ * Inspect all hooks in a fiber's memoizedState linked list.
+ * Returns an array of HookInfo objects with type, value, and deps.
+ */
+declare function inspectHooks(fiber: Fiber$1): HookInfo[];
+
+/**
+ * Effect Dependency Tracker for @flotrace/runtime
+ *
+ * Walks fiber.updateQueue.lastEffect circular linked list to extract
+ * all effects (useEffect, useLayoutEffect, useInsertionEffect) with:
+ * - Current and previous dependency arrays
+ * - Which specific deps changed (triggering the effect)
+ * - Whether the effect will run on this render
+ * - Whether a cleanup function exists
+ *
+ * Effect tag bitmask (from React's HookFlags):
+ *   HookHasEffect  = 0b0001 (1)  — effect will execute
+ *   HookInsertion  = 0b0010 (2)  — useInsertionEffect
+ *   HookLayout     = 0b0100 (4)  — useLayoutEffect
+ *   HookPassive    = 0b1000 (8)  — useEffect
+ */
+
+/**
+ * Inspect all effects in a fiber's updateQueue.
+ * Compares current deps with previous (from fiber.alternate) to detect changes.
+ */
+declare function inspectEffects(fiber: Fiber$1): EffectInfo[];
+
+type MessageHandler = (message: ExtensionToRuntimeMessage) => void;
+type ConnectionHandler = (connected: boolean) => void;
+/**
+ * WebSocket client for connecting to FloTrace VS Code extension.
+ * Handles connection, reconnection, and message batching.
+ */
+declare class FloTraceWebSocketClient {
+    private ws;
+    private config;
+    private messageQueue;
+    private flushTimeout;
+    private reconnectTimeout;
+    private isConnecting;
+    private reconnectAttempts;
+    private static readonly MAX_RECONNECT_ATTEMPTS;
+    private static readonly MAX_RECONNECT_INTERVAL;
+    private static readonly BATCH_FLUSH_MS;
+    private static readonly MAX_QUEUE_SIZE;
+    private messageHandlers;
+    private connectionHandlers;
+    constructor(config?: FloTraceConfig);
+    /**
+     * Connect to the FloTrace WebSocket server
+     */
+    connect(): void;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Send a message to the extension (queued and batched)
+     */
+    send(message: RuntimeMessage): void;
+    /**
+     * Send a message immediately (not batched)
+     */
+    sendImmediate(message: RuntimeMessage): void;
+    /**
+     * Flush the message queue
+     */
+    private flush;
+    /**
+     * Schedule a reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Handle incoming message from extension
+     */
+    private handleMessage;
+    /**
+     * Notify connection state change
+     */
+    private notifyConnectionChange;
+    /**
+     * Add a message handler
+     */
+    onMessage(handler: MessageHandler): () => void;
+    /**
+     * Add a connection state handler
+     */
+    onConnectionChange(handler: ConnectionHandler): () => void;
+    /**
+     * Check if connected
+     */
+    get connected(): boolean;
+    /**
+     * Get React version if available
+     */
+    private getReactVersion;
+}
+/**
+ * Get or create the singleton WebSocket client
+ */
+declare function getWebSocketClient(config?: FloTraceConfig): FloTraceWebSocketClient;
+/**
+ * Dispose the singleton client
+ */
+declare function disposeWebSocketClient(): void;
+
+/**
+ * Zustand Store Tracker for @flotrace/runtime
+ *
+ * Subscribes to explicitly registered Zustand stores and sends
+ * state change notifications to the FloTrace VS Code extension.
+ *
+ * Design: User registers stores via the `stores` prop on <FloTraceProvider>.
+ * We subscribe to each store's .subscribe() method and use .getState()
+ * to capture state on change.
+ *
+ * Why explicit registration vs. automatic detection:
+ * - Automatic detection requires patching Zustand internals (fragile across versions)
+ * - Explicit registration is simple, reliable, and version-independent
+ * - Users can control exactly which stores are tracked
+ */
+
+/** Minimal Zustand store interface — only what we need to subscribe */
+interface ZustandStoreApi {
+    subscribe: (listener: (state: Record<string, unknown>, prevState: Record<string, unknown>) => void) => () => void;
+    getState: () => Record<string, unknown>;
+}
+/**
+ * Install Zustand store tracking.
+ * Subscribes to each store and sends runtime:zustand messages on state change.
+ */
+declare function installZustandTracker(stores: Record<string, ZustandStoreApi>, client: FloTraceWebSocketClient): void;
+/**
+ * Uninstall Zustand store tracking, unsubscribing from all stores.
+ */
+declare function uninstallZustandTracker(): void;
+
+/**
+ * Redux Store Tracker for @flotrace/runtime
+ *
+ * Subscribes to a Redux store and sends state change notifications
+ * to the FloTrace VS Code extension.
+ *
+ * Design: User passes their Redux store via the `reduxStore` prop on <FloTraceProvider>.
+ * We subscribe via store.subscribe() and use store.getState() to capture state.
+ *
+ * Key difference from Zustand tracker:
+ * - Redux store.subscribe() callback receives no arguments
+ * - We must call store.getState() manually and diff against previous snapshot
+ * - Redux is a single global store (no multi-store record)
+ */
+
+/** Minimal Redux store interface — only what we need to subscribe */
+interface ReduxStoreApi {
+    subscribe: (listener: () => void) => () => void;
+    getState: () => Record<string, unknown>;
+}
+/**
+ * Validate that an object looks like a Redux store.
+ * Checks for getState, subscribe, and dispatch as functions.
+ */
+declare function isReduxStore(obj: unknown): obj is ReduxStoreApi;
+/**
+ * Install Redux store tracking.
+ * Subscribes to the store and sends runtime:redux messages on state change.
+ */
+declare function installReduxTracker(store: ReduxStoreApi, client: FloTraceWebSocketClient): void;
+/**
+ * Uninstall Redux store tracking.
+ */
+declare function uninstallReduxTracker(): void;
+
+/**
+ * TanStack Query Tracker for @flotrace/runtime
+ *
+ * Subscribes to QueryCache and MutationCache events and sends
+ * query/mutation state snapshots to the FloTrace desktop app.
+ *
+ * Features:
+ * - Cache state snapshots with config for health analysis
+ * - Wasted refetch detection (data unchanged across fetches)
+ * - Per-query state transition timeline (ring buffer)
+ * - Mutation → query correlation (detects invalidation cascades)
+ *
+ * Uses duck-typed interface — no @tanstack/react-query dependency needed.
+ */
+
+/** Minimal Query interface — only what we need to read state */
+interface DuckQuery {
+    queryKey: unknown[];
+    queryHash: string;
+    state: {
+        status: 'pending' | 'success' | 'error';
+        fetchStatus: 'idle' | 'fetching' | 'paused';
+        data: unknown;
+        error: unknown;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        isInvalidated: boolean;
+        fetchFailureCount: number;
+        fetchFailureReason: unknown;
+    };
+    options: {
+        staleTime?: number;
+        gcTime?: number;
+        retry?: number | boolean;
+        refetchInterval?: number | false;
+        refetchOnWindowFocus?: boolean | 'always';
+        refetchOnMount?: boolean | 'always';
+        refetchOnReconnect?: boolean | 'always';
+        networkMode?: 'online' | 'always' | 'offlineFirst';
+        enabled?: boolean;
+        meta?: Record<string, unknown>;
+    };
+    getObserversCount(): number;
+    isStale(): boolean;
+    isActive(): boolean;
+    isDisabled(): boolean;
+}
+/** Minimal Mutation interface */
+interface DuckMutation {
+    mutationId: number;
+    state: {
+        status: 'idle' | 'pending' | 'error' | 'success';
+        isPaused: boolean;
+        submittedAt: number;
+        variables: unknown;
+        error: unknown;
+        failureCount: number;
+    };
+    options: {
+        mutationKey?: unknown[];
+        scope?: {
+            id: string;
+        };
+    };
+}
+/** Minimal QueryCache interface */
+interface DuckQueryCache {
+    getAll(): DuckQuery[];
+    subscribe(cb: (event: {
+        type: string;
+        query?: DuckQuery;
+    }) => void): () => void;
+}
+/** Minimal MutationCache interface */
+interface DuckMutationCache {
+    getAll(): DuckMutation[];
+    subscribe(cb: (event: {
+        type: string;
+        mutation?: DuckMutation;
+    }) => void): () => void;
+}
+/** Duck-typed QueryClient — what we need from the user */
+interface TanStackQueryClientApi {
+    getQueryCache(): DuckQueryCache;
+    getMutationCache(): DuckMutationCache;
+}
+/** Validate that an object looks like a TanStack QueryClient */
+declare function isTanStackQueryClient(obj: unknown): obj is TanStackQueryClientApi;
+/**
+ * Install TanStack Query tracking.
+ * Subscribes to QueryCache and MutationCache and sends runtime:tanstackQuery messages.
+ */
+declare function installTanStackQueryTracker(queryClient: TanStackQueryClientApi, client: FloTraceWebSocketClient): void;
+/**
+ * Uninstall TanStack Query tracking.
+ */
+declare function uninstallTanStackQueryTracker(): void;
+
+/**
+ * Component Event Timeline for @flotrace/runtime
+ *
+ * Emits lifecycle events (mount, unmount, render, effect-run, effect-cleanup,
+ * state-update, props-change) for each component. Events are stored in a
+ * ring buffer per component (max 100 events) to prevent memory growth.
+ *
+ * Events are batched and flushed every 500ms to avoid flooding the WebSocket.
+ */
+
+/**
+ * Install the timeline tracker.
+ * Call once during ext:startTracking.
+ */
+declare function installTimelineTracker(wsClient: FloTraceWebSocketClient): void;
+/**
+ * Uninstall the timeline tracker and clean up resources.
+ */
+declare function uninstallTimelineTracker(): void;
+/**
+ * Record a lifecycle event for a component.
+ * Called from the fiber tree walker during tree walks and from effect trackers.
+ *
+ * @param nodeId - Path-based node ID (e.g., "App-0/Dashboard-0/Card-2")
+ * @param componentName - Component display name
+ * @param eventType - Lifecycle event type
+ * @param detail - Optional additional context (serialized)
+ * @param duration - Optional duration in ms (for render events)
+ */
+declare function recordTimelineEvent(nodeId: string, componentName: string, eventType: TimelineEventType, detail?: unknown, duration?: number): void;
+/**
+ * Get the timeline for a specific component (for on-demand requests).
+ */
+declare function getTimeline(nodeId: string): TimelineEvent[];
+
+/**
+ * Serialize a value for safe transmission over WebSocket.
+ * Handles circular references, functions, symbols, and large values.
+ */
+declare function serializeValue(value: unknown, depth?: number, seen?: WeakSet<object>): SerializedValue;
+/**
+ * Serialize props object, filtering out React internals and children
+ */
+declare function serializeProps(props: Record<string, unknown>): Record<string, SerializedValue>;
+/**
+ * Get changed keys between two objects
+ */
+declare function getChangedKeys(prev: Record<string, unknown> | undefined, next: Record<string, unknown>): string[];
+
+/**
+ * Shared WeakMap registry for API response → requestId causal correlation.
+ *
+ * Written by the platform-specific network tracker (`networkTracker` on web,
+ * `networkTrackerNative` on React Native) when a fetch response is parsed,
+ * and read by store trackers (Zustand/Redux/TanStack Query) inside their
+ * synchronous subscribe callbacks so we can attribute a store mutation to
+ * the fetch that produced the data.
+ *
+ * State lives here — in platform-agnostic core — so both the web and native
+ * network trackers can write to the same registry that the analyzers read.
+ */
+/** Tag an object and its nested children (depth ≤ 2) with the requestId. */
+declare function tagFetchData(obj: unknown, requestId: string, depth?: number): void;
+/** Returns true if any API request's response data is currently tagged (within TTL window). */
+declare function hasActiveTags(): boolean;
+/**
+ * Clear the timestamp tag map — fetchDataOrigin (WeakMap) self-cleans via GC.
+ * Called by network trackers on uninstall so stale tags don't survive into a
+ * fresh session.
+ */
+declare function clearFetchOriginTags(): void;
+/**
+ * Scan an object (and nested children up to depth 2) for a WeakMap-tagged fetch origin.
+ * Called by Zustand/Redux trackers synchronously in their subscribe callbacks.
+ * Returns the requestId if this object was the result of a tracked fetch within the TTL
+ * window, else undefined. TTL prevents stale entries from matching on later store updates
+ * that reuse the same object references (immutable store pattern).
+ */
+declare function findFetchOrigin(obj: unknown, depth?: number): string | undefined;
+
+/**
+ * Next.js App Router client-side detection.
+ * - Emits runtime:nextjsContext on startup when Next.js is detected
+ * - Provides per-fiber heuristics for isServerComponent / isClientBoundary
+ *
+ * All detection is heuristic and best-effort. Server Components themselves
+ * don't create client-side fibers, so detection is approximate.
+ */
+
+interface Fiber {
+    _debugSource?: {
+        fileName: string;
+        lineNumber: number;
+    } | null;
+    type: unknown;
+}
+/**
+ * Detect Next.js presence from window globals and emit runtime:nextjsContext once.
+ * Safe to call repeatedly — emits at most once per page load.
+ */
+declare function maybeEmitNextjsContext(client: FloTraceWebSocketClient): void;
+/**
+ * Heuristic: is this fiber likely a Next.js Server Component?
+ * Uses _debugSource file path and display name patterns.
+ * Approximate — Server Components don't exist as client fibers, but framework
+ * wrappers/references that represent them do.
+ */
+declare function detectServerComponent(fiber: Fiber): boolean;
+/** Reset detection state (useful for tests / hot-reload) */
+declare function resetNextjsDetection(): void;
+
+/**
+ * RSC payload fetch interceptor for Next.js App Router.
+ * Patches globalThis.fetch to detect Next.js data / RSC fetch requests,
+ * captures metadata (route, cache status, size), and emits runtime:rscPayload.
+ *
+ * Privacy guarantee: only metadata is captured (URL path, headers, size).
+ * Response bodies are never read or transmitted.
+ */
+
+/**
+ * Install the RSC payload interceptor.
+ * Safe to call multiple times — installs once.
+ */
+declare function installRscPayloadInterceptor(client: FloTraceWebSocketClient): void;
+/** Remove the RSC payload interceptor and restore original fetch */
+declare function uninstallRscPayloadInterceptor(): void;
+
+export { DEFAULT_CONFIG, type DetailedRenderReason, type DetailedRenderReasonType, type EffectInfo, type Fiber$1 as Fiber, type FiberEffect, type FiberHookState, type FiberTreeWalkerOptions, type FloTraceConfig, FloTraceWebSocketClient, type HookInfo, type HookType, type LiveTreeNode, type MutationCorrelation, type NetworkRequestEntry, type PropChange, type ReduxStoreApi, type ResolvedFloTraceConfig, type RuntimeTreeDiffMessage, type SerializedValue, type TanStackMutationInfo, type TanStackQueryClientApi, type TanStackQueryEvent, type TanStackQueryInfo, type TimelineEvent, type TimelineEventType, type TrackingOptions, type ZustandStoreApi, buildAncestorChain, clearFetchOriginTags, detectServerComponent, disposeWebSocketClient, findFetchOrigin, getChangedKeys, getComponentNameFromFiber, getCurrentRenderingFiber, getDetailedRenderReason, getFiberRefMap, getNodeEffects, getNodeHooks, getNodeProps, getTimeline, getWebSocketClient, hasActiveTags, inspectEffects, inspectHooks, installFiberTreeWalker, installReduxTracker, installRscPayloadInterceptor, installTanStackQueryTracker, installTimelineTracker, installZustandTracker, isReduxStore, isTanStackQueryClient, maybeEmitNextjsContext, recordTimelineEvent, requestFullSnapshot, requestTreeSnapshot, resetNextjsDetection, serializeProps, serializeValue, tagFetchData, uninstallFiberTreeWalker, uninstallReduxTracker, uninstallRscPayloadInterceptor, uninstallTanStackQueryTracker, uninstallTimelineTracker, uninstallZustandTracker };