Type Alias EditorAnalysisResults 

pub type EditorAnalysisResults = AnalysisResults;

Aliased Type

pub struct EditorAnalysisResults {

    pub unused_files: Vec<UnusedFileFinding>,
    pub unused_exports: Vec<UnusedExportFinding>,
    pub unused_types: Vec<UnusedTypeFinding>,
    pub private_type_leaks: Vec<PrivateTypeLeakFinding>,
    pub unused_dependencies: Vec<UnusedDependencyFinding>,
    pub unused_dev_dependencies: Vec<UnusedDevDependencyFinding>,
    pub unused_optional_dependencies: Vec<UnusedOptionalDependencyFinding>,
    pub unused_enum_members: Vec<UnusedEnumMemberFinding>,
    pub unused_class_members: Vec<UnusedClassMemberFinding>,
    pub unused_store_members: Vec<UnusedStoreMemberFinding>,
    pub unresolved_imports: Vec<UnresolvedImportFinding>,
    pub unlisted_dependencies: Vec<UnlistedDependencyFinding>,
    pub duplicate_exports: Vec<DuplicateExportFinding>,
    pub type_only_dependencies: Vec<TypeOnlyDependencyFinding>,
    pub test_only_dependencies: Vec<TestOnlyDependencyFinding>,
    pub circular_dependencies: Vec<CircularDependencyFinding>,
    pub re_export_cycles: Vec<ReExportCycleFinding>,
    pub boundary_violations: Vec<BoundaryViolationFinding>,
    pub boundary_coverage_violations: Vec<BoundaryCoverageViolationFinding>,
    pub boundary_call_violations: Vec<BoundaryCallViolationFinding>,
    pub policy_violations: Vec<PolicyViolationFinding>,
    pub stale_suppressions: Vec<StaleSuppression>,
    pub unused_catalog_entries: Vec<UnusedCatalogEntryFinding>,
    pub empty_catalog_groups: Vec<EmptyCatalogGroupFinding>,
    pub unresolved_catalog_references: Vec<UnresolvedCatalogReferenceFinding>,
    pub unused_dependency_overrides: Vec<UnusedDependencyOverrideFinding>,
    pub misconfigured_dependency_overrides: Vec<MisconfiguredDependencyOverrideFinding>,
    pub invalid_client_exports: Vec<InvalidClientExportFinding>,
    pub mixed_client_server_barrels: Vec<MixedClientServerBarrelFinding>,
    pub misplaced_directives: Vec<MisplacedDirectiveFinding>,
    pub unprovided_injects: Vec<UnprovidedInjectFinding>,
    pub unrendered_components: Vec<UnrenderedComponentFinding>,
    pub route_collisions: Vec<RouteCollisionFinding>,
    pub dynamic_segment_name_conflicts: Vec<DynamicSegmentNameConflictFinding>,
    pub unused_component_props: Vec<UnusedComponentPropFinding>,
    pub unused_component_emits: Vec<UnusedComponentEmitFinding>,
    pub unused_component_inputs: Vec<UnusedComponentInputFinding>,
    pub unused_component_outputs: Vec<UnusedComponentOutputFinding>,
    pub unused_svelte_events: Vec<UnusedSvelteEventFinding>,
    pub unused_server_actions: Vec<UnusedServerActionFinding>,
    pub unused_load_data_keys: Vec<UnusedLoadDataKeyFinding>,
    pub unused_load_data_keys_global_abstain: bool,
    pub prop_drilling_chains: Vec<PropDrillingChainFinding>,
    pub thin_wrappers: Vec<ThinWrapperFinding>,
    pub duplicate_prop_shapes: Vec<DuplicatePropShapeFinding>,
    pub suppression_count: usize,
    pub unused_component_props_exempted: usize,
    pub active_suppressions: Vec<ActiveSuppression>,
    pub feature_flags: Vec<FeatureFlag>,
    pub security_findings: Vec<SecurityFinding>,
    pub security_unresolved_edge_files: usize,
    pub security_unresolved_callee_sites: usize,
    pub security_unresolved_callee_diagnostics: Vec<SecurityUnresolvedCalleeDiagnostic>,
    pub export_usages: Vec<ExportUsage>,
    pub entry_point_summary: Option<EntryPointSummary>,
    pub render_fan_in: Option<RenderFanInMetric>,
    pub react_component_intel: Vec<ReactComponentIntel>,
}

Fields

unused_files: Vec<UnusedFileFinding>

Files not reachable from any entry point. Wrapped in UnusedFileFinding so each entry carries a typed actions array natively, replacing the pre-2.76 post-pass injection.

unused_exports: Vec<UnusedExportFinding>

Exports never imported by other modules. Wrapped in UnusedExportFinding so each entry carries a typed actions array natively.

unused_types: Vec<UnusedTypeFinding>

Type exports never imported by other modules. Wrapped in UnusedTypeFinding: the inner UnusedExport struct is shared with unused_exports but the wrapper emits a type-targeted fix description.

private_type_leaks: Vec<PrivateTypeLeakFinding>

Exported symbols whose public signature references same-file private types. Wrapped in PrivateTypeLeakFinding so each entry carries a typed actions array natively.

unused_dependencies: Vec<UnusedDependencyFinding>

Dependencies listed in package.json but never imported. Wrapped in UnusedDependencyFinding so each entry carries a typed actions array natively. The fix action swaps from remove-dependency to move-dependency when used_in_workspaces is non-empty.

unused_dev_dependencies: Vec<UnusedDevDependencyFinding>

Dev dependencies listed in package.json but never imported. Wrapped in UnusedDevDependencyFinding: same bare struct as unused_dependencies with a devDependencies-targeted fix description.

unused_optional_dependencies: Vec<UnusedOptionalDependencyFinding>

Optional dependencies listed in package.json but never imported. Wrapped in UnusedOptionalDependencyFinding with an optionalDependencies-targeted fix description.

unused_enum_members: Vec<UnusedEnumMemberFinding>

Enum members never accessed. Wrapped in UnusedEnumMemberFinding so each entry carries a typed actions array natively.

unused_class_members: Vec<UnusedClassMemberFinding>

Class members never accessed. Wrapped in UnusedClassMemberFinding: same inner UnusedMember struct as unused_enum_members, with a class-targeted fix description and the auto_fixable: false default to reflect dependency-injection patterns.

unused_store_members: Vec<UnusedStoreMemberFinding>

Store members (Pinia state / getters / actions key, or a setup-store returned key) declared but never accessed by any consumer project-wide. Wrapped in UnusedStoreMemberFinding: same inner UnusedMember struct as unused_class_members, with a store-targeted fix description. Cross-graph: the store binding is imported (the module is reachable) yet a specific member is dead.

unresolved_imports: Vec<UnresolvedImportFinding>

Import specifiers that could not be resolved. Wrapped in UnresolvedImportFinding so each entry carries a typed actions array natively.

unlisted_dependencies: Vec<UnlistedDependencyFinding>

Dependencies used in code but not listed in package.json. Wrapped in UnlistedDependencyFinding.

duplicate_exports: Vec<DuplicateExportFinding>

Exports with the same name across multiple modules. Wrapped in DuplicateExportFinding so each entry carries a typed actions array natively, with the position-0 add-to-config ignoreExports snippet wired in at wrapper construction.

type_only_dependencies: Vec<TypeOnlyDependencyFinding>

Production dependencies only used via type-only imports (could be devDependencies). Only populated in production mode. Wrapped in TypeOnlyDependencyFinding.

test_only_dependencies: Vec<TestOnlyDependencyFinding>

Production dependencies only imported by test files (could be devDependencies). Wrapped in TestOnlyDependencyFinding.

circular_dependencies: Vec<CircularDependencyFinding>

Circular dependency chains detected in the module graph. Wrapped in CircularDependencyFinding so each entry carries a typed actions array natively.

re_export_cycles: Vec<ReExportCycleFinding>

Cycles or self-loops in the re-export edge subgraph (barrel files re-exporting from each other in a loop). Wrapped in ReExportCycleFinding so each entry carries a typed actions array natively (a refactor-re-export-cycle informational primary plus a suppress-file secondary; cycles are file-scoped so a single suppression breaks the cycle).

boundary_violations: Vec<BoundaryViolationFinding>

Imports that cross architecture boundary rules. Wrapped in BoundaryViolationFinding so each entry carries a typed actions array natively.

boundary_coverage_violations: Vec<BoundaryCoverageViolationFinding>

Files that matched no architecture boundary zone while boundaries.coverage.requireAllFiles was enabled.

boundary_call_violations: Vec<BoundaryCallViolationFinding>

Calls from zoned files to callees forbidden for that zone via boundaries.calls.forbidden. Wrapped in BoundaryCallViolationFinding so each entry carries a typed actions array natively.

policy_violations: Vec<PolicyViolationFinding>

Banned calls, imports, and catalogue-derived effects matched by declarative rule packs (rulePacks config). Wrapped in PolicyViolationFinding so each entry carries a typed actions array natively. Each finding carries its effective per-rule severity.

stale_suppressions: Vec<StaleSuppression>

Suppression comments or JSDoc tags that no longer match any issue.

unused_catalog_entries: Vec<UnusedCatalogEntryFinding>

Entries in package manager catalog sections not referenced by any workspace package via the catalog: protocol. Supports pnpm-workspace.yaml catalogs and Bun root package.json catalogs. Wrapped in UnusedCatalogEntryFinding so each entry carries a typed actions array natively, with per-instance auto_fixable derived from hardcoded_consumers and the catalog source file.

empty_catalog_groups: Vec<EmptyCatalogGroupFinding>

Named groups under package manager catalogs sections that declare no package entries. The top-level catalog: map is not reported. Wrapped in EmptyCatalogGroupFinding.

unresolved_catalog_references: Vec<UnresolvedCatalogReferenceFinding>

Workspace package.json references to catalogs (catalog: or catalog:<name>) that do not declare the consumed package. The package manager install will error until the named catalog grows to include the package or the reference is switched / removed. Wrapped in UnresolvedCatalogReferenceFinding with the discriminated add-catalog-entry / update-catalog-reference primary at position 0.

unused_dependency_overrides: Vec<UnusedDependencyOverrideFinding>

Entries in pnpm-workspace.yaml’s overrides: section, or package.json’s pnpm.overrides block, whose target package is not declared by any workspace package and is not present in pnpm-lock.yaml. Default severity is warn because projects without a readable lockfile fall back to manifest-only checks; the hint field flags those conservative cases. Wrapped in UnusedDependencyOverrideFinding.

misconfigured_dependency_overrides: Vec<MisconfiguredDependencyOverrideFinding>

pnpm.overrides entries whose key or value does not parse as a valid override spec (empty key, empty value, malformed selector, unbalanced parent matcher). pnpm install will reject these. Default severity is error. Wrapped in MisconfiguredDependencyOverrideFinding.

invalid_client_exports: Vec<InvalidClientExportFinding>

"use client" files that export a Next.js server-only / route-segment config name (e.g. metadata, revalidate, GET). Next.js rejects this at build time. Wrapped in InvalidClientExportFinding so each entry carries a typed actions array natively. Default severity is warn.

mixed_client_server_barrels: Vec<MixedClientServerBarrelFinding>

Barrel files that re-export BOTH a "use client" origin module AND a server-only origin module (the Next.js App Router footgun). Wrapped in MixedClientServerBarrelFinding so each entry carries a typed actions array natively. Default severity is warn.

misplaced_directives: Vec<MisplacedDirectiveFinding>

"use client" / "use server" directives written as expression statements after a non-directive statement, so the RSC bundler parses them as ordinary strings and silently ignores them. Wrapped in MisplacedDirectiveFinding so each entry carries a typed actions array natively. Default severity is warn.

unprovided_injects: Vec<UnprovidedInjectFinding>

Vue inject(KEY) / Svelte getContext(KEY) calls whose symbol KEY is provided nowhere in the project (the injected-never-provided dead-half). Wrapped in UnprovidedInjectFinding so each entry carries a typed actions array natively. Default severity is warn.

unrendered_components: Vec<UnrenderedComponentFinding>

Vue/Svelte single-file components that are reachable but rendered nowhere (the imported-but-never-rendered dead-half). Wrapped in UnrenderedComponentFinding so each entry carries a typed actions array natively. Default severity is warn.

route_collisions: Vec<RouteCollisionFinding>

Next.js App Router route files that resolve to the same URL within one app-root (a guaranteed next build failure). Wrapped in RouteCollisionFinding so each entry carries a typed actions array natively. One finding per colliding file. Default severity is warn.

dynamic_segment_name_conflicts: Vec<DynamicSegmentNameConflictFinding>

Sibling Next.js dynamic route segments at one tree position using different param spellings (a dev / runtime error; next build does NOT catch it). Wrapped in DynamicSegmentNameConflictFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_props: Vec<UnusedComponentPropFinding>

Vue <script setup> defineProps, Svelte 5 $props(), and React props referenced nowhere in their own component. Wrapped in UnusedComponentPropFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_emits: Vec<UnusedComponentEmitFinding>

Vue <script setup> defineEmits events emitted nowhere in their own SFC (no emit('<name>') call). Wrapped in UnusedComponentEmitFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_inputs: Vec<UnusedComponentInputFinding>

Angular @Input() / signal input() / model() inputs read nowhere in their own component (neither the template nor the class body). Wrapped in UnusedComponentInputFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_component_outputs: Vec<UnusedComponentOutputFinding>

Angular @Output() / signal output() outputs emitted nowhere in their own component (no this.<output>.emit(...)). Wrapped in UnusedComponentOutputFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_svelte_events: Vec<UnusedSvelteEventFinding>

Svelte components dispatching a custom event via createEventDispatcher() whose event name is listened to nowhere project-wide (cross-file dead-output direction). Wrapped in UnusedSvelteEventFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_server_actions: Vec<UnusedServerActionFinding>

Next.js Server Actions (exports of "use server" files) that no code in the project references. Reclassified out of unused_exports for "use server" files. Wrapped in UnusedServerActionFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_load_data_keys: Vec<UnusedLoadDataKeyFinding>

SvelteKit +page.{ts,server.ts,js,server.js} load() return-object keys read by no consumer. Wrapped in UnusedLoadDataKeyFinding so each entry carries a typed actions array natively. Default severity is warn.

unused_load_data_keys_global_abstain: bool

true when the unused-load-data-key detector abstained project-wide because a whole-object use of page.data / $page.data was seen somewhere (S1 observability: an empty unused_load_data_keys with this flag set is NOT a clean bill, it means the rule could not run safely). Serialized only when true so the default JSON contract is unchanged.

prop_drilling_chains: Vec<PropDrillingChainFinding>

React/Preact props forwarded unchanged through >= N intermediate pass-through components until a consumer (located per-chain records). Wrapped in PropDrillingChainFinding so each entry carries a typed actions array natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

thin_wrappers: Vec<ThinWrapperFinding>

React/Preact components whose entire body is a single spread-forwarded child render (return <Child {...props}/>): pure structural indirection, a candidate for inlining at call sites. Wrapped in ThinWrapperFinding so each entry carries a typed actions array natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

duplicate_prop_shapes: Vec<DuplicatePropShapeFinding>

React/Preact components that participate in a duplicate-prop-shape group: three or more components across two or more files whose statically-known prop NAME set is identical after stripping ubiquitous DOM / passthrough names (a missing shared Props type / base component). Wrapped in DuplicatePropShapeFinding so each entry carries a typed actions array and its sibling roster natively. Health signal: the rule defaults to off (opt-in), so this is dormant and populated ONLY when the user enables it.

suppression_count: usize

Number of suppression entries that matched an issue during analysis. Human output uses this for the suppression footer; it is skipped in machine output to avoid changing the public JSON issue contract.

unused_component_props_exempted: usize

Number of component props exempted from unused-component-props this run because their local destructure binding name matched unusedComponentProps.ignorePattern. Drives a human-output note so a typo’d pattern (matching nothing) is not a silent no-op; skipped in machine output, like Self::suppression_count.

active_suppressions: Vec<ActiveSuppression>

Suppression comments present in analyzed files this run (every present marker, all kinds, not only consumed ones). Internal: read in-process by fallow impact to distinguish a genuinely resolved finding from one silenced by a fallow-ignore. Skipped during serialization, like Self::suppression_count, so the public JSON output contract is unchanged.

feature_flags: Vec<FeatureFlag>

Detected feature flag patterns. Advisory output, not included in issue counts. Skipped during default serialization: injected separately in JSON output when enabled.

security_findings: Vec<SecurityFinding>

Local security candidates (e.g. client-server-leak). CANDIDATES for downstream agent verification, NOT verified vulnerabilities. Off by default; populated only when the corresponding security_* rule is enabled (forced on by fallow security). Excluded from total_issues and skipped during serialization so they never surface under bare fallow or the audit gate; the fallow security command reads this field and emits its own envelope. Mirrors Self::feature_flags.

security_unresolved_edge_files: usize

In-band blind-spot count: number of "use client" files whose transitive import cone contains a dynamic import() the reachability BFS cannot follow. Surfaced by fallow security so a leak hidden behind an unresolved edge is never silently reported as “clean”. Skipped during serialization like Self::security_findings.

security_unresolved_callee_sites: usize

In-band blind-spot count: number of sink-shaped nodes the catalogue detector could not flatten to a static callee path (dynamic dispatch, computed members, aliased bindings). Surfaced by fallow security so an empty catalogue result with a non-zero count is not reported as “clean”. Skipped during serialization like Self::security_findings.

security_unresolved_callee_diagnostics: Vec<SecurityUnresolvedCalleeDiagnostic>

Location samples for sink-shaped nodes the catalogue detector could not flatten to a static callee path. Skipped during default serialization; fallow security summarizes this metadata in its own envelope.

export_usages: Vec<ExportUsage>

Usage counts for all exports across the project. Used by the LSP for Code Lens. Not included in issue counts – this is metadata, not an issue type. Skipped during serialization: this is internal LSP data, not part of the JSON output schema.

entry_point_summary: Option<EntryPointSummary>

Summary of detected entry points, grouped by discovery source. Not included in issue counts – this is informational metadata. Skipped during serialization: rendered separately in JSON output.

render_fan_in: Option<RenderFanInMetric>

Per-component render fan-in (JSX render SITES + distinct parents) plus the precomputed concentration aggregates. DESCRIPTIVE blast-radius signal, not an issue type: the component-graph analogue of module fan-in. None on non-React projects (the dep gate fails and render_edges is empty). Skipped during serialization (internal carrier, like Self::export_usages); the public surface is the VitalSigns aggregate, so bare fallow / audit never serialize it. See RenderFanInMetric.

react_component_intel: Vec<ReactComponentIntel>

Per-component React render/prop/hook intelligence. DESCRIPTIVE ambient editor context (LSP code lens + per-prop hover), NOT an issue type: it is never in total_issues. Empty on non-React projects (the dep gate fails and component_functions is empty). Skipped during serialization (in-process LSP carrier, like Self::render_fan_in); bare fallow / audit never serialize it and the JSON / schema surface is unchanged. See ReactComponentIntel.