svelte-shaker 0.14.1 → 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/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

@@ -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`,
@@ -181,7 +182,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/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.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"
   },