@eagleoutice/flowr - v2.13.2
    Preparing search index...
    interface ConfigQuery {
        inspect?: readonly string[];
        reset?: boolean;
        type: "config";
        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)[];
                classification?: {
                    notebookExtensions?: (string | undefined)[];
                    shinyDescriptionTypes?: (string | undefined)[];
                    shinyEntryFiles?: (string | undefined)[];
                    shinyUsagePattern?: string;
                };
                discovery?: {
                    full?: boolean;
                    ignore?: (string | undefined)[];
                    perKind?: {
                        notebook?: { exclude?: (...) | (...); include?: (...) | (...) };
                        package?: { exclude?: (...) | (...); include?: (...) | (...) };
                        project?: { exclude?: (...) | (...); include?: (...) | (...) };
                        script?: { exclude?: (...) | (...); include?: (...) | (...) };
                        "shiny-app"?: { exclude?: (...) | (...); include?: (...) | (...) };
                        unknown?: { exclude?: (...) | (...); include?: (...) | (...) };
                    };
                };
                failOnInaccessiblePath?: boolean;
                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?: ((...) | (...) | (...) | (...))[];
                        loadDefaults?: boolean;
                    };
                };
            };
            solver?: {
                evalStrings?: boolean;
                instrument?: {
                    dataflowExtractors?: (
                        extractor: DataflowProcessors<ParentInformation>,
                        ctx: FlowrAnalyzerContext,
                    ) => DataflowProcessors<ParentInformation>;
                };
                resolveSource?: {
                    applyReplacements?: ({ [key: string]: (...) | (...) } | 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?: (((...) | (...))[] | undefined)[];
                };
            };
            specializeConfig?: {
                notebook?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                package?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                project?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                script?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                "shiny-app"?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
                unknown?: {
                    abstractInterpretation?: {
                        dataFrame?: {
                            maxColNames?: (...)
                            | (...);
                            readLoadedData?: (...) | (...);
                        };
                        wideningThreshold?: number;
                    };
                    defaultEngine?: "tree-sitter"
                    | "r-shell";
                    defaultPlugins?: (
                        string
                        | [((...) | (...))?, ((...) | (...))?]
                        | undefined
                    )[];
                    engines?: (
                        | {
                            lax?: (...)
                            | (...)
                            | (...);
                            treeSitterWasmPath?: (...) | (...);
                            type?: (...) | (...);
                            wasmPath?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | {
                            rPath?: (...)
                            | (...);
                            type?: (...) | (...);
                            [key: string]: unknown;
                        }
                        | undefined
                    )[];
                    gas?: {
                        features?: { [key: string]: (...)
                        | (...) };
                        heapProvider?: () => (...) | (...);
                        thresholds?: {
                            memory?: (...) | (...);
                            timeMs?: (...) | (...);
                            [key: string]: unknown;
                        };
                        [key: string]: unknown;
                    };
                    ignoreLoadCalls?: boolean;
                    ignoreSourceCalls?: boolean;
                    inherit?: ProjectKind;
                    linter?: { disabledRules?: ((...) | (...))[] };
                    logLevel?:
                        | "error"
                        | "info"
                        | "debug"
                        | "trace"
                        | "silly"
                        | "warn"
                        | "fatal";
                    project?: {
                        basePackages?: ((...) | (...))[];
                        classification?: {
                            notebookExtensions?: (...) | (...);
                            shinyDescriptionTypes?: (...) | (...);
                            shinyEntryFiles?: (...) | (...);
                            shinyUsagePattern?: (...) | (...);
                        };
                        discovery?: {
                            full?: (...)
                            | (...)
                            | (...);
                            ignore?: (...) | (...);
                            perKind?: (...) | (...);
                        };
                        failOnInaccessiblePath?: boolean;
                        implicitSources?: ((...) | (...))[];
                        resolveUnknownPathsOnDisk?: boolean;
                        useProjectType?: ProjectKind;
                    };
                    repl?: {
                        autoUseFileProtocol?: boolean;
                        dfProcessorHeat?: boolean;
                        hints?: boolean;
                        plugins?: ((...) | (...) | (...))[];
                        queryStats?: boolean;
                        quickStats?: boolean;
                        showPlugins?: boolean;
                    };
                    semantics?: { environment?: { overwriteBuiltIns?: (...)
                    | (...) } };
                    solver?: {
                        evalStrings?: boolean;
                        instrument?: { dataflowExtractors?: (...) | (...) };
                        resolveSource?: {
                            applyReplacements?: (...) | (...);
                            assumeFilesExist?: (...) | (...) | (...);
                            dropPaths?: (...) | (...);
                            ignoreCapitalization?: (...) | (...) | (...);
                            inferWorkingDirectory?: (...) | (...);
                            repeatedSourceLimit?: (...) | (...);
                            searchPath?: (...) | (...);
                            [key: string]: unknown;
                        };
                        sigdb?: {
                            additionalPaths?: (...)
                            | (...);
                            assumedRVersion?: (...) | (...);
                            autoSync?: (...) | (...) | (...);
                            downloadRepo?: (...) | (...);
                            eagerlyLoad?: (...) | (...) | (...);
                            eagerlyLoadExports?: (...) | (...) | (...);
                            enabled?: (...) | (...) | (...);
                            linkBaseR?: (...) | (...) | (...);
                            linkBaseRCalls?: (...) | (...) | (...);
                            linkDescriptionDependencies?: (...) | (...) | (...);
                            linkPackageCalls?: (...) | (...) | (...);
                            loadProjectDependencies?: (...) | (...) | (...);
                            versionOverrides?: (...) | (...);
                            versionSelection?: (...) | (...);
                            warmInBackground?: (...) | (...) | (...);
                        };
                        slicer?: {
                            autoExtend?: (...)
                            | (...)
                            | (...);
                            threshold?: (...) | (...);
                        };
                        trackEnvironments?: boolean;
                        variables?: VariableResolve;
                        versionManagement?: { linkedVersionGroups?: (...)
                        | (...) };
                    };
                    specializeConfig?: {
                        notebook?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        package?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        project?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        script?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        "shiny-app"?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                        unknown?: {
                            abstractInterpretation?: (...)
                            | (...);
                            defaultEngine?: (...) | (...) | (...);
                            defaultPlugins?: (...) | (...);
                            engines?: (...) | (...);
                            gas?: (...) | (...);
                            ignoreLoadCalls?: (...) | (...) | (...);
                            ignoreSourceCalls?: (...) | (...) | (...);
                            inherit?: (...) | (...);
                            linter?: (...) | (...);
                            logLevel?:
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...)
                                | (...);
                            project?: (...) | (...);
                            repl?: (...) | (...);
                            semantics?: (...) | (...);
                            solver?: (...) | (...);
                            specializeConfig?: (...) | (...);
                            [key: string]: unknown;
                        };
                    };
                    [key: string]: unknown;
                };
            };
            [key: string]: unknown;
        };
    }

    Hierarchy (View Summary)

    Hierarchy-Diagram

    UML class diagram of ConfigQuery
    Index

    Properties

    inspect?: readonly string[]

    a .-separated path to inspect (read) a single config value instead of dumping the whole config (repl: path, which also accepts a */** glob)

    reset?: boolean

    discard every runtime update made so far, reverting to the config the analyzer was created with (repl: +reset)

    type: "config"

    used to select the query type :)

    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)[];
            classification?: {
                notebookExtensions?: (string | undefined)[];
                shinyDescriptionTypes?: (string | undefined)[];
                shinyEntryFiles?: (string | undefined)[];
                shinyUsagePattern?: string;
            };
            discovery?: {
                full?: boolean;
                ignore?: (string | undefined)[];
                perKind?: {
                    notebook?: { exclude?: (...) | (...); include?: (...) | (...) };
                    package?: { exclude?: (...) | (...); include?: (...) | (...) };
                    project?: { exclude?: (...) | (...); include?: (...) | (...) };
                    script?: { exclude?: (...) | (...); include?: (...) | (...) };
                    "shiny-app"?: { exclude?: (...) | (...); include?: (...) | (...) };
                    unknown?: { exclude?: (...) | (...); include?: (...) | (...) };
                };
            };
            failOnInaccessiblePath?: boolean;
            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?: ((...) | (...) | (...) | (...))[];
                    loadDefaults?: boolean;
                };
            };
        };
        solver?: {
            evalStrings?: boolean;
            instrument?: {
                dataflowExtractors?: (
                    extractor: DataflowProcessors<ParentInformation>,
                    ctx: FlowrAnalyzerContext,
                ) => DataflowProcessors<ParentInformation>;
            };
            resolveSource?: {
                applyReplacements?: ({ [key: string]: (...) | (...) } | 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?: (((...) | (...))[] | undefined)[];
            };
        };
        specializeConfig?: {
            notebook?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
            package?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
            project?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
            script?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
            "shiny-app"?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
            unknown?: {
                abstractInterpretation?: {
                    dataFrame?: {
                        maxColNames?: (...)
                        | (...);
                        readLoadedData?: (...) | (...);
                    };
                    wideningThreshold?: number;
                };
                defaultEngine?: "tree-sitter"
                | "r-shell";
                defaultPlugins?: (
                    string
                    | [((...) | (...))?, ((...) | (...))?]
                    | undefined
                )[];
                engines?: (
                    | {
                        lax?: (...)
                        | (...)
                        | (...);
                        treeSitterWasmPath?: (...) | (...);
                        type?: (...) | (...);
                        wasmPath?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | {
                        rPath?: (...)
                        | (...);
                        type?: (...) | (...);
                        [key: string]: unknown;
                    }
                    | undefined
                )[];
                gas?: {
                    features?: { [key: string]: (...)
                    | (...) };
                    heapProvider?: () => (...) | (...);
                    thresholds?: {
                        memory?: (...) | (...);
                        timeMs?: (...) | (...);
                        [key: string]: unknown;
                    };
                    [key: string]: unknown;
                };
                ignoreLoadCalls?: boolean;
                ignoreSourceCalls?: boolean;
                inherit?: ProjectKind;
                linter?: { disabledRules?: ((...) | (...))[] };
                logLevel?:
                    | "error"
                    | "info"
                    | "debug"
                    | "trace"
                    | "silly"
                    | "warn"
                    | "fatal";
                project?: {
                    basePackages?: ((...) | (...))[];
                    classification?: {
                        notebookExtensions?: (...) | (...);
                        shinyDescriptionTypes?: (...) | (...);
                        shinyEntryFiles?: (...) | (...);
                        shinyUsagePattern?: (...) | (...);
                    };
                    discovery?: {
                        full?: (...)
                        | (...)
                        | (...);
                        ignore?: (...) | (...);
                        perKind?: (...) | (...);
                    };
                    failOnInaccessiblePath?: boolean;
                    implicitSources?: ((...) | (...))[];
                    resolveUnknownPathsOnDisk?: boolean;
                    useProjectType?: ProjectKind;
                };
                repl?: {
                    autoUseFileProtocol?: boolean;
                    dfProcessorHeat?: boolean;
                    hints?: boolean;
                    plugins?: ((...) | (...) | (...))[];
                    queryStats?: boolean;
                    quickStats?: boolean;
                    showPlugins?: boolean;
                };
                semantics?: { environment?: { overwriteBuiltIns?: (...)
                | (...) } };
                solver?: {
                    evalStrings?: boolean;
                    instrument?: { dataflowExtractors?: (...) | (...) };
                    resolveSource?: {
                        applyReplacements?: (...) | (...);
                        assumeFilesExist?: (...) | (...) | (...);
                        dropPaths?: (...) | (...);
                        ignoreCapitalization?: (...) | (...) | (...);
                        inferWorkingDirectory?: (...) | (...);
                        repeatedSourceLimit?: (...) | (...);
                        searchPath?: (...) | (...);
                        [key: string]: unknown;
                    };
                    sigdb?: {
                        additionalPaths?: (...)
                        | (...);
                        assumedRVersion?: (...) | (...);
                        autoSync?: (...) | (...) | (...);
                        downloadRepo?: (...) | (...);
                        eagerlyLoad?: (...) | (...) | (...);
                        eagerlyLoadExports?: (...) | (...) | (...);
                        enabled?: (...) | (...) | (...);
                        linkBaseR?: (...) | (...) | (...);
                        linkBaseRCalls?: (...) | (...) | (...);
                        linkDescriptionDependencies?: (...) | (...) | (...);
                        linkPackageCalls?: (...) | (...) | (...);
                        loadProjectDependencies?: (...) | (...) | (...);
                        versionOverrides?: (...) | (...);
                        versionSelection?: (...) | (...);
                        warmInBackground?: (...) | (...) | (...);
                    };
                    slicer?: {
                        autoExtend?: (...)
                        | (...)
                        | (...);
                        threshold?: (...) | (...);
                    };
                    trackEnvironments?: boolean;
                    variables?: VariableResolve;
                    versionManagement?: { linkedVersionGroups?: (...)
                    | (...) };
                };
                specializeConfig?: {
                    notebook?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    package?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    project?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    script?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    "shiny-app"?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                    unknown?: {
                        abstractInterpretation?: (...)
                        | (...);
                        defaultEngine?: (...) | (...) | (...);
                        defaultPlugins?: (...) | (...);
                        engines?: (...) | (...);
                        gas?: (...) | (...);
                        ignoreLoadCalls?: (...) | (...) | (...);
                        ignoreSourceCalls?: (...) | (...) | (...);
                        inherit?: (...) | (...);
                        linter?: (...) | (...);
                        logLevel?:
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...)
                            | (...);
                        project?: (...) | (...);
                        repl?: (...) | (...);
                        semantics?: (...) | (...);
                        solver?: (...) | (...);
                        specializeConfig?: (...) | (...);
                        [key: string]: unknown;
                    };
                };
                [key: string]: unknown;
            };
        };
        [key: string]: unknown;
    }

    Type Declaration

    • [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)[];
          classification?: {
              notebookExtensions?: (string | undefined)[];
              shinyDescriptionTypes?: (string | undefined)[];
              shinyEntryFiles?: (string | undefined)[];
              shinyUsagePattern?: string;
          };
          discovery?: {
              full?: boolean;
              ignore?: (string | undefined)[];
              perKind?: {
                  notebook?: { exclude?: (...) | (...); include?: (...) | (...) };
                  package?: { exclude?: (...) | (...); include?: (...) | (...) };
                  project?: { exclude?: (...) | (...); include?: (...) | (...) };
                  script?: { exclude?: (...) | (...); include?: (...) | (...) };
                  "shiny-app"?: { exclude?: (...) | (...); include?: (...) | (...) };
                  unknown?: { exclude?: (...) | (...); include?: (...) | (...) };
              };
          };
          failOnInaccessiblePath?: boolean;
          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.

      • Optionalclassification?: {
            notebookExtensions?: (string | undefined)[];
            shinyDescriptionTypes?: (string | undefined)[];
            shinyEntryFiles?: (string | undefined)[];
            shinyUsagePattern?: string;
        }

        Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

        • OptionalnotebookExtensions?: (string | undefined)[]

          File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

        • OptionalshinyDescriptionTypes?: (string | undefined)[]

          DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

        • OptionalshinyEntryFiles?: (string | undefined)[]

          File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

        • OptionalshinyUsagePattern?: string

          Regex source evidencing shiny usage in an entry file.

      • Optionaldiscovery?: {
            full?: boolean;
            ignore?: (string | undefined)[];
            perKind?: {
                notebook?: { exclude?: (...) | (...); include?: (...) | (...) };
                package?: { exclude?: (...) | (...); include?: (...) | (...) };
                project?: { exclude?: (...) | (...); include?: (...) | (...) };
                script?: { exclude?: (...) | (...); include?: (...) | (...) };
                "shiny-app"?: { exclude?: (...) | (...); include?: (...) | (...) };
                unknown?: { exclude?: (...) | (...); include?: (...) | (...) };
            };
        }

        Scoping options for the default project discovery.

        • Optionalfull?: boolean

          Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

        • Optionalignore?: (string | undefined)[]

          Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

        • OptionalperKind?: {
              notebook?: { exclude?: (...) | (...); include?: (...) | (...) };
              package?: { exclude?: (...) | (...); include?: (...) | (...) };
              project?: { exclude?: (...) | (...); include?: (...) | (...) };
              script?: { exclude?: (...) | (...); include?: (...) | (...) };
              "shiny-app"?: { exclude?: (...) | (...); include?: (...) | (...) };
              unknown?: { exclude?: (...) | (...); include?: (...) | (...) };
          }

          Per-ProjectKind include/exclude glob overrides layered on the default scoping.

      • OptionalfailOnInaccessiblePath?: boolean

        Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

      • 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?: ((...) | (...) | (...) | (...))[];
                  loadDefaults?: boolean;
              };
          };
      }

      Configure language semantics and how flowR handles them

      • Optional Readonlyenvironment?: {
            overwriteBuiltIns?: {
                definitions?: ((...) | (...) | (...) | (...))[];
                loadDefaults?: boolean;
            };
        }

        Semantics regarding the handling of the environment

        • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ((...) | (...) | (...) | (...))[]; loadDefaults?: boolean }

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

          • Optional Readonlydefinitions?: ((...) | (...) | (...) | (...))[]

            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]: (...) | (...) } | 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?: (((...) | (...))[] | 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]: (...) | (...) } | 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]: (...) | (...) } | 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?: (((...) | (...))[] | undefined)[] }

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

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

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

          Configuration options for abstract interpretation

          • Optional ReadonlydataFrame?: { maxColNames?: (...) | (...); readLoadedData?: (...) | (...) }

            The configuration of the shape inference for data frames

            • Optional ReadonlymaxColNames?: (...) | (...)

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

            • Optional ReadonlyreadLoadedData?: (...) | (...)

              Configuration options for reading data frame shapes 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 | [((...) | (...))?, ((...) | (...))?] | undefined)[]

          Plugins to load by default when creating a new FlowrAnalyzer

        • Optional Readonlyengines?: (
              | {
                  lax?: (...)
                  | (...)
                  | (...);
                  treeSitterWasmPath?: (...) | (...);
                  type?: (...) | (...);
                  wasmPath?: (...) | (...);
                  [key: string]: unknown;
              }
              | { rPath?: (...)
              | (...); type?: (...) | (...); [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]: (...) | (...) };
              heapProvider?: () => (...) | (...);
              thresholds?: {
                  memory?: (...) | (...);
                  timeMs?: (...) | (...);
                  [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]: (...) | (...) }

            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?: { memory?: (...) | (...); timeMs?: (...) | (...); [key: string]: unknown }

            Shared thresholds scaled by each feature factor before comparison.

            • Optional Readonlymemory?: (...) | (...)

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

            • Optional ReadonlytimeMs?: (...) | (...)

              Elapsed analysis time thresholds in milliseconds (before 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?: ((...) | (...))[] }

          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?: ((...) | (...))[];
              classification?: {
                  notebookExtensions?: (...) | (...);
                  shinyDescriptionTypes?: (...) | (...);
                  shinyEntryFiles?: (...) | (...);
                  shinyUsagePattern?: (...) | (...);
              };
              discovery?: {
                  full?: (...)
                  | (...)
                  | (...);
                  ignore?: (...) | (...);
                  perKind?: (...) | (...);
              };
              failOnInaccessiblePath?: boolean;
              implicitSources?: ((...) | (...))[];
              resolveUnknownPathsOnDisk?: boolean;
              useProjectType?: ProjectKind;
          }
          • 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.

          • Optionalclassification?: {
                notebookExtensions?: (...) | (...);
                shinyDescriptionTypes?: (...) | (...);
                shinyEntryFiles?: (...) | (...);
                shinyUsagePattern?: (...) | (...);
            }

            Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

            • OptionalnotebookExtensions?: (...) | (...)

              File extensions marking a notebook (default ipynb, rmd, qmd, rnw).

            • OptionalshinyDescriptionTypes?: (...) | (...)

              DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

            • OptionalshinyEntryFiles?: (...) | (...)

              File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

            • OptionalshinyUsagePattern?: (...) | (...)

              Regex source evidencing shiny usage in an entry file.

          • Optionaldiscovery?: {
                full?: (...) | (...) | (...);
                ignore?: (...) | (...);
                perKind?: (...) | (...);
            }

            Scoping options for the default project discovery.

            • Optionalfull?: (...) | (...) | (...)

              Collect every file below the project root (greedy) instead of only the files the detected ProjectKind needs (default false).

            • Optionalignore?: (...) | (...)

              Case-insensitive globs that drop matching files from the intelligent discovery, regardless of kind (e.g. .Renviron to ignore environment files).

            • OptionalperKind?: (...) | (...)

              Per-ProjectKind include/exclude glob overrides layered on the default scoping.

          • OptionalfailOnInaccessiblePath?: boolean

            Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

          • 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?: 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?: ((...) | (...) | (...))[];
              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?: ((...) | (...) | (...))[]

            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?: (...) | (...) } }

          Configure language semantics and how flowR handles them

          • Optional Readonlyenvironment?: { overwriteBuiltIns?: (...) | (...) }

            Semantics regarding the handling of the environment

            • Optional ReadonlyoverwriteBuiltIns?: (...) | (...)

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

        • Optional Readonlysolver?: {
              evalStrings?: boolean;
              instrument?: { dataflowExtractors?: (...) | (...) };
              resolveSource?: {
                  applyReplacements?: (...) | (...);
                  assumeFilesExist?: (...) | (...) | (...);
                  dropPaths?: (...) | (...);
                  ignoreCapitalization?: (...) | (...) | (...);
                  inferWorkingDirectory?: (...) | (...);
                  repeatedSourceLimit?: (...) | (...);
                  searchPath?: (...) | (...);
                  [key: string]: unknown;
              };
              sigdb?: {
                  additionalPaths?: (...)
                  | (...);
                  assumedRVersion?: (...) | (...);
                  autoSync?: (...) | (...) | (...);
                  downloadRepo?: (...) | (...);
                  eagerlyLoad?: (...) | (...) | (...);
                  eagerlyLoadExports?: (...) | (...) | (...);
                  enabled?: (...) | (...) | (...);
                  linkBaseR?: (...) | (...) | (...);
                  linkBaseRCalls?: (...) | (...) | (...);
                  linkDescriptionDependencies?: (...) | (...) | (...);
                  linkPackageCalls?: (...) | (...) | (...);
                  loadProjectDependencies?: (...) | (...) | (...);
                  versionOverrides?: (...) | (...);
                  versionSelection?: (...) | (...);
                  warmInBackground?: (...) | (...) | (...);
              };
              slicer?: { autoExtend?: (...)
              | (...)
              | (...); threshold?: (...) | (...) };
              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?: (...) | (...) }

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

            • OptionaldataflowExtractors?: (...) | (...)

              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?: (...) | (...) | (...);
                dropPaths?: (...) | (...);
                ignoreCapitalization?: (...) | (...) | (...);
                inferWorkingDirectory?: (...) | (...);
                repeatedSourceLimit?: (...) | (...);
                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?: (...) | (...) | (...)

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

            • Optional ReadonlydropPaths?: (...) | (...)

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

            • Optional ReadonlyignoreCapitalization?: (...) | (...) | (...)

              search for filenames matching in the lowercase

            • Optional ReadonlyinferWorkingDirectory?: (...) | (...)

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

            • Optional ReadonlyrepeatedSourceLimit?: (...) | (...)

              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?: (...) | (...);
                autoSync?: (...) | (...) | (...);
                downloadRepo?: (...) | (...);
                eagerlyLoad?: (...) | (...) | (...);
                eagerlyLoadExports?: (...) | (...) | (...);
                enabled?: (...) | (...) | (...);
                linkBaseR?: (...) | (...) | (...);
                linkBaseRCalls?: (...) | (...) | (...);
                linkDescriptionDependencies?: (...) | (...) | (...);
                linkPackageCalls?: (...) | (...) | (...);
                loadProjectDependencies?: (...) | (...) | (...);
                versionOverrides?: (...) | (...);
                versionSelection?: (...) | (...);
                warmInBackground?: (...) | (...) | (...);
            }

            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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...)

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

            • Optional ReadonlyeagerlyLoad?: (...) | (...) | (...)

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

            • Optional ReadonlyeagerlyLoadExports?: (...) | (...) | (...)

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

            • Optional Readonlyenabled?: (...) | (...) | (...)

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

            • Optional ReadonlylinkBaseR?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...)

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

            • Optional ReadonlyloadProjectDependencies?: (...) | (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...)

              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?: (...) | (...) | (...)

              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?: (...) | (...) | (...); threshold?: (...) | (...) }

            The configuration for flowR's slicer

            • Optional ReadonlyautoExtend?: (...) | (...) | (...)

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

            • Optional Readonlythreshold?: (...) | (...)

              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?: (...) | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              package?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              project?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              script?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              "shiny-app"?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [key: string]: unknown;
              };
              unknown?: {
                  abstractInterpretation?: (...)
                  | (...);
                  defaultEngine?: (...) | (...) | (...);
                  defaultPlugins?: (...) | (...);
                  engines?: (...) | (...);
                  gas?: (...) | (...);
                  ignoreLoadCalls?: (...) | (...) | (...);
                  ignoreSourceCalls?: (...) | (...) | (...);
                  inherit?: (...) | (...);
                  linter?: (...) | (...);
                  logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                  project?: (...) | (...);
                  repl?: (...) | (...);
                  semantics?: (...) | (...);
                  solver?: (...) | (...);
                  specializeConfig?: (...) | (...);
                  [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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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?: (...) | (...);
                defaultEngine?: (...) | (...) | (...);
                defaultPlugins?: (...) | (...);
                engines?: (...) | (...);
                gas?: (...) | (...);
                ignoreLoadCalls?: (...) | (...) | (...);
                ignoreSourceCalls?: (...) | (...) | (...);
                inherit?: (...) | (...);
                linter?: (...) | (...);
                logLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...);
                project?: (...) | (...);
                repl?: (...) | (...);
                semantics?: (...) | (...);
                solver?: (...) | (...);
                specializeConfig?: (...) | (...);
                [key: string]: unknown;
            }
            • Optional ReadonlyabstractInterpretation?: (...) | (...)

              Configuration options for abstract interpretation

            • Optional ReadonlydefaultEngine?: (...) | (...) | (...)

              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?: (...) | (...)

              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 ReadonlyignoreLoadCalls?: (...) | (...) | (...)

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

            • Optional ReadonlyignoreSourceCalls?: (...) | (...) | (...)

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

            • Optional Readonlyinherit?: (...) | (...)
            • Optional Readonlylinter?: (...) | (...)

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

            • Optional ReadonlylogLevel?: (...) | (...) | (...) | (...) | (...) | (...) | (...) | (...)
            • Optional Readonlyproject?: (...) | (...)
            • Optional Readonlyrepl?: (...) | (...)

              Configuration options for the REPL

            • Optional Readonlysemantics?: (...) | (...)

              Configure language semantics and how flowR handles them

            • Optional Readonlysolver?: (...) | (...)

              How to resolve constants, constraints, cells, …

            • Optional ReadonlyspecializeConfig?: (...) | (...)

              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.