Struct FallowConfig 

pub struct FallowConfig {

    pub schema: Option<String>,
    pub extends: Vec<String>,
    pub entry: Vec<String>,
    pub ignore_patterns: Vec<String>,
    pub framework: Vec<ExternalPluginDef>,
    pub workspaces: Option<WorkspaceConfig>,
    pub ignore_dependencies: Vec<String>,
    pub ignore_exports: Vec<IgnoreExportRule>,
    pub ignore_catalog_references: Vec<IgnoreCatalogReferenceRule>,
    pub ignore_dependency_overrides: Vec<IgnoreDependencyOverrideRule>,
    pub ignore_exports_used_in_file: IgnoreExportsUsedInFileConfig,
    pub ignore_decorators: Vec<String>,
    pub used_class_members: Vec<UsedClassMemberRule>,
    pub duplicates: DuplicatesConfig,
    pub health: HealthConfig,
    pub rules: RulesConfig,
    pub boundaries: BoundaryConfig,
    pub flags: FlagsConfig,
    pub fix: FixConfig,
    pub resolve: ResolveConfig,
    pub production: ProductionConfig,
    pub plugins: Vec<String>,
    pub dynamically_loaded: Vec<String>,
    pub overrides: Vec<ConfigOverride>,
    pub codeowners: Option<String>,
    pub public_packages: Vec<String>,
    pub regression: Option<RegressionConfig>,
    pub audit: AuditConfig,
    pub sealed: bool,
    pub include_entry_exports: bool,
    pub cache: CacheConfig,
}

User-facing configuration loaded from .fallowrc.json, .fallowrc.jsonc, fallow.toml, or .fallow.toml.

Examples

use fallow_config::FallowConfig;

// Default config has sensible defaults
let config = FallowConfig::default();
assert!(config.entry.is_empty());
assert!(!config.production);

// Deserialize from JSON
let config: FallowConfig = serde_json::from_str(r#"{
    "entry": ["src/main.ts"],
    "production": true
}"#).unwrap();
assert_eq!(config.entry, vec!["src/main.ts"]);
assert!(config.production);

Fields

schema: Option<String>

JSON Schema reference (ignored during deserialization).

extends: Vec<String>

Base config files to extend from.

Supports three resolution strategies:

• Relative paths: "./base.json" — resolved relative to the config file.
• npm packages: "npm:@co/config" — resolved by walking up node_modules/. Package resolution checks package.json exports/main first, then falls back to standard config file names. Subpaths are supported (e.g., npm:@co/config/strict.json).
• HTTPS URLs: "https://example.com/fallow-base.json" — fetched remotely. Only HTTPS is supported (no plain HTTP). URL-sourced configs may extend other URLs or npm: packages, but not relative paths. Only JSON/JSONC format is supported for remote configs. Timeout is configurable via FALLOW_EXTENDS_TIMEOUT_SECS (default: 5s).

Base configs are loaded first, then this config’s values override them. Later entries in the array override earlier ones.

Note: npm: resolution uses node_modules/ directory walk-up and is incompatible with Yarn Plug’n’Play (PnP), which has no node_modules/. URL extends fetch on every run (no caching). For reliable CI, prefer npm: for private or critical configs.

entry: Vec<String>

Additional entry point glob patterns.

ignore_patterns: Vec<String>

Glob patterns to ignore from analysis.

framework: Vec<ExternalPluginDef>

Custom framework definitions (inline plugin definitions).

workspaces: Option<WorkspaceConfig>

Workspace overrides.

ignore_dependencies: Vec<String>

Dependencies to ignore (always considered used and always considered available).

Listed dependencies are excluded from both unused dependency and unlisted dependency detection. Useful for runtime-provided packages like bun:sqlite or implicitly available dependencies.

ignore_exports: Vec<IgnoreExportRule>

Export ignore rules.

ignore_catalog_references: Vec<IgnoreCatalogReferenceRule>

Rules for suppressing unresolved-catalog-reference findings.

Each rule matches by package name, optionally scoped to a specific catalog and/or consumer package.json glob. Useful for staged catalog migrations where the catalog edit lands separately from the consumer edit, and for library-internal placeholder packages whose target catalog isn’t ready yet.

ignore_dependency_overrides: Vec<IgnoreDependencyOverrideRule>

Rules for suppressing unused-dependency-override and misconfigured-dependency-override findings.

Each rule matches by override target package, optionally scoped to the declaring source file (pnpm-workspace.yaml or package.json). Useful for overrides targeting purely-transitive packages (CVE-fix pattern) where the conservative static algorithm would otherwise cry wolf.

ignore_exports_used_in_file: IgnoreExportsUsedInFileConfig

Suppress unused-export findings when the exported symbol is referenced inside the file that declares it. This mirrors Knip’s ignoreExportsUsedInFile option while still reporting exports that have no references at all.

ignore_decorators: Vec<String>

Decorators that fallow should NOT treat as evidence of reflective use. Members carrying only these decorators are checked for usage as if they were undecorated. Members carrying any decorator NOT in this list stay skipped (frameworks like NestJS, Angular, TypeORM rely on reflection so the conservative default is to keep skipping).

Matching rule: entries containing . (e.g. "decorators.log") match the full dotted path of a decorator. Bare entries (e.g. "step" or "decorators") match the leftmost segment; a bare "decorators" entry thus collapses every @decorators.* decorator. Both "@step" and "step" round-trip equivalently (a leading @ is stripped before matching).

Entries that never match a decorator in the analyzed codebase produce a one-time warning at end of run, mirroring the existing usedClassMembers warn-on-unmatched-pattern behavior. See issue #471.

used_class_members: Vec<UsedClassMemberRule>

Class member method/property rules that should never be flagged as unused. Supports plain member names for global suppression and scoped objects with extends / implements constraints for framework-invoked methods that should only be suppressed on matching classes.

duplicates: DuplicatesConfig

Duplication detection settings.

health: HealthConfig

Complexity health metrics settings.

rules: RulesConfig

Per-issue-type severity rules.

boundaries: BoundaryConfig

Architecture boundary enforcement configuration.

flags: FlagsConfig

Feature flag detection configuration.

fix: FixConfig

Auto-fix behavior settings.

resolve: ResolveConfig

Module resolver configuration (custom conditions, etc.).

production: ProductionConfig

Production mode: exclude test/dev files, only start/build scripts.

Accepts the legacy boolean form (true applies to all analyses) or a per-analysis object ({ "deadCode": false, "health": true, "dupes": false }).

plugins: Vec<String>

Paths to external plugin files or directories containing plugin files.

Supports TOML, JSON, and JSONC formats.

In addition to these explicit paths, fallow automatically discovers:

• *.toml, *.json, *.jsonc files in .fallow/plugins/
• fallow-plugin-*.{toml,json,jsonc} files in the project root

dynamically_loaded: Vec<String>

Glob patterns for files that are dynamically loaded at runtime (plugin directories, locale files, etc.). These files are treated as always-used and will never be flagged as unused.

overrides: Vec<ConfigOverride>

Per-file rule overrides matching oxlint’s overrides pattern.

codeowners: Option<String>

Path to a CODEOWNERS file for --group-by owner.

When unset, fallow auto-probes CODEOWNERS, .github/CODEOWNERS, .gitlab/CODEOWNERS, and docs/CODEOWNERS. Set this to use a non-standard location.

public_packages: Vec<String>

Workspace package name patterns that are public libraries. Exported API surface from these packages is not flagged as unused.

regression: Option<RegressionConfig>

Regression detection baseline embedded in config. Stores issue counts from a known-good state for CI regression checks. Populated by --save-regression-baseline (no path), read by --fail-on-regression.

audit: AuditConfig

Audit command baseline paths (one per analysis: dead-code, health, dupes).

fallow audit runs three analyses and each has its own baseline format. Paths in this section are resolved relative to the project root. CLI flags (--dead-code-baseline, --health-baseline, --dupes-baseline) override these values when provided.

sealed: bool

Mark this config as sealed: extends paths must be file-relative and resolve within this config’s own directory. npm: and https: extends are rejected. Useful for library publishers and monorepo sub-packages that want to guarantee their config is self-contained and not subject to ancestor configs being injected via extends.

Discovery is unaffected (first-match-wins already stops the directory walk at the nearest config). This only constrains extends.

include_entry_exports: bool

Report unused exports in entry files instead of auto-marking them as used. Catches typos in framework exports (e.g. meatdata instead of metadata). The CLI flag --include-entry-exports (global) overrides this when set; otherwise the config value is used.

cache: CacheConfig

Incremental cache tuning. Today the only knob is maxSizeMb, which caps the on-disk cache and triggers LRU eviction during save. See CacheConfig.

Implementations

impl FallowConfig

pub fn load(path: &Path) -> Result<Self, Report>

Load config from a fallow config file (TOML or JSON/JSONC).

The format is detected from the file extension:

• .toml → TOML
• .json → JSON (with JSONC comment stripping)

Supports extends for config inheritance. Extended configs are loaded and deep-merged before this config’s values are applied.

User-supplied glob patterns (entry, ignorePatterns, dynamicallyLoaded, duplicates.ignore, health.ignore, boundaries.zones[].patterns, overrides[].files, ignoreExports[].file, ignoreCatalogReferences[].consumer) are validated against absolute paths, .. traversal segments, and invalid glob syntax. Loading fails loud on any rejection so silent no-match configs surface to the user. See issue #463.

Errors

Returns an error when the config file cannot be read, merged, or deserialized, or when any user-supplied glob pattern is rejected.

pub fn validate_user_globs(&self) -> Result<(), Vec<GlobValidationError>>

Validate all user-supplied glob patterns and directory paths in this config.

Accumulates errors from every glob- or path-bearing field so the user sees ALL offending values in one run rather than fixing them one at a time.

Covered glob fields: entry, ignorePatterns, dynamicallyLoaded, duplicates.ignore, health.ignore, overrides[].files, ignoreExports[].file, ignoreCatalogReferences[].consumer, boundaries.zones[].patterns, plus every glob-bearing field on inline framework[] plugin definitions (entry points, always-used, config patterns, used-exports patterns, and fileExists detection patterns; the last reaches glob::glob on disk so a .. segment there is a real path traversal).

Covered directory-path fields: boundaries.zones[].root and boundaries.zones[].autoDiscover. These are literal paths (not globs), so only the absolute-path + traversal checks apply.

Errors

Returns a non-empty Vec of glob_validation::GlobValidationError when any field contains a rejected value.

pub fn find_config_path(start: &Path) -> Option<PathBuf>

Find the config file path without loading it. Searches the same locations as find_and_load.

pub fn find_and_load(start: &Path) -> Result<Option<(Self, PathBuf)>, String>

Find and load config, searching from start up to the project root.

Errors

Returns an error if a config file is found but cannot be read or parsed.

pub fn json_schema() -> Value

Generate JSON Schema for the configuration format.

pub fn validate_resolved_boundaries( &self, root: &Path, ) -> Result<(), Vec<ZoneValidationError>>

Validate boundary zone references and zone-root-prefix conflicts AFTER preset and auto-discover expansion.

Runs the same expand sequence as FallowConfig::resolve (preset expansion gated on tsconfig rootDir, then expand_auto_discover) before invoking BoundaryConfig::validate_zone_references and BoundaryConfig::validate_root_prefixes, so Bulletproof-style presets whose authored rule references logical groups (features) still load cleanly.

Call sites (runtime_support::load_config_for_analysis in the CLI, core::lib::config_for_project for LSP and programmatic embedders) surface every collected error in a single rendered diagnostic, then exit with code 2. Previously these failures emitted tracing::error! and continued, producing a flood of false-positive boundary violations at analysis time (#468).

root is the project root used by expand_auto_discover to scan for child directories. Caller is responsible for passing the same root it later hands to resolve().

Errors

Returns a non-empty Vec<ZoneValidationError> aggregating every offending zone reference and redundant-root-prefix pattern; the empty case becomes Ok(()).

impl FallowConfig

pub fn resolve( self, root: PathBuf, output: OutputFormat, threads: usize, no_cache: bool, quiet: bool, cache_max_size_mb: Option<u32>, ) -> ResolvedConfig

Resolve into a fully resolved config with compiled globs.

cache_max_size_mb is the user’s override for the cache cap (env var or in-config cache.maxSizeMb). When None, the cap defaults to fallow_extract::cache::DEFAULT_CACHE_MAX_SIZE (256 MB). Env-var precedence is resolved at the CLI layer, so the resolver itself only sees the final value.

Trait Implementations

impl Debug for FallowConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FallowConfig

fn default() -> FallowConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FallowConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for FallowConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for FallowConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.