svelte-shaker 0.16.0 → 0.16.1

package/README.md

@@ -47,19 +47,21 @@ reachable value set of `variant` and removes the `.btn-danger` rule.
 npm i -D svelte-shaker   # requires svelte@^5
 ```
 
-Nothing else to install. The plugin picks its engine and parser automatically
-(see [Options](#options)): a small/medium app runs on the native **Rust (WASM)
-engine** and parses with **rsvelte** (loaded from `@rsvelte/compiler`, a bundled
-WASM dependency — no peer, no platform-specific binary); a large app runs on the
-**JS engine** with **svelte/compiler**. `engine` and `parser` let you pin either.
+Nothing else to install. The plugin picks its engine automatically (see
+[Options](#options)): if a **native (napi) Rust** binary loads it runs there —
+parsing with rsvelte in process, fastest, no size ceiling; otherwise a small/medium
+app runs on the **WASM Rust engine** (parsing with **rsvelte** from
+`@rsvelte/compiler`, a bundled WASM dependency — no peer, no platform-specific
+binary) and a large app on the **JS engine** with **svelte/compiler**. `engine` and
+`parser` let you pin the choice.
 
 ## Usage (Vite)
 
 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)). The engine and parser are chosen automatically per app size
-(Rust + rsvelte for small/medium, JS + svelte/compiler for large), and both fall
-back cleanly (see [Options](#options)).
+[Options](#options)). The engine is chosen automatically (native Rust if a binary
+loads, else WASM Rust for small/medium or JS for large), and every path falls back
+cleanly (see [Options](#options)).
 
 ```ts
 // vite.config.ts
@@ -104,10 +106,10 @@ shaker({
   // or { maxVariants: 16, minSavings: 0.05 } to tune
   verbose: false, // true = per-file size breakdown after the build
 
-  // Engine + parser are auto-selected by app size; set these only to pin.
-  engine: 'auto', // 'auto' (Rust/WASM if <=~300 components, else JS) | 'js' | 'rust'
-  parser: undefined, // default follows the engine (Rust->rsvelte, JS->svelte);
-  // set 'rsvelte' | 'svelte' to pin one
+  // Engine is auto-selected; set these only to pin.
+  engine: 'auto', // 'auto' (native Rust if it loads, else WASM if <=~300, else JS) | 'js' | 'rust'
+  parser: undefined, // JS/WASM parse only (native always uses in-process rsvelte);
+  // default follows the engine (WASM->rsvelte, JS->svelte); set 'rsvelte' | 'svelte' to pin
 
   dev: false, // default off: dev is a pass-through. 'incremental' (re-parse only
   // changed files) | 'coarse' (re-analyze everything) opts in; never monomorphizes
@@ -118,27 +120,33 @@ That list is exhaustive: any other key **fails the build**, naming the key and t
 options that do exist. A typo would otherwise be ignored — and a misspelled
 `preserve` ships the component you meant to protect, over-shaken.
 
-- **`engine`** — which engine runs the shake. **`'auto'`** (default) picks by app
-  size: a small/medium app (up to a few hundred components) uses the native
-  **Rust (WASM) engine**, loaded from
-  [`@rsvelte/compiler`](https://github.com/baseballyama/rsvelte) (a bundled WASM
-  dependency — nothing to install); a **large** app stays on the **JS engine**,
-  because the native engine's speed-up comes from a fast parse, but it must ship
-  the whole-program AST across the JS↔WASM boundary as JSON, and past a few
-  hundred components that round-trip (tens of MB) costs more than it saves.
-  `'rust'` forces the native engine (throwing if `@rsvelte/compiler` can't load);
-  `'js'` forces the JS engine. The two engines are differentially tested to shake
-  **byte-identically**, so this is **speed-only** — it never changes what ships.
-- **`parser`** — which parser feeds the engine. The default **follows the
-  engine**: **rsvelte** on the native engine (its AST crosses into Rust directly),
-  **svelte/compiler** on the JS engine (where rsvelte's parse is ~2× slower with
-  no downstream benefit). Set `'rsvelte'` or `'svelte'` to pin one regardless of
-  engine. The choice is **soundness-neutral** — the engine reads only UTF-16
-  `start`/`end`, so both parsers are differentially tested to produce
-  **byte-identical** output, never changing what renders. When rsvelte is the
-  resolved parser and `@rsvelte/compiler` can't load, the plugin **throws** rather
-  than silently swapping (so the same source can't shake differently on another
-  machine); `parser: 'svelte'` is the explicit opt-out.
+- **`engine`** — which engine runs the shake. There are two Rust engines (the same
+  analysis behind two frontends) plus the JS engine. The **native (napi)** engine
+  parses with rsvelte **in process** and keeps the ASTs Rust-side, so no
+  whole-program AST crosses a boundary — fastest, no size ceiling — but it ships as
+  a per-platform prebuilt binary that may not exist for every install. The **WASM**
+  engine is the same Rust engine, but the whole-program AST must cross the JS↔WASM
+  boundary as JSON (tens of MB past a few hundred components), so it only wins for
+  small/medium apps; the **JS** engine needs no boundary crossing, so it wins for a
+  large app when the native binary isn't available. **`'auto'`** (default) uses the
+  native engine if a binary loads (no size gate), else the WASM engine for a
+  small/medium app or the JS engine for a large one. **`'rust'`** forces a Rust
+  engine — native if it loads, else WASM (throwing if `@rsvelte/compiler` can't load
+  for the WASM fallback); **`'js'`** forces the JS engine. All three are
+  differentially tested to shake **byte-identically**, so this is **speed-only** — it
+  never changes what ships.
+- **`parser`** — how the **JS / WASM** engines parse `.svelte`. It does **not** apply
+  to the native engine, which always parses with rsvelte in process. The default
+  **follows the engine**: **rsvelte** on the WASM engine (its AST crosses into Rust
+  directly), **svelte/compiler** on the JS engine (where rsvelte's parse is ~2× slower
+  with no downstream benefit). The choice is **soundness-neutral** — the engine reads
+  only UTF-16 `start`/`end`, so both parsers are differentially tested to produce
+  **byte-identical** output, never changing what renders. `parser: 'svelte'` also
+  forces the native engine **off** (it can't honor svelte/compiler), so the shake uses
+  a JS/WASM engine with svelte/compiler. When rsvelte is the resolved JS-side parser
+  (`parser: 'rsvelte'`, or the WASM engine's default) and `@rsvelte/compiler` can't
+  load, the plugin **throws** rather than silently swapping (so the same source can't
+  shake differently on another machine); `parser: 'svelte'` is the explicit opt-out.
 - **`monomorphize`** — the one shaking knob, **on** by default. A measured
   net-win gate only specializes a component when that strictly shrinks the whole
   program, so monomorphization **never bloats**: whatever the knobs are set to,

package/dist/analyze.d.ts

@@ -237,14 +237,32 @@ export declare function planFixpoint(models: Map<ComponentId, FileModel>): Map<C
  * import is never crawled — its `<Comp/>` site cannot exist, so it cannot taint a
  * value set), keeping the produced model set — and thus the output — identical.
  */
-export declare function buildAnalyzeInput(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[]): Promise<AnalyzeInput>;
+/**
+ * The three per-file facts the crawl needs to resolve edges — import specifiers,
+ * rendered `<Local>` tag names, and `<ns.X>` member tag names. `null` when the file
+ * has no instance script (nothing to attribute), matching the crawl's skip.
+ */
+export interface CrawlFacts {
+    imports: ImportInfo[];
+    renderedTags: Set<string>;
+    memberTags: Set<string>;
+}
+/**
+ * Source of {@link CrawlFacts} for one `(id, code)`. The default is a JS parse +
+ * extraction ({@link jsCrawlFacts}); the native engine passes a provider backed by
+ * `ShakeSession` facts, so the crawl resolves the SAME edges without the JS parse.
+ */
+export type FactsProvider = (id: ComponentId, code: string) => CrawlFacts | null;
+/** The default facts provider: parse (svelte/compiler or rsvelte) and extract. */
+export declare function jsCrawlFacts(id: ComponentId, code: string, parseCache?: ParseCache, parse?: Parse): CrawlFacts | null;
+export declare function buildAnalyzeInput(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[], factsProvider?: FactsProvider): Promise<AnalyzeInput>;
 /**
  * Synchronous twin of {@link buildAnalyzeInput} for callers that cannot await
  * (an ESLint rule runs synchronously). Byte-for-byte the same crawl with sync
  * `resolve`/`readFile`; the `tests/build-analyze-input-sync` differential test
  * pins it identical to the async path, so keep the two bodies in lockstep.
  */
-export declare function buildAnalyzeInputSync(entries: ComponentId | ComponentId[], resolve: ResolveSync, readFile: ReadFileSync, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[]): AnalyzeInput;
+export declare function buildAnalyzeInputSync(entries: ComponentId | ComponentId[], resolve: ResolveSync, readFile: ReadFileSync, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[], factsProvider?: FactsProvider): AnalyzeInput;
 /**
  * Dead `{#if}` spans per component implied by `plans`, via the SAME shared
  * predicate the transform uses ({@link computeDeadSpans}).  A bailed component
@@ -299,6 +317,22 @@ export declare function findNeverPassedProps(input: AnalyzeInput): Map<Component
  * maps cleanly; an external name with no matching declared local is dropped.
  */
 export declare function remapToLocalNames<V>(map: Map<string, V>, model: FileModel): Map<string, V>;
+/**
+ * The bare component tag names this file RENDERS (`<Local/>`, excluding dotted
+ * `<ns.X/>` member tags). The Shell crawl uses this to resolve a barrel (a
+ * `.js`/`.ts` re-export, which costs a module read+parse) only for named imports
+ * actually rendered as a component — a value-only named import (a helper / type)
+ * is never a `<Local>` call site, so following it would read+parse a module for
+ * nothing. Skipping it only ever drops a non-call-site, so attribution (and the
+ * resulting models) are unchanged.
+ */
+export declare function renderedComponentTagNames(ast: Root): Set<string>;
+/**
+ * Every dotted component tag a file renders (`<ns.Child/>` -> `"ns.Child"`).  The
+ * Shell resolves each through its namespace import's barrel; bare `<Child/>` tags
+ * have no dot and are bound by the plain import maps instead.
+ */
+export declare function memberComponentTags(ast: Root): Set<string>;
 /**
  * Read one `<Child .../>` into a {@link CallSite}.  Attributes are in source
  * order, so we resolve last-write-wins (a later `a={…}` overrides an earlier
@@ -323,3 +357,11 @@ export declare function readCallSite(component: AnyNode, owner?: ComponentId): C
  * monomorphization specialization (mono.ts) must honor this identically.
  */
 export declare function isFoldBlockedName(model: FileModel, name: string): boolean;
+export interface ImportInfo {
+    value: string;
+    local: string;
+    /** `default` for a default import, the exported name for a named import, or
+     * `*` for a namespace import. */
+    imported: string;
+}
+export declare function importSources(instance: AnyNode): Generator<ImportInfo>;

package/dist/analyze.js

@@ -150,20 +150,23 @@ function buildModels(input, parseCache) {
     }
     return models;
 }
-/**
- * The Shell-side resolution + IO layer (docs/RUST-MIGRATION.md §2.1): BFS-crawl
- * the component graph from `entries`, resolving every import edge and reading
- * every reachable `.svelte` file up front, into a batched {@link AnalyzeInput}.
- *
- * This is the half that STAYS in JS — it owns `this.resolve` / file IO for Vite
- * ecosystem compat (docs ARCHITECTURE §5/§9) — so the engine ({@link
- * analyzeInput}) consumes its output with no callback across the boundary.  The
- * traversal mirrors the old crawl exactly: direct default-`.svelte` children and
- * the barrel children a file actually RENDERS are followed (an unrendered barrel
- * import is never crawled — its `<Comp/>` site cannot exist, so it cannot taint a
- * value set), keeping the produced model set — and thus the output — identical.
- */
-export async function buildAnalyzeInput(entries, resolve, readFile, parseCache, parse, escaped = []) {
+/** The default facts provider: parse (svelte/compiler or rsvelte) and extract. */
+export function jsCrawlFacts(id, code, parseCache, parse) {
+    const ast = parseCached(id, code, parseCache, parse);
+    const instance = ast.instance;
+    if (!instance)
+        return null;
+    return {
+        imports: [...importSources(instance)],
+        renderedTags: renderedComponentTagNames(ast),
+        memberTags: memberComponentTags(ast),
+    };
+}
+export async function buildAnalyzeInput(entries, resolve, readFile, parseCache, parse, escaped = [], 
+// The facts source. Defaults to a JS parse + extract; the native engine injects a
+// `ShakeSession`-backed provider (docs M3). Internal — the public crawl is unchanged.
+factsProvider) {
+    const getFacts = factsProvider ?? ((id, code) => jsCrawlFacts(id, code, parseCache, parse));
     const entryList = Array.isArray(entries) ? [...entries] : [entries];
     const files = [];
     const edges = [];
@@ -176,16 +179,15 @@ export async function buildAnalyzeInput(entries, resolve, readFile, parseCache,
         const id = queue.shift();
         const code = await readFile(id);
         files.push({ id, code });
-        const ast = parseCached(id, code, parseCache, parse);
-        const instance = ast.instance;
-        if (!instance)
+        const facts = getFacts(id, code);
+        if (!facts)
             continue;
         // The bare component tags this file renders (`<Local …>`). Resolving a barrel
         // (a `.js`/`.ts` re-export) means READING and PARSING the target module to
         // chase the export, so we do it ONLY for named imports actually rendered as a
         // component here — a named import used as a value (a helper / type) can never
         // be a `<Local>` call site, so chasing it is pure waste.
-        const renderedTags = renderedComponentTagNames(ast);
+        const renderedTags = facts.renderedTags;
         // Resolve this file's imports into the three attributable edge kinds.  Direct
         // default `.svelte` and simple barrel/named imports bind a bare local; a
         // namespace import (`import * as ns`) binds no single component, so it is
@@ -193,7 +195,7 @@ export async function buildAnalyzeInput(entries, resolve, readFile, parseCache,
         const barrelLocals = new Map();
         const namespaceSources = new Map();
         const directChildren = [];
-        for (const imp of importSources(instance)) {
+        for (const imp of facts.imports) {
             if (imp.imported === '*') {
                 namespaceSources.set(imp.local, imp.value);
                 continue;
@@ -223,7 +225,7 @@ export async function buildAnalyzeInput(entries, resolve, readFile, parseCache,
         // renders, so the engine attributes `<ns.X .../>` by name lookup.
         const nsChildren = [];
         if (namespaceSources.size > 0) {
-            for (const tag of memberComponentTags(ast)) {
+            for (const tag of facts.memberTags) {
                 const dot = tag.indexOf('.');
                 const source = namespaceSources.get(tag.slice(0, dot));
                 if (source == null)
@@ -253,7 +255,8 @@ export async function buildAnalyzeInput(entries, resolve, readFile, parseCache,
  * `resolve`/`readFile`; the `tests/build-analyze-input-sync` differential test
  * pins it identical to the async path, so keep the two bodies in lockstep.
  */
-export function buildAnalyzeInputSync(entries, resolve, readFile, parseCache, parse, escaped = []) {
+export function buildAnalyzeInputSync(entries, resolve, readFile, parseCache, parse, escaped = [], factsProvider) {
+    const getFacts = factsProvider ?? ((id, code) => jsCrawlFacts(id, code, parseCache, parse));
     const entryList = Array.isArray(entries) ? [...entries] : [entries];
     const files = [];
     const edges = [];
@@ -264,18 +267,17 @@ export function buildAnalyzeInputSync(entries, resolve, readFile, parseCache, pa
         const id = queue.shift();
         const code = readFile(id);
         files.push({ id, code });
-        const ast = parseCached(id, code, parseCache, parse);
-        const instance = ast.instance;
-        if (!instance)
+        const facts = getFacts(id, code);
+        if (!facts)
             continue;
         // See {@link buildAnalyzeInput}: resolve a barrel only for named imports
         // actually rendered as a `<Local>` component here, to avoid reading+parsing
         // modules behind value-only named imports.
-        const renderedTags = renderedComponentTagNames(ast);
+        const renderedTags = facts.renderedTags;
         const barrelLocals = new Map();
         const namespaceSources = new Map();
         const directChildren = [];
-        for (const imp of importSources(instance)) {
+        for (const imp of facts.imports) {
             if (imp.imported === '*') {
                 namespaceSources.set(imp.local, imp.value);
                 continue;
@@ -298,7 +300,7 @@ export function buildAnalyzeInputSync(entries, resolve, readFile, parseCache, pa
         }
         const nsChildren = [];
         if (namespaceSources.size > 0) {
-            for (const tag of memberComponentTags(ast)) {
+            for (const tag of facts.memberTags) {
                 const dot = tag.indexOf('.');
                 const source = namespaceSources.get(tag.slice(0, dot));
                 if (source == null)
@@ -1269,7 +1271,7 @@ function collectChildCalls(ast, imports) {
  * nothing. Skipping it only ever drops a non-call-site, so attribution (and the
  * resulting models) are unchanged.
  */
-function renderedComponentTagNames(ast) {
+export function renderedComponentTagNames(ast) {
     const names = new Set();
     walk(ast.fragment, null, {
         Component(node, { next }) {
@@ -1286,7 +1288,7 @@ function renderedComponentTagNames(ast) {
  * Shell resolves each through its namespace import's barrel; bare `<Child/>` tags
  * have no dot and are bound by the plain import maps instead.
  */
-function memberComponentTags(ast) {
+export function memberComponentTags(ast) {
     const tags = new Set();
     walk(ast.fragment, null, {
         Component(node, { next }) {
@@ -1650,7 +1652,7 @@ function literalDefault(expr) {
         return { known: true, value: undefined };
     return { known: false };
 }
-function* importSources(instance) {
+export function* importSources(instance) {
     const program = instance.content;
     for (const stmt of program?.body ?? []) {
         if (stmt.type !== 'ImportDeclaration')

package/dist/native-engine.d.ts

@@ -0,0 +1,47 @@
+import { type ReadFile, type Resolve } from './analyze.js';
+import { type MonomorphizeOptions } from './mono.js';
+import type { ComponentId } from './ir.js';
+/** The long-lived native session: parse + retain ASTs, then shake to edits. */
+interface ShakeSession {
+    parse: (inputJson: string) => string;
+    parseMore: (inputJson: string) => string;
+    shake: (configJson: string, ownSize: (payload: string) => number | null) => string;
+}
+/** The subset of the napi addon the plugin uses. */
+interface NativeEngine {
+    ShakeSession: new () => ShakeSession;
+}
+/**
+ * Load the native Rust (napi) engine, or `null` if it can't be loaded (then the caller
+ * falls back to the WASM / JS engine). Two locations are tried in order:
+ *  - the published `svelte-shaker-engine-scan-native` package (an
+ *    `optionalDependency` — installed only when a prebuilt binary exists for this
+ *    platform); this is the layout an npm consumer gets.
+ *  - `../engine-scan-native/index.cjs` — the in-repo package, used from source in
+ *    this package's own tests / dev (where the npm package isn't a dependency).
+ * Either loader resolves the platform `.node`; a missing binary throws (swallowed).
+ * A resolved-but-API-incompatible module (an older publish) is rejected so a version
+ * skew degrades to a fallback engine, never a crash.
+ */
+export declare function tryLoadNativeEngine(): NativeEngine | null;
+/** The output of a native monomorphization shake: the wired owner files + the variant
+ * residuals keyed by their request specifier (what the Shell's `load` hook serves). */
+export interface NativeMonoResult {
+    files: Record<ComponentId, string>;
+    variants: Map<string, string>;
+}
+/**
+ * Whole-program shake via the native Rust engine — the counterpart of
+ * {@link svelteShakerWithMono} / {@link svelteShakerWasmWithMono}, handling
+ * monomorphization too (mono off → an empty variant set).
+ *
+ * The seed components are parsed ONCE by the session (a batched, parallel rsvelte
+ * parse); the crawl then resolves edges reading those facts instead of re-parsing in
+ * JS, parsing any file discovered outside the seed on demand (`parseMore`). The
+ * session retains every AST, so the shake needs no AST at the boundary — only the
+ * resolved graph and the `ownSize` callback cross. A final svelte/compiler revert
+ * cascade (the AUTHORITY) force-bails any residual unparseable output; the session's
+ * own inner rsvelte cascade means valid programs settle in one outer pass.
+ */
+export declare function svelteShakerNativeWithMono(engine: NativeEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono: MonomorphizeOptions, escaped?: ComponentId[]): Promise<NativeMonoResult>;
+export {};

package/dist/native-engine.js

@@ -0,0 +1,145 @@
+import { createRequire } from 'node:module';
+import { compile } from 'svelte/compiler';
+import { buildAnalyzeInput, } from './analyze.js';
+import {} from './mono.js';
+import { revertCascade } from './revert-cascade.js';
+// NODE-ONLY: loads the native Rust (napi) engine and drives it from the Vite plugin.
+// Imported only by `vite.ts` (a Node entry), never by the environment-free engine, so
+// the browser playground build stays clean. Unlike the WASM engine, this parses with
+// rsvelte IN PROCESS and keeps the ASTs Rust-side (a `ShakeSession`), so no
+// whole-program AST ever crosses the JS boundary — the crawl reads per-file FACTS from
+// the session instead of re-parsing in JS (docs/RUST-MIGRATION.md M3).
+const require = createRequire(import.meta.url);
+/** Whether a loaded module exposes the `ShakeSession` API this engine drives —
+ * `parse` + `parseMore` + `shake` on the prototype. Guards against an OLDER published
+ * `svelte-shaker-engine-scan-native` (e.g. one predating `parseMore`) being resolved:
+ * an API-incompatible binary is rejected so the caller falls back to WASM/JS rather
+ * than crashing on a missing method. */
+function hasSessionApi(mod) {
+    const ctor = mod.ShakeSession;
+    const proto = ctor?.prototype;
+    return (typeof ctor === 'function' &&
+        typeof proto?.parse === 'function' &&
+        typeof proto?.parseMore === 'function' &&
+        typeof proto?.shake === 'function');
+}
+/**
+ * Load the native Rust (napi) engine, or `null` if it can't be loaded (then the caller
+ * falls back to the WASM / JS engine). Two locations are tried in order:
+ *  - the published `svelte-shaker-engine-scan-native` package (an
+ *    `optionalDependency` — installed only when a prebuilt binary exists for this
+ *    platform); this is the layout an npm consumer gets.
+ *  - `../engine-scan-native/index.cjs` — the in-repo package, used from source in
+ *    this package's own tests / dev (where the npm package isn't a dependency).
+ * Either loader resolves the platform `.node`; a missing binary throws (swallowed).
+ * A resolved-but-API-incompatible module (an older publish) is rejected so a version
+ * skew degrades to a fallback engine, never a crash.
+ */
+export function tryLoadNativeEngine() {
+    for (const spec of ['svelte-shaker-engine-scan-native', '../engine-scan-native/index.cjs']) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = require(spec);
+            if (hasSessionApi(mod))
+                return { ShakeSession: mod.ShakeSession };
+        }
+        catch {
+            // Not resolvable here — try the next location.
+        }
+    }
+    return null;
+}
+/** The compiled-byte size proxy the monomorphization net-win gate uses — the same call
+ * `mono.ts` / the WASM engine make, so the Rust gate decides byte-for-byte alike. */
+function ownSize(id, source) {
+    try {
+        return compile(source, { generate: 'client', dev: false, filename: id }).js.code.length;
+    }
+    catch {
+        return null;
+    }
+}
+/** `ShakeSession.shake`'s single-arg `ownSize` form: `[id, source]` JSON in (a napi
+ * multi-arg marshaling bug makes the single-arg payload the reliable shape). */
+function ownSizePayload(payload) {
+    const [id, source] = JSON.parse(payload);
+    return ownSize(id, source);
+}
+/**
+ * One native facts record → the crawl's {@link CrawlFacts}. An unparseable file is
+ * treated as contributing nothing (its retained AST is Null, so the shake skips it —
+ * sound under-shake), matching the session's own parse-error handling; a file with no
+ * instance script simply has empty imports, so it resolves no edges either way.
+ */
+function toCrawlFacts(f) {
+    if (f.parseError)
+        return null;
+    return {
+        imports: f.imports.map((i) => ({ value: i.source, local: i.local, imported: i.imported })),
+        renderedTags: new Set(f.renderedTags),
+        memberTags: new Set(f.memberTags),
+    };
+}
+/**
+ * Whole-program shake via the native Rust engine — the counterpart of
+ * {@link svelteShakerWithMono} / {@link svelteShakerWasmWithMono}, handling
+ * monomorphization too (mono off → an empty variant set).
+ *
+ * The seed components are parsed ONCE by the session (a batched, parallel rsvelte
+ * parse); the crawl then resolves edges reading those facts instead of re-parsing in
+ * JS, parsing any file discovered outside the seed on demand (`parseMore`). The
+ * session retains every AST, so the shake needs no AST at the boundary — only the
+ * resolved graph and the `ownSize` callback cross. A final svelte/compiler revert
+ * cascade (the AUTHORITY) force-bails any residual unparseable output; the session's
+ * own inner rsvelte cascade means valid programs settle in one outer pass.
+ */
+export async function svelteShakerNativeWithMono(engine, entries, resolve, readFile, mono, escaped = []) {
+    const seedIds = Array.isArray(entries) ? entries : [entries];
+    // Batch-read + batch-parse the seed. Cache the source so the crawl's `readFile`
+    // does not read the seed a second time.
+    const codeCache = new Map();
+    const seedFiles = await Promise.all(seedIds.map(async (id) => {
+        const code = await readFile(id);
+        codeCache.set(id, code);
+        return { id, code };
+    }));
+    const session = new engine.ShakeSession();
+    const seedFacts = JSON.parse(session.parse(JSON.stringify({ files: seedFiles })));
+    const factsById = new Map();
+    for (const f of seedFacts.files)
+        factsById.set(f.id, toCrawlFacts(f));
+    const cachedRead = async (id) => {
+        const hit = codeCache.get(id);
+        if (hit !== undefined)
+            return hit;
+        const code = await readFile(id);
+        codeCache.set(id, code);
+        return code;
+    };
+    // Facts source for the crawl: a seed hit, or parse the newly discovered file into the
+    // session now (retaining its AST for the shake) and cache its facts.
+    const provider = (id, code) => {
+        if (factsById.has(id))
+            return factsById.get(id);
+        const res = JSON.parse(session.parseMore(JSON.stringify({ files: [{ id, code }] })));
+        const facts = res.files.length > 0 ? toCrawlFacts(res.files[0]) : null;
+        factsById.set(id, facts);
+        return facts;
+    };
+    const input = await buildAnalyzeInput(entries, resolve, cachedRead, undefined, undefined, escaped, provider);
+    const config = {
+        edges: input.edges,
+        entries: input.entries,
+        escaped: input.escaped ?? [],
+        mono,
+    };
+    let last;
+    const files = revertCascade(input.files, (forceBail) => {
+        last = JSON.parse(session.shake(JSON.stringify({ ...config, forceBail: [...forceBail] }), ownSizePayload));
+        return last.files;
+    });
+    // The engine already keys each variant by its `?shaker_variant=` request specifier
+    // (mono.rs `variant_specifier`), the same key the `load` hook serves — so pass it
+    // through, exactly as the WASM engine does.
+    return { files, variants: new Map(Object.entries(last.variants)) };
+}

package/dist/vite.d.ts

@@ -118,18 +118,24 @@ export interface ShakerOptions {
     monomorphize?: boolean | Partial<Omit<MonomorphizeOptions, 'enabled'>>;
     /**
      * Which engine runs the whole shake (analysis + transform, including
-     * monomorphization).  Default `'auto'`.  The native Rust (WASM) engine
-     * implements every pass — for monomorphization it calls back into JS only for
-     * the per-module compiled-size proxy the net-win gate needs — so it is the
-     * default fast path:
-     *  - `'auto'` — use the native Rust engine for small/medium apps; a large app
-     *    (more than a few hundred components) stays on the JS engine, because the
-     *    whole-program AST that must cross the JS<->WASM boundary as JSON grows to
-     *    tens of MB and the round-trip then costs more than the faster parse saves.
-     *    Also falls back to JS if the WASM module can't be loaded.
-     *  - `'rust'` — force the Rust engine; throws if the WASM module can't be loaded.
+     * monomorphization).  Default `'auto'`.  There are two Rust engines — the same
+     * analysis behind two frontends — plus the JS engine:
+     *  - the NATIVE (napi) engine parses with rsvelte IN PROCESS and keeps the ASTs
+     *    Rust-side, so no whole-program AST crosses a boundary. It is the fastest and
+     *    has no size ceiling, but ships as a per-platform prebuilt binary that may not
+     *    exist for every install;
+     *  - the WASM engine is the same Rust engine, but the whole-program AST must cross
+     *    the JS<->WASM boundary as JSON — tens of MB past a few hundred components — so
+     *    it only wins for small/medium apps;
+     *  - the JS engine needs no boundary crossing at all, so it wins for a large app
+     *    when the native engine isn't available.
+     *
+     *  - `'auto'` — the native engine if a binary loads (no size gate); otherwise the
+     *    WASM engine for a small/medium app, or the JS engine for a large one.
+     *  - `'rust'` — force a Rust engine: native if it loads, else WASM; throws if
+     *    neither can be loaded.
      *  - `'js'` — force the JS engine.
-     * Both engines are differentially tested to produce byte-identical output, so the
+     * All three are differentially tested to produce byte-identical output, so the
      * choice only affects speed, never what is shaken.
      */
     engine?: 'auto' | 'js' | 'rust';
@@ -146,20 +152,23 @@ export interface ShakerOptions {
      */
     dev?: false | DevMode;
     /**
-     * Which parser feeds the engine.  Defaults to FOLLOW THE ENGINE: `'rsvelte'` on
-     * the native (Rust) engine — its AST crosses the WASM boundary directly — and
-     * `'svelte'` (svelte/compiler) on the JS engine, where rsvelte's parse is pure
-     * overhead (~2x slower) with no downstream benefit.  Set this to pin one parser
-     * regardless of engine.  rsvelte loads from `@rsvelte/compiler` (a bundled WASM
-     * dependency — nothing extra to install, no platform-specific binary).
+     * How the JS / WASM engines parse `.svelte`.  Does NOT apply to the native engine,
+     * which always parses with rsvelte IN PROCESS (there is no JS-side parse to pick).
+     * Defaults to FOLLOW THE ENGINE: `'rsvelte'` on the WASM engine — its AST crosses
+     * the boundary directly — and `'svelte'` (svelte/compiler) on the JS engine, where
+     * rsvelte's parse is pure overhead (~2x slower) with no downstream benefit.  The
+     * JS-side rsvelte parser loads from `@rsvelte/compiler` (a bundled WASM dependency —
+     * nothing extra to install, no platform-specific binary).
      *
-     * The engine reads only UTF-16 `start`/`end`, never `loc`, so the choice can
-     * never affect what renders — it is soundness-neutral, differentially tested to
-     * produce byte-identical output either way.  When rsvelte IS the resolved parser
-     * (the native engine, or an explicit `parser: 'rsvelte'`) and `@rsvelte/compiler`
-     * can't be loaded, the plugin THROWS rather than silently swapping to
-     * svelte/compiler, so the same source can't shake differently on another machine:
-     * set `parser: 'svelte'` to opt out.
+     * The engine reads only UTF-16 `start`/`end`, never `loc`, so the choice can never
+     * affect what renders — it is soundness-neutral, differentially tested to produce
+     * byte-identical output either way.  `parser: 'svelte'` also forces the native
+     * engine OFF (it cannot honor svelte/compiler), so the shake uses a JS/WASM engine
+     * that parses with svelte/compiler.  When rsvelte IS the resolved JS-side parser (an
+     * explicit `parser: 'rsvelte'`, or the WASM engine's default) and `@rsvelte/compiler`
+     * can't be loaded, the plugin THROWS rather than silently swapping to svelte/compiler,
+     * so the same source can't shake differently on another machine: set
+     * `parser: 'svelte'` to opt out.
      */
     parser?: 'svelte' | 'rsvelte';
     /**

package/dist/vite.js

@@ -12,6 +12,7 @@ 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';
+import { svelteShakerNativeWithMono, tryLoadNativeEngine } from './native-engine.js';
 /** kB with two decimals, the unit Vite itself uses in its build size report. */
 function formatKB(bytes) {
     return `${(bytes / 1024).toFixed(2)} kB`;
@@ -479,23 +480,49 @@ export function shaker(options = {}) {
             // is the default: `'auto'` uses it whenever it can be loaded and falls back
             // to JS otherwise, `'rust'` forces it (throwing if it can't load), `'js'`
             // forces the JS engine.  Both engines produce byte-identical output.
+            // Decide the engine. The native (napi) Rust engine parses with rsvelte IN
+            // PROCESS and keeps the ASTs Rust-side, so no whole-program AST crosses a
+            // boundary — it is the fastest and has no size ceiling. The WASM engine is the
+            // SAME Rust engine but marshals the whole-program AST across the JS<->WASM
+            // boundary as JSON (tens of MB past a few hundred components), so `auto` only
+            // uses it below the size gate; past it the boundary-free JS engine wins.
+            //   `'rust'` — native if it loads, else WASM (throws if neither can load).
+            //   `'auto'` — native if it loads; else WASM below the gate; else JS.
+            //   `'js'`   — the JS engine.
+            // All three are differentially tested to emit byte-identical output.
             const engineChoice = options.engine ?? 'auto';
+            // `parser: 'svelte'` asks for svelte/compiler, which the native engine (always
+            // in-process rsvelte) cannot honor — so it forces the native engine off, and the
+            // shake falls back to a WASM/JS engine that parses with the requested parser.
+            const nativeAllowed = options.parser !== 'svelte';
+            let native = null;
             let wasm = null;
             if (engineChoice === 'rust') {
-                wasm = tryLoadWasmEngine();
-                if (!wasm)
-                    throw new Error('[vite-plugin-svelte-shaker] engine: "rust" was requested but the WASM engine ' +
-                        'could not be loaded. Remove the option (or use engine: "js") to use the JS engine.');
+                native = nativeAllowed ? tryLoadNativeEngine() : null;
+                if (!native) {
+                    wasm = tryLoadWasmEngine();
+                    if (!wasm)
+                        throw new Error('[vite-plugin-svelte-shaker] engine: "rust" was requested but neither the native ' +
+                            'nor the WASM Rust engine could be loaded. Remove the option (or use engine: "js") ' +
+                            'to use the JS engine.');
+                }
+            }
+            else if (engineChoice === 'auto') {
+                native = nativeAllowed ? tryLoadNativeEngine() : null;
+                if (!native && entryComponents.length <= RUST_ENGINE_MAX_COMPONENTS) {
+                    wasm = tryLoadWasmEngine();
+                }
             }
-            else if (engineChoice === 'auto' && entryComponents.length <= RUST_ENGINE_MAX_COMPONENTS) {
-                // The native engine parses fast, but the whole-program AST must cross the
-                // JS<->WASM boundary as JSON, and past a few hundred components that AST is
-                // tens of MB (this app: ~600 components -> ~60 MB) — the round-trip then
-                // costs more than the faster parse saves, so `auto` keeps a large app on the
-                // boundary-free JS engine.  Speed-only: both engines emit byte-identical
-                // output, so a borderline misjudgment only affects build time, never what
-                // ships.  `engine: 'rust'` overrides this to force the native engine.
-                wasm = tryLoadWasmEngine();
+            if (native) {
+                // Native Rust engine (napi): parses with rsvelte in process, shakes over the
+                // retained ASTs, and returns only the edits — byte-identical to the JS engine,
+                // monomorphization included (mono off -> an empty variant set). The `parser`
+                // option does not apply here (the session always parses in-process rsvelte).
+                const result = await svelteShakerNativeWithMono(native, entryComponents, resolve, read, mono, escaped);
+                shaken = result.files;
+                variantSources = result.variants;
+                reportSizes(shaken, read, root, options.verbose === true, log);
+                return;
             }
             if (wasm) {
                 // Native Rust engine — byte-identical to the JS engine, including

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",
@@ -63,6 +63,9 @@
   "peerDependencies": {
     "svelte": "^5.56.6"
   },
+  "optionalDependencies": {
+    "svelte-shaker-engine-scan-native": "~0.2.0"
+  },
   "engines": {
     "node": ">=22.23.1"
   },