auto-server-split 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,116 @@
+# Changelog
+
+All notable changes to this project are documented here. The project follows [Semantic Versioning](https://semver.org/).
+
+## 1.0.0 — interactive mode, docs, benchmarks
+
+- `--interactive`: `[y]es / [n]o / [r]ename islands / [d]iff / [q]uit`; renames re-run the engine
+  and its self-check.
+- `--version` prints the package version.
+- `--write` refuses untracked and git-ignored targets as well as modified ones.
+- Effects that sync island state move with that island; shared-context hooks (`usePathname`…) are
+  allowed in per-item list islands; `const X = () => <jsx/>` components are no longer mistaken for
+  module constants in multi-component files; blank lines between moved statements are kept.
+- Real-path resolution of the project root (symlinked checkouts, macOS temp dirs).
+- README, `docs/api.md`, `docs/configuration.md`, `docs/eslint.md`, `docs/benchmarks.md`.
+- `scripts/benchmark.mjs` (three real App Router apps) and `scripts/perf.mjs` (500-file dry run in
+  ~7 s).
+- CLI and interactive-mode tests; fixture 32 (`islandsDir`).
+- Release prep: `prepublishOnly` runs lint, typecheck and tests (which rebuild `dist/`); Next.js
+  hook names moved into the framework adapter so `analysis/` stays framework-neutral; packaging
+  verified by installing the packed tarball into a fresh Next.js 16 app (CLI, API, types, ESLint
+  plugin, `.ts` config) and running the CLI on Node 20.
+- `--interactive` can't be combined with `--dry-run` (it used to write the accepted splits anyway).
+- New skip code `measure-failed`: when esbuild can't bundle a file, its saving is unknown, so it no
+  longer passes `minBytesSaved` silently. With `minBytesSaved: 0` the file is split and the result
+  has `measureError` ("saving not measured" in the CLI output and summary).
+- Size measurement no longer fails on CSS Modules (`import styles from "./Card.module.css"`):
+  esbuild's built-in `local-css` loader for `.module.css` took precedence over the empty `.css`
+  loader, so every such file was skipped as `measure-failed` under the default `minBytesSaved`.
+  `.module.css`, `.module.scss`, `.module.sass` and `.module.less` imports are now measured as empty.
+- The ESLint rule now applies the CLI's config and thresholds: it loads every config format
+  (`.ts`, `.mts`, `.mjs`, `.js`, `.json`), its `minStaticRatio` can raise the config's but not
+  lower it, and it measures the saving and applies `minBytesSaved` (new option `measure`). It only
+  reports files the CLI would split.
+- Untyped linting builds the program the way TypeScript does: a file the tsconfig's `include`
+  doesn't match but that an included file imports (for example a `.jsx` component with `allowJs`)
+  is analysed, as the CLI already did.
+- Files saved with Windows line endings (CRLF) keep them: inserted lines and the island file use
+  the original's line ending. They used to come out LF, and an interactive rename turned the whole
+  rewritten file LF (ts-morph's `replaceWithText` rewrites line breaks; the self-check now sets
+  file text byte for byte).
+- Repository housekeeping: author and license holder set to Himesh Gunathilake; fixtures moved to
+  `test/fixtures/`; `CONTRIBUTING.md`, `.editorconfig`, `.nvmrc`; `format`/`format:check` scripts
+  (checked in CI); `noUnusedLocals`/`noUnusedParameters`; unused exports and dead helpers removed.
+
+## 0.5.0 — ESLint plugin
+
+- `auto-server-split/eslint`: flat-config plugin with `prefer-server-split` (report only, on the
+  `"use client"` directive) and `configs.recommended` (`warn`, `minStaticRatio: 0.5`).
+- Typed linting uses the full project for the program's tsconfig; without it, a lazy project loads
+  only the linted file, its imports and its importers (module graph built syntactically). Both are
+  cached per tsconfig for the lint process. The rule runs the self-check before reporting.
+- Engine refactor: synchronous `analyzeFile` / `checkAnalyzed`, `createRunContext`.
+- RuleTester tests with and without typed linting.
+
+## 0.4.0 — multiple components, Mongoose, JSX
+
+- Multiple components per file: unchanged server components, wholesale-moved interactive helpers,
+  server components copied into islands that render them.
+- `mongoose.autoSerialize`: Mongoose documents and ObjectId-bearing values crossing the boundary
+  are reduced to the fields the island reads (`String()` for ObjectIds, Dates kept).
+- `.jsx` input (untyped-boundary rules), CSS Modules on both sides, `src/` path aliases.
+- Second e2e app (`shop`); both apps pass the before/after DOM equality checks.
+- Fixtures 28–31c.
+
+## 0.3.0 — donut slots, e2e
+
+- Donut/slot pattern: static, non-trivial subtrees inside an island stay on the server and are
+  passed in as `children` (or `slot1`, `slot2`, ...).
+- `e2e/run.mjs` + `e2e/apps/blog`: `next build` before and after `--write`, identical server HTML,
+  identical DOM after hydration and after every Playwright interaction, per-route JS sizes.
+  Blog app: 16 components split, 5 skipped as expected, `/` ships 18.5 KB gzip less JavaScript.
+- Fixture 27 (accordion donut), donut unit tests.
+
+## 0.2.0 — grouping, loops, packages, size
+
+- Union-find grouping of anchors that share client state or handlers; LCA island roots; merging of
+  nested islands; escape check.
+- `.map` loop islands (loop variable becomes a prop, `key` moves to the usage). Islands that need
+  component-level hooks are hoisted above the `.map` so state stays shared.
+- Custom hooks (imported or declared in the file), browser globals, client-only packages
+  (framer-motion etc.), `next/navigation` hooks.
+- Server Actions: imported actions move with the island; action props pass through when every
+  importer passes a Server Action.
+- Module-level helpers and constants used by islands are copied into the island file and removed
+  from the server file when no longer used there.
+- Unit tests: LCA, grouping/union-find, taint propagation, loop rule, import pruning.
+- Fixtures 08–26.
+
+## 0.1.0 — first split
+
+- Module graph over the whole tsconfig program plus JS/MDX files outside it (static imports,
+  re-exports, `import()`, `require`), with client reachability from `"use client"` roots.
+- Importer check (direct, through barrels, dynamic, value usage).
+- Client-only marking: hooks, event/ref/function props, browser globals, client-only packages,
+  render nondeterminism, with fixpoint propagation over the component body.
+- Leaf islands (plus union-find grouping, LCA, escape check and `.map` handling, unit-tested in 0.2).
+- Free variables become props; serializability checked with the type checker.
+- Rewrite with magic-string (untouched bytes preserved), island file generation, import
+  move/copy/prune, optional Prettier pass.
+- Self-check before every report/write: parse, no new type errors, no client code left, serializable
+  props, no server-only imports in the island.
+- esbuild size measurement (isolated + conservative gzip), `minBytesSaved`, `minStaticRatio`.
+- CLI: `--dry-run` (default), `--write` (git-dirty guard, `--allow-dirty`), `--check` (exit 2), `--json`,
+  `--config`, `--root`, `--verbose`, `--no-measure`.
+- Config file loading and validation (`auto-split.config.{ts,mts,mjs,js,json}`).
+- Fixtures: PostCard (exact spec output), server props, two islands, and skips for client importer,
+  context provider, function prop, conditional hook.
+
+## 0.0.0 — scaffold
+
+- pnpm + tsup (ESM only) + strict TypeScript + Vitest + ESLint flat config + GitHub Actions CI.
+- Fixture runner (`test/fixtures.test.ts`) with `UPDATE_FIXTURES=1` regeneration.
+- `SkipCode` framework (`src/analysis/skip.ts`).
+- `docs/prior-art.md`: no existing tool performs this split automatically.
+- npm name `auto-server-split` checked: available (404 on 2026-10-19).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Himesh Gunathilake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,280 @@
-# Temporary Holding Version
+# auto-server-split
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Split partly-interactive `"use client"` components into a Server Component plus small generated client islands, so the browser downloads less JavaScript, with no manual refactoring.**
+
+For the Next.js App Router and React Server Components. It ships as a CLI codemod, a programmatic API and an ESLint plugin, all built on the same analysis engine. When the tool isn't sure a split is safe, it skips the file and tells you why.
+
+## Before / after
+
+```tsx
+// PostCard.tsx (before)
+"use client";
+import { format } from "date-fns";
+import { marked } from "marked";
+import { useState } from "react";
+
+type Post = { title: string; date: string; body: string };
+
+export default function PostCard({ post }: { post: Post }) {
+  const [liked, setLiked] = useState(false);
+  return (
+    <article>
+      <h2>{post.title}</h2>
+      <time>{format(new Date(post.date), "PPP")}</time>
+      <div dangerouslySetInnerHTML={{ __html: marked(post.body) as string }} />
+      <button onClick={() => setLiked(!liked)}>{liked ? "♥" : "♡"}</button>
+    </article>
+  );
+}
+```
+
+```tsx
+// PostCard.tsx (after): a Server Component; date-fns and marked no longer ship to the browser
+import { format } from "date-fns";
+import { marked } from "marked";
+import { PostCardButton } from "./PostCard.client";
+
+type Post = { title: string; date: string; body: string };
+
+export default function PostCard({ post }: { post: Post }) {
+  return (
+    <article>
+      <h2>{post.title}</h2>
+      <time>{format(new Date(post.date), "PPP")}</time>
+      <div dangerouslySetInnerHTML={{ __html: marked(post.body) as string }} />
+      <PostCardButton />
+    </article>
+  );
+}
+```
+
+```tsx
+// PostCard.client.tsx (generated)
+"use client";
+import { useState } from "react";
+
+export function PostCardButton() {
+  const [liked, setLiked] = useState(false);
+  return <button onClick={() => setLiked(!liked)}>{liked ? "♥" : "♡"}</button>;
+}
+```
+
+In the e2e app that renders this component, the route ships **18.5 KB gzip less JavaScript**. The page's HTML is identical before and after, and the DOM stays identical after every click.
+
+## Install
+
+Node.js 20 or later. The analysis uses the TypeScript compiler that ships with the tool (via ts-morph), so it doesn't depend on your project's TypeScript version (tested with TypeScript 5 and 6 projects). Your project's own Prettier is used for formatting when it has a Prettier config.
+
+```bash
+npm install --save-dev auto-server-split     # or pnpm add -D / yarn add -D
+npx auto-server-split --help
+```
+
+## Recommended workflow
+
+1. **Start from a clean git state.** `--write` refuses to touch files with uncommitted changes, so commit or stash first. Every change the tool makes then shows up as one reviewable diff.
+2. **Preview.** Start with one folder rather than the whole app:
+
+   ```bash
+   npx auto-server-split components
+   ```
+
+   Nothing is written. The output looks like this (abridged, colours removed):
+
+   ```
+   ✔ split components/ArticleFooter.tsx · 1 island · 83% static · ~83 B gzip saved (estimated)
+       ArticleFooterButton <button>
+   ===================================================================
+   --- a/components/ArticleFooter.tsx
+   +++ b/components/ArticleFooter.tsx
+   @@ -1,4 +1,4 @@
+   -"use client";
+   +import { ArticleFooterButton } from "./ArticleFooter.client";
+   …
+   – skipped components/Badge.tsx [imported-by-client] imported by components/ClientPanel.tsx (client)
+   – skipped components/Banner.tsx:6:5 [state-spans-component] client state is used across the whole returned tree (<div>, <small>)
+
+   Summary
+     files scanned:  27 (21 with "use client")
+     files split:    16 (dry run, nothing written)
+     files skipped:  5
+         1  imported-by-client             imported by a client module
+         1  state-spans-component          client state spans the whole component
+         …
+     estimated saving: 727 B gzip of client JavaScript (1 split not measured)
+
+   Run again with --write to apply.
+   ```
+
+3. **Apply.** Use `--write` to apply every split, or `--interactive` to accept, reject or rename them one at a time.
+4. **Review before you commit.**
+   - Read the diff: the rewritten `X.tsx` files and the new `X.client.tsx` files.
+   - Run your build, type checker and tests.
+   - Click through the affected pages, especially the interactive parts.
+   - Look for timezone- or locale-dependent output (dates, numbers, `toLocaleString`). That code now runs on the server, which may use a different timezone or locale from your users' browsers.
+5. **Run it again.** Splitting a file can make another file splittable: a component that was only imported by a client component becomes splittable once that importer turns into a Server Component. Repeat until the summary shows no new splits.
+6. **Look at the skips.** Some point to a small refactor that makes the file splittable (for example `exports-non-components` or `context-provider`). Others, such as `fully-interactive`, mean the component belongs on the client. [docs/skip-reasons.md](docs/skip-reasons.md) has a fix for each.
+7. **Keep it from regressing** with the [ESLint rule](#eslint) in the editor and [`--check` in CI](#ci).
+
+**Island names** are the component name followed by the island's root element in PascalCase: `PostCard` + `<button>` gives `PostCardButton`, and `<motion.div>` gives `PostCardMotionDiv`. When that name is already taken (by another island or a name in the file), a number is added (`ToolbarButton2`). Rename them with `[r]ename` in `--interactive` mode, or edit the generated file afterwards: it's ordinary source code, and the tool never writes into an existing `X.client.tsx`.
+
+**To undo a split** before committing, restore the original file and delete the generated one:
+
+```bash
+git restore components/PostCard.tsx && rm components/PostCard.client.tsx
+```
+
+## CLI
+
+```bash
+npx auto-server-split <paths...> [--dry-run | --write | --check] [--interactive] [--json]
+                                 [--config <file>] [--root <dir>] [--allow-dirty] [--verbose] [--no-measure]
+```
+
+| Flag                    | What it does                                                                                                                                                                                                                                                                              |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| _(default)_ `--dry-run` | Prints a coloured unified diff per file, the islands and the estimated KB saved. Skipped files show their reason. Nothing is written.                                                                                                                                                     |
+| `--write`               | Applies the changes. Refuses if any target file has uncommitted changes, is untracked or is git-ignored (or the project isn't a git repository), unless you pass `--allow-dirty`.                                                                                                         |
+| `--check`               | For CI: exits `2` if any split is available. Changes nothing.                                                                                                                                                                                                                             |
+| `--allow-dirty`         | Lets `--write` and `--interactive` write files that have uncommitted changes, are untracked or git-ignored, or are outside a git repository.                                                                                                                                              |
+| `--interactive`         | Walks through each proposed split: `[y]es / [n]o / [r]ename islands / [d]iff / [q]uit`, then writes the accepted ones (same git checks as `--write`). Renames go back through the engine and its self-check. Needs a terminal; can't be combined with `--dry-run`, `--json` or `--check`. |
+| `--json`                | Machine-readable report with the same shape as the API result.                                                                                                                                                                                                                            |
+| `--config <file>`       | Config file (default: `auto-split.config.{ts,mts,mjs,js,json}` in the project root).                                                                                                                                                                                                      |
+| `--root <dir>`          | Project root, where `tsconfig.json` lives (default: the current directory).                                                                                                                                                                                                               |
+| `--no-measure`          | Skips the esbuild size measurement (faster; `minBytesSaved` isn't applied, and no saving is reported).                                                                                                                                                                                    |
+| `--verbose`             | Prints stack traces for internal errors.                                                                                                                                                                                                                                                  |
+| `--help`, `--version`   | Usage and version.                                                                                                                                                                                                                                                                        |
+
+Without paths, the config's `include` globs are used (`app/**`, `components/**`, `src/**`).
+Exit codes: `0` ok, `1` internal error or bad input, `2` splits available (with `--check`).
+The summary lists files scanned, files split, files skipped grouped by reason, and the total estimated saving
+(see the sample output under [Recommended workflow](#recommended-workflow)).
+
+### CI
+
+`--check` exits `2` when a split is available, which fails the step:
+
+```yaml
+# .github/workflows/ci.yml (excerpt)
+- run: npx auto-server-split --check
+```
+
+To report splits without failing the build, add `continue-on-error: true` to the step. The output lists each available split and its estimated saving either way.
+
+## API
+
+```ts
+import { split } from "auto-server-split";
+
+const result = await split({
+  root: process.cwd(), // project root (where tsconfig.json lives)
+  paths: ["app", "components"],
+  write: false,
+  config: {}, // overrides the config file
+});
+
+for (const file of result.files) {
+  console.log(file.file, file.status, file.skipped?.code, file.bytesSaved?.conservative);
+}
+```
+
+See [docs/api.md](docs/api.md) for the full result type.
+
+## ESLint
+
+```js
+// eslint.config.js
+import tseslint from "typescript-eslint";
+import autoSplit from "auto-server-split/eslint";
+
+export default [
+  ...tseslint.configs.recommended, // or any config that parses TypeScript/JSX
+  autoSplit.configs.recommended,
+];
+```
+
+The rule `auto-server-split/prefer-server-split` reports on the `"use client"` directive:
+
+```
+PostCard is 80% static with 1 interactive island (<button>). Run: npx auto-server-split app/blog/PostCard.tsx --write
+```
+
+It applies the same config file, self-check and size thresholds as the CLI, so it only reports files the CLI would split. It has no autofix, because a split creates a new file and ESLint fixes can't do that. The CLI is the fixer. See [docs/eslint.md](docs/eslint.md).
+
+## Configuration
+
+```ts
+// auto-split.config.ts
+import { defineConfig } from "auto-server-split";
+
+export default defineConfig({
+  include: ["app/**", "components/**", "src/**"],
+  exclude: ["**/*.test.*", "**/*.stories.*"],
+  clientOnlyPackages: ["my-ui-lib/interactive"], // added to the built-in list
+  serverSafeHooks: [], // e.g. ["useTranslations"]
+  clientFileSuffix: ".client", // or islandsDir: "_islands"
+  minBytesSaved: 2048, // gzip bytes, conservative estimate
+  minStaticRatio: 0.3,
+  prettier: "auto", // format touched files with the project's Prettier config
+  mongoose: { autoSerialize: false },
+});
+```
+
+Unknown keys are an error. See [docs/configuration.md](docs/configuration.md).
+
+## Skip reasons
+
+Every skip has a stable code, a one-sentence message and, where possible, a source location.
+[docs/skip-reasons.md](docs/skip-reasons.md) has an example and a fix for each.
+
+| Code                                     | When                                                                                          |
+| ---------------------------------------- | --------------------------------------------------------------------------------------------- |
+| `imported-by-client`                     | A client module imports the file (directly or through a barrel)                               |
+| `exports-non-components`                 | The file exports hooks, utilities or values                                                   |
+| `state-spans-component`                  | Client state is used across the whole returned element                                        |
+| `context-provider`                       | The file creates or provides a Context                                                        |
+| `css-in-js-runtime`                      | styled-components, Emotion, styled-jsx…                                                       |
+| `non-serializable-prop`                  | A value crossing the boundary isn't serializable                                              |
+| `untyped-boundary`                       | `.js`/`.jsx` file and the prop types can't be proven                                          |
+| `spread-props`                           | A spread that can't be proven serializable                                                    |
+| `conditional-hooks-or-returns`           | Conditional hooks, or early returns that depend on client state                               |
+| `class-component`                        | The file contains a class component                                                           |
+| `dynamic-import` / `render-prop` / `hoc` | `next/dynamic`/`lazy`/`import()`, render props, `memo`/`forwardRef`                           |
+| `server-env-difference`                  | Reads a non-`NEXT_PUBLIC_` env var                                                            |
+| `no-islands` / `fully-interactive`       | No client code at all (the directive may be unnecessary), or nothing would stay on the server |
+| `below-threshold`                        | Below `minBytesSaved` or `minStaticRatio`                                                     |
+| `measure-failed`                         | esbuild couldn't bundle the file, so `minBytesSaved` can't be checked                         |
+| `output-exists` / `would-create-route`   | File-system conflicts                                                                         |
+| `unsupported-pattern`                    | Valid code this version doesn't handle (the message says which)                               |
+| `self-check-failed`                      | The generated code failed the self-check                                                      |
+| `parse-error` / `internal-error`         | Bugs: reported per file, never crash the run                                                  |
+
+## How it decides
+
+1. **Module graph.** Every file the tsconfig covers (plus JS/MDX files it doesn't), with static imports, re-exports, `import()` and `next/dynamic`. Anything reachable from a `"use client"` module is client code.
+2. **Candidates.** A `"use client"` file is a candidate only if every importer is a server module that renders its components as `<X />`, it exports only components and types, and nothing at module level behaves differently on the server.
+3. **Client-only marking.** Hooks, event/ref/function props, browser globals, client-only packages (framer-motion, Radix, react-hook-form…), render nondeterminism (`Date.now()`, `Math.random()`), and anything that can't be proven server-safe (unknown React packages, local modules that use hooks) are client-only. Taint propagates through the component body to a fixpoint.
+4. **Islands.** Elements that use client-only code are anchors. Anchors that share state merge (union-find), the island root is their lowest common ancestor, and an escape check grows the island until no client value is read outside it. In `.map()` lists, the mapped element becomes a per-item island, unless that would duplicate component-level state. Effects join the island whose state they use. Static, non-trivial subtrees inside an island stay on the server as `children` ("donut"). In a file with several components, a non-exported helper component that is entirely interactive moves into the island file whole.
+5. **Boundary.** Free variables become props and are proven serializable with the type checker (React's rules: primitives, plain objects, arrays, `Date`, `Map`, `Set`, typed arrays, Promises, JSX, Server Actions). Non-serializable helpers are copied into the island instead.
+6. **Rewrite.** magic-string range edits keep every untouched byte of the original. Imports move, are copied or are pruned, the island file is generated, and Prettier runs only if the project has a config. Inserted lines and the island file use the original file's line ending (CRLF or LF, taken from its first line); a file that already mixes the two keeps its existing lines as they are.
+7. **Self-check.** Before anything is reported or written, the output is typechecked in memory, re-analysed (no client code may remain in the server file), and every prop is re-checked. The typecheck allows no _new_ diagnostics: errors the file already had are tolerated, and diagnostics are compared by code and message. `.js`/`.jsx` files only get semantic checks when `checkJs` is on (never with a `jsconfig.json`), so for them this step is mostly a parse check.
+8. **Measure.** The original file and the island file are bundled with esbuild (react/next external) and the gzip sizes compared. The conservative number leaves out dependencies other client modules still ship. If esbuild can't bundle a file, the saving is unknown: the file is skipped (`measure-failed`) unless `minBytesSaved` is 0, in which case it's split and labelled "saving not measured".
+
+## Limitations
+
+- **It's conservative.** On three well-known open-source apps, most `"use client"` files are skipped, because they are already genuinely interactive ([docs/benchmarks.md](docs/benchmarks.md)). The tool pays off in codebases that put `"use client"` high in the tree.
+- **Server vs browser rendering differences** that the tool can't see stay a risk: for example, timezone- or locale-dependent formatting moves from the browser to the server (`format(new Date(x), "PPP")` in the example above). Nondeterministic calls it _can_ see (`Date.now()`, `Math.random()`, `new Date()`) are kept on the client.
+- **Safety of local modules is decided per module, not per export**, so one client-only helper in a utility module keeps every caller of that module on the client.
+- Third-party React packages are client-only unless they have a `"use client"` entry or are on the small built-in server-safe list. Unknown packages stay in islands.
+- Not handled yet (they skip): class components, `memo`/`forwardRef`, render props, `next/dynamic`, Context providers, runtime CSS-in-JS, statements other than declarations/hook calls/early returns in a component body, and existing `X.client.tsx` files (it never merges).
+- The ESLint rule caches the module graph and config per lint process, and can't load a config file that uses top-level await (rules are synchronous). It reads the config file the CLI finds by default, not one passed with `--config`.
+- "Same rendered output" is enforced by the analysis rules, not re-checked on every run. The e2e suite checks it on two sample apps (identical server HTML, identical DOM after every interaction).
+- Next.js only for now; framework specifics live in `src/frameworks/next.ts`.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the project layout, tests and release checklist.
+
+## License
+
+[MIT](LICENSE) © Himesh Gunathilake

package/dist/bundleSize-KPGJRR3B.js

@@ -0,0 +1,8 @@
+import {
+  BundleMeasurer
+} from "./chunk-YQKO5FJM.js";
+import "./chunk-YCSBOPV3.js";
+export {
+  BundleMeasurer
+};
+//# sourceMappingURL=bundleSize-KPGJRR3B.js.map

package/dist/bundleSize-KPGJRR3B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}