svelte-shaker 0.14.0 → 0.15.0

package/README.md

@@ -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
@@ -171,6 +174,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
 

package/dist/analyze.d.ts

@@ -18,8 +18,10 @@ export type ReadFileSync = (id: ComponentId) => string;
  *    never be seen and is safe to drop;
  *  - `{ kind: 'all' }` — anything we cannot pin down: a `...rest` (captures
  *    undeclared inputs), an Identifier/Array binding (`let p = $props()`),
- *    more than one `$props()` call, or `$props()` outside a `let <pat> = …`
- *    declarator.  Then any input might be observed, so nothing is dropped.
+ *    more than one `$props()` call, `$props()` outside a `let <pat> = …`
+ *    declarator, or a component that observes slotted content outside `$props()`
+ *    — a legacy `<slot>` element or a `$$slots` read (both legal in runes mode).
+ *    Then any input might be observed, so nothing is dropped.
  */
 export type ReachableInputs = {
     kind: 'all';
@@ -275,8 +277,9 @@ export interface UnpassedProp {
  *    spread that could set it (`readCallSite` already folds `bind:`, known
  *    spreads, and `children`/snippet body into `explicit`/`hadSpread`);
  *  - a component in `input.escaped` — one the Shell knows has a consumer OUTSIDE
- *    the `.svelte` graph (a `.ts`/`.js` call site, or a user `preserve`, docs
- *    §4.2) — is skipped, because that consumer may pass a prop the crawl cannot see.
+ *    the `.svelte` graph (a call site in a non-`.svelte` module, or a user
+ *    `preserve`, docs §4.2) — is skipped, because that consumer may pass a prop
+ *    the crawl cannot see.
  *
  * Missing a `.svelte` EDGE (e.g. an unfollowed barrel) only DROPS call sites, so it
  * can only make this UNDER-report (the component looks unused and is skipped). The

package/dist/analyze.js

@@ -29,22 +29,22 @@ function fixpointIterationBound(componentCount) {
 /** Bail reason stamped on a component leaked as a value (docs §4.1 escape). */
 const ESCAPE_REASON = 'escapes as value (e.g. <svelte:component this={X}>)';
 /** Bail reason stamped on a component with a consumer OUTSIDE the analyzed
- * `.svelte` graph — a `.ts`/`.js` call site the crawl cannot parse, or a
- * user-declared `preserve` (docs §4.2, {@link AnalyzeInput.escaped}).  Kept
- * byte-identical to the Rust engine's constant so the two agree. */
-const EXTERNAL_ESCAPE_REASON = 'has a consumer outside the analyzed .svelte graph';
+ * `.svelte` graph — a call site in a non-`.svelte` module the crawl cannot
+ * parse, or a user-declared `preserve` (docs §4.2, {@link AnalyzeInput.escaped}).
+ * Kept byte-identical to the Rust engine's constant so the two agree. */
+const MODULE_ESCAPE_REASON = 'has a consumer outside the analyzed .svelte graph';
 /**
- * Stamp {@link EXTERNAL_ESCAPE_REASON} on every model in `escaped` that exists in
+ * Stamp {@link MODULE_ESCAPE_REASON} on every model in `escaped` that exists in
  * the program — the single injection point both the whole-program shake and
  * {@link findNeverPassedProps} share (docs §4.2).  Ids not in the program are
- * ignored (a stale `preserve` entry or a scanned `.ts` import to a component
- * outside the crawl is simply a no-op, never an error).
+ * ignored (a stale `preserve` entry or a scanned import to a component outside
+ * the crawl is simply a no-op, never an error).
  */
-function stampExternalEscapes(models, escaped) {
+function stampModuleEscapes(models, escaped) {
     for (const id of escaped ?? []) {
         const model = models.get(id);
-        if (model && !model.bailReasons.includes(EXTERNAL_ESCAPE_REASON))
-            model.bailReasons.push(EXTERNAL_ESCAPE_REASON);
+        if (model && !model.bailReasons.includes(MODULE_ESCAPE_REASON))
+            model.bailReasons.push(MODULE_ESCAPE_REASON);
     }
 }
 /**
@@ -86,9 +86,10 @@ export function analyzeInput(input, parseCache) {
         if (model && !model.bailReasons.includes(ESCAPE_REASON))
             model.bailReasons.push(ESCAPE_REASON);
     }
-    // Components with consumers outside the `.svelte` graph (a `.ts`/`.js` call site
-    // or a user `preserve`, docs §4.2) join the same whole-component escape bail.
-    stampExternalEscapes(models, input.escaped);
+    // Components with consumers outside the `.svelte` graph (a call site in a
+    // non-`.svelte` module or a user `preserve`, docs §4.2) join the same
+    // whole-component escape bail.
+    stampModuleEscapes(models, input.escaped);
     return { models, plans: planFixpoint(models) };
 }
 /**
@@ -499,8 +500,9 @@ export function deadSpansForPlans(models, plans) {
  *    spread that could set it (`readCallSite` already folds `bind:`, known
  *    spreads, and `children`/snippet body into `explicit`/`hadSpread`);
  *  - a component in `input.escaped` — one the Shell knows has a consumer OUTSIDE
- *    the `.svelte` graph (a `.ts`/`.js` call site, or a user `preserve`, docs
- *    §4.2) — is skipped, because that consumer may pass a prop the crawl cannot see.
+ *    the `.svelte` graph (a call site in a non-`.svelte` module, or a user
+ *    `preserve`, docs §4.2) — is skipped, because that consumer may pass a prop
+ *    the crawl cannot see.
  *
  * Missing a `.svelte` EDGE (e.g. an unfollowed barrel) only DROPS call sites, so it
  * can only make this UNDER-report (the component looks unused and is skipped). The
@@ -521,9 +523,10 @@ export function findNeverPassedProps(input) {
         if (model && !model.bailReasons.includes(ESCAPE_REASON))
             model.bailReasons.push(ESCAPE_REASON);
     }
-    // External consumers (`.ts`/`.js` call sites or `preserve`) escape too, so a prop
-    // they pass is never mis-reported as never-passed (docs §4.2).
-    stampExternalEscapes(models, input.escaped);
+    // Consumers outside the `.svelte` graph (non-`.svelte` module call sites or
+    // `preserve`) escape too, so a prop they pass is never mis-reported as
+    // never-passed (docs §4.2).
+    stampModuleEscapes(models, input.escaped);
     // Every textual call site counts (no cascade dead-span filtering): a prop passed
     // only at a folded-away site is still author-written, so we do not flag it.
     const usage = buildUsage(models, new Map());
@@ -666,7 +669,7 @@ function buildModelFromInput(file, edges, parseCache) {
             }
         }
     }
-    const reachableInputs = computeReachableInputs(instance, props, hasRestProp, propsPattern);
+    const reachableInputs = computeReachableInputs(instance, props, hasRestProp, propsPattern, usesLegacySlotInputs(ast));
     const childCalls = collectChildCalls(ast, imports);
     const { shadowedNames, debugNames, writtenNames } = collectTemplateBindings(ast, instance, propsDeclaration);
     const unreadDeclaredProps = computeUnreadDeclaredProps(ast, instance, props, propsPattern, shadowedNames, debugNames, writtenNames);
@@ -1832,7 +1835,15 @@ function parseModuleBody(code, id) {
  * `$props.id()` (a member call) is NOT a `$props()` call — the props object never
  * leaks through it — so it does not count and does not affect the result.
  */
-function computeReachableInputs(instance, props, hasRestProp, propsPattern) {
+function computeReachableInputs(instance, props, hasRestProp, propsPattern, usesSlotInputs) {
+    // A legacy `<slot>` (or a bare `$$slots` read) observes slotted content —
+    // inputs that arrive OUTSIDE `$props()` (in Svelte 5 terms, the synthetic
+    // `children` input and named-slot / `let:` inputs a call site supplies as body
+    // content).  The `$props()` shape cannot model them, so the reverse pass must
+    // treat every input as observable, or it would delete the slot-carrying body at
+    // each call site.  This holds whether or not an instance script exists.
+    if (usesSlotInputs)
+        return { kind: 'all' };
     // No instance script -> no `$props()` -> the component reads no input at all.
     if (!instance)
         return { kind: 'names', names: new Set() };
@@ -1853,6 +1864,32 @@ function computeReachableInputs(instance, props, hasRestProp, propsPattern) {
         return { kind: 'all' };
     return { kind: 'names', names: new Set(props.map((p) => p.name)) };
 }
+/** True when the component observes slotted content outside `$props()`: a legacy
+ * `<slot>` element, or a read of the `$$slots` identifier (legal in runes mode,
+ * unlike `$$props`/`$$restProps`).  Either signal means {@link
+ * computeReachableInputs} cannot model the inputs and must fall back to ALL.
+ * `$$slots` can appear in the instance script OR a template expression
+ * (`{#if $$slots.default}`), so both trees are scanned; its `$$` prefix cannot be
+ * a user binding, so no shadowing check is needed. */
+function usesLegacySlotInputs(ast) {
+    return (nodeSignalsSlotInputs(ast.fragment) || (!!ast.instance && nodeSignalsSlotInputs(ast.instance)));
+}
+function nodeSignalsSlotInputs(root) {
+    let found = false;
+    walk(root, null, {
+        SlotElement(_node, { stop }) {
+            found = true;
+            stop();
+        },
+        Identifier(node, { stop }) {
+            if (node.name === '$$slots') {
+                found = true;
+                stop();
+            }
+        },
+    });
+    return found;
+}
 /** True when a `$props()` ObjectPattern binds a prop whose external name is not a
  * plain identifier (a string-literal or computed key), so {@link declared_props}
  * did not capture it. */

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/engine.d.ts

@@ -53,7 +53,7 @@ export declare class DevShaker {
     /** Current slimmed output per `.svelte` id (the live shake result). */
     private output;
     constructor(files: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mode?: DevMode, parse?: Parse, escaped?: ComponentId[]);
-    /** Replace the external-escape set (docs §4.2).  The Shell calls this before
+    /** Replace the module-escape set (docs §4.2).  The Shell calls this before
      * {@link update} when a non-`.svelte` module changed the set of components
      * reached from `.ts`/`.js`, so the next shake bails them. */
     setEscaped(escaped: ComponentId[]): void;

package/dist/engine.js

@@ -38,7 +38,7 @@ export class DevShaker {
         this.parse = parse;
         this.escaped = escaped;
     }
-    /** Replace the external-escape set (docs §4.2).  The Shell calls this before
+    /** Replace the module-escape set (docs §4.2).  The Shell calls this before
      * {@link update} when a non-`.svelte` module changed the set of components
      * reached from `.ts`/`.js`, so the next shake bails them. */
     setEscaped(escaped) {

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

@@ -8,6 +8,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { parseSvelte, 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,27 +32,27 @@ 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`,
@@ -115,7 +116,7 @@ function moduleImportSpecifiers(code, id) {
  * A module that cannot be read or parsed is collected into `unscannable` (NOT
  * silently dropped): a call site inside it is invisible, so the caller must warn.
  */
-async function collectExternalEscapes(modules, resolve, readFile) {
+async function collectModuleEscapes(modules, resolve, readFile) {
     const escaped = new Set();
     const unscannable = new Set();
     for (const id of modules) {
@@ -181,7 +182,11 @@ export function matchPreserve(preserve, root, components) {
  * `svelte-shaker/node`).
  */
 export async function computeEscapedComponents(opts) {
-    const { escaped, unscannable } = await collectExternalEscapes(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/ir.d.ts

@@ -43,8 +43,9 @@ export interface AnalyzeInput {
      * this set (its FS scan cannot parse `.ts` call sites); the engine unions it
      * into the same whole-component escape bail auto-detected escapes use, so these
      * components are never folded and never reported as never-passed — while their
-     * OWN call sites still count toward their children.  Omitted/`[]` means "no
-     * external consumers", keeping the output byte-for-byte unchanged.
+     * OWN call sites still count toward their children.  Omitted/`[]` means every
+     * consumer is inside the crawled `.svelte` graph, keeping the output
+     * byte-for-byte unchanged.
      */
     escaped?: ComponentId[];
 }

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/unread.js

@@ -81,7 +81,8 @@ export function collectUnread(models, plans) {
     // (b): a prop is droppable when it survived every site's veto (and had the
     // structural gates).  A child with NO call sites keeps every `true` here — safe,
     // since the child does not read the prop, so its own render is unchanged whether
-    // it is declared or not (and external consumers, if any, bail the child).
+    // it is declared or not (and a consumer outside the `.svelte` graph, if any,
+    // bails the child).
     for (const [id, perProp] of dropEligible) {
         const set = new Set();
         for (const [name, ok] of perProp)

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.0",
+  "version": "0.15.0",
   "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"
   },