svelte-shaker 0.14.1 → 0.15.1

package/README.md

@@ -54,10 +54,10 @@ binary). `parser: 'svelte'` falls back to svelte/compiler if you ever need it
 
 ## Usage (Vite)
 
-Add the plugin **before** `svelte()`. It runs only in `vite build` — dev/HMR is
-a pass-through by design. Out of the box it runs the native **Rust (WASM)
-engine** and parses with **rsvelte**; both fall back cleanly (see
-[Options](#options)).
+Add the plugin **before** `svelte()`. By default it runs only in `vite build` —
+dev/HMR is a pass-through (opt into dev shaking with the `dev` option, see
+[Options](#options)). Out of the box it runs the native **Rust (WASM) engine**
+and parses with **rsvelte**; both fall back cleanly (see [Options](#options)).
 
 ```ts
 // vite.config.ts
@@ -92,6 +92,9 @@ shaker({
   entries: ['src'], // dirs (relative to root) the crawl starts from; they must
   // hold every .svelte call site in the app. Not a glob, not a filter.
   preserve: [], // components whose props must never be folded (see below)
+  devOnly: [...], // glob patterns of files that never ship (tests, stories); they
+  // stop counting as call sites. Defaults to tests/mocks/stories; replaces, spread
+  // to extend.
   monomorphize: true, // default on; `false` disables it for faster builds,
   // or { maxVariants: 16, minSavings: 0.05 } to tune
   verbose: false, // true = per-file size breakdown after the build
@@ -100,6 +103,9 @@ shaker({
   // out (e.g. if you ever hit a bug in it).
   engine: 'auto', // 'auto' (default: Rust/WASM, else JS) | 'js' | 'rust'
   parser: 'rsvelte', // 'rsvelte' (default) | 'svelte' (fallback)
+
+  dev: false, // default off: dev is a pass-through. 'incremental' (re-parse only
+  // changed files) | 'coarse' (re-analyze everything) opts in; never monomorphizes
 });
 ```
 
@@ -147,6 +153,14 @@ options that do exist. A typo would otherwise be ignored — and a misspelled
   can't (a broken install), the plugin **throws** rather than silently falling
   back — so the same source always shakes the same on every machine. Reinstall
   dependencies, or set `parser: 'svelte'`.
+- **`dev`** — whether to shake in `vite dev` too. **Off** by default: dev is a
+  pass-through, which is always correct and keeps HMR simple. Opt in with
+  `dev: 'incremental'` — re-parses only the changed files and re-runs the
+  whole-program fixpoint over a long-lived incremental engine (the intended mode)
+  — or `dev: 'coarse'`, which re-analyzes the whole program on every change (the
+  slow but trivially-correct safety valve). Monomorphization is **never** applied
+  in dev; only the always-on passes (unused-prop fold / constant fold / value-set
+  narrowing) run.
 - **`preserve`** — keep a component's **prop interface** exactly as written, because
   something the shake can't see passes props to it. What is preserved is the props,
   **not** the file's presence in the bundle: this is unrelated to Rollup/Vite's
@@ -171,6 +185,32 @@ options that do exist. A typo would otherwise be ignored — and a misspelled
   The build **warns** (with the file path) about any module the scan couldn't
   parse — so a mounted component isn't silently left unprotected — and about
   `preserve` entries that matched no component.
+- **`devOnly`** — glob patterns (matched with
+  [`picomatch`](https://github.com/micromatch/picomatch) against each file's path
+  relative to the Vite root) naming files that **never ship in the production
+  bundle** — colocated tests, mocks, Storybook stories. A matched file **stops
+  counting as a component consumer** in **both directory scans** (the `.svelte` seed
+  scan and the non-`.svelte` escape scan), so a `Foo.test.svelte` or a
+  `Button.test.ts` can no longer pessimize the shake. It defaults to:
+
+  ```ts
+  // the built-in default (import DEFAULT_DEV_ONLY to extend it)
+  devOnly: ['**/*.test.*', '**/*.spec.*', '**/__tests__/**', '**/__mocks__/**', '**/*.stories.*'];
+  ```
+
+  Passing `devOnly` **replaces** this list (predictable semantics) — spread it to
+  extend: `devOnly: [...DEFAULT_DEV_ONLY, 'src/dev/**']` (import `DEFAULT_DEV_ONLY`
+  from `svelte-shaker/vite`). Pass `devOnly: []` to count every file (the pre-`devOnly`
+  behavior).
+
+  **List only files that never ship.** A matched file isn't excluded from the shake —
+  one the app actually imports is still crawled and shaken; it just stops _counting_
+  as a call site. So a file that really ships but matches a pattern (a `+page.svelte`
+  under a route dir named `__tests__`) has its distinct prop values stop blocking
+  folds, the same failure mode as leaving it out of `entries` — which is why the
+  defaults are narrow. See
+  [`docs/ARCHITECTURE.md` §8.1.1](https://github.com/baseballyama/svelte-shaker/blob/main/docs/ARCHITECTURE.md)
+  for the full argument.
 
 ## What it removes
 
@@ -207,8 +247,9 @@ The whole point is to **never change observable behavior**.
   scope.
 - **Needs `.svelte` source** — libraries shipping compiled JS pass through
   unshaken; distribute via `svelte-package`.
-- **Build only** — whole-program analysis is incompatible with dev/HMR locality,
-  so dev is always a pass-through.
+- **Build-first** — whole-program analysis is incompatible with dev/HMR locality,
+  so dev is a pass-through by default; opt into incremental dev shaking with the
+  `dev` option.
 - **`entries` must cover the whole app** — the crawl starts there, and every
   `.svelte` file it finds is a call-site source. A call site outside those roots
   is invisible, so narrowing `entries` does not shake less, it shakes _wrongly_.

package/dist/analyze.js

@@ -1,4 +1,4 @@
-import { parseCached, parseSvelte, walk, } from './parse.js';
+import { parseCached, parseModuleProgram, walk, } from './parse.js';
 import { emptyPlan, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
 import { evaluate, setVar } from './eval.js';
@@ -1809,21 +1809,15 @@ function followLocalImport(body, localName) {
     return null;
 }
 /**
- * Parse a `.js`/`.ts` module's top-level body by reusing the Svelte parser via a
- * `<script module>` wrapper (the engine has no standalone JS parser).  `lang="ts"`
- * is required so TypeScript barrels parse — `export type { … }`, type-only
- * specifiers and annotations are the norm for a design-system's `index.ts`, and a
- * plain JS parse throws on them, leaving the whole library unfollowed.  Returns
- * `null` if it cannot be parsed — callers then leave the barrel unfollowed.
+ * Parse a `.js`/`.ts` barrel's top-level body via {@link parseModuleProgram}
+ * (the engine has no standalone JS parser; the shared helper wraps the source in
+ * a `<script module lang="ts">` so TypeScript barrels — `export type { … }`,
+ * type-only specifiers — parse, and neutralizes any `</script>` in the text so a
+ * valid module that merely mentions it still parses, issue #146).  Returns `null`
+ * if it cannot be parsed — callers then leave the barrel unfollowed.
  */
 function parseModuleBody(code, id) {
-    try {
-        const ast = parseSvelte(`<script module lang="ts">\n${code}\n</script>`, id);
-        return ast.module?.content?.body ?? null;
-    }
-    catch {
-        return null;
-    }
+    return parseModuleProgram(code, id)?.body ?? null;
 }
 /**
  * Derive the child's {@link ReachableInputs} from its `$props()` shape (docs

package/dist/dev-only.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentId } from './ir.js';
+/**
+ * Files treated as DEV-ONLY by default: colocated tests, mocks, and Storybook
+ * stories — files that never ship, so their call sites must not count toward the
+ * shake.  Discounting them is sound precisely because they never reach production;
+ * see docs/ARCHITECTURE.md §8.1.1 for the full argument (why a glob is safe here but
+ * not for narrowing app coverage, and the shipped-file-matching failure mode).
+ * Passing `devOnly` REPLACES this list; `devOnly: []` counts every file.
+ */
+export declare const DEFAULT_DEV_ONLY: readonly string[];
+/** Predicate over an ABSOLUTE path: `true` when the file is dev-only (discounted by a scan). */
+export type DevOnlyFilter = (file: ComponentId) => boolean;
+/**
+ * Compile dev-only `patterns` into a {@link DevOnlyFilter}.  Each candidate path is
+ * matched (with `picomatch`) as its `base`-relative, posix-normalized form, so the
+ * result is OS-independent (backslashes on Windows are folded to `/`).  `base` is
+ * the Vite root for the plugin and the scanned dir for a standalone `svelte-shaker/node`
+ * caller.  Compile ONCE and reuse across the whole walk — never per file.
+ *
+ * Defaults to {@link DEFAULT_DEV_ONLY}; an empty `patterns` array matches nothing, so
+ * `devOnly: []` counts every file (the pre-`devOnly` behavior).
+ */
+export declare function compileDevOnly(base: string, patterns?: readonly string[]): DevOnlyFilter;

package/dist/dev-only.js

@@ -0,0 +1,43 @@
+// ----------------------------------------------------------------------
+// Shell-side glob for the two directory scans (docs/ARCHITECTURE.md §4.2, §8.1.1):
+// which files are DEV-ONLY — they never ship in the production bundle, so their
+// call sites must not count toward the shake.  Kept OUT of the env-free engine
+// core (docs §5): it depends on `picomatch` and `node:path`.  Both scans — the
+// `.svelte` seed scan (`collectSvelteFiles`) and the non-`.svelte` escape scan
+// (`collectNonSvelteModules`) — take the SAME compiled predicate, so a dev-only
+// file is discounted by both.
+// ----------------------------------------------------------------------
+import picomatch from 'picomatch';
+import * as path from 'node:path';
+/**
+ * Files treated as DEV-ONLY by default: colocated tests, mocks, and Storybook
+ * stories — files that never ship, so their call sites must not count toward the
+ * shake.  Discounting them is sound precisely because they never reach production;
+ * see docs/ARCHITECTURE.md §8.1.1 for the full argument (why a glob is safe here but
+ * not for narrowing app coverage, and the shipped-file-matching failure mode).
+ * Passing `devOnly` REPLACES this list; `devOnly: []` counts every file.
+ */
+export const DEFAULT_DEV_ONLY = [
+    '**/*.test.*',
+    '**/*.spec.*',
+    '**/__tests__/**',
+    '**/__mocks__/**',
+    '**/*.stories.*',
+];
+const NONE_DEV_ONLY = () => false;
+/**
+ * Compile dev-only `patterns` into a {@link DevOnlyFilter}.  Each candidate path is
+ * matched (with `picomatch`) as its `base`-relative, posix-normalized form, so the
+ * result is OS-independent (backslashes on Windows are folded to `/`).  `base` is
+ * the Vite root for the plugin and the scanned dir for a standalone `svelte-shaker/node`
+ * caller.  Compile ONCE and reuse across the whole walk — never per file.
+ *
+ * Defaults to {@link DEFAULT_DEV_ONLY}; an empty `patterns` array matches nothing, so
+ * `devOnly: []` counts every file (the pre-`devOnly` behavior).
+ */
+export function compileDevOnly(base, patterns = DEFAULT_DEV_ONLY) {
+    if (patterns.length === 0)
+        return NONE_DEV_ONLY;
+    const isMatch = picomatch([...patterns]);
+    return (file) => isMatch(path.relative(base, file).split(path.sep).join('/'));
+}

package/dist/escape-scan.d.ts

@@ -1,5 +1,6 @@
 import type { ComponentId } from './ir.js';
 import type { Resolve, ReadFile } from './analyze.js';
+import { type DevOnlyFilter } from './dev-only.js';
 /**
  * Is `file` a module the escape scan reads — a non-`.svelte` JS/TS source
  * ({@link NON_SVELTE_MODULE_EXTS}), excluding `.d.ts` declaration files (types-only,
@@ -45,6 +46,13 @@ export declare function computeEscapedComponents(opts: {
     preserve?: string[] | undefined;
     /** The crawled `.svelte` component ids, for matching `preserve` prefixes. */
     components: Iterable<ComponentId>;
+    /**
+     * Dev-only files to discount in the escape scan (docs §8.1.1) — the SAME predicate
+     * the seed scan (`collectSvelteFiles`) applies, so a `Button.test.ts` neither seeds
+     * a component nor escapes one.  Omitted, it defaults to {@link DEFAULT_DEV_ONLY}
+     * matched relative to `root`.  Pass `compileDevOnly(root, [])` to scan everything.
+     */
+    devOnly?: DevOnlyFilter | undefined;
     resolve: Resolve;
     readFile: ReadFile;
 }): Promise<EscapeScanResult>;

package/dist/escape-scan.js

@@ -7,7 +7,8 @@
 // ----------------------------------------------------------------------
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { parseSvelte, walk } from './parse.js';
+import { parseModuleProgram, walk } from './parse.js';
+import { compileDevOnly } from './dev-only.js';
 /**
  * The non-`.svelte` module extensions we scan for `.svelte` call sites (docs
  * §4.2).  A component imported by any of these has a consumer the `.svelte`-only
@@ -31,51 +32,43 @@ export function isScannableModule(file) {
  * Recursively collect every non-`.svelte` module under `dir` (skipping
  * `node_modules` and dot-directories, mirroring `collectSvelteFiles`).  Same
  * include scope as the seed scan — `.ts` inside `node_modules` is deliberately NOT
- * scanned (docs §4.2).
+ * scanned (docs §4.2).  `devOnly` drops modules that never ship (a `Button.test.ts`)
+ * so a colocated test does not mark the component it imports escaped (docs §8.1.1);
+ * it is the SAME predicate the seed scan uses, so both scans discount the same files.
  */
-function collectNonSvelteModules(dir) {
-    const out = [];
+function collectNonSvelteModules(dir, devOnly, out) {
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     }
     catch {
-        return out;
+        return;
     }
     for (const entry of entries) {
         if (entry.name === 'node_modules' || entry.name.startsWith('.'))
             continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory())
-            out.push(...collectNonSvelteModules(full));
-        else if (entry.isFile() && isScannableModule(entry.name))
+            collectNonSvelteModules(full, devOnly, out);
+        else if (entry.isFile() && isScannableModule(entry.name) && !devOnly(full))
             out.push(full);
     }
-    return out;
 }
 /**
  * Every module specifier a JS/TS module statically references: `import … from`,
  * `export … from` / `export *`, and a dynamic `import('…')` whose argument is a
  * STRING LITERAL.  A computed dynamic import (`import(expr)`) is unknowable here —
- * the `preserve` option (docs §4.2) is the sound fallback for it.  Parsed via the
- * Svelte parser's `<script module lang="ts">` wrapper (the same TS-capable parse
- * the engine's barrel-following uses).  Returns `null` when the module does NOT
- * parse — the wrapper handles TS but not JSX, and rejects some exotic syntax
- * (`.jsx`/`.tsx` bodies, bleeding-edge TS), and a parse failure hides any call site
- * inside, so the caller must surface it (a mounted component would go un-escaped);
- * `preserve` is the fix for that file.
+ * the `preserve` option (docs §4.2) is the sound fallback for it.  Parsed via
+ * {@link parseModuleProgram} (the same TS-capable parse the engine's
+ * barrel-following uses).  Returns `null` when the module does NOT parse — a JSX
+ * body or exotic/bleeding-edge TS the wrapper rejects — because a parse failure
+ * hides any call site inside, so the caller must surface it (a mounted component
+ * would go un-escaped); `preserve` is the fix for that file.
  */
 function moduleImportSpecifiers(code, id) {
-    let module;
-    try {
-        module = parseSvelte(`<script module lang="ts">\n${code}\n</script>`, id).module;
-    }
-    catch {
-        return null; // unparseable — the caller reports it (soundness hole, `preserve` fixes it)
-    }
-    const program = module?.content;
-    if (!program)
-        return []; // parsed, no module body — nothing to follow (not a failure)
+    const program = parseModuleProgram(code, id);
+    if (program === null)
+        return null; // unparseable — the caller reports it (`preserve` fixes it)
     const specs = [];
     const literalSource = (node) => node?.type === 'Literal' && typeof node.value === 'string' ? node.value : undefined;
     walk(program, null, {
@@ -181,7 +174,11 @@ export function matchPreserve(preserve, root, components) {
  * `svelte-shaker/node`).
  */
 export async function computeEscapedComponents(opts) {
-    const { escaped, unscannable } = await collectModuleEscapes(opts.entryDirs.flatMap(collectNonSvelteModules), opts.resolve, opts.readFile);
+    const devOnly = opts.devOnly ?? compileDevOnly(opts.root);
+    const modules = [];
+    for (const dir of opts.entryDirs)
+        collectNonSvelteModules(dir, devOnly, modules);
+    const { escaped, unscannable } = await collectModuleEscapes(modules, opts.resolve, opts.readFile);
     const { matched, unmatched } = partitionPreserve(opts.preserve, opts.root, opts.components);
     for (const id of matched)
         escaped.add(id);

package/dist/parse.d.ts

@@ -81,6 +81,39 @@ export interface Root extends AnyNode {
     fragment: AnyNode;
 }
 export declare function parseSvelte(code: string, filename: string): Root;
+/**
+ * Parse a plain `.js`/`.ts` module (NOT a `.svelte` component) and return its
+ * top-level ESTree Program, or `null` if it does not parse.  The engine has no
+ * standalone JS parser, so we reuse the Svelte parser via a `<script module
+ * lang="ts">` wrapper: `lang="ts"` is what lets a TypeScript barrel — `export
+ * type { … }`, type-only specifiers, annotations, the norm for a design-system
+ * `index.ts` — parse where a plain-JS parse would throw.
+ *
+ * The Svelte parser ends a `<script>` at the first `</script…>` it finds in the
+ * RAW text (`read_until(/<\/script\s*>/)`), so a valid module whose text merely
+ * MENTIONS `</script>` — in a comment, string, regex or template literal, as an
+ * HTML sanitizer or a markdown pipeline routinely does — would close the wrapper
+ * early and fail to parse (issue #146).  We break every `</script` in the body
+ * before wrapping by inserting a space after the `<`.  In valid JS/TS `</script`
+ * only ever occurs inside a comment or a string/regex/template literal (it is
+ * never part of executable syntax), so this alters only inert text — with ONE
+ * exception a caller does read: a module SPECIFIER that itself contains
+ * `</script` (`import x from './a</script>b.js'`).  Rewriting it would silently
+ * change which file it resolves to, turning a parse failure into a partial one
+ * (a missed escape / an unfollowed export).  Rather than claim such a specifier
+ * cannot exist, we detect a rewritten one after parsing and fail the whole
+ * module (return `null`), the same loud degrade a parse failure gives — the
+ * specifier is absurd (`<`/`>` are invalid in real paths and package names), so
+ * this only trades one conservative outcome for another.  The inserted spaces
+ * shift byte offsets, but no caller reads spans off this AST — only specifier
+ * names and string values.
+ *
+ * Returns `null` on a genuine parse failure (a JSX body, exotic/bleeding-edge
+ * TS) or a specifier the neutralization would corrupt: a call site hidden inside
+ * then goes unfollowed, which each caller handles conservatively (escape scan
+ * reports the file as unscannable; barrel-following leaves the barrel unfollowed).
+ */
+export declare function parseModuleProgram(code: string, filename: string): AnyNode | null;
 /**
  * Content-keyed parse cache: a hit returns the IDENTICAL AST for unchanged
  * source, so the dev engine re-parses only the files that actually changed

package/dist/parse.js

@@ -3,6 +3,93 @@ import { walk as zfWalk } from 'zimmerframe';
 export function parseSvelte(code, filename) {
     return parse(code, { modern: true, filename });
 }
+/** Matches every `</script` in module text (any case), the sequence that would
+ * otherwise close the {@link parseModuleProgram} wrapper early. */
+const CLOSING_SCRIPT = /<\/script/gi;
+/** What `CLOSING_SCRIPT` is rewritten to: a space after the `<` breaks the
+ * `</script\s*>` the Svelte parser scans for, while staying a recognizable
+ * marker so a corrupted specifier can be detected afterwards. */
+const NEUTRALIZED_SCRIPT = '< /script';
+/**
+ * Parse a plain `.js`/`.ts` module (NOT a `.svelte` component) and return its
+ * top-level ESTree Program, or `null` if it does not parse.  The engine has no
+ * standalone JS parser, so we reuse the Svelte parser via a `<script module
+ * lang="ts">` wrapper: `lang="ts"` is what lets a TypeScript barrel — `export
+ * type { … }`, type-only specifiers, annotations, the norm for a design-system
+ * `index.ts` — parse where a plain-JS parse would throw.
+ *
+ * The Svelte parser ends a `<script>` at the first `</script…>` it finds in the
+ * RAW text (`read_until(/<\/script\s*>/)`), so a valid module whose text merely
+ * MENTIONS `</script>` — in a comment, string, regex or template literal, as an
+ * HTML sanitizer or a markdown pipeline routinely does — would close the wrapper
+ * early and fail to parse (issue #146).  We break every `</script` in the body
+ * before wrapping by inserting a space after the `<`.  In valid JS/TS `</script`
+ * only ever occurs inside a comment or a string/regex/template literal (it is
+ * never part of executable syntax), so this alters only inert text — with ONE
+ * exception a caller does read: a module SPECIFIER that itself contains
+ * `</script` (`import x from './a</script>b.js'`).  Rewriting it would silently
+ * change which file it resolves to, turning a parse failure into a partial one
+ * (a missed escape / an unfollowed export).  Rather than claim such a specifier
+ * cannot exist, we detect a rewritten one after parsing and fail the whole
+ * module (return `null`), the same loud degrade a parse failure gives — the
+ * specifier is absurd (`<`/`>` are invalid in real paths and package names), so
+ * this only trades one conservative outcome for another.  The inserted spaces
+ * shift byte offsets, but no caller reads spans off this AST — only specifier
+ * names and string values.
+ *
+ * Returns `null` on a genuine parse failure (a JSX body, exotic/bleeding-edge
+ * TS) or a specifier the neutralization would corrupt: a call site hidden inside
+ * then goes unfollowed, which each caller handles conservatively (escape scan
+ * reports the file as unscannable; barrel-following leaves the barrel unfollowed).
+ */
+export function parseModuleProgram(code, filename) {
+    const wrapped = `<script module lang="ts">\n${code.replace(CLOSING_SCRIPT, NEUTRALIZED_SCRIPT)}\n</script>`;
+    let program;
+    try {
+        program = parseSvelte(wrapped, filename).module?.content ?? null;
+    }
+    catch {
+        return null; // unparseable — the caller decides how to degrade (see above)
+    }
+    // A specifier that carried `</script` was rewritten by the neutralization and
+    // no longer names the real module; degrade loudly rather than resolve a lie.
+    if (program && hasNeutralizedSpecifier(program))
+        return null;
+    return program;
+}
+/** True when any static import/export/dynamic-`import()` specifier string in
+ * `program` contains the {@link NEUTRALIZED_SCRIPT} marker — i.e. the source
+ * originally held `</script` and was rewritten by {@link parseModuleProgram}, so
+ * it can no longer be trusted to resolve. */
+function hasNeutralizedSpecifier(program) {
+    let corrupted = false;
+    const check = (source) => {
+        if (source?.type === 'Literal' &&
+            typeof source.value === 'string' &&
+            source.value.includes(NEUTRALIZED_SCRIPT)) {
+            corrupted = true;
+        }
+    };
+    walk(program, null, {
+        ImportDeclaration(node, { next }) {
+            check(node.source);
+            next();
+        },
+        ExportNamedDeclaration(node, { next }) {
+            check(node.source);
+            next();
+        },
+        ExportAllDeclaration(node, { next }) {
+            check(node.source);
+            next();
+        },
+        ImportExpression(node, { next }) {
+            check(node.source);
+            next();
+        },
+    });
+    return corrupted;
+}
 export function parseCached(filename, code, cache, parse = parseSvelte) {
     if (!cache)
         return parse(code, filename);

package/dist/rsvelte-parse.d.ts

@@ -6,9 +6,9 @@ import type { Parse } from './parse.js';
  * rsvelte is the default parser, the caller THROWS on `null` rather than silently
  * using svelte/compiler; `parser: 'svelte'` is the explicit opt-out.
  *
- * The AST carries per-node `loc` (there is no option to drop it), but the engine
- * reads only UTF-16 `start`/`end`, never `loc`, so the parser choice can never
- * change the shaken output — only which parser produced the identical tree.
+ * rsvelte's AST positions match svelte/compiler's — UTF-16 code-unit offsets — so
+ * the AST feeds the engine directly (`@rsvelte/compiler` <= 0.6 reported UTF-8
+ * *byte* offsets and needed a remap; 0.7 emits UTF-16, so the remap is gone).
  * A genuine parse error on a specific file is a real failure and PROPAGATES; only
  * a load/init failure returns `null`.
  */

package/dist/rsvelte-parse.js

@@ -8,6 +8,11 @@ import { createRequire } from 'node:module';
 // free engine (`index.ts`/`analyze.ts`), so the browser playground build stays
 // clean.
 const require = createRequire(import.meta.url);
+/** The wasm-pack `--target web` bytes shipped in `@rsvelte/compiler`, reached via
+ * the package's stable `./wasm` subpath export (added upstream in 0.8.1). Using
+ * the public subpath keeps the loader independent of the internal crate name that
+ * determines the actual artifact basename. */
+const WASM_FILE = '@rsvelte/compiler/wasm';
 let ready = false;
 /** Require `@rsvelte/compiler` and initialize its wasm once. Throws if the
  * package can't be resolved or the wasm can't be instantiated. */
@@ -17,7 +22,7 @@ function loadCompiler() {
     if (!ready) {
         // A `wasm-pack --target web` module: init once with the wasm bytes (Node has
         // no fetch for file URLs), after which `parse_svelte` is callable.
-        const wasmPath = require.resolve('@rsvelte/compiler/rsvelte_core_bg.wasm');
+        const wasmPath = require.resolve(WASM_FILE);
         compiler.initSync({ module: readFileSync(wasmPath) });
         ready = true;
     }
@@ -30,9 +35,9 @@ function loadCompiler() {
  * rsvelte is the default parser, the caller THROWS on `null` rather than silently
  * using svelte/compiler; `parser: 'svelte'` is the explicit opt-out.
  *
- * The AST carries per-node `loc` (there is no option to drop it), but the engine
- * reads only UTF-16 `start`/`end`, never `loc`, so the parser choice can never
- * change the shaken output — only which parser produced the identical tree.
+ * rsvelte's AST positions match svelte/compiler's — UTF-16 code-unit offsets — so
+ * the AST feeds the engine directly (`@rsvelte/compiler` <= 0.6 reported UTF-8
+ * *byte* offsets and needed a remap; 0.7 emits UTF-16, so the remap is gone).
  * A genuine parse error on a specific file is a real failure and PROPAGATES; only
  * a load/init failure returns `null`.
  */

package/dist/scan.d.ts

@@ -1,6 +1,8 @@
 import type { ComponentId } from './ir.js';
 import type { Resolve, ReadFile } from './analyze.js';
+import { type DevOnlyFilter } from './dev-only.js';
 export { computeEscapedComponents, type EscapeScanResult } from './escape-scan.js';
+export { DEFAULT_DEV_ONLY, compileDevOnly, type DevOnlyFilter } from './dev-only.js';
 /** Default filesystem resolver: resolve `source` relative to its importer. */
 export declare const fsResolve: Resolve;
 /** Default filesystem reader. */
@@ -9,5 +11,14 @@ export declare const fsReadFile: ReadFile;
  * Recursively collect every `.svelte` file under `dir` (skipping `node_modules`
  * and dot-directories).  A Shell helper, kept out of the env-free engine core
  * (docs/ARCHITECTURE.md §5): plugins use it to seed the whole-program crawl.
+ *
+ * `devOnly` lists files that never ship in the production bundle (tests, stories);
+ * a match stops counting as a component consumer, so it is not seeded as an entry
+ * and cannot pessimize the shake (docs §8.1.1).  A matched file the app actually
+ * imports is still crawled and shaken through the normal graph — this only removes
+ * it as a SEED.  Omitted, it defaults to {@link DEFAULT_DEV_ONLY} matched relative
+ * to `dir`; the Vite plugin passes a predicate compiled against the Vite ROOT so a
+ * custom pattern is root-relative there.  Pass `compileDevOnly(dir, [])` to seed
+ * every file.
  */
-export declare function collectSvelteFiles(dir: string): ComponentId[];
+export declare function collectSvelteFiles(dir: string, devOnly?: DevOnlyFilter): ComponentId[];

package/dist/scan.js

@@ -5,9 +5,14 @@
 // ----------------------------------------------------------------------
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { compileDevOnly } from './dev-only.js';
 // The escape-scan machinery lives in `./escape-scan.js` (internal); only the single
 // entry helper is part of the public `svelte-shaker/node` surface.
 export { computeEscapedComponents } from './escape-scan.js';
+// The dev-only glob support (docs §8.1.1) is Shell-side and part of the public
+// `svelte-shaker/node` surface, so a plain-Rollup pipeline can compile the same
+// predicate the Vite plugin does and feed it to both scans.
+export { DEFAULT_DEV_ONLY, compileDevOnly } from './dev-only.js';
 /** Default filesystem resolver: resolve `source` relative to its importer. */
 export const fsResolve = (source, importer) => {
     if (!source.startsWith('.'))
@@ -20,24 +25,37 @@ export const fsReadFile = (id) => fs.readFileSync(id, 'utf-8');
  * Recursively collect every `.svelte` file under `dir` (skipping `node_modules`
  * and dot-directories).  A Shell helper, kept out of the env-free engine core
  * (docs/ARCHITECTURE.md §5): plugins use it to seed the whole-program crawl.
+ *
+ * `devOnly` lists files that never ship in the production bundle (tests, stories);
+ * a match stops counting as a component consumer, so it is not seeded as an entry
+ * and cannot pessimize the shake (docs §8.1.1).  A matched file the app actually
+ * imports is still crawled and shaken through the normal graph — this only removes
+ * it as a SEED.  Omitted, it defaults to {@link DEFAULT_DEV_ONLY} matched relative
+ * to `dir`; the Vite plugin passes a predicate compiled against the Vite ROOT so a
+ * custom pattern is root-relative there.  Pass `compileDevOnly(dir, [])` to seed
+ * every file.
  */
-export function collectSvelteFiles(dir) {
+export function collectSvelteFiles(dir, devOnly = compileDevOnly(dir)) {
     const out = [];
+    collectSvelteFilesInto(dir, devOnly, out);
+    return out;
+}
+/** Recursive worker: the compiled `devOnly` predicate is threaded, never recompiled. */
+function collectSvelteFilesInto(dir, devOnly, out) {
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     }
     catch {
-        return out;
+        return;
     }
     for (const entry of entries) {
         if (entry.name === 'node_modules' || entry.name.startsWith('.'))
             continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory())
-            out.push(...collectSvelteFiles(full));
-        else if (entry.isFile() && entry.name.endsWith('.svelte'))
+            collectSvelteFilesInto(full, devOnly, out);
+        else if (entry.isFile() && entry.name.endsWith('.svelte') && !devOnly(full))
             out.push(full);
     }
-    return out;
 }

package/dist/vite.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from 'vite';
 import { type DevMode } from './engine.js';
+export { DEFAULT_DEV_ONLY } from './dev-only.js';
 import { type MonomorphizeOptions } from './mono.js';
 /**
  * Options for the {@link shaker} plugin.  The set below is exhaustive: any other
@@ -52,6 +53,35 @@ export interface ShakerOptions {
      * without needing it is merely shaken less, never wrongly.
      */
     preserve?: string[];
+    /**
+     * Glob patterns naming files that are DEV-ONLY — they never ship in the production
+     * bundle (colocated tests, mocks, Storybook stories), so their call sites must not
+     * count toward the shake.  A matched file stops counting as a component consumer in
+     * BOTH directory scans (the `.svelte` seed scan and the non-`.svelte` escape scan);
+     * patterns are matched with `picomatch` against the posix-normalized path relative
+     * to the Vite root.  Defaults to {@link DEFAULT_DEV_ONLY}.
+     *
+     * List ONLY files that never ship: the option declares a property of the files,
+     * which is exactly the soundness contract that makes discounting them safe.  A
+     * matched file is NOT excluded from the shake — a dev-only `.svelte` file the app
+     * actually imports is still crawled and shaken through the normal import graph, so
+     * its genuine app call sites still count.  This only removes it as a SEED / ESCAPE
+     * source; it cannot un-cover reachable app code.
+     *
+     * The failure mode to avoid: a matched file's call sites simply STOP COUNTING.  So
+     * if a file that really ships matches a pattern — a `+page.svelte` under a route
+     * dir named `__tests__`, a `foo.test.utils.ts` that mounts a component — the
+     * distinct prop values it passes no longer block a fold, exactly as if you had left
+     * it out of {@link entries}.  That is why the defaults are narrow, convention-based
+     * patterns rather than an open glob (see docs/ARCHITECTURE.md §8.1.1).  It is
+     * unrelated to {@link preserve}: that keeps a shipping component's props as written;
+     * this declares that a file is not part of the production graph at all.
+     *
+     * Passing `devOnly` REPLACES the default rather than adding to it (predictable
+     * semantics); extend it with `[...DEFAULT_DEV_ONLY, '…']`, and pass `devOnly: []` to
+     * count every file (the pre-`devOnly` behavior).
+     */
+    devOnly?: string[];
     /**
      * Per-call-site monomorphization tuning (docs §13.2).  Monomorphization is ON
      * by default because it is bail-safe and never bloats (the measured net-win

package/dist/vite.js

@@ -5,6 +5,9 @@ import { svelteShaker, svelteShakerWithMono } from './index.js';
 import { DevShaker } from './engine.js';
 import { collectSvelteFiles, fsResolve } from './scan.js';
 import { computeEscapedComponents, isScannableModule, } from './escape-scan.js';
+import { compileDevOnly } from './dev-only.js';
+// Re-export so a user can extend the default dev-only list: `devOnly: [...DEFAULT_DEV_ONLY, '…']`.
+export { DEFAULT_DEV_ONLY } from './dev-only.js';
 import { DEFAULT_MONO_OPTIONS } from './mono.js';
 import { tryLoadRsvelteParser } from './rsvelte-parse.js';
 import { svelteShakerWasm, svelteShakerWasmWithMono, tryLoadWasmEngine } from './wasm-engine.js';
@@ -126,6 +129,7 @@ const RENAMED_OPTIONS = {
 const KNOWN_OPTIONS = {
     entries: true,
     preserve: true,
+    devOnly: true,
     monomorphize: true,
     engine: true,
     dev: true,
@@ -263,9 +267,13 @@ export function shaker(options = {}) {
             if (!devMode)
                 return;
             const dirs = (options.entries ?? ['.']).map((p) => path.resolve(root, p));
+            // One dev-only predicate for the whole dev session, compiled against the Vite
+            // root so custom patterns are root-relative regardless of which entry dir a
+            // file sits under.  Fed to both scans and the watch guards below (docs §8.1.1).
+            const isDevOnly = compileDevOnly(root, options.devOnly);
             // The engine's entry components, collected from the entry DIRS: `entries`
             // names the roots to crawl from, these are the `.svelte` files under them.
-            const entryComponents = dirs.flatMap(collectSvelteFiles);
+            const entryComponents = dirs.flatMap((d) => collectSvelteFiles(d, isDevOnly));
             const read = (id) => fs.readFileSync(id, 'utf-8');
             const underDirs = (file) => dirs.some((d) => file === d || file.startsWith(d + path.sep));
             // Re-scan the non-`.svelte` modules for `.svelte` call sites and re-apply
@@ -280,6 +288,7 @@ export function shaker(options = {}) {
                     root,
                     preserve: options.preserve,
                     components: entryComponents,
+                    devOnly: isDevOnly,
                     resolve: fsResolve,
                     readFile: read,
                 });
@@ -301,7 +310,10 @@ export function shaker(options = {}) {
             // un-shake a child; a removed one can re-shake it — docs §4).  Re-shake and
             // full-reload: over-invalidation is always sound, and add/remove is rare
             // enough that fine-grained HMR for it is not worth the complexity here.
-            const isOurs = (file) => file.endsWith('.svelte') && underDirs(file);
+            // Dev-only files are discounted by both scans, so an edit to one never moves
+            // the shake — skip them here too, or a `Foo.test.svelte` save would retrigger a
+            // full re-shake for no effect.
+            const isOurs = (file) => file.endsWith('.svelte') && underDirs(file) && !isDevOnly(file);
             const onGraphChange = async (file, kind) => {
                 if (!devShaker || !isOurs(file))
                     return;
@@ -315,7 +327,7 @@ export function shaker(options = {}) {
             // we re-shake and full-reload (over-invalidation is sound, but pointless
             // reloads on unrelated `.ts` edits are avoided).
             const onModuleChange = async (file) => {
-                if (!devShaker || !isScannableModule(file) || !underDirs(file))
+                if (!devShaker || !isScannableModule(file) || !underDirs(file) || isDevOnly(file))
                     return;
                 const before = escapedKey;
                 devShaker.setEscaped(await currentEscaped());
@@ -363,9 +375,12 @@ export function shaker(options = {}) {
             if (devShaker)
                 return;
             const dirs = (options.entries ?? ['.']).map((p) => path.resolve(root, p));
+            // One dev-only predicate for both scans, compiled against the Vite root so
+            // custom patterns are root-relative regardless of the entry dir (docs §8.1.1).
+            const isDevOnly = compileDevOnly(root, options.devOnly);
             // The engine's entry components, collected from the entry DIRS: `entries`
             // names the roots to crawl from, these are the `.svelte` files under them.
-            const entryComponents = dirs.flatMap(collectSvelteFiles);
+            const entryComponents = dirs.flatMap((d) => collectSvelteFiles(d, isDevOnly));
             if (entryComponents.length === 0) {
                 shaken = {};
                 variantSources = new Map();
@@ -404,6 +419,7 @@ export function shaker(options = {}) {
                 root,
                 preserve: options.preserve,
                 components: entryComponents,
+                devOnly: isDevOnly,
                 resolve,
                 readFile: read,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.14.1",
+  "version": "0.15.1",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",
@@ -49,12 +49,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@rsvelte/compiler": "0.6.1",
+    "@rsvelte/compiler": "0.8.1",
     "magic-string": "1.0.0",
+    "picomatch": "4.0.5",
     "zimmerframe": "1.1.4"
   },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^7.2.0",
+    "@types/picomatch": "4.0.2",
     "svelte": "^5.56.6",
     "vite": "^8.1.5"
   },