feat: vite-plugin-solid-three — build-time tree-shaking for createT(THREE)

[bigmistqke]

Summary

A new Vite plugin, vite-plugin-solid-three, that makes createT(THREE) tree-shakeable. createT returns a runtime proxy, and passing the whole THREE namespace into it defeats the bundler's tree-shaking — so all of three ships. This plugin narrows the call to only the classes your app actually reaches through T.

It lets the bundler do the analysis, in two passes on production builds:

• Measure: a nested build temporarily turns the catalogue into a namespace; the bundler's own tree-shaking reports (via renderedExports) exactly which keys survive — across files, dynamic imports, and code-split chunks.
• Emit: createT(THREE) is rewritten to createT({ Mesh: THREE.Mesh, … }) with only the measured keys. createT stays in the output, so runtime and debugging are unchanged.

Soundness is structural: any access the bundler can't resolve statically (T[expr], T escaping into a function, {...T}) deopts to keeping the whole catalogue; dynamic catalogue sources (createT(store), computed keys) are left untouched. No static cross-file analysis, no alias replication, no resolution guard — the bundler is the analyzer, so the result is exact rather than over-approximate. Dev is untouched (the runtime proxy is used).

This supersedes the earlier ts-morph/unplugin approach (#60), which reconstructed cross-file analysis the bundler already performs.

What's covered

Fixtures build small consumer projects through the plugin and assert drop/keep:

• namespace createT(THREE), custom object literals, spread + override precedence (last-write-wins), verbatim getters
• dynamic-usage bail, whole-value escape, {...T} spread → full catalogue kept (sound)
• cross-file union, lazy chunks, template-literal dynamic imports → reached classes survive
• a browser soundness oracle: every class the rendered scene accesses through T is present in the narrowed catalogue

Test plan

• pnpm --filter vite-plugin-solid-three test (30 Node tests)
• pnpm --filter vite-plugin-solid-three test:oracle (browser soundness gate)
• pnpm --filter vite-plugin-solid-three build (clean dist)
• Try on a real solid-three app with a non-trivial Vite config and a custom catalogue

Notes / deferred

• Two-pass ≈ 2× production build cost; the measure pass can be made cheaper (build-until-tree-shake, skip output stages). Design rationale and the build-cost trilemma are in docs/superpowers/specs/2026-06-01-createt-narrowing-design.md.
• Vite-only for now. Cross-bundler is no longer architecturally blocked (the bundler does its own resolution and tree-shaking) and is a documented follow-up.

🤖 Generated with Claude Code

[pkg-pr-new]

• solid-three-demo

  npm i https://pkg.pr.new/solid-three@61
  

commit: 3144780

[bigmistqke]

Closing this one. After living with it for a bit, the two-pass "let the bundler measure usage" approach — rewriting createT(THREE) into a scaffold namespace, running a throwaway nested build to read Rollup's surviving exports, then narrowing — works, but it's too hacky to commit to: it leans on a nested build coordinated by process-global state (one build per process, user plugins run twice), and it's tightly coupled to Rollup internals (renderedExports).

For the cost and the moving parts, the immediate payoff just isn't there to justify carrying it. Leaving the branch up for reference in case we want to revisit the idea later, but not pursuing this path for now.