svelte-shaker 0.16.0 → 0.17.0

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

@@ -1,6 +1,6 @@
 import { type ReadFile, type Resolve } from './analyze.js';
 import { type Parse } from './parse.js';
-import { type MonomorphizeOptions, type MonomorphizeResult } from './mono.js';
+import { type MonomorphizeOptions, type MonomorphizeResult, type OwnSize } from './mono.js';
 import type { ComponentId } from './ir.js';
 export type { ComponentId, AnalyzeInput, InputFile, ResolvedEdge, EdgeKind, EditResult, } from './ir.js';
 export type { Resolve, ReadFile, ResolveSync, ReadFileSync } from './analyze.js';
@@ -9,7 +9,7 @@ export { analyze, analyzeInput, buildAnalyzeInput, buildAnalyzeInputSync, deadSp
 export type { UnpassedProp } from './analyze.js';
 export { DevShaker, type DevMode, type DevShakerChange } from './engine.js';
 export { transformAll, transformAllWithMono } from './transform.js';
-export { monomorphize, DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type MonomorphizeResult, type Variant, type CallSiteBinding, } from './mono.js';
+export { monomorphize, DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type MonomorphizeResult, type OwnSize, type Variant, type CallSiteBinding, } from './mono.js';
 /**
  * Whole-program shake: crawl the component graph from `entry`, decide what to
  * fold, and return the shaken source for every reachable `.svelte` file.
@@ -45,4 +45,4 @@ export type VariantSpecifier = (variantId: string) => string;
  * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
  * superset of the default behavior, so existing consumers are unaffected.
  */
-export declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[]): Promise<ShakeResult>;
+export declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[], ownSize?: OwnSize): Promise<ShakeResult>;

package/dist/index.js

@@ -46,7 +46,7 @@ async function analyzeWith(entries, resolve, readFile, parse, escaped = []) {
  * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
  * superset of the default behavior, so existing consumers are unaffected.
  */
-export async function svelteShakerWithMono(entries, resolve, readFile, mono = DEFAULT_MONO_OPTIONS, variantSpecifier = (id) => id, parse, escaped = []) {
+export async function svelteShakerWithMono(entries, resolve, readFile, mono = DEFAULT_MONO_OPTIONS, variantSpecifier = (id) => id, parse, escaped = [], ownSize) {
     const { models, plans } = await analyzeWith(entries, resolve, readFile, parse, escaped);
     // The cascade may re-run the transform with force-bailed plans, so recompute
     // monomorphization inside it: a bailed component must not be specialized either.
@@ -58,7 +58,7 @@ export async function svelteShakerWithMono(entries, resolve, readFile, mono = DE
     const files = shakeWithRevertCascade(models, plans, (p) => {
         // Thread the shake entries through so the net-win gate can compute module
         // reachability from them (docs §3 monomorphization, §13.2).
-        lastResult = monomorphize(models, p, mono, entries);
+        lastResult = monomorphize(models, p, mono, entries, ownSize);
         // With no bindings the wired pass and the base pass are identical, so reuse
         // the plain transform to keep the default path byte-for-byte unchanged.
         return lastResult.bindings.length === 0

package/dist/mono.d.ts

@@ -1,6 +1,19 @@
 import { type FileModel } from './analyze.js';
 import { type AnyNode } from './parse.js';
 import { type ComponentId, type ComponentPlan, type Literal } from './ir.js';
+/**
+ * The monomorphization net-win gate's per-module compiled-byte size proxy (docs §3):
+ * `(id, source) -> byte count | null`, where `null` means the module can't be sized
+ * (a compile error) and the gate declines the child rather than bloat.
+ *
+ * INJECTED by the Shell so the environment-free engine holds no compiler: the Vite
+ * plugin passes an rsvelte-backed sizer (`@rsvelte/compiler`'s `compile_client`),
+ * and the native engine computes the SAME proxy in-process (`session::own_size`), so
+ * all three engines' gates decide byte-for-byte alike (parity is test-gated). The
+ * default (`() => null`) sizes nothing, so an environment without a sizer simply
+ * specializes nothing — sound, just unoptimized.
+ */
+export type OwnSize = (id: ComponentId, source: string) => number | null;
 /** Tuning knobs for monomorphization (docs §8.1, §13.2).  All have sound defaults. */
 export interface MonomorphizeOptions {
     /** Master switch.  Default OFF — every existing behavior is unchanged. */
@@ -79,4 +92,4 @@ export interface MonomorphizeResult {
  * inputs and never touches the base transform, so with monomorphization off (or when no child
  * passes the gate) the default whole-program output is byte-for-byte unchanged.
  */
-export declare function monomorphize(models: Map<ComponentId, FileModel>, plans: Map<ComponentId, ComponentPlan>, options?: MonomorphizeOptions, entries?: ComponentId | ComponentId[]): MonomorphizeResult;
+export declare function monomorphize(models: Map<ComponentId, FileModel>, plans: Map<ComponentId, ComponentPlan>, options?: MonomorphizeOptions, entries?: ComponentId | ComponentId[], measureSize?: OwnSize): MonomorphizeResult;

package/dist/mono.js

@@ -55,7 +55,6 @@
 //      — a strict, measured net reduction.  When in doubt we keep the base.
 // ----------------------------------------------------------------------
 import MagicString from 'magic-string';
-import { compile } from 'svelte/compiler';
 import { inSpans } from './dead.js';
 import { shakeBody } from './transform.js';
 import { readCallSite, deadSpansForPlans, isFoldBlockedName, } from './analyze.js';
@@ -79,7 +78,7 @@ export const DEFAULT_MONO_OPTIONS = {
  * inputs and never touches the base transform, so with monomorphization off (or when no child
  * passes the gate) the default whole-program output is byte-for-byte unchanged.
  */
-export function monomorphize(models, plans, options = DEFAULT_MONO_OPTIONS, entries = []) {
+export function monomorphize(models, plans, options = DEFAULT_MONO_OPTIONS, entries = [], measureSize = () => null) {
     const variants = new Map();
     const bindings = [];
     if (!options.enabled)
@@ -163,23 +162,17 @@ export function monomorphize(models, plans, options = DEFAULT_MONO_OPTIONS, entr
             incoming.add(c);
     const entryList = (Array.isArray(entries) ? entries : [entries]).filter((e) => models.has(e));
     const roots = entryList.filter((e) => !incoming.has(e));
+    // Memoize the injected size proxy by source string (measuring is the hot cost).
+    // `measureSize` is the rsvelte compiled-byte proxy the Shell injects (docs §3);
+    // its default (`() => null`) makes every module un-sizable, so the gate below
+    // declines every child — an environment with no sizer specializes nothing, which
+    // is sound (never bloat), just unoptimized.
     const sizeCache = new Map();
     const ownSize = (id, source) => {
         const cached = sizeCache.get(source);
         if (cached !== undefined)
             return cached;
-        let size;
-        try {
-            const { js } = compile(source, {
-                generate: 'client',
-                dev: false,
-                filename: id,
-            });
-            size = js.code.length;
-        }
-        catch {
-            size = null; // un-sizable -> caller skips the child
-        }
+        const size = measureSize(id, source);
         if (size !== null)
             sizeCache.set(source, size);
         return size;

package/dist/native-engine.d.ts

@@ -0,0 +1,59 @@
+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. The
+ * shake needs no size callback — the monomorphization net-win gate's compiled-byte
+ * proxy is computed in-process by rsvelte (`session::own_size`), so the native path
+ * never calls back into a JS compiler. */
+interface ShakeSession {
+    parse: (inputJson: string) => string;
+    parseMore: (inputJson: string) => string;
+    shake: (configJson: string) => string;
+}
+/** The subset of the napi addon the plugin uses. */
+interface NativeEngine {
+    ShakeSession: new () => ShakeSession;
+    engineApiVersion: () => number;
+}
+/** Whether a loaded module is a native addon this engine can drive: the right ABI
+ * generation AND the `ShakeSession` shape (`parse` + `parseMore` + `shake`). An OLDER
+ * published `svelte-shaker-engine-scan-native` — one with no `engineApiVersion`, a
+ * different generation, or predating `parseMore` — is REJECTED so the caller degrades
+ * to WASM/JS instead of mis-calling an incompatible binary and crashing the build. */
+export declare function hasSessionApi(mod: Partial<NativeEngine>): mod is NativeEngine;
+/**
+ * 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 crosses, and the monomorphization size proxy is computed in-process
+ * by rsvelte (`session::own_size`), so nothing calls back into a JS compiler. 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,141 @@
+import { createRequire } from 'node:module';
+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);
+/** The addon ABI generation this driver speaks (native `engine_api_version`). Bump
+ * in lockstep with a breaking change to the exported methods. The 0.2.x addon's
+ * `shake` took a JS `ownSize` callback; 0.3.x computes the size proxy in Rust and
+ * `shake` takes ONE argument — calling a 0.2.x binary the 0.3.x way throws a napi
+ * TypeError that crashes `vite build`, so a version mismatch MUST be rejected here. */
+const EXPECTED_ENGINE_API_VERSION = 3;
+/** Whether a loaded module is a native addon this engine can drive: the right ABI
+ * generation AND the `ShakeSession` shape (`parse` + `parseMore` + `shake`). An OLDER
+ * published `svelte-shaker-engine-scan-native` — one with no `engineApiVersion`, a
+ * different generation, or predating `parseMore` — is REJECTED so the caller degrades
+ * to WASM/JS instead of mis-calling an incompatible binary and crashing the build. */
+export function hasSessionApi(mod) {
+    const versionFn = mod.engineApiVersion;
+    // The 0.2.x addon has no `engineApiVersion` export, so this rejects it — the exact
+    // skew that would otherwise throw on the new one-argument `shake` call.
+    if (typeof versionFn !== 'function' || versionFn() !== EXPECTED_ENGINE_API_VERSION)
+        return false;
+    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, engineApiVersion: mod.engineApiVersion };
+        }
+        catch {
+            // Not resolvable here — try the next location.
+        }
+    }
+    return null;
+}
+/**
+ * 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 crosses, and the monomorphization size proxy is computed in-process
+ * by rsvelte (`session::own_size`), so nothing calls back into a JS compiler. 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] })));
+        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/rsvelte-parse.d.ts

@@ -1,4 +1,5 @@
 import type { Parse } from './parse.js';
+import type { OwnSize } from './mono.js';
 /**
  * Build a {@link Parse} backed by rsvelte's parser (`@rsvelte/compiler`, a
  * bundled WASM dependency), or `null` if that module can't be loaded/initialized
@@ -13,3 +14,12 @@ import type { Parse } from './parse.js';
  * a load/init failure returns `null`.
  */
 export declare function tryLoadRsvelteParser(): Parse | null;
+/**
+ * Build the rsvelte-backed {@link OwnSize} for the JS/WASM engines, or `null` if
+ * `@rsvelte/compiler` can't be loaded/initialized. The native engine computes the
+ * SAME proxy in-process (`session::own_size` over the pinned rsvelte crate), so all
+ * three engines' monomorphization gates decide byte-for-byte alike (parity is
+ * test-gated). `name` is passed as the component id — its exact string is immaterial
+ * to the SIZE as long as every engine passes the same one, which they do.
+ */
+export declare function tryLoadRsvelteOwnSize(): OwnSize | null;

package/dist/rsvelte-parse.js

@@ -56,3 +56,24 @@ export function tryLoadRsvelteParser() {
         return JSON.parse(result.ast);
     };
 }
+/**
+ * Build the rsvelte-backed {@link OwnSize} for the JS/WASM engines, or `null` if
+ * `@rsvelte/compiler` can't be loaded/initialized. The native engine computes the
+ * SAME proxy in-process (`session::own_size` over the pinned rsvelte crate), so all
+ * three engines' monomorphization gates decide byte-for-byte alike (parity is
+ * test-gated). `name` is passed as the component id — its exact string is immaterial
+ * to the SIZE as long as every engine passes the same one, which they do.
+ */
+export function tryLoadRsvelteOwnSize() {
+    let compiler;
+    try {
+        compiler = loadCompiler();
+    }
+    catch {
+        return null;
+    }
+    return (id, source) => {
+        const result = compiler.compile_client(source, id);
+        return result.success ? result.js.length : null;
+    };
+}

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

@@ -10,8 +10,9 @@ import { compileExclude } from './exclude.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 { tryLoadRsvelteParser, tryLoadRsvelteOwnSize } 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`;
@@ -473,35 +474,82 @@ export function shaker(options = {}) {
             });
             reportEscapeDiagnostics(escapeScan);
             const escaped = escapeScan.escaped;
+            // The monomorphization net-win gate's size proxy, computed by rsvelte's client
+            // codegen (`@rsvelte/compiler`), for the JS and WASM engines so their gate decides
+            // byte-for-byte like the native engine (which computes the SAME proxy in-process).
+            // Loaded lazily by the js/wasm mono branches only — the native path sizes in Rust
+            // and never needs it. If `@rsvelte/compiler` can't load, sizing returns null and
+            // the gate specializes nothing — sound (never bloat), just unoptimized.
+            const loadOwnSize = () => tryLoadRsvelteOwnSize() ?? (() => null);
             // Decide the engine.  The native Rust engine now implements every pass
             // INCLUDING monomorphization (it calls back to JS only for the compiled-size
             // proxy), so it
             // 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).
+                //
+                // Defense in depth: `tryLoadNativeEngine` already rejects an ABI-incompatible
+                // binary (`engineApiVersion`), but any OTHER native failure (a napi marshaling
+                // error, an unforeseen throw) must NOT crash the build — degrade to the JS
+                // engine with a warning. `session.shake` is `catch_unwind`, so a native panic
+                // surfaces here as a throw rather than aborting the process.
+                try {
+                    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;
+                }
+                catch (err) {
+                    warn(`the native engine failed at runtime (${err instanceof Error ? err.message : String(err)}); ` +
+                        `falling back to the JS engine for this build`);
+                    native = null;
+                    wasm = null; // fall through to the always-available JS engine below
+                }
             }
             if (wasm) {
                 // Native Rust engine — byte-identical to the JS engine, including
                 // monomorphization.
                 if (mono.enabled) {
-                    const result = await svelteShakerWasmWithMono(wasm, entryComponents, resolve, read, mono, getParse(true), escaped);
+                    const result = await svelteShakerWasmWithMono(wasm, entryComponents, resolve, read, mono, loadOwnSize(), getParse(true), escaped);
                     shaken = result.files;
                     variantSources = result.variants;
                 }
@@ -520,7 +568,7 @@ export function shaker(options = {}) {
                 reportSizes(shaken, read, root, options.verbose === true, log);
                 return;
             }
-            const result = await svelteShakerWithMono(entryComponents, resolve, read, mono, variantSpecifier, getParse(false), escaped);
+            const result = await svelteShakerWithMono(entryComponents, resolve, read, mono, variantSpecifier, getParse(false), escaped, loadOwnSize());
             shaken = result.files;
             variantSources = new Map();
             for (const v of result.mono.variants.values())

package/dist/wasm-engine.d.ts

@@ -1,6 +1,6 @@
 import { type ReadFile, type Resolve } from './analyze.js';
 import { type Parse } from './parse.js';
-import { type MonomorphizeOptions } from './mono.js';
+import { type MonomorphizeOptions, type OwnSize } from './mono.js';
 import type { ComponentId } from './ir.js';
 /** The subset of the WASM exports the plugin uses (docs/RUST-MIGRATION.md M5+). */
 interface WasmEngine {
@@ -48,9 +48,9 @@ export interface WasmMonoResult {
  * Whole-program shake WITH monomorphization, run entirely in the native Rust
  * engine — the counterpart of {@link svelteShakerWithMono}.  The crawl/resolution
  * stays in JS; the Rust engine does the analysis, the monomorphization graph/gate, and the
- * call-site rewrite, calling back into JS only for {@link ownSize} (the Svelte
- * compiler).  Feeding it the same compiler the JS engine uses makes the result
- * byte-identical (pinned by the differential `wasm-mono` test).
+ * call-site rewrite, calling back into JS only for `ownSize` (the injected rsvelte
+ * size proxy).  The native engine computes the SAME proxy in-process, so the results
+ * are byte-identical (pinned by the differential `wasm-mono` / native parity tests).
  */
-export declare function svelteShakerWasmWithMono(engine: WasmEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono: MonomorphizeOptions, parse?: Parse, escaped?: ComponentId[]): Promise<WasmMonoResult>;
+export declare function svelteShakerWasmWithMono(engine: WasmEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono: MonomorphizeOptions, ownSize: OwnSize, parse?: Parse, escaped?: ComponentId[]): Promise<WasmMonoResult>;
 export {};

package/dist/wasm-engine.js

@@ -1,5 +1,4 @@
 import { createRequire } from 'node:module';
-import { compile } from 'svelte/compiler';
 import { buildAnalyzeInput } from './analyze.js';
 import { parseCached } from './parse.js';
 import {} from './mono.js';
@@ -35,16 +34,6 @@ export function tryLoadWasmEngine() {
     }
     return null;
 }
-/** The compiled-byte size proxy the monomorphization net-win gate uses — the same call
- * `mono.ts` makes, so the Rust gate decides byte-for-byte like the JS engine. */
-function ownSize(id, source) {
-    try {
-        return compile(source, { generate: 'client', dev: false, filename: id }).js.code.length;
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Whole-program shake via the native Rust engine — the unused-prop fold / constant fold / value-set narrowing counterpart of
  * {@link svelteShaker} (monomorphization lives only in the JS engine).  The crawl/resolution
@@ -77,11 +66,11 @@ export async function svelteShakerWasm(engine, entries, resolve, readFile, parse
  * Whole-program shake WITH monomorphization, run entirely in the native Rust
  * engine — the counterpart of {@link svelteShakerWithMono}.  The crawl/resolution
  * stays in JS; the Rust engine does the analysis, the monomorphization graph/gate, and the
- * call-site rewrite, calling back into JS only for {@link ownSize} (the Svelte
- * compiler).  Feeding it the same compiler the JS engine uses makes the result
- * byte-identical (pinned by the differential `wasm-mono` test).
+ * call-site rewrite, calling back into JS only for `ownSize` (the injected rsvelte
+ * size proxy).  The native engine computes the SAME proxy in-process, so the results
+ * are byte-identical (pinned by the differential `wasm-mono` / native parity tests).
  */
-export async function svelteShakerWasmWithMono(engine, entries, resolve, readFile, mono, parse, escaped = []) {
+export async function svelteShakerWasmWithMono(engine, entries, resolve, readFile, mono, ownSize, parse, escaped = []) {
     const cache = new Map();
     const input = await buildAnalyzeInput(entries, resolve, readFile, cache, parse, escaped);
     const programInput = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "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.3.0"
+  },
   "engines": {
     "node": ">=22.23.1"
   },