@eagleoutice/flowr - v2.13.1
    Preparing search index...
    • The first schema violation (an unknown key or a wrong-typed value) in a config update, or undefined if it is valid. Shared by the repl line parser and the executor, so a programmatic or JSON-API update is validated exactly like a :config +key=value line and never merges junk or a mistyped value.

      Parameters

      • update: {
            abstractInterpretation?: {
                dataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean };
                };
                wideningThreshold?: number;
            };
            defaultEngine?: "tree-sitter"
            | "r-shell";
            defaultPlugins?: (string | [string?, unknown[]?] | undefined)[];
            engines?: (
                | {
                    lax?: boolean;
                    treeSitterWasmPath?: string;
                    type?: "tree-sitter";
                    wasmPath?: string;
                    [key: string]: unknown;
                }
                | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                | undefined
            )[];
            gas?: {
                features?: { [key: string]: number | undefined };
                heapProvider?: () => GasHeapStatistics | undefined;
                thresholds?: {
                    memory?: {
                        critical?: number;
                        problematic?: number;
                        [key: string]: unknown;
                    };
                    timeMs?: {
                        critical?: number;
                        problematic?: number;
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            };
            ignoreLoadCalls?: boolean;
            ignoreSourceCalls?: boolean;
            linter?: { disabledRules?: (string | undefined)[] };
            logLevel?:
                | "error"
                | "info"
                | "debug"
                | "trace"
                | "silly"
                | "warn"
                | "fatal";
            project?: {
                basePackages?: (string | undefined)[];
                implicitSources?: (string | undefined)[];
                resolveUnknownPathsOnDisk?: boolean;
                useProjectType?: ProjectKind;
            };
            repl?: {
                autoUseFileProtocol?: boolean;
                dfProcessorHeat?: boolean;
                hints?: boolean;
                plugins?: (string | [string?, unknown[]?] | undefined)[];
                queryStats?: boolean;
                quickStats?: boolean;
                showPlugins?: boolean;
            };
            semantics?: {
                environment?: {
                    overwriteBuiltIns?: {
                        definitions?: (
                            | { assumePrimitive?: ...; names?: ...; type?: ...; value?: ... }
                            | {
                                assumePrimitive?: ...;
                                config?: ...;
                                names?: ...;
                                suffixes?: ...;
                                type?: ...;
                            }
                            | {
                                assumePrimitive?: ...;
                                config?: ...;
                                evalHandler?: ...;
                                names?: ...;
                                processor?: ...;
                                type?: ...;
                            }
                            | undefined
                        )[];
                        loadDefaults?: boolean;
                    };
                };
            };
            solver?: {
                evalStrings?: boolean;
                instrument?: {
                    dataflowExtractors?: (
                        extractor: DataflowProcessors<ParentInformation>,
                        ctx: FlowrAnalyzerContext,
                    ) => DataflowProcessors<ParentInformation>;
                };
                resolveSource?: {
                    applyReplacements?: (
                        { [key: string]: string | undefined }
                        | undefined
                    )[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (string | undefined)[];
                    [key: string]: unknown;
                };
                sigdb?: {
                    additionalPaths?: (string | undefined)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: string]: string | undefined };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                };
                slicer?: { autoExtend?: boolean; threshold?: number };
                trackEnvironments?: boolean;
                variables?: VariableResolve;
                versionManagement?: {
                    linkedVersionGroups?: ((string | undefined)[] | undefined)[];
                };
            };
            specializeConfig?: {
                notebook?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                package?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                project?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                script?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                "shiny-app"?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                unknown?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: number;
                            readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                    engines?: (
                        | {
                            lax?: boolean;
                            treeSitterWasmPath?: string;
                            type?: "tree-sitter";
                            wasmPath?: string;
                            [key: string]: unknown;
                        }
                        | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: number | undefined };
                        heapProvider?: () => GasHeapStatistics | undefined;
                        thresholds?: {
                            memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: (string | undefined)[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: (string | undefined)[];
                        implicitSources?: (string | undefined)[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: (string | [(...)?, (...)?] | undefined)[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: {
                        environment?: {
                            overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                        };
                    };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                        resolveSource?: {
                            applyReplacements?: (...)[];
                            assumeFilesExist?: boolean;
                            dropPaths?: DropPathsOption;
                            ignoreCapitalization?: boolean;
                            inferWorkingDirectory?: InferWorkingDirectory;
                            repeatedSourceLimit?: number;
                            searchPath?: (...)[];
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)[];
                            assumedRVersion?: string;
                            autoSync?: boolean;
                            downloadRepo?: string;
                            eagerlyLoad?: boolean;
                            eagerlyLoadExports?: boolean;
                            enabled?: boolean;
                            linkBaseR?: boolean;
                            linkBaseRCalls?: boolean;
                            linkDescriptionDependencies?: boolean;
                            linkPackageCalls?: boolean;
                            loadProjectDependencies?: boolean;
                            versionOverrides?: { [key: ...]: ... };
                            versionSelection?: VersionSelection;
                            warmInBackground?: boolean;
                        };
                        slicer?: { autoExtend?: boolean; threshold?: number };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)[] };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: {
                                dataFrame?: ...;
                                wideningThreshold?: ...;
                            };
                            defaultEngine?: "tree-sitter"
                            | "r-shell";
                            defaultPlugins?: (...)[];
                            engines?: (...)[];
                            gas?: {
                                features?: ...;
                                heapProvider?: ...;
                                thresholds?: ...;
                                [key: ...]: ...;
                            };
                            ignoreLoadCalls?: boolean;
                            ignoreSourceCalls?: boolean;
                            inherit?: ProjectKind;
                            linter?: { disabledRules?: ... };
                            logLevel?:
                                | "error"
                                | "info"
                                | "debug"
                                | "trace"
                                | "silly"
                                | "warn"
                                | "fatal";
                            project?: {
                                basePackages?: ...;
                                implicitSources?: ...;
                                resolveUnknownPathsOnDisk?: ...;
                                useProjectType?: ...;
                            };
                            repl?: {
                                autoUseFileProtocol?: ...;
                                dfProcessorHeat?: ...;
                                hints?: ...;
                                plugins?: ...;
                                queryStats?: ...;
                                quickStats?: ...;
                                showPlugins?: ...;
                            };
                            semantics?: { environment?: ... };
                            solver?: {
                                evalStrings?: ...;
                                instrument?: ...;
                                resolveSource?: ...;
                                sigdb?: ...;
                                slicer?: ...;
                                trackEnvironments?: ...;
                                variables?: ...;
                                versionManagement?: ...;
                            };
                            specializeConfig?: {
                                notebook?: ...;
                                package?: ...;
                                project?: ...;
                                script?: ...;
                                "shiny-app"?: ...;
                                unknown?: ...;
                            };
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
            };
            [key: string]: unknown;
        }
        • [key: string]: unknown
        • Optional ReadonlyabstractInterpretation?: {
              dataFrame?: {
                  maxColNames?: number;
                  readLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean };
              };
              wideningThreshold?: number;
          }

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: {
                maxColNames?: number;
                readLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean };
            }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: number

              The maximum number of columns names to infer for data frames before over-approximating the column names to top

            • Optional ReadonlyreadLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean }

              Configuration options for reading data frame shapes from loaded external data files, such as CSV files

              • Optional ReadonlymaxReadLines?: number

                The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

              • Optional ReadonlyreadExternalFiles?: boolean

                Whether data frame shapes should be extracted from loaded external data files, such as CSV files

          • Optional ReadonlywideningThreshold?: number

            The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

        • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

          The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

        • Optional ReadonlydefaultPlugins?: (string | [string?, unknown[]?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: boolean;
                  treeSitterWasmPath?: string;
                  type?: "tree-sitter";
                  wasmPath?: string;
                  [key: string]: unknown;
              }
              | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
              | undefined
          )[]

          The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

        • Optional Readonlygas?: {
              features?: { [key: string]: number | undefined };
              heapProvider?: () => GasHeapStatistics | undefined;
              thresholds?: {
                  memory?: {
                      critical?: number;
                      problematic?: number;
                      [key: string]: unknown;
                  };
                  timeMs?: {
                      critical?: number;
                      problematic?: number;
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              };
              [key: string]: unknown;
          }

          Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

          • Optional Readonlyfeatures?: { [key: string]: number | undefined }

            Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

          • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

            Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

          • Optional Readonlythresholds?: {
                memory?: {
                    critical?: number;
                    problematic?: number;
                    [key: string]: unknown;
                };
                timeMs?: {
                    critical?: number;
                    problematic?: number;
                    [key: string]: unknown;
                };
                [key: string]: unknown;
            }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: { critical?: number; problematic?: number; [key: string]: unknown }

              Heap-usage fraction thresholds (0-1, before factor scaling).

              • Optional Readonlycritical?: number

                Returns GasLevel.Critical when reached (after factor scaling).

              • Optional Readonlyproblematic?: number

                Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlytimeMs?: { critical?: number; problematic?: number; [key: string]: unknown }

              Elapsed analysis time thresholds in milliseconds (before factor scaling).

              • Optional Readonlycritical?: number

                Returns GasLevel.Critical when reached (after factor scaling).

              • Optional Readonlyproblematic?: number

                Returns GasLevel.Problematic when reached (after factor scaling).

        • Optional ReadonlyignoreLoadCalls?: boolean

          Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

        • Optional ReadonlyignoreSourceCalls?: boolean

          Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

        • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

          Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

          • Optional ReadonlydisabledRules?: (string | undefined)[]

            Rule names excluded from the default rule set (a rule requested explicitly still runs).

        • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
        • Optional Readonlyproject?: {
              basePackages?: (string | undefined)[];
              implicitSources?: (string | undefined)[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • OptionalbasePackages?: (string | undefined)[]

            The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

          • OptionalimplicitSources?: (string | undefined)[]

            Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

          • OptionalresolveUnknownPathsOnDisk?: boolean

            Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

          • OptionaluseProjectType?: ProjectKind

            Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

        • Optional Readonlyrepl?: {
              autoUseFileProtocol?: boolean;
              dfProcessorHeat?: boolean;
              hints?: boolean;
              plugins?: (string | [string?, unknown[]?] | undefined)[];
              queryStats?: boolean;
              quickStats?: boolean;
              showPlugins?: boolean;
          }

          Configuration options for the REPL

          • OptionalautoUseFileProtocol?: boolean

            Automatically use the file protocol for inputs that look like paths (default true)

          • OptionaldfProcessorHeat?: boolean

            This instruments the dataflow processors to count how often each processor is called

          • Optionalhints?: boolean

            Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

          • Optionalplugins?: (string | [string?, unknown[]?] | undefined)[]

            Plugins to load in REPL mode

          • OptionalqueryStats?: boolean

            Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

          • OptionalquickStats?: boolean

            Whether to show quick stats in the REPL after each evaluation

          • OptionalshowPlugins?: boolean

            Whether :version grays out the plugins that did not activate during the last analysis (default false)

        • Optional Readonlysemantics?: {
              environment?: {
                  overwriteBuiltIns?: {
                      definitions?: (
                          | { assumePrimitive?: ...; names?: ...; type?: ...; value?: ... }
                          | {
                              assumePrimitive?: ...;
                              config?: ...;
                              names?: ...;
                              suffixes?: ...;
                              type?: ...;
                          }
                          | {
                              assumePrimitive?: ...;
                              config?: ...;
                              evalHandler?: ...;
                              names?: ...;
                              processor?: ...;
                              type?: ...;
                          }
                          | undefined
                      )[];
                      loadDefaults?: boolean;
                  };
              };
          }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: {
                overwriteBuiltIns?: {
                    definitions?: (
                        | { assumePrimitive?: ...; names?: ...; type?: ...; value?: ... }
                        | {
                            assumePrimitive?: ...;
                            config?: ...;
                            names?: ...;
                            suffixes?: ...;
                            type?: ...;
                        }
                        | {
                            assumePrimitive?: ...;
                            config?: ...;
                            evalHandler?: ...;
                            names?: ...;
                            processor?: ...;
                            type?: ...;
                        }
                        | undefined
                    )[];
                    loadDefaults?: boolean;
                };
            }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: {
                  definitions?: (
                      | { assumePrimitive?: ...; names?: ...; type?: ...; value?: ... }
                      | {
                          assumePrimitive?: ...;
                          config?: ...;
                          names?: ...;
                          suffixes?: ...;
                          type?: ...;
                      }
                      | {
                          assumePrimitive?: ...;
                          config?: ...;
                          evalHandler?: ...;
                          names?: ...;
                          processor?: ...;
                          type?: ...;
                      }
                      | undefined
                  )[];
                  loadDefaults?: boolean;
              }

              Do you want to overwrite (parts) of the builtin definition?

              • Optional Readonlydefinitions?: (
                    | { assumePrimitive?: ...; names?: ...; type?: ...; value?: ... }
                    | {
                        assumePrimitive?: ...;
                        config?: ...;
                        names?: ...;
                        suffixes?: ...;
                        type?: ...;
                    }
                    | {
                        assumePrimitive?: ...;
                        config?: ...;
                        evalHandler?: ...;
                        names?: ...;
                        processor?: ...;
                        type?: ...;
                    }
                    | undefined
                )[]

                The definitions to load

              • Optional ReadonlyloadDefaults?: boolean

                Should the default configuration still be loaded?

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: {
                  dataflowExtractors?: (
                      extractor: DataflowProcessors<ParentInformation>,
                      ctx: FlowrAnalyzerContext,
                  ) => DataflowProcessors<ParentInformation>;
              };
              resolveSource?: {
                  applyReplacements?: ({ [key: string]: string | undefined } | undefined)[];
                  assumeFilesExist?: boolean;
                  dropPaths?: DropPathsOption;
                  ignoreCapitalization?: boolean;
                  inferWorkingDirectory?: InferWorkingDirectory;
                  repeatedSourceLimit?: number;
                  searchPath?: (string | undefined)[];
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (string | undefined)[];
                  assumedRVersion?: string;
                  autoSync?: boolean;
                  downloadRepo?: string;
                  eagerlyLoad?: boolean;
                  eagerlyLoadExports?: boolean;
                  enabled?: boolean;
                  linkBaseR?: boolean;
                  linkBaseRCalls?: boolean;
                  linkDescriptionDependencies?: boolean;
                  linkPackageCalls?: boolean;
                  loadProjectDependencies?: boolean;
                  versionOverrides?: { [key: string]: string | undefined };
                  versionSelection?: VersionSelection;
                  warmInBackground?: boolean;
              };
              slicer?: { autoExtend?: boolean; threshold?: number };
              trackEnvironments?: boolean;
              variables?: VariableResolve;
              versionManagement?: {
                  linkedVersionGroups?: ((string | undefined)[] | undefined)[];
              };
          }

          How to resolve constants, constraints, cells, …

          • Optional ReadonlyevalStrings?: boolean

            Should we include eval(parse(text="...")) calls in the dataflow graph?

          • Optional Readonlyinstrument?: {
                dataflowExtractors?: (
                    extractor: DataflowProcessors<ParentInformation>,
                    ctx: FlowrAnalyzerContext,
                ) => DataflowProcessors<ParentInformation>;
            }

            These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

            • OptionaldataflowExtractors?: (
                  extractor: DataflowProcessors<ParentInformation>,
                  ctx: FlowrAnalyzerContext,
              ) => DataflowProcessors<ParentInformation>

              Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

          • Optional ReadonlyresolveSource?: {
                applyReplacements?: ({ [key: string]: string | undefined } | undefined)[];
                assumeFilesExist?: boolean;
                dropPaths?: DropPathsOption;
                ignoreCapitalization?: boolean;
                inferWorkingDirectory?: InferWorkingDirectory;
                repeatedSourceLimit?: number;
                searchPath?: (string | undefined)[];
                [key: string]: unknown;
            }

            If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

            • Optional ReadonlyapplyReplacements?: ({ [key: string]: string | undefined } | undefined)[]

              sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

              [
              { }, // no replacement -> still try the original name/path
              { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
              { '\s' : '_' }, // replace all spaces with underscores
              { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
              ]

              Given a source("foo bar.R") this configuration will search for (in this order):

              • foo bar.R (original name)
              • main.R (replaced with main.R)
              • foo_bar.R (replaced spaces)
              • faa-bar.R (replaced spaces and oo)
            • Optional ReadonlyassumeFilesExist?: boolean

              Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

            • Optional ReadonlydropPaths?: DropPathsOption

              Allow to drop the first or all parts of the sourced path, if it is relative.

            • Optional ReadonlyignoreCapitalization?: boolean

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

              try to infer the working directory from the main or any script to analyze.

            • Optional ReadonlyrepeatedSourceLimit?: number

              How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

            • Optional ReadonlysearchPath?: (string | undefined)[]

              Additionally search in these paths

          • Optional Readonlysigdb?: {
                additionalPaths?: (string | undefined)[];
                assumedRVersion?: string;
                autoSync?: boolean;
                downloadRepo?: string;
                eagerlyLoad?: boolean;
                eagerlyLoadExports?: boolean;
                enabled?: boolean;
                linkBaseR?: boolean;
                linkBaseRCalls?: boolean;
                linkDescriptionDependencies?: boolean;
                linkPackageCalls?: boolean;
                loadProjectDependencies?: boolean;
                versionOverrides?: { [key: string]: string | undefined };
                versionSelection?: VersionSelection;
                warmInBackground?: boolean;
            }

            Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

            • Optional ReadonlyadditionalPaths?: (string | undefined)[]

              Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

            • Optional ReadonlyassumedRVersion?: string

              The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

            • Optional ReadonlyautoSync?: boolean

              On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

            • Optional ReadonlydownloadRepo?: string

              GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

            • Optional ReadonlyeagerlyLoad?: boolean

              Parse the database up front rather than on the first package load (default false, ignored if disabled).

            • Optional ReadonlyeagerlyLoadExports?: boolean

              Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

            • Optional Readonlyenabled?: boolean

              Resolve library exports from a signature database (default true); when false no database is consulted.

            • Optional ReadonlylinkBaseR?: boolean

              Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

            • Optional ReadonlylinkBaseRCalls?: boolean

              Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

            • Optional ReadonlylinkDescriptionDependencies?: boolean

              Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

            • Optional ReadonlylinkPackageCalls?: boolean

              Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

            • Optional ReadonlyloadProjectDependencies?: boolean

              Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

            • Optional ReadonlyversionOverrides?: { [key: string]: string | undefined }

              Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

            • Optional ReadonlyversionSelection?: VersionSelection

              When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

            • Optional ReadonlywarmInBackground?: boolean

              Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

          • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: boolean

              If set, the slicer will gain an additional post-pass

            • Optional Readonlythreshold?: number

              The maximum number of iterations to perform on a single function call during slicing

          • Optional ReadonlytrackEnvironments?: boolean

            Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

          • Optional Readonlyvariables?: VariableResolve

            How to resolve variables and their values

          • Optional ReadonlyversionManagement?: { linkedVersionGroups?: ((string | undefined)[] | undefined)[] }

            Policies for reasoning about dependency versions (independent of how the signature database is loaded).

            • Optional ReadonlylinkedVersionGroups?: ((string | undefined)[] | undefined)[]

              Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

        • Optional ReadonlyspecializeConfig?: {
              notebook?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: {
                      dataFrame?: {
                          maxColNames?: number;
                          readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                      };
                      wideningThreshold?: number;
                  };
                  defaultEngine?: "tree-sitter"
                  | "r-shell";
                  defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                  engines?: (
                      | {
                          lax?: boolean;
                          treeSitterWasmPath?: string;
                          type?: "tree-sitter";
                          wasmPath?: string;
                          [key: string]: unknown;
                      }
                      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                      | undefined
                  )[];
                  gas?: {
                      features?: { [key: string]: number | undefined };
                      heapProvider?: () => GasHeapStatistics | undefined;
                      thresholds?: {
                          memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                          [key: string]: unknown;
                      };
                      [key: string]: unknown;
                  };
                  ignoreLoadCalls?: boolean;
                  ignoreSourceCalls?: boolean;
                  inherit?: ProjectKind;
                  linter?: { disabledRules?: (string | undefined)[] };
                  logLevel?:
                      | "error"
                      | "info"
                      | "debug"
                      | "trace"
                      | "silly"
                      | "warn"
                      | "fatal";
                  project?: {
                      basePackages?: (string | undefined)[];
                      implicitSources?: (string | undefined)[];
                      resolveUnknownPathsOnDisk?: boolean;
                      useProjectType?: ProjectKind;
                  };
                  repl?: {
                      autoUseFileProtocol?: boolean;
                      dfProcessorHeat?: boolean;
                      hints?: boolean;
                      plugins?: (string | [(...)?, (...)?] | undefined)[];
                      queryStats?: boolean;
                      quickStats?: boolean;
                      showPlugins?: boolean;
                  };
                  semantics?: {
                      environment?: {
                          overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                      };
                  };
                  solver?: {
                      evalStrings?: boolean;
                      instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                      resolveSource?: {
                          applyReplacements?: (...)[];
                          assumeFilesExist?: boolean;
                          dropPaths?: DropPathsOption;
                          ignoreCapitalization?: boolean;
                          inferWorkingDirectory?: InferWorkingDirectory;
                          repeatedSourceLimit?: number;
                          searchPath?: (...)[];
                          [key: string]: unknown;
                      };
                      sigdb?: {
                          additionalPaths?: (...)[];
                          assumedRVersion?: string;
                          autoSync?: boolean;
                          downloadRepo?: string;
                          eagerlyLoad?: boolean;
                          eagerlyLoadExports?: boolean;
                          enabled?: boolean;
                          linkBaseR?: boolean;
                          linkBaseRCalls?: boolean;
                          linkDescriptionDependencies?: boolean;
                          linkPackageCalls?: boolean;
                          loadProjectDependencies?: boolean;
                          versionOverrides?: { [key: ...]: ... };
                          versionSelection?: VersionSelection;
                          warmInBackground?: boolean;
                      };
                      slicer?: { autoExtend?: boolean; threshold?: number };
                      trackEnvironments?: boolean;
                      variables?: VariableResolve;
                      versionManagement?: { linkedVersionGroups?: (...)[] };
                  };
                  specializeConfig?: {
                      notebook?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      package?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      project?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      script?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      "shiny-app"?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                      unknown?: {
                          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                          defaultEngine?: "tree-sitter" | "r-shell";
                          defaultPlugins?: (...)[];
                          engines?: (...)[];
                          gas?: {
                              features?: ...;
                              heapProvider?: ...;
                              thresholds?: ...;
                              [key: ...]: ...;
                          };
                          ignoreLoadCalls?: boolean;
                          ignoreSourceCalls?: boolean;
                          inherit?: ProjectKind;
                          linter?: { disabledRules?: ... };
                          logLevel?:
                              | "error"
                              | "info"
                              | "debug"
                              | "trace"
                              | "silly"
                              | "warn"
                              | "fatal";
                          project?: {
                              basePackages?: ...;
                              implicitSources?: ...;
                              resolveUnknownPathsOnDisk?: ...;
                              useProjectType?: ...;
                          };
                          repl?: {
                              autoUseFileProtocol?: ...;
                              dfProcessorHeat?: ...;
                              hints?: ...;
                              plugins?: ...;
                              queryStats?: ...;
                              quickStats?: ...;
                              showPlugins?: ...;
                          };
                          semantics?: { environment?: ... };
                          solver?: {
                              evalStrings?: ...;
                              instrument?: ...;
                              resolveSource?: ...;
                              sigdb?: ...;
                              slicer?: ...;
                              trackEnvironments?: ...;
                              variables?: ...;
                              versionManagement?: ...;
                          };
                          specializeConfig?: {
                              notebook?: ...;
                              package?: ...;
                              project?: ...;
                              script?: ...;
                              "shiny-app"?: ...;
                              unknown?: ...;
                          };
                          [key: string]: unknown;
                      };
                  };
                  [key: string]: unknown;
              };
          }

          Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalnotebook?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalpackage?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalproject?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalscript?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalshiny-app?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

          • Optionalunknown?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: number;
                        readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (string | [string?, (...)[]?] | undefined)[];
                engines?: (
                    | {
                        lax?: boolean;
                        treeSitterWasmPath?: string;
                        type?: "tree-sitter";
                        wasmPath?: string;
                        [key: string]: unknown;
                    }
                    | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: number | undefined };
                    heapProvider?: () => GasHeapStatistics | undefined;
                    thresholds?: {
                        memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: (string | undefined)[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: (string | undefined)[];
                    implicitSources?: (string | undefined)[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: (string | [(...)?, (...)?] | undefined)[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: {
                    environment?: {
                        overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                    };
                };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                    resolveSource?: {
                        applyReplacements?: (...)[];
                        assumeFilesExist?: boolean;
                        dropPaths?: DropPathsOption;
                        ignoreCapitalization?: boolean;
                        inferWorkingDirectory?: InferWorkingDirectory;
                        repeatedSourceLimit?: number;
                        searchPath?: (...)[];
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)[];
                        assumedRVersion?: string;
                        autoSync?: boolean;
                        downloadRepo?: string;
                        eagerlyLoad?: boolean;
                        eagerlyLoadExports?: boolean;
                        enabled?: boolean;
                        linkBaseR?: boolean;
                        linkBaseRCalls?: boolean;
                        linkDescriptionDependencies?: boolean;
                        linkPackageCalls?: boolean;
                        loadProjectDependencies?: boolean;
                        versionOverrides?: { [key: ...]: ... };
                        versionSelection?: VersionSelection;
                        warmInBackground?: boolean;
                    };
                    slicer?: { autoExtend?: boolean; threshold?: number };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)[] };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                        defaultEngine?: "tree-sitter" | "r-shell";
                        defaultPlugins?: (...)[];
                        engines?: (...)[];
                        gas?: {
                            features?: ...;
                            heapProvider?: ...;
                            thresholds?: ...;
                            [key: ...]: ...;
                        };
                        ignoreLoadCalls?: boolean;
                        ignoreSourceCalls?: boolean;
                        inherit?: ProjectKind;
                        linter?: { disabledRules?: ... };
                        logLevel?:
                            | "error"
                            | "info"
                            | "debug"
                            | "trace"
                            | "silly"
                            | "warn"
                            | "fatal";
                        project?: {
                            basePackages?: ...;
                            implicitSources?: ...;
                            resolveUnknownPathsOnDisk?: ...;
                            useProjectType?: ...;
                        };
                        repl?: {
                            autoUseFileProtocol?: ...;
                            dfProcessorHeat?: ...;
                            hints?: ...;
                            plugins?: ...;
                            queryStats?: ...;
                            quickStats?: ...;
                            showPlugins?: ...;
                        };
                        semantics?: { environment?: ... };
                        solver?: {
                            evalStrings?: ...;
                            instrument?: ...;
                            resolveSource?: ...;
                            sigdb?: ...;
                            slicer?: ...;
                            trackEnvironments?: ...;
                            variables?: ...;
                            versionManagement?: ...;
                        };
                        specializeConfig?: {
                            notebook?: ...;
                            package?: ...;
                            project?: ...;
                            script?: ...;
                            "shiny-app"?: ...;
                            unknown?: ...;
                        };
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: {
                  dataFrame?: {
                      maxColNames?: number;
                      readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                  };
                  wideningThreshold?: number;
              }

              Configuration options for abstract interpretation

              • Optional ReadonlydataFrame?: {
                    maxColNames?: number;
                    readLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... };
                }

                The configuration of the shape inference for data frames

                • Optional ReadonlymaxColNames?: number

                  The maximum number of columns names to infer for data frames before over-approximating the column names to top

                • Optional ReadonlyreadLoadedData?: { maxReadLines?: ...; readExternalFiles?: ... }

                  Configuration options for reading data frame shapes from loaded external data files, such as CSV files

                  • Optional ReadonlymaxReadLines?: ...

                    The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

                  • Optional ReadonlyreadExternalFiles?: ...

                    Whether data frame shapes should be extracted from loaded external data files, such as CSV files

              • Optional ReadonlywideningThreshold?: number

                The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

            • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

              The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

            • Optional ReadonlydefaultPlugins?: (string | [string?, (...)[]?] | undefined)[]

              Plugins to load by default when creating a new FlowrAnalyzer

            • Optional Readonlyengines?: (
                  | {
                      lax?: boolean;
                      treeSitterWasmPath?: string;
                      type?: "tree-sitter";
                      wasmPath?: string;
                      [key: string]: unknown;
                  }
                  | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
                  | undefined
              )[]

              The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

            • Optional Readonlygas?: {
                  features?: { [key: string]: number | undefined };
                  heapProvider?: () => GasHeapStatistics | undefined;
                  thresholds?: {
                      memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                      [key: string]: unknown;
                  };
                  [key: string]: unknown;
              }

              Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

              • Optional Readonlyfeatures?: { [key: string]: number | undefined }

                Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

              • Optional ReadonlyheapProvider?: () => GasHeapStatistics | undefined

                Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

              • Optional Readonlythresholds?: {
                    memory?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    timeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... };
                    [key: string]: unknown;
                }

                Shared thresholds scaled by each feature factor before comparison.

                • Optional Readonlymemory?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Heap-usage fraction thresholds (0-1, before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

                • Optional ReadonlytimeMs?: { critical?: ...; problematic?: ...; [key: ...]: ... }

                  Elapsed analysis time thresholds in milliseconds (before factor scaling).

                  • Optional Readonlycritical?: ...

                    Returns GasLevel.Critical when reached (after factor scaling).

                  • Optional Readonlyproblematic?: ...

                    Returns GasLevel.Problematic when reached (after factor scaling).

            • Optional ReadonlyignoreLoadCalls?: boolean

              Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

            • Optional ReadonlyignoreSourceCalls?: boolean

              Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

            • Optional Readonlyinherit?: ProjectKind
            • Optional Readonlylinter?: { disabledRules?: (string | undefined)[] }

              Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

              • Optional ReadonlydisabledRules?: (string | undefined)[]

                Rule names excluded from the default rule set (a rule requested explicitly still runs).

            • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
            • Optional Readonlyproject?: {
                  basePackages?: (string | undefined)[];
                  implicitSources?: (string | undefined)[];
                  resolveUnknownPathsOnDisk?: boolean;
                  useProjectType?: ProjectKind;
              }
              • OptionalbasePackages?: (string | undefined)[]

                The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

              • OptionalimplicitSources?: (string | undefined)[]

                Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

              • OptionalresolveUnknownPathsOnDisk?: boolean

                Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

              • OptionaluseProjectType?: ProjectKind

                Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

            • Optional Readonlyrepl?: {
                  autoUseFileProtocol?: boolean;
                  dfProcessorHeat?: boolean;
                  hints?: boolean;
                  plugins?: (string | [(...)?, (...)?] | undefined)[];
                  queryStats?: boolean;
                  quickStats?: boolean;
                  showPlugins?: boolean;
              }

              Configuration options for the REPL

              • OptionalautoUseFileProtocol?: boolean

                Automatically use the file protocol for inputs that look like paths (default true)

              • OptionaldfProcessorHeat?: boolean

                This instruments the dataflow processors to count how often each processor is called

              • Optionalhints?: boolean

                Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

              • Optionalplugins?: (string | [(...)?, (...)?] | undefined)[]

                Plugins to load in REPL mode

              • OptionalqueryStats?: boolean

                Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

              • OptionalquickStats?: boolean

                Whether to show quick stats in the REPL after each evaluation

              • OptionalshowPlugins?: boolean

                Whether :version grays out the plugins that did not activate during the last analysis (default false)

            • Optional Readonlysemantics?: {
                  environment?: {
                      overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... };
                  };
              }

              Configure language semantics and how flowR handles them

              • Optional Readonlyenvironment?: { overwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... } }

                Semantics regarding the handling of the environment

                • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ...; loadDefaults?: ... }

                  Do you want to overwrite (parts) of the builtin definition?

                  • Optional Readonlydefinitions?: ...

                    The definitions to load

                  • Optional ReadonlyloadDefaults?: ...

                    Should the default configuration still be loaded?

            • Optional Readonlysolver?: {
                  evalStrings?: boolean;
                  instrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... };
                  resolveSource?: {
                      applyReplacements?: (...)[];
                      assumeFilesExist?: boolean;
                      dropPaths?: DropPathsOption;
                      ignoreCapitalization?: boolean;
                      inferWorkingDirectory?: InferWorkingDirectory;
                      repeatedSourceLimit?: number;
                      searchPath?: (...)[];
                      [key: string]: unknown;
                  };
                  sigdb?: {
                      additionalPaths?: (...)[];
                      assumedRVersion?: string;
                      autoSync?: boolean;
                      downloadRepo?: string;
                      eagerlyLoad?: boolean;
                      eagerlyLoadExports?: boolean;
                      enabled?: boolean;
                      linkBaseR?: boolean;
                      linkBaseRCalls?: boolean;
                      linkDescriptionDependencies?: boolean;
                      linkPackageCalls?: boolean;
                      loadProjectDependencies?: boolean;
                      versionOverrides?: { [key: ...]: ... };
                      versionSelection?: VersionSelection;
                      warmInBackground?: boolean;
                  };
                  slicer?: { autoExtend?: boolean; threshold?: number };
                  trackEnvironments?: boolean;
                  variables?: VariableResolve;
                  versionManagement?: { linkedVersionGroups?: (...)[] };
              }

              How to resolve constants, constraints, cells, …

              • Optional ReadonlyevalStrings?: boolean

                Should we include eval(parse(text="...")) calls in the dataflow graph?

              • Optional Readonlyinstrument?: { dataflowExtractors?: (extractor: ..., ctx: ...) => ... }

                These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                • OptionaldataflowExtractors?: (extractor: ..., ctx: ...) => ...

                  Modify the dataflow processors used during dataflow analysis. Make sure that all processors required for correct analysis are still present! This may have arbitrary consequences on the analysis precision and performance, consider focusing on decorating existing processors instead of replacing them.

              • Optional ReadonlyresolveSource?: {
                    applyReplacements?: (...)[];
                    assumeFilesExist?: boolean;
                    dropPaths?: DropPathsOption;
                    ignoreCapitalization?: boolean;
                    inferWorkingDirectory?: InferWorkingDirectory;
                    repeatedSourceLimit?: number;
                    searchPath?: (...)[];
                    [key: string]: unknown;
                }

                If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                • Optional ReadonlyapplyReplacements?: (...)[]

                  sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

                  [
                  { }, // no replacement -> still try the original name/path
                  { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
                  { '\s' : '_' }, // replace all spaces with underscores
                  { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
                  ]

                  Given a source("foo bar.R") this configuration will search for (in this order):

                  • foo bar.R (original name)
                  • main.R (replaced with main.R)
                  • foo_bar.R (replaced spaces)
                  • faa-bar.R (replaced spaces and oo)
                • Optional ReadonlyassumeFilesExist?: boolean

                  Assume a sourced file is always there, making what it defines certain instead of conditional on the source call.

                • Optional ReadonlydropPaths?: DropPathsOption

                  Allow to drop the first or all parts of the sourced path, if it is relative.

                • Optional ReadonlyignoreCapitalization?: boolean

                  search for filenames matching in the lowercase

                • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

                  try to infer the working directory from the main or any script to analyze.

                • Optional ReadonlyrepeatedSourceLimit?: number

                  How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

                • Optional ReadonlysearchPath?: (...)[]

                  Additionally search in these paths

              • Optional Readonlysigdb?: {
                    additionalPaths?: (...)[];
                    assumedRVersion?: string;
                    autoSync?: boolean;
                    downloadRepo?: string;
                    eagerlyLoad?: boolean;
                    eagerlyLoadExports?: boolean;
                    enabled?: boolean;
                    linkBaseR?: boolean;
                    linkBaseRCalls?: boolean;
                    linkDescriptionDependencies?: boolean;
                    linkPackageCalls?: boolean;
                    loadProjectDependencies?: boolean;
                    versionOverrides?: { [key: ...]: ... };
                    versionSelection?: VersionSelection;
                    warmInBackground?: boolean;
                }

                Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                • Optional ReadonlyadditionalPaths?: (...)[]

                  Extra directories (or bundle/manifest files) searched for signature databases, alongside the shipped default and $FLOWR_SIGDB_DIR. A downloaded full-history bundle placed here is mounted automatically.

                • Optional ReadonlyassumedRVersion?: string

                  The R version analysis assumes when resolving versioned (base-R) package exports: a pin like "4.5", or "auto" to detect the locally installed R (falling back to DefaultAssumedRVersion when the engine reports none, e.g. the tree-sitter engine). Resolve it with resolveAssumedRVersion.

                • Optional ReadonlyautoSync?: boolean

                  On startup, compare the cache against the committed sigdb.remote.json link file and re-download changed shards in the background (default false; needs network, so opt-in — a git pull that updates the pointer then re-syncs automatically).

                • Optional ReadonlydownloadRepo?: string

                  GitHub owner/repo the full-history bundle is downloaded from (:signature download); default flowr-analysis/flowr, release tag sigdb-v<flowR-version>.

                • Optional ReadonlyeagerlyLoad?: boolean

                  Parse the database up front rather than on the first package load (default false, ignored if disabled).

                • Optional ReadonlyeagerlyLoadExports?: boolean

                  Add a vertex for every export on load rather than on demand (default false); keeps the graph small.

                • Optional Readonlyenabled?: boolean

                  Resolve library exports from a signature database (default true); when false no database is consulted.

                • Optional ReadonlylinkBaseR?: boolean

                  Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

                • Optional ReadonlylinkBaseRCalls?: boolean

                  Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

                • Optional ReadonlylinkDescriptionDependencies?: boolean

                  Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

                • Optional ReadonlylinkPackageCalls?: boolean

                  Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

                • Optional ReadonlyloadProjectDependencies?: boolean

                  Load the project's declared dependencies from its metadata files (DESCRIPTION Imports/Depends, rproject.toml, renv.lock, rv.lock) into the dependency context (default true); when false these files are not read, so neither the undefined-symbol linter nor linkDescriptionDependencies sees any project-declared dependency.

                • Optional ReadonlyversionOverrides?: { [key: ...]: ... }

                  Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

                • Optional ReadonlyversionSelection?: VersionSelection

                  When a project constrains a dependency, resolve to the newest (default) or oldest version satisfying the constraint, or the system-installed version (needs R; falls back to newest when unavailable). Base-R packages always resolve against the assumed R version.

                • Optional ReadonlywarmInBackground?: boolean

                  Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

              • Optionalslicer?: { autoExtend?: boolean; threshold?: number }

                The configuration for flowR's slicer

                • Optional ReadonlyautoExtend?: boolean

                  If set, the slicer will gain an additional post-pass

                • Optional Readonlythreshold?: number

                  The maximum number of iterations to perform on a single function call during slicing

              • Optional ReadonlytrackEnvironments?: boolean

                Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

              • Optional Readonlyvariables?: VariableResolve

                How to resolve variables and their values

              • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }

                Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlylinkedVersionGroups?: (...)[]

                  Groups of packages that must resolve to the same version (like the base packages, which share the R version); version guessing intersects each group so its members stay mutually compatible (default []).

            • Optional ReadonlyspecializeConfig?: {
                  notebook?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  package?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  project?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  script?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  "shiny-app"?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
                  unknown?: {
                      abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                      defaultEngine?: "tree-sitter" | "r-shell";
                      defaultPlugins?: (...)[];
                      engines?: (...)[];
                      gas?: {
                          features?: ...;
                          heapProvider?: ...;
                          thresholds?: ...;
                          [key: ...]: ...;
                      };
                      ignoreLoadCalls?: boolean;
                      ignoreSourceCalls?: boolean;
                      inherit?: ProjectKind;
                      linter?: { disabledRules?: ... };
                      logLevel?:
                          | "error"
                          | "info"
                          | "debug"
                          | "trace"
                          | "silly"
                          | "warn"
                          | "fatal";
                      project?: {
                          basePackages?: ...;
                          implicitSources?: ...;
                          resolveUnknownPathsOnDisk?: ...;
                          useProjectType?: ...;
                      };
                      repl?: {
                          autoUseFileProtocol?: ...;
                          dfProcessorHeat?: ...;
                          hints?: ...;
                          plugins?: ...;
                          queryStats?: ...;
                          quickStats?: ...;
                          showPlugins?: ...;
                      };
                      semantics?: { environment?: ... };
                      solver?: {
                          evalStrings?: ...;
                          instrument?: ...;
                          resolveSource?: ...;
                          sigdb?: ...;
                          slicer?: ...;
                          trackEnvironments?: ...;
                          variables?: ...;
                          versionManagement?: ...;
                      };
                      specializeConfig?: {
                          notebook?: ...;
                          package?: ...;
                          project?: ...;
                          script?: ...;
                          "shiny-app"?: ...;
                          unknown?: ...;
                      };
                      [key: string]: unknown;
                  };
              }

              Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalnotebook?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalpackage?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalproject?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalscript?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalshiny-app?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

              • Optionalunknown?: {
                    abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
                    defaultEngine?: "tree-sitter" | "r-shell";
                    defaultPlugins?: (...)[];
                    engines?: (...)[];
                    gas?: {
                        features?: ...;
                        heapProvider?: ...;
                        thresholds?: ...;
                        [key: ...]: ...;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ... };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ...;
                        implicitSources?: ...;
                        resolveUnknownPathsOnDisk?: ...;
                        useProjectType?: ...;
                    };
                    repl?: {
                        autoUseFileProtocol?: ...;
                        dfProcessorHeat?: ...;
                        hints?: ...;
                        plugins?: ...;
                        queryStats?: ...;
                        quickStats?: ...;
                        showPlugins?: ...;
                    };
                    semantics?: { environment?: ... };
                    solver?: {
                        evalStrings?: ...;
                        instrument?: ...;
                        resolveSource?: ...;
                        sigdb?: ...;
                        slicer?: ...;
                        trackEnvironments?: ...;
                        variables?: ...;
                        versionManagement?: ...;
                    };
                    specializeConfig?: {
                        notebook?: ...;
                        package?: ...;
                        project?: ...;
                        script?: ...;
                        "shiny-app"?: ...;
                        unknown?: ...;
                    };
                    [key: string]: unknown;
                }
                • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

                  Configuration options for abstract interpretation

                  • Optional ReadonlydataFrame?: ...

                    The configuration of the shape inference for data frames

                  • Optional ReadonlywideningThreshold?: ...

                    The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

                • Optional ReadonlydefaultEngine?: "tree-sitter" | "r-shell"

                  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

                • Optional ReadonlydefaultPlugins?: (...)[]

                  Plugins to load by default when creating a new FlowrAnalyzer

                • Optional Readonlyengines?: (...)[]

                  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

                • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

                  Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

                  • Optional Readonlyfeatures?: ...

                    Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

                  • Optional ReadonlyheapProvider?: ...

                    Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

                  • Optional Readonlythresholds?: ...

                    Shared thresholds scaled by each feature factor before comparison.

                • Optional ReadonlyignoreLoadCalls?: boolean

                  Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

                • Optional ReadonlyignoreSourceCalls?: boolean

                  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

                • Optional Readonlyinherit?: ProjectKind
                • Optional Readonlylinter?: { disabledRules?: ... }

                  Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

                  • Optional ReadonlydisabledRules?: ...

                    Rule names excluded from the default rule set (a rule requested explicitly still runs).

                • Optional ReadonlylogLevel?: "error" | "info" | "debug" | "trace" | "silly" | "warn" | "fatal"
                • Optional Readonlyproject?: {
                      basePackages?: ...;
                      implicitSources?: ...;
                      resolveUnknownPathsOnDisk?: ...;
                      useProjectType?: ...;
                  }
                  • OptionalbasePackages?: ...

                    The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

                  • OptionalimplicitSources?: ...

                    Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

                  • OptionalresolveUnknownPathsOnDisk?: ...

                    Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

                  • OptionaluseProjectType?: ...

                    Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

                • Optional Readonlyrepl?: {
                      autoUseFileProtocol?: ...;
                      dfProcessorHeat?: ...;
                      hints?: ...;
                      plugins?: ...;
                      queryStats?: ...;
                      quickStats?: ...;
                      showPlugins?: ...;
                  }

                  Configuration options for the REPL

                  • OptionalautoUseFileProtocol?: ...

                    Automatically use the file protocol for inputs that look like paths (default true)

                  • OptionaldfProcessorHeat?: ...

                    This instruments the dataflow processors to count how often each processor is called

                  • Optionalhints?: ...

                    Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

                  • Optionalplugins?: ...

                    Plugins to load in REPL mode

                  • OptionalqueryStats?: ...

                    Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

                  • OptionalquickStats?: ...

                    Whether to show quick stats in the REPL after each evaluation

                  • OptionalshowPlugins?: ...

                    Whether :version grays out the plugins that did not activate during the last analysis (default false)

                • Optional Readonlysemantics?: { environment?: ... }

                  Configure language semantics and how flowR handles them

                  • Optional Readonlyenvironment?: ...

                    Semantics regarding the handling of the environment

                • Optional Readonlysolver?: {
                      evalStrings?: ...;
                      instrument?: ...;
                      resolveSource?: ...;
                      sigdb?: ...;
                      slicer?: ...;
                      trackEnvironments?: ...;
                      variables?: ...;
                      versionManagement?: ...;
                  }

                  How to resolve constants, constraints, cells, …

                  • Optional ReadonlyevalStrings?: ...

                    Should we include eval(parse(text="...")) calls in the dataflow graph?

                  • Optional Readonlyinstrument?: ...

                    These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

                  • Optional ReadonlyresolveSource?: ...

                    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

                  • Optional Readonlysigdb?: ...

                    Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

                  • Optionalslicer?: ...

                    The configuration for flowR's slicer

                  • Optional ReadonlytrackEnvironments?: ...

                    Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

                  • Optional Readonlyvariables?: ...

                    How to resolve variables and their values

                  • Optional ReadonlyversionManagement?: ...

                    Policies for reasoning about dependency versions (independent of how the signature database is loaded).

                • Optional ReadonlyspecializeConfig?: {
                      notebook?: ...;
                      package?: ...;
                      project?: ...;
                      script?: ...;
                      "shiny-app"?: ...;
                      unknown?: ...;
                  }

                  Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

      • formatter: OutputFormatter = voidFormatter

      Returns string | undefined