fix(graph): SCSS imports no longer resolve to sibling .tsx files

Closes #245.

When a `.scss` / `.sass` file does `@use 'Widget'` (extensionless) and
both `Widget.scss` and `Widget.tsx` exist as siblings, fallow now resolves
the import to `Widget.scss` per Sass's actual resolution algorithm. The
standard `oxc_resolver` extension list contains `.tsx` / `.ts` before
`.scss`, so without this guard a bare specifier from a stylesheet was
silently picking the JS/TS sibling, creating phantom circular
dependencies in standard CSS-modules / Angular `styleUrls` patterns:

  Helper.scss -> Widget.tsx -> Helper.tsx -> Helper.scss

(Helper.scss meant to share Sass variables with Widget.scss but
mis-resolved to Widget.tsx instead.)

Implementation: in `resolve_specifier`, after the standard resolver
returns a hit, reject any path whose extension is a JS/TS-family
extension (.tsx, .ts, .mts, .cts, .js, .jsx, .mjs, .cjs) when the
importer is `.scss` / `.sass`, and re-route through the SCSS-aware
fallback chain (CSS-extension probe, `_filename` partial convention,
framework include paths, `node_modules` walk-up). When those also fail,
the import is reported as unresolved instead of falling through to
JS/TS extensions. SFC `<style>` block imports (`from_style = true`)
keep their existing behaviour because their importer extension is
`.vue` / `.svelte` rather than `.scss`.

Tests: new fixture `scss-bare-import-tsx-collision` exactly mirrors the
issue's reproduction (Widget.tsx + Widget.scss siblings, Helper.scss
with `@use 'Widget'`, Helper.tsx imports `./Helper.scss`). Integration
test asserts zero circular dependencies, zero unresolved imports, and
that Widget.scss is reachable. The OLD binary built via `git stash` of
the diff produces the exact 3-file phantom cycle the issue documents;
the FIXED binary produces zero. The other 9 SCSS integration tests
(partial convention, include paths, node_modules resolution, external
package SCSS subpaths, SFC `<style>` blocks, Vite preprocessor
additionalData) continue to pass.

Author: BartWaardenburg

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **`includeEntryExports` config option, and `--include-entry-exports` is now a global CLI flag.** Set `"includeEntryExports": true` (JSON / JSONC) or `includeEntryExports = true` (TOML) in your fallow config to opt in to entry-file export validation persistently, without passing `--include-entry-exports` on every run. The flag is now accepted in combined mode (`fallow --include-entry-exports`) as well as on `fallow dead-code` and `fallow audit`; previously the bare combined invocation rejected the flag because it was only defined on the `dead-code` subcommand. Thanks [@filipw01](https://github.com/filipw01) for the report. (Closes [#249](https://github.com/fallow-rs/fallow/issues/249))
 
+### Fixed
+
+- **SCSS / Sass `@use 'X'` no longer resolves to a sibling `X.tsx`.** When both `Widget.scss` and `Widget.tsx` exist next to each other and a `.scss` importer does `@use 'Widget'`, fallow now resolves the import to `Widget.scss` per Sass's actual resolution algorithm. The standard module resolver's extension list contains `.tsx` / `.ts` before `.scss`, so without this guard a bare specifier from a stylesheet was silently picking the JS/TS sibling, creating phantom circular dependencies in CSS-modules / Angular `styleUrls` patterns where the `.tsx` component imports its own `.scss` and a sibling `.scss` shares variables/mixins. Stylesheet importers now reject any standard-resolver hit whose extension is a JS/TS-family extension (`.tsx`, `.ts`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`) and re-route through the SCSS-aware fallback chain (CSS-extension probe, `_filename` partial convention, framework include paths, `node_modules` walk-up); when those also fail, the import is reported as unresolved instead of falling through to JS/TS extensions. Thanks [@OmerGronich](https://github.com/OmerGronich) for the precise reproduction and the suggested fix. (Closes [#245](https://github.com/fallow-rs/fallow/issues/245))
+
 ## [2.59.0] - 2026-05-01
 
 ### Added

crates/core/tests/integration_test/scss_partials.rs

@@ -197,3 +197,51 @@ fn external_package_scss_subpaths_credit_nested_style_dependencies() {
         "real unused dependencies should still be reported: {unused_dep_names:?}"
     );
 }
+
+#[test]
+fn scss_bare_import_does_not_collide_with_sibling_tsx() {
+    // Issue #245: `@use 'Widget'` from a `.scss` file MUST resolve only to
+    // `Widget.scss` / `_Widget.scss` etc. Sass never sees JS/TS files; a
+    // sibling `Widget.tsx` is invisible to the Sass resolver. The bug
+    // manifested as a phantom 3-file circular dependency chain when both a
+    // `.tsx` component file and its `.scss` style sheet existed alongside.
+    let root = fixture_path("scss-bare-import-tsx-collision");
+    let config = create_config(root);
+    let results = fallow_core::analyze(&config).expect("analysis should succeed");
+
+    assert!(
+        results.circular_dependencies.is_empty(),
+        "expected no circular dependencies, got: {:?}",
+        results
+            .circular_dependencies
+            .iter()
+            .map(|c| c
+                .files
+                .iter()
+                .map(|p| p.display().to_string())
+                .collect::<Vec<_>>())
+            .collect::<Vec<_>>()
+    );
+
+    let unresolved_specs: Vec<&str> = results
+        .unresolved_imports
+        .iter()
+        .map(|u| u.specifier.as_str())
+        .collect();
+    assert!(
+        unresolved_specs.is_empty(),
+        "expected no unresolved imports, got: {unresolved_specs:?}"
+    );
+
+    let unused_files: Vec<String> = results
+        .unused_files
+        .iter()
+        .filter_map(|f| f.path.file_name())
+        .filter_map(|n| n.to_str())
+        .map(ToString::to_string)
+        .collect();
+    assert!(
+        !unused_files.contains(&"Widget.scss".to_string()),
+        "Widget.scss must be reachable via Helper.scss `@use 'Widget'`: {unused_files:?}"
+    );
+}

crates/graph/src/resolve/specifier.rs

@@ -243,6 +243,25 @@ fn is_style_file(path: &Path) -> bool {
         .is_some_and(|ext| matches!(ext, "css" | "scss" | "sass"))
 }
 
+/// Return `true` when the path's extension is a JS/TS-family runtime extension.
+///
+/// Used to reject standard-resolver hits when the importer is a stylesheet:
+/// Sass's resolution algorithm only ever considers `.css` / `.scss` / `.sass`
+/// files, so a sibling `.tsx` / `.ts` / `.js` cannot legally satisfy a Sass
+/// `@use` / `@import`. The resolver's extension list mixes JS/TS and CSS,
+/// so without this guard `@use 'Widget'` from a `.scss` importer would
+/// resolve to a sibling `Widget.tsx` whenever both files exist. See #245.
+fn is_js_ts_extension(path: &Path) -> bool {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .is_some_and(|ext| {
+            matches!(
+                ext,
+                "ts" | "tsx" | "mts" | "cts" | "js" | "jsx" | "mjs" | "cjs"
+            )
+        })
+}
+
 fn is_node_modules_path(path: &Path) -> bool {
     path.components().any(|component| match component {
         std::path::Component::Normal(segment) => segment == "node_modules",
@@ -388,6 +407,24 @@ pub(super) fn resolve_specifier(
     match resolve_file_with_tsconfig_fallback(ctx, from_file, specifier) {
         ResolveFileAttempt::Resolved(resolved) => {
             let resolved_path = resolved.path();
+            // Reject JS/TS hits for stylesheet importers. The standard resolver's
+            // extension list mixes JS/TS with CSS-family extensions and tries
+            // `.tsx` / `.ts` before `.scss` / `.sass` / `.css`, so a `@use 'Widget'`
+            // from a `.scss` file would otherwise resolve to a sibling
+            // `Widget.tsx` even when `Widget.scss` exists next to it. Sass's
+            // actual resolution algorithm only considers stylesheets; redirect
+            // to the SCSS-aware fallback chain (CSS-extension probe, partial
+            // convention, include paths, node_modules) and short-circuit with
+            // `Unresolvable` if those also fail. See issue #245.
+            let is_scss_importer = from_file
+                .extension()
+                .is_some_and(|e| e == "scss" || e == "sass");
+            if is_scss_importer && is_js_ts_extension(resolved_path) {
+                if let Some(result) = try_scss_fallbacks(ctx, from_file, specifier, from_style) {
+                    return result;
+                }
+                return ResolveResult::Unresolvable(specifier.to_string());
+            }
             // Try raw path lookup first (avoids canonicalize syscall in most cases)
             if let Some(&file_id) = ctx.raw_path_to_id.get(resolved_path) {
                 return ResolveResult::InternalModule(file_id);

tests/fixtures/scss-bare-import-tsx-collision/.fallowrc.json

@@ -0,0 +1,3 @@
+{
+  "entry": ["src/main.tsx"]
+}

tests/fixtures/scss-bare-import-tsx-collision/package.json

@@ -0,0 +1 @@
+{ "name": "scss-bare-import-tsx-collision", "private": true, "version": "0.0.1" }

tests/fixtures/scss-bare-import-tsx-collision/src/Helper.scss

@@ -0,0 +1,3 @@
+@use 'Widget';
+
+.helper { background: blue; }

tests/fixtures/scss-bare-import-tsx-collision/src/Helper.tsx

@@ -0,0 +1,5 @@
+import './Helper.scss';
+
+export function Helper() {
+  return 'helper';
+}

tests/fixtures/scss-bare-import-tsx-collision/src/Widget.scss

@@ -0,0 +1 @@
+.widget { color: red; }

tests/fixtures/scss-bare-import-tsx-collision/src/Widget.tsx

@@ -0,0 +1,6 @@
+import './Widget.scss';
+import { Helper } from './Helper';
+
+export function Widget() {
+  return Helper();
+}

tests/fixtures/scss-bare-import-tsx-collision/src/main.tsx

@@ -0,0 +1,2 @@
+import { Widget } from './Widget';
+console.log(Widget());