[nstepien]

Summary

Removes the last big TODO: interpolations resolve across modules through every ES module import and export form. Query variants and modules without a file get their own identity, and raw TypeScript is handled. The static resolution model this builds on (const-only, lazily resolved values, scoping) landed in main through #79, which started out as the first slice of this PR.

Supported import and export forms

• Default and namespace imports (import d from, import * as ns from), including ${ns.member} and nested ${ns.inner.member}
• Re-exports: export { x } from, export { default as x } from, export { x as default } from, export * from (except default), export * as ns from, and chains through barrel files. This includes the export of an imported binding, like import d from 'mod'; export { d };, which re-exports it, as in the spec
• export default of css templates and of static expressions (literals, signed numbers, and their parenthesized and type-asserted forms)
• Type-only imports and exports are ignored in all their forms
• Values imported with a query resolve from that variant module's own code: ?raw is the file's text, and ?url its URL

Resolution semantics

• An export resolves to the binding it comes from, like ECMAScript's ResolveExport, and that binding is evaluated like main's const bindings: on demand, cached for the transform
• Explicit exports take precedence over export *, even when their value is not static
• A name that several export * provide through different bindings is ambiguous and not resolved, and the ambiguity propagates through further hops. Two paths to the same binding are fine
• export * never provides default
• Each import is resolved and loaded once per transform, and external modules are skipped instead of loaded
• The stylesheet a value brings along is the one of the module that declares it, so probing export * sources that do not provide a name never imports theirs

Raw TypeScript (plain Rolldown): an enum binds its name, and ambient enums bind nothing. TypeScript namespaces are not supported, beyond the scope of their own that main gives them (#130).

Module identity: a module's identity is its id without Vite's marker queries (?v=, ?t=, …). Query variants (?raw, ?url, an HTML page's inline <script type="module"> served as index.html?html-proxy&index=N.js, framework sub-modules) keep their own parse, class names, class hashes, and stylesheet. On main, a ?raw request of a module replaces the module's parse. watchChange forgets the variants of an edited file too. Modules that no file holds, like virtual modules and query variants, are read from the module graph, or in Vite's dev server, which does not keep the code of the modules loaded through this.load(), through their load hooks.

Output: stylesheet imports are injected after a hashbang and the directive prologue ('use client'), instead of before them, which is a parse error on main.

Behavior changes vs main

• Namespace imports, export … from, export *, and export * as ns resolve, with ESM precedence and ambiguity
• Parentheses and TypeScript type assertions are ignored, like in 'blue' as const
• Type-only imports and exports bind and export nothing
• External modules are skipped, and modules that no file holds are read from the module graph
• An unresolved member expression, like ${theme.color}, warns with UNRESOLVED_INTERPOLATION and its path, instead of COMPLEX_INTERPOLATION
• Query variants are modules of their own
• Stylesheet imports follow the hashbang and the directive prologue

Merging main (2026-10-17)

main solved several of this PR's problems differently since August, so the merge ported the rest of this branch onto main's design instead of keeping both:

• Lazy const resolution (Resolve only const bindings; scope templates and tags correctly #79) replaces the eager evaluation, and the export records became references to bindings
• pendingLoads and isWaitingFor (Stop builds from hanging on mutually interpolated class names #102) replace the wait graph, the deferred same-file passes, and the import-last ordering
• IIFE class names (Resolve tree-shaking issues with inlineConst #87, Bump the dependencies group with 7 updates #98) replace moduleSideEffects: true, which did not help barrels in the measurements for Bump the dependencies group with 7 updates #98
• Vite's dev server keeps main's behavior (Update the CSS of modules that depend on edited modules in the Vite dev server #104) and does not transform imported modules through environment.transformRequest

Dropped with them:

• The guard against inlining the class names of templates whose extraction failed. It relied on the imported modules' transforms, which Vite's dev server does not run, and the runtime css call of such a template still throws
• Per-declaration stylesheet dependencies, as dependencies are collected per transform like on main
• UNREADABLE_MODULE, as a module whose code cannot be read now exports nothing, and UNPARSEABLE_MODULE, as modules are parsed as the language Rolldown assigned them

Known limitations

• The css tag must be a named import from 'ecij'. A namespace import or a re-export of the tag leaves its templates untransformed
• A wait cycle closed through another plugin's this.load cannot be detected and would hang the build

Merging main (2026-11-04)

main reshaped the code this PR builds on since the previous merge, so the merge ports it onto main's design again:

• The scope visitor is shared across parses (Share one scope visitor across parses to stop leaking memory #109), so the callbacks for raw TypeScript bindings and export default join it, and the default export is recorded through its visit state
• Imported modules are resolved, loaded, and parsed once per transform through main's loadImportedModule (Resolve and load each imported module once per transform #124), which this PR extends to skip external modules, key modules by moduleKey, and record dependencies by file
• Modules are parsed as the language the bundler assigned them through main's parseLangOf (Parse modules as the language the bundler assigned them #125), which came from this PR
• extractCssFromCode keeps main's single pass (Do the plugin's work in fewer passes #114), and hotUpdate its early return, with this PR's handling of query variants
• readModuleCode moved to module level, as consistent-function-scoping is on since Share one scope visitor across parses to stop leaking memory #109

The inline snapshots of this PR's tests follow Rolldown's new module comments (// path instead of //#region path and //#endregion), with no other change. Vite builds of react-data-grid's src and of a token-heavy project are byte-for-byte identical to main's, source maps included.

Merging main (2026-11-07)

main reworked the import handling this PR builds on, so the merge ports it onto main's design once more:

• Imports and exports are read from the top-level statements instead of the module record (Read imports and exports from the AST instead of the module record #127). Type-only forms are skipped through importKind and exportKind, and exported functions, classes, enums, and destructured bindings are recorded, so that they take precedence over export *
• Imports are bindings of the module-level scope (Bind imports in the module-level scope, and resolve default imports #131). Namespace imports are NamespaceImport bindings, and an exported import re-exports it, as in the spec, so that two export * that provide the same binding through different modules are not ambiguous
• export default binds *default* like on main (Bind imports in the module-level scope, and resolve default imports #131), and its templates get no default name, so their class names hash like main's
• resolveExport returns the module-level binding an export comes from, which main's resolveBinding resolves and caches (Resolve values without promises unless an import has to be loaded #133), and the value imports the stylesheet of the module that declares it
• Imported modules are read through main's cache of pending parses (Share pending parses of imported modules between transforms #128), with this PR's readModuleCode for the modules that no file holds
• TypeScript namespaces are not supported (Keep the declarations of TypeScript namespaces out of the module scope #130), so this PR no longer binds namespace names or import x = …, and the raw TypeScript fixture dropped its namespace cases. Enums still shadow

main's import-forms test now extracts the namespace member and the export … from re-export it skipped. New fixture cases cover the export of a namespace import and a member of a local object. Vite builds of react-data-grid's src and of two token-heavy projects are byte-for-byte identical to main's, source maps included. The 400-component token project builds in 182 ms against 172 ms on main (+6%), as each imported value goes through resolveExport.

Test plan

• 41 tests: main's, this PR's tests of the kept features, and a Vite dev server test of a virtual module and a ?raw variant. The kept tests cover the default, namespace, and re-export matrix, barrels with explicit-over-star precedence, namespace edge cases, a self-referencing barrel, external modules, query variants, explicit exports shadowing export *, ambiguous names, raw TypeScript through plain Rolldown, concurrent siblings, failed export * probes, an HTML entry's inline script, and the prologue
• The CSS and warnings of every kept test match this PR's previous snapshots, and only the class names changed format (IIFEs)
• New cases cover a default-exported function, direct and re-exported imports of external modules, and a member of a value that is not a namespace
• The tests of the dropped behavior, and the cycle test main already has, are removed. basic.input.ts is restored for main's inlineConst tests, and this PR's barrel.ts is now barrel-index.ts
• node --run test (locally and with CI=true against dist/), lint, typecheck, format:check, and build pass. src/index.ts statement coverage is 99.7%, and its one uncovered line (TypeScript parameter properties) is uncovered on main too
• Vite builds of scratch projects: a const cycle across two modules and a re-export cycle terminate unresolved, a chain of aliases across three modules resolves with the stylesheets in dependency order, modules interpolating each other's aliased class names build, and a binding exported under two names resolves under both

🤖 Generated with Claude Code

Summary by CodeRabbit

• Documentation

  • Added "Limitations" section describing css tag constraints and interpolation resolution requirements.

• New Features

  • Enhanced ESM module resolution with improved namespace, default export, and re-export chain handling.
  • Added cycle detection to prevent deadlock during concurrent module transforms.
  • Better static resolution of string and number interpolations in CSS templates.

• Bug Fixes

  • Improved handling of complex import/export patterns and edge cases.

[coderabbitai]

Walkthrough

This PR substantially refactors ecij's CSS extraction pipeline to support rich ESM module resolution. The core changes introduce richer type models for tracking imports and exports, helpers for static expression evaluation and cycle detection, and a comprehensive re-export resolution pipeline that follows export {x} from, export * from, and export * as ns chains while respecting export precedence. Interpolation extraction is rewritten to defer same-file forward references until later and emit distinct warning codes for unresolved vs complex interpolations. The PR includes 40+ test fixtures and extensive test cases validating all import/export patterns, cycles, type-only imports, and edge cases.

Changes

ESM Import/Export Resolver

Layer / File(s)	Summary
Core type model and expression evaluation helpers src/index.ts	New ImportedIdentifier and ExportRecord types distinguish import/export kinds; stripQuery, unwrapExpression, resolveStaticExpression, and flattenMemberExpressionPath helpers handle module ID normalization, AST simplification, and static literal evaluation; deadlock-detection bookkeeping (pendingLoads cache) is added.
Import and export data collection src/index.ts	parseFile prefers transformed module-graph code over disk reads; parsing state now tracks exportStarSources, localNameToExportedNamesMap, cssTagNames, and default-import spans; import/export collection is rewritten to populate the new richer model, record export * from provenance, and defer unresolved local exports.
Static literal and CSS template extraction src/index.ts	AST visitors now unwrap TS assertions on initializers, resolve static strings/numbers via resolveStaticExpression, directly handle CSS-tagged templates when the tag resolves to the tracked css binding, and record unknown values for shadowing logic.
Export resolution and dependency tracking src/index.ts	loadWouldDeadlock and resolveImportedFile add cycle detection; resolveExportTarget recursively follows re-export chains and detects ambiguity from multiple export * sources; traversed-file accumulation wires stylesheet dependencies.
Identifier and namespace member resolution src/index.ts	resolveValue routes through import kinds (rejecting namespace for direct access); new resolveMemberPath resolves chained accesses like ns.foo through namespace re-exports while tracking dependencies; "own class names" are tracked for same-file forward-reference deferral.
Interpolated CSS extraction with deferred resolution src/index.ts	processInterpolatedDeclaration unwraps/evaluates simple literals, resolves identifiers and namespace members, defers same-file forward refs when the class exists but isn't yet extracted, emits UNRESOLVED_INTERPOLATION vs COMPLEX_INTERPOLATION codes, and retries deferred declarations in a loop until fixed-point.
Cache management, watch/HMR eviction, and test configuration src/index.ts, vitest.config.ts	buildEnd and watchChange clear new caches (extractedClassesPerFile, pendingLoads); module IDs are normalized via stripQuery; CSS modules are keyed by generated ID; Vitest console trace printing is disabled.
Test fixtures exercising import/export patterns and edge cases test/fixtures/*	40+ fixture files covering: default exports (literals, CSS, wrapped, negative), export * precedence and ambiguous collisions, nested barrel aggregation with precedence rules, broken/complex interpolations, mutual import cycles, re-export chains (named, star, namespace), sibling concurrent resolution, same-file forward references and extraction isolation, type-only imports/exports, external package fallback patterns, and namespace member access edge cases.
Comprehensive test cases with snapshots test/plugin.test.ts	Extensive Vitest cases validate default/export * precedence, ambiguous warnings, namespace resolution, chained namespace hardening, type-only erasure, cycle deadlock avoidance, sibling concurrent resolution, same-file forward-reference deferral, extraction isolation, and graceful external module skipping; test harness extended to support external modules and Windows path normalization.
README limitations and TODO cleanup README.md	New "Limitations" section documents that css must be imported directly from ecij and interpolations must statically resolve to strings or numbers; TODO for "Full import/export handling" is removed.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• nstepien/ecij#58: Both PRs introduce distinct plugin warning codes for skipped CSS template extraction (COMPLEX_INTERPOLATION / UNRESOLVED_INTERPOLATION) when interpolations fail to resolve statically.
• nstepien/ecij#14: Both PRs enhance identifier/value resolution during CSS template interpolation extraction—this PR refactors import/export-based resolution with support for re-export chains and namespaces, while the prior PR adds lexical scope-chain resolution for shadowed identifiers.

Pre-merge checks: 4

Check name	Status	Explanation
Linked Issues check		Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check		Check skipped because no linked issues were found for this pull request.
Title check		The title "Full import/export handling, query variant modules, and raw TypeScript" names the main change. The changeset adds cross-module resolution for default, namespace, re-export, and export * for…
Description check		The description is related to the changeset. It describes cross-module interpolation resolution for css tagged templates, supported import and export forms, resolution semantics, module identity and q…

Full details: Title check

Explanation

The title "Full import/export handling, query variant modules, and raw TypeScript" names the main change. The changeset adds cross-module resolution for default, namespace, re-export, and export * forms (src/index.ts, README, and many fixtures). It also covers query-variant module identity and raw TypeScript parsing, which the PR description and objectives both state. The title is 70 characters and 9 words, which is somewhat long but still a single descriptive sentence.

Full details: Description check

Explanation

The description is related to the changeset. It describes cross-module interpolation resolution for css tagged templates, supported import and export forms, resolution semantics, module identity and query variants, output changes for stylesheet imports, and behavior changes versus main. Its merge notes and test plan also match the changed files, which include the README, the src/index.ts pipeline, and many import/export fixtures. The description is detailed and not off-topic, so it passes.

Finishing Touches

Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch full-import-export-support

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

• X
• Mastodon
• Reddit
• LinkedIn

[coderabbitai]

Actionable comments posted: 2

🧹 Nitpick comments (5)

test/fixtures/sibling-tokens.ts (1)

1-1: ⚡ Quick win

Use SCREAMING_SNAKE_CASE for module-level constant.

The exported constant pad should use SCREAMING_SNAKE_CASE per the coding guidelines for this project. As per coding guidelines, "Use SCREAMING_SNAKE_CASE for module-level constants" applies to **/*.{ts,tsx,js} files.

♻️ Proposed fix

-export const pad = 4;
+export const PAD = 4;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/fixtures/sibling-tokens.ts` at line 1, Rename the module-level exported
constant `pad` to SCREAMING_SNAKE_CASE (`PAD`) and update its export declaration
(`export const pad`) to `export const PAD`, then update all usages/imports in
the codebase to reference `PAD` instead of `pad` (search for the symbol `pad` to
find call sites), ensuring build and tests pass after the rename.

Source: Coding guidelines

test/fixtures/self-barrel-tokens.ts (1)

1-1: ⚡ Quick win

Use SCREAMING_SNAKE_CASE for module-level constant.

The exported constant tokenColor should use SCREAMING_SNAKE_CASE per the coding guidelines for this project. As per coding guidelines, "Use SCREAMING_SNAKE_CASE for module-level constants" applies to **/*.{ts,tsx,js} files.

♻️ Proposed fix

-export const tokenColor = 'teal';
+export const TOKEN_COLOR = 'teal';

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/fixtures/self-barrel-tokens.ts` at line 1, The module-level constant
tokenColor violates the SCREAMING_SNAKE_CASE rule; rename the exported symbol to
TOKEN_COLOR and update every usage/import to match (change export const
tokenColor -> export const TOKEN_COLOR and update any references/imports across
the codebase, including barrels or tests that import tokenColor). Ensure
TypeScript/ES exports and any default/barrel re-exports still resolve after
renaming.

Source: Coding guidelines

test/fixtures/typed.input.ts (1)

14-20: 💤 Low value

Module-level constant uses camelCase instead of SCREAMING_SNAKE_CASE.

The exported constant usesTypedTone should be USES_TYPED_TONE per the guideline requiring SCREAMING_SNAKE_CASE for module-level constants. However, as with the other fixture files, this is a test fixture where readability and natural naming may take precedence. As per coding guidelines, "Use SCREAMING_SNAKE_CASE for module-level constants" applies to **/*.{ts,tsx,js} files.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/fixtures/typed.input.ts` around lines 14 - 20, The exported module-level
constant usesTypedTone violates the SCREAMING_SNAKE_CASE rule; rename the symbol
usesTypedTone to USES_TYPED_TONE and update any local references/usages in this
fixture so the CSS template string remains the same but the exported identifier
uses SCREAMING_SNAKE_CASE (ensure you change the export name wherever
usesTypedTone is referenced).

Source: Coding guidelines

test/fixtures/typed-decoy.ts (1)

3-3: 💤 Low value

Module-level constant uses camelCase instead of SCREAMING_SNAKE_CASE.

Per coding guidelines, typedTone should be TYPED_TONE (SCREAMING_SNAKE_CASE for module-level constants). However, since this is a test fixture where the export name is significant for import resolution testing, and renaming would cascade to all consumers, this may be an acceptable deviation. Consider whether test fixtures should follow relaxed naming rules.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/fixtures/typed-decoy.ts` at line 3, The module-level constant exported
as typedTone violates the SCREAMING_SNAKE_CASE convention; either rename the
export to TYPED_TONE to follow guidelines (update all imports/consumers
accordingly) or, if this is an intentional test fixture exception, add a brief
comment above the export explaining the deliberate deviation so reviewers know
it’s intentional; locate the export named typedTone in the fixture and apply one
of these two changes consistently.

Source: Coding guidelines

test/fixtures/typed-tokens.ts (1)

1-1: 💤 Low value

Module-level constant uses camelCase instead of SCREAMING_SNAKE_CASE.

Per coding guidelines, typedTone should be TYPED_TONE. Same consideration as in typed-decoy.ts: this is a test fixture where the export name matters for resolution testing. As per coding guidelines, "Use SCREAMING_SNAKE_CASE for module-level constants" applies to **/*.{ts,tsx,js} files.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/fixtures/typed-tokens.ts` at line 1, The module-level constant is named
typedTone but must follow SCREAMING_SNAKE_CASE; rename the export symbol
typedTone to TYPED_TONE and update any consumers/tests that import or reference
typedTone to use TYPED_TONE instead (match the change made in typed-decoy.ts
style); ensure the exported value remains the same ('salmon') and that any
resolution tests or fixtures referencing the original symbol are adjusted
accordingly.

Source: Coding guidelines

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/index.ts`:
- Around line 1101-1183: The code mutates the shared stylesheetDependencies
while resolving interpolations in processInterpolatedDeclaration, causing
imports to be committed even when a declaration is later skipped or deferred;
fix by creating a per-declaration Set (e.g., localDependencies) inside
processInterpolatedDeclaration and use it for any dependency additions performed
by resolveValue/resolveMemberPath paths instead of mutating
stylesheetDependencies directly, ensure all early returns ('skipped' or
'deferred') do not touch the global set, and after
addProcessedDeclaration(declaration, cssContent) succeeds merge
localDependencies into the global stylesheetDependencies Set.
- Around line 426-438: isCssTagTemplate currently only checks scope.identifiers
and thus misses bindings declared later in the same scope; update it to also
scan the scope's AST block for any declarations that bind the same name
(node.tag.name) even if they haven't been added to scope.identifiers yet.
Specifically, inside isCssTagTemplate (and where you reference
scope.identifiers), inspect scope.block (or scope.node) for VariableDeclarator
ids, FunctionDeclaration ids, ClassDeclaration ids (and similar binding sites)
whose name equals node.tag.name and return false if any are found; keep the
existing parent-scope walk for earlier shadowing as well.

---

Nitpick comments:
In `@test/fixtures/self-barrel-tokens.ts`:
- Line 1: The module-level constant tokenColor violates the SCREAMING_SNAKE_CASE
rule; rename the exported symbol to TOKEN_COLOR and update every usage/import to
match (change export const tokenColor -> export const TOKEN_COLOR and update any
references/imports across the codebase, including barrels or tests that import
tokenColor). Ensure TypeScript/ES exports and any default/barrel re-exports
still resolve after renaming.

In `@test/fixtures/sibling-tokens.ts`:
- Line 1: Rename the module-level exported constant `pad` to
SCREAMING_SNAKE_CASE (`PAD`) and update its export declaration (`export const
pad`) to `export const PAD`, then update all usages/imports in the codebase to
reference `PAD` instead of `pad` (search for the symbol `pad` to find call
sites), ensuring build and tests pass after the rename.

In `@test/fixtures/typed-decoy.ts`:
- Line 3: The module-level constant exported as typedTone violates the
SCREAMING_SNAKE_CASE convention; either rename the export to TYPED_TONE to
follow guidelines (update all imports/consumers accordingly) or, if this is an
intentional test fixture exception, add a brief comment above the export
explaining the deliberate deviation so reviewers know it’s intentional; locate
the export named typedTone in the fixture and apply one of these two changes
consistently.

In `@test/fixtures/typed-tokens.ts`:
- Line 1: The module-level constant is named typedTone but must follow
SCREAMING_SNAKE_CASE; rename the export symbol typedTone to TYPED_TONE and
update any consumers/tests that import or reference typedTone to use TYPED_TONE
instead (match the change made in typed-decoy.ts style); ensure the exported
value remains the same ('salmon') and that any resolution tests or fixtures
referencing the original symbol are adjusted accordingly.

In `@test/fixtures/typed.input.ts`:
- Around line 14-20: The exported module-level constant usesTypedTone violates
the SCREAMING_SNAKE_CASE rule; rename the symbol usesTypedTone to
USES_TYPED_TONE and update any local references/usages in this fixture so the
CSS template string remains the same but the exported identifier uses
SCREAMING_SNAKE_CASE (ensure you change the export name wherever usesTypedTone
is referenced).

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: e19a3158-9acc-42d8-b238-2df58492bf4b

📥 Commits

Reviewing files that changed from the base of the PR and between 7d29442 and bda0816.

📒 Files selected for processing (56)

• README.md
• src/index.ts
• test/fixtures/ambiguous-a.ts
• test/fixtures/ambiguous-b.ts
• test/fixtures/ambiguous-barrel.ts
• test/fixtures/ambiguous.input.ts
• test/fixtures/barrel-a.ts
• test/fixtures/barrel-b.ts
• test/fixtures/barrel-c.ts
• test/fixtures/barrel-d.ts
• test/fixtures/barrel-deep-only.input.ts
• test/fixtures/barrel-nested.ts
• test/fixtures/barrel.input.ts
• test/fixtures/barrel.ts
• test/fixtures/broken-export.input.ts
• test/fixtures/broken-export.ts
• test/fixtures/cycle-a.input.ts
• test/fixtures/cycle-b.ts
• test/fixtures/default-passthrough-source.ts
• test/fixtures/default-passthrough.ts
• test/fixtures/export-default-css.ts
• test/fixtures/export-default-literal.ts
• test/fixtures/export-default-local.ts
• test/fixtures/export-default-negative.ts
• test/fixtures/export-default-wrapped-css.ts
• test/fixtures/external-barrel.ts
• test/fixtures/external-star.input.ts
• test/fixtures/external-tokens.ts
• test/fixtures/import-export-hardening.input.ts
• test/fixtures/import-export.input.ts
• test/fixtures/named-styles.ts
• test/fixtures/namespace-edge-cases.input.ts
• test/fixtures/ns-chain-star.ts
• test/fixtures/ns-chain.ts
• test/fixtures/reexports-named.ts
• test/fixtures/reexports-namespace.ts
• test/fixtures/reexports-star.ts
• test/fixtures/same-file-classes.input.ts
• test/fixtures/self-barrel-tokens.ts
• test/fixtures/self-barrel.input.ts
• test/fixtures/self-barrel.ts
• test/fixtures/sibling-consumer.ts
• test/fixtures/sibling-producer.ts
• test/fixtures/sibling-tokens.ts
• test/fixtures/siblings.input.ts
• test/fixtures/star-over-default.ts
• test/fixtures/star-precedence-a.ts
• test/fixtures/star-precedence.input.ts
• test/fixtures/star-precedence.ts
• test/fixtures/tag-alias.input.ts
• test/fixtures/typed-barrel.ts
• test/fixtures/typed-decoy.ts
• test/fixtures/typed-tokens.ts
• test/fixtures/typed.input.ts
• test/plugin.test.ts
• vitest.config.ts

[coderabbitai]

⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

Shadow checks miss later bindings in the same scope.

isCssTagTemplate() only sees names already inserted into scope.identifiers, but those bindings are recorded when the visitor reaches their declarations later on (for example, Line 565 and Line 672). A later let/const/var/function/class styled = ... still shadows the imported alias from the start of the scope, so styled\...`can be extracted here even though runtime resolution hits a TDZ or hoisted local binding instead ofecij`'s tag.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/index.ts` around lines 426 - 438, isCssTagTemplate currently only checks
scope.identifiers and thus misses bindings declared later in the same scope;
update it to also scan the scope's AST block for any declarations that bind the
same name (node.tag.name) even if they haven't been added to scope.identifiers
yet. Specifically, inside isCssTagTemplate (and where you reference
scope.identifiers), inspect scope.block (or scope.node) for VariableDeclarator
ids, FunctionDeclaration ids, ClassDeclaration ids (and similar binding sites)
whose name equals node.tag.name and return false if any are found; keep the
existing parent-scope walk for earlier shadowing as well.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

Only commit stylesheet dependencies after the declaration is emitted.

This path evaluates interpolations against the shared stylesheetDependencies set as it goes. If an early interpolation resolves through resolveExportValue()/resolveMemberPath() but a later one returns 'skipped' or 'deferred', the dependency import remains even though this declaration never reaches addProcessedDeclaration(). That can pull unrelated CSS into the final output. Keep a per-declaration dependency set and merge it only after extraction succeeds.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/index.ts` around lines 1101 - 1183, The code mutates the shared
stylesheetDependencies while resolving interpolations in
processInterpolatedDeclaration, causing imports to be committed even when a
declaration is later skipped or deferred; fix by creating a per-declaration Set
(e.g., localDependencies) inside processInterpolatedDeclaration and use it for
any dependency additions performed by resolveValue/resolveMemberPath paths
instead of mutating stylesheetDependencies directly, ensure all early returns
('skipped' or 'deferred') do not touch the global set, and after
addProcessedDeclaration(declaration, cssContent) succeeds merge
localDependencies into the global stylesheetDependencies Set.