engine

type Result struct {
	// FilesChecked is the number of files processed (after ignore filtering).
	FilesChecked int
	Diagnostics  []lint.Diagnostic
	Errors       []error
}

type Runner struct {
	Config           *config.Config
	Rules            []rule.Rule
	StripFrontMatter bool
	Logger           *vlog.Logger
	// RootDir is the project root directory (parent of .mdsmith.yml).
	// Used by rules that need to read files relative to the project root.
	RootDir string
	// MaxInputBytes is the maximum file size in bytes before a file is
	// skipped with an error. Zero or negative means unlimited.
	MaxInputBytes int64
	// Explain, when true, attaches per-leaf rule provenance to each
	// diagnostic so output formatters can render an explanation trailer.
	Explain bool
	// SkipSourceContext, when true, suppresses per-diagnostic
	// SourceLines population. Set it for callers that never render the
	// source window (the check benchmark/gate, machine output that
	// omits it) to avoid its large per-diagnostic allocation. Default
	// false preserves the CLI text formatter's context display.
	SkipSourceContext bool
	// ConfigPath is the path to the loaded .mdsmith.yml. When set,
	// config-target rules (rule.ConfigTarget) are run once against a
	// synthetic lint.File for this path before per-file processing.
	ConfigPath string
	// SourceFS, when non-nil, is set as lint.File.FS for RunSource so
	// in-memory linting (e.g. an LSP buffer) sees the same filesystem
	// view processFile constructs for on-disk runs. Rules like
	// include/catalog short-circuit on a nil FS; without this hook
	// LSP diagnostics drift from the CLI's. Run() (path-based)
	// ignores this field and continues to derive FS from filepath.Dir
	// per file.
	SourceFS fs.FS
	// Concurrency controls how many files Run lints in parallel.
	// Zero or negative means "use runtime.GOMAXPROCS"; 1 forces the
	// sequential path; n>1 uses n workers. The worker count is
	// clamped to the file count. Output is merged in input order and
	// then sorted, so the value never changes observable results —
	// it only trades CPU for wall time. RunSource (single in-memory
	// file) ignores this field.
	Concurrency int
	// IntraFileConcurrency caps how many non-NodeChecker rules run
	// concurrently inside one file's checkRules call. The default
	// (0 = auto) computes `max(1, GOMAXPROCS / fileWorkers)` so the
	// inner pool fills whichever cores the outer file-level pool
	// leaves idle: 1 when the file pool saturates cores (mdsmith
	// check on many files), N when the file pool is small (a 5-file
	// PR check on a 16-core host, mdsmith lsp single-file). A
	// caller-set 1 forces serial dispatch; n>1 is taken as the
	// explicit cap. RunSource uses GOMAXPROCS directly because the
	// file-level pool does not run for single-file in-memory paths.
	IntraFileConcurrency int

	// RunCache is the engine-owned read cache shared by every File
	// processed in one Run / RunSource pass. The catalog rule reads
	// through it so a target globbed by N host catalogs is read once
	// per run instead of N times. nil means "create a fresh cache
	// for the next Run" (the CLI case where the corpus is immutable
	// for one process). Callers with a long-lived process — the LSP
	// — install a shared instance so it survives across runLint
	// calls and call its Invalidate seam on document edits.
	RunCache *lint.RunCache
	// contains filtered or unexported fields
}