svelte-shaker 0.6.0 → 0.8.0

package/README.md

@@ -99,14 +99,22 @@ pipelines; the Vite plugin is preferred for apps.
 ```ts
 shaker({
   include: ['src'], // dirs (relative to root) holding every .svelte call site
-  level: 1, //  0 | 1 | 2 — default 1 (L0/L1/L1.5 always on). 2 = opt-in L2.
-  monomorphize: false, // L2 tuning; only consulted when level: 2.
+  level: 2, //  0 | 1 | 2 — default 2 (L0/L1/L1.5 always on; 2 also enables L2).
+  monomorphize: true, // L2 tuning; on by default — object overrides maxVariants/minSavings.
+  engine: 'auto', // 'auto' (default) | 'js' | 'rust' — see below.
   parser: 'svelte', // 'svelte' (default) | 'rsvelte' — see below.
 });
 
-// Opt into L2 per-call-site monomorphization:
-shaker({ include: ['src'], level: 2, monomorphize: true });
-shaker({ include: ['src'], level: 2, monomorphize: { maxVariants: 16 } });
+// L2 is ON by default (it is bail-safe and never bloats). Turn it OFF for faster
+// builds, or tune it:
+shaker({ include: ['src'], level: 1 }); // L2 off (L0/L1/L1.5 only)
+shaker({ include: ['src'], monomorphize: { maxVariants: 16 } }); // raise the variant cap
+
+// Run the analysis + transform in the native Rust (WASM) engine. It implements
+// L0/L1/L1.5 and is differentially tested to be byte-identical to the JS engine,
+// so it only changes speed. L2 lives only in the JS engine, so the Rust engine
+// skips it — pair it with `level: 1`:
+shaker({ include: ['src'], level: 1, engine: 'rust' });
 
 // Opt into the faster rsvelte parser (~1.46x full build, ~2.2x parse).
 // Requires the optional peer `@rsvelte/vite-plugin-svelte-native` (install it
@@ -154,7 +162,7 @@ for the design.
 | **L1**   | Props that collapse to one constant app-wide → fold + drop + strip every call site's attribute                                               | on         |
 | **L1.5** | Value-set **narrowing**: with `variant ∈ {primary, secondary}`, delete provably-dead `{#if}`/`{:else if}` arms (prop stays in the signature) | on         |
 | **CSS**  | `<style>` rules whose class can never be produced given the value sets — the bundler-can't differentiator                                    | on         |
-| **L2**   | Per-call-site monomorphization: specialize a component per prop shape (deduped by residual, capped by `maxVariants`)                         | **opt-in** |
+| **L2**   | Per-call-site monomorphization: specialize a component per prop shape (deduped by residual, capped by `maxVariants`)                         | on (set `level: 1` to disable) |
 
 Folding also reaches template ternaries (`{cond ? a : b}`) and class-string
 interpolation when the condition/parts are provable constants.

package/dist/analyze.d.ts

@@ -81,11 +81,15 @@ export interface ChildCall {
 }
 /**
  * One value passed explicitly to a prop at one call site, after last-write-wins
- * has been resolved (`{...obj}` aside).  `dynamic` means the attribute had a
- * non-literal value (`bind:`, dynamic expression): used, value not statically
- * known.  `afterLastSpread` records whether this explicit write happened after
- * the site's last `{...spread}` — only then can a spread not silently override
- * it (docs §4.1, "後勝ち順序で救う").
+ * has been resolved.  An explicit write is either a real attribute (`a={1}`) OR a
+ * key expanded out of a statically-known object-literal spread (`{...{a:1}}`,
+ * docs §4.1) — both name a prop and a value the same way.  `dynamic` means the
+ * value is non-literal (`bind:`, a dynamic expression, or a spread key whose
+ * value is non-literal): used, value not statically known.  `afterLastSpread`
+ * records whether this write happened after the site's last *unknown* spread (one
+ * we could not expand) — only then can no spread silently override it (docs §4.1,
+ * "後勝ち順序で救う").  A known object-literal spread is expanded, not opaque, so
+ * it never counts as an "unknown spread" here.
  */
 export interface ExplicitProp {
     value: Literal;
@@ -94,7 +98,12 @@ export interface ExplicitProp {
 }
 /** How a child component is called at one `<Child .../>` site. */
 export interface CallSite {
-    /** Did this site have at least one `{...spread}` attribute? */
+    /**
+     * Did this site have at least one spread we could NOT statically expand (an
+     * identifier / call / `{...{…computed/nested…}}`)?  A fully-known object-literal
+     * spread is expanded into {@link ExplicitProp} writes instead, so it does not
+     * set this — only an opaque spread, which may set any prop, does (docs §4.1).
+     */
     hadSpread: boolean;
     /** Last-write-wins explicit props at this site, keyed by prop name. */
     explicit: Map<string, ExplicitProp>;
@@ -160,7 +169,11 @@ export declare function remapToLocalNames<V>(map: Map<string, V>, model: FileMod
  * Read one `<Child .../>` into a {@link CallSite}.  Attributes are in source
  * order, so we resolve last-write-wins (a later `a={…}` overrides an earlier
  * one) and record, per prop, whether its winning write came *after* the last
- * spread — the only case a spread cannot silently override it (docs §4.1).
+ * *unknown* spread — the only case a spread cannot silently override it (docs
+ * §4.1).  A statically-known object-literal spread (`{...{a:1, b:2}}`) is not
+ * opaque: we expand its keys into explicit writes at the spread's position, so it
+ * both contributes those literals AND does not poison props it cannot set (docs
+ * §4.1, "{...obj} が object literal ならキー展開").
  */
 export declare function readCallSite(component: AnyNode): CallSite;
 /** Decide what to fold for one component from its global usage. */

package/dist/analyze.js

@@ -1,6 +1,7 @@
 import { parseCached, parseSvelte, walk, } from './parse.js';
 import { emptyPlan, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
+import { evaluate } from './eval.js';
 const isSvelte = (source) => source.endsWith('.svelte');
 /** Hard cap on fixpoint iterations: convergence is monotone (dead spans only
  * grow as profiles shrink), so this is reached only if something is non-monotone
@@ -672,18 +673,40 @@ function memberComponentTags(ast) {
  * Read one `<Child .../>` into a {@link CallSite}.  Attributes are in source
  * order, so we resolve last-write-wins (a later `a={…}` overrides an earlier
  * one) and record, per prop, whether its winning write came *after* the last
- * spread — the only case a spread cannot silently override it (docs §4.1).
+ * *unknown* spread — the only case a spread cannot silently override it (docs
+ * §4.1).  A statically-known object-literal spread (`{...{a:1, b:2}}`) is not
+ * opaque: we expand its keys into explicit writes at the spread's position, so it
+ * both contributes those literals AND does not poison props it cannot set (docs
+ * §4.1, "{...obj} が object literal ならキー展開").
  */
 export function readCallSite(component) {
     const attrs = component.attributes ?? [];
+    // Only spreads we CANNOT expand are opaque (may set any prop).  Classify first
+    // so `afterLastSpread` is measured against the last *unknown* spread, not a
+    // known object literal we are about to expand into explicit writes.
     let lastSpreadIndex = -1;
     for (let i = 0; i < attrs.length; i++) {
-        if (attrs[i].type === 'SpreadAttribute')
+        const attr = attrs[i];
+        if (attr.type === 'SpreadAttribute' && knownSpreadEntries(attr) === null)
             lastSpreadIndex = i;
     }
     const explicit = new Map();
     for (let i = 0; i < attrs.length; i++) {
         const attr = attrs[i];
+        if (attr.type === 'SpreadAttribute') {
+            // A known object-literal spread expands to one explicit write per key, at
+            // this spread's position; an unknown spread is opaque and handled by the
+            // `hadSpread`/`afterLastSpread` poisoning in `valueSetFor`.
+            const entries = knownSpreadEntries(attr);
+            if (entries) {
+                for (const [name, value] of entries) {
+                    explicit.set(name, value.known
+                        ? { value: value.value, dynamic: false, afterLastSpread: i > lastSpreadIndex }
+                        : dynamicWrite(i, lastSpreadIndex));
+                }
+            }
+            continue;
+        }
         const name = attr.name;
         if (attr.type === 'BindDirective') {
             // `bind:prop` is a used, dynamic two-way binding (docs §4.1).
@@ -759,6 +782,51 @@ function dynamicWrite(index, lastSpreadIndex) {
         afterLastSpread: index > lastSpreadIndex,
     };
 }
+/**
+ * The `[name, value]` entries a spread contributes IF it is a statically-known
+ * object literal whose complete key set we can see (docs §4.1 "object literal な
+ * spread はキー展開").  Returns `null` for any spread we cannot fully expand — an
+ * identifier/call (`{...rest}`), or an object literal carrying a nested spread
+ * (`{...{...x}}`), a computed key (`{...{[k]: 1}}`), or a getter/setter/method —
+ * because then we do not know the full set of props it sets and must treat it as
+ * opaque.  Each entry's value is `{known:true,value}` for a literal (so it folds)
+ * or `{known:false}` for a non-literal value (key known, value dynamic): both are
+ * sound, since the key set is fully known either way.
+ */
+function knownSpreadEntries(attr) {
+    const obj = attr.expression;
+    if (obj?.type !== 'ObjectExpression')
+        return null;
+    const entries = [];
+    for (const prop of obj.properties ?? []) {
+        // A nested spread, computed key, or accessor/method means the full key set is
+        // not statically knowable -> the whole spread is opaque.
+        if (prop.type !== 'Property')
+            return null;
+        if (prop.computed === true ||
+            prop.kind === 'get' ||
+            prop.kind === 'set' ||
+            prop.method === true)
+            return null;
+        const key = prop.key;
+        const name = key?.type === 'Identifier'
+            ? key.name
+            : key?.type === 'Literal' &&
+                (typeof key.value === 'string' || typeof key.value === 'number')
+                ? String(key.value)
+                : null;
+        if (name == null)
+            return null;
+        entries.push([name, evalToLiteral(prop.value)]);
+    }
+    return entries;
+}
+/** Constant-evaluate a spread property value with no environment (literals + the
+ * tiny pure operator fragment), as `{known:true,value}` or `{known:false}`. */
+function evalToLiteral(node) {
+    const r = evaluate(node, new Map());
+    return r.known ? { known: true, value: r.value } : { known: false };
+}
 /** Extract a literal from an attribute value, or `{ known:false }`. */
 function literalAttrValue(value) {
     if (value === true)

package/dist/mono.js

@@ -256,7 +256,9 @@ function netWin(childId, variantSources, models, baseSource, baseChildrenOf, roo
     const variantChildren = new Map();
     for (const v of variantSources)
         variantChildren.set(v.id, liveChildIds(v.code, childModel));
-    // --- Sigma_base: reachable set in the BASE scenario, sized by base residual.
+    // --- Reachability is graph-only (NO compile): the costly `ownSize` is deferred
+    // until we know which modules actually differ between the two scenarios.
+    // BASE scenario: components reachable from the roots through the base graph.
     const baseReached = new Set();
     const stackB = [...roots];
     while (stackB.length > 0) {
@@ -267,23 +269,12 @@ function netWin(childId, variantSources, models, baseSource, baseChildrenOf, roo
         for (const c of baseChildrenOf.get(id) ?? [])
             stackB.push(c);
     }
-    let sigmaBase = 0;
-    for (const id of baseReached) {
-        const size = ownSize(id, baseSource.get(id));
-        if (size === null)
-            return false; // un-sizable -> decline
-        sigmaBase += size;
-    }
-    // --- Sigma_spec: reachability with the child expanded into its variants.
-    //   * reached non-variant components are sized by their base residual,
-    //   * each reached variant by its own residual,
-    //   * the child's base module is NOT a node (its edges redirect to variants).
-    // A worklist over a tagged node: either a real component id or a variant id.
+    // SPEC scenario: the same graph, but every edge into the child redirects to ALL
+    // its variants (all-sites means each live caller now renders a variant); the
+    // child's base module is gone and each variant renders its OWN live children.
     const allVariantIds = variantSources.map((v) => v.id);
-    const reachedComponents = new Set();
-    const reachedVariants = new Set();
-    // Redirect any edge into the child to ALL its variants (all-sites means every
-    // live caller now renders a variant; for a sound upper bound we keep them all).
+    const specComponents = new Set();
+    const specVariants = new Set();
     const expand = (id) => id === childId ? { comps: [], vars: allVariantIds } : { comps: [id], vars: [] };
     const compStack = [];
     const varStack = [];
@@ -295,9 +286,9 @@ function netWin(childId, variantSources, models, baseSource, baseChildrenOf, roo
     while (compStack.length > 0 || varStack.length > 0) {
         if (compStack.length > 0) {
             const id = compStack.pop();
-            if (reachedComponents.has(id))
+            if (specComponents.has(id))
                 continue;
-            reachedComponents.add(id);
+            specComponents.add(id);
             for (const c of baseChildrenOf.get(id) ?? []) {
                 const e = expand(c);
                 compStack.push(...e.comps);
@@ -306,30 +297,63 @@ function netWin(childId, variantSources, models, baseSource, baseChildrenOf, roo
             continue;
         }
         const vid = varStack.pop();
-        if (reachedVariants.has(vid))
+        if (specVariants.has(vid))
             continue;
-        reachedVariants.add(vid);
+        specVariants.add(vid);
         for (const c of variantChildren.get(vid) ?? []) {
             const e = expand(c);
             compStack.push(...e.comps);
             varStack.push(...e.vars);
         }
     }
-    let sigmaSpec = 0;
-    for (const id of reachedComponents) {
+    // A component reachable in BOTH scenarios has the same base size on each side, so
+    // for the default `minSavings === 0` it cancels out of `Σ_spec < Σ_base` — we
+    // only have to size the SYMMETRIC DIFFERENCE: the variants (spec-only), and the
+    // child base plus any now-orphaned modules (base-only).  Compiling only the diff
+    // — instead of the whole reachable program, once per candidate — is what keeps a
+    // large `maxVariants` affordable: a child that orphans nothing sizes just its
+    // variants vs. its base and declines without touching the rest of the graph.
+    let baseSide = 0; // Σ over base-only modules (child base + orphaned)
+    let specSide = 0; // Σ over spec-only modules (the variants, + any spec-only comp)
+    for (const id of baseReached) {
+        if (specComponents.has(id))
+            continue; // shared -> cancels
         const size = ownSize(id, baseSource.get(id));
         if (size === null)
-            return false;
-        sigmaSpec += size;
+            return false; // un-sizable -> decline
+        baseSide += size;
     }
-    for (const vid of reachedVariants) {
+    for (const vid of specVariants) {
         const src = variantSources.find((v) => v.id === vid).code;
         const size = ownSize(vid, src);
         if (size === null)
             return false;
-        sigmaSpec += size;
+        specSide += size;
+    }
+    // Folding never adds reachability, so this set is normally empty; sizing it keeps
+    // the comparison sound regardless.
+    for (const id of specComponents) {
+        if (baseReached.has(id))
+            continue;
+        const size = ownSize(id, baseSource.get(id));
+        if (size === null)
+            return false;
+        specSide += size;
+    }
+    // Default gate: shared modules cancel, so the strict net win is `specSide < baseSide`.
+    if (minSavings === 0)
+        return specSide < baseSide;
+    // A non-zero `minSavings` needs the ABSOLUTE base total, so size the shared set too.
+    let shared = 0;
+    for (const id of baseReached) {
+        if (!specComponents.has(id))
+            continue;
+        const size = ownSize(id, baseSource.get(id));
+        if (size === null)
+            return false;
+        shared += size;
     }
-    return sigmaSpec < sigmaBase * (1 - minSavings);
+    return specSide + shared < (baseSide + shared) * (1 - minSavings);
 }
 /**
  * The live child component ids a `.svelte` SOURCE renders: parse it and resolve

package/dist/parse.d.ts

@@ -67,6 +67,10 @@ export interface AnyNode {
     computed?: boolean | undefined;
     shorthand?: boolean | undefined;
     elseif?: boolean | undefined;
+    /** ObjectExpression `Property` accessor kind (`init` / `get` / `set`). */
+    kind?: string | undefined;
+    /** ObjectExpression `Property` shorthand-method flag (`{ m() {} }`). */
+    method?: boolean | undefined;
     value?: unknown;
 }
 export interface Root extends AnyNode {

package/dist/svelte_shaker_engine.js

@@ -0,0 +1,170 @@
+/* @ts-self-types="./svelte_shaker_engine.d.ts" */
+
+/**
+ * Analyze one component AST (JSON) given its resolved outgoing edges (JSON), and
+ * return the per-file model fields ported so far: declared props, `...rest`
+ * presence, shadowed / `{@debug}` fold-blocking names, the `<svelte:options>`
+ * bail, the rendered child calls, and escaped components. `{"error": "..."}` on
+ * malformed input.
+ * @param {string} ast_json
+ * @param {string} edges_json
+ * @returns {string}
+ */
+function analyze_component(ast_json, edges_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(ast_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(edges_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.analyze_component(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.analyze_component = analyze_component;
+
+/**
+ * Whole-program analysis entry: `input` is `{ files: [{id, ast}], edges:
+ * [{from, local, to, kind}], entries }` (the AST is parsed on the JS side).
+ * Returns `{ id: plan }` for every component.
+ * @param {string} input_json
+ * @returns {string}
+ */
+function analyze_program(input_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.analyze_program(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.analyze_program = analyze_program;
+
+/**
+ * Whole-program shake: analyze + transform.  `input` is `{ files: [{id, ast,
+ * code}], edges, entries }`.  Returns `{ id: slimmedSource }` for every file —
+ * byte-for-byte the L0/L1/L1.5 output (the `svelteShaker` equivalent).
+ * @param {string} input_json
+ * @returns {string}
+ */
+function shake_program(input_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.shake_program(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.shake_program = shake_program;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./svelte_shaker_engine_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/svelte_shaker_engine_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/dist/vite.d.ts

@@ -10,17 +10,37 @@ export interface ShakerOptions {
      */
     include?: string[];
     /**
-     * Optimization level (docs §3).  L0/L1/L1.5 are always on (`level >= 1`); only
-     * `level: 2` additionally enables L2 per-call-site monomorphization, which is
-     * OPT-IN.  Default `1` — behavior with the level unset is unchanged.
+     * Optimization level (docs §3).  L0/L1/L1.5 are always on; `level: 2`
+     * additionally enables L2 per-call-site monomorphization.  **Default `2`** — L2
+     * is ON by default because it is bail-safe and never bloats (the measured
+     * net-win gate, docs §3 L2).  Set `level: 1` (or `0`) to turn L2 OFF, e.g. to
+     * trade a little compression for faster builds, or to use the Rust {@link
+     * engine} (which implements L0/L1/L1.5 only).
      */
     level?: 0 | 1 | 2;
     /**
-     * L2 monomorphization tuning (docs §13.2).  Only consulted when `level: 2`.
-     * `true` enables it with defaults; an object overrides `maxVariants`.  Defaults
-     * to OFF.
+     * L2 monomorphization tuning (docs §13.2).  Consulted whenever L2 is active
+     * (i.e. not turned off via `level: 1`/`0`).  `true`/omitted enables it with
+     * defaults; an object overrides `maxVariants` / `minSavings`; `false` turns L2
+     * OFF (same as `level: 1`).  Raising `maxVariants` lets children with more
+     * distinct call-site shapes be specialized — affordable now that the net-win
+     * gate only sizes the modules that actually differ (docs §13.2).
      */
     monomorphize?: boolean | Partial<Omit<MonomorphizeOptions, 'enabled'>>;
+    /**
+     * Which engine runs the L0/L1/L1.5 analysis + transform.  Default `'auto'`.
+     *  - `'auto'` — use the native Rust (WASM) engine when it can be loaded AND L2
+     *    is off; otherwise fall back to the JS engine.  Since L2 lives only in the
+     *    JS engine, a build with L2 active (the default) runs on JS; turn L2 off
+     *    (`level: 1`) to get the faster Rust path.
+     *  - `'rust'` — force the Rust engine.  L2 is not available there, so it is
+     *    skipped (a one-time notice is logged) even if requested.  Throws if the
+     *    WASM module cannot be loaded.
+     *  - `'js'` — force the JS engine (the established, L2-capable path).
+     * The Rust engine is differentially tested to produce byte-identical output to
+     * the JS engine, so the choice only affects speed, never what is shaken.
+     */
+    engine?: 'auto' | 'js' | 'rust';
     /**
      * Whether to shake in `vite dev` too (docs/RUST-MIGRATION.md §3 M2,
      * ARCHITECTURE §6.2).  Default `false` — dev is a pass-through, which is always

package/dist/vite.js

@@ -1,14 +1,33 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { compile } from 'svelte/compiler';
 import { svelteShaker, svelteShakerWithMono } from './index.js';
 import { DevShaker } from './engine.js';
 import { collectSvelteFiles, fsResolve } from './scan.js';
 import { DEFAULT_MONO_OPTIONS } from './mono.js';
 import { tryLoadRsvelteParser } from './rsvelte-parse.js';
+import { svelteShakerWasm, tryLoadWasmEngine } from './wasm-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`;
 }
+/**
+ * Compiled-output size proxy: the bytes the Svelte compiler emits for `code`
+ * (client JS + scoped CSS).  This is the number that actually ships, so it
+ * captures what the SOURCE-byte total cannot: a dead `{#if}` arm or a removed
+ * `<style>` rule shrinks the compiled output far more than its few source bytes
+ * suggest.  Reporting-only; `null` if the (always valid) source fails to compile,
+ * so the caller can skip it without aborting the build.
+ */
+function compiledSize(code, id) {
+    try {
+        const { js, css } = compile(code, { generate: 'client', dev: false, filename: id });
+        return js.code.length + (css?.code.length ?? 0);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Print what the shake saved.  Always emits a one-line whole-program summary;
  * when `verbose`, also lists each shrunk file (largest saving first).  Sizes are
@@ -43,16 +62,39 @@ function reportSizes(shaken, read, root, verbose, log) {
         const filePct = ((fileSaved / row.before) * 100).toFixed(1);
         log(`  ${rel}: ${formatKB(row.before)} → ${formatKB(row.after)} (-${filePct}%)`);
     }
+    // The source-byte delta UNDER-reports the real win: a folded dead branch or a
+    // removed `<style>` rule shrinks the compiled output much more than its source.
+    // Compiling is costly, so we only do it for the files that actually shrank, and
+    // only under `verbose` — it never affects the build, just the visible number.
+    let compiledBefore = 0;
+    let compiledAfter = 0;
+    for (const row of rows) {
+        const before = compiledSize(read(row.id), row.id);
+        const after = compiledSize(shaken[row.id], row.id);
+        if (before === null || after === null)
+            continue; // skip the un-compilable
+        compiledBefore += before;
+        compiledAfter += after;
+    }
+    if (compiledBefore > 0) {
+        const compiledSaved = compiledBefore - compiledAfter;
+        const compiledPct = ((compiledSaved / compiledBefore) * 100).toFixed(1);
+        log(`compiled output (js+css) of shaken files: ` +
+            `${formatKB(compiledBefore)} → ${formatKB(compiledAfter)} ` +
+            `(saved ${formatKB(compiledSaved)}, ${compiledPct}%)`);
+    }
 }
 /** Query flag a specialized-variant `.svelte` request carries (see below). */
 const VARIANT_QUERY = 'shaker_variant';
 /**
  * Resolve the {@link MonomorphizeOptions} from the public option surface.  L2 is
- * active only when `level: 2` AND `monomorphize` is truthy; anything else leaves
- * it disabled (the default), so existing configs are unaffected.
+ * ON by default (it is bail-safe and never bloats); it is disabled only by an
+ * explicit opt-out — `level: 1`/`0` or `monomorphize: false`.  An object
+ * `monomorphize` overrides the tuning knobs (`maxVariants` / `minSavings`).
  */
 function resolveMono(options) {
-    if (options.level !== 2 || !options.monomorphize)
+    const optedOut = options.level === 0 || options.level === 1 || options.monomorphize === false;
+    if (optedOut)
         return DEFAULT_MONO_OPTIONS;
     const overrides = typeof options.monomorphize === 'object' ? options.monomorphize : {};
     return { ...DEFAULT_MONO_OPTIONS, enabled: true, ...overrides };
@@ -227,14 +269,41 @@ export function shaker(options = {}) {
                     return null;
                 return resolved.id.split('?')[0];
             };
-            if (!mono.enabled) {
-                // Default path: byte-for-byte the L0/L1/L1.5 output (no L2 at all).
+            // Decide the engine.  L2 (the default) lives only in the JS engine, so it
+            // takes precedence; the native Rust engine drives the L0/L1/L1.5 path when
+            // selected (`engine: 'rust'`) or under `'auto'` whenever L2 is off.
+            const engineChoice = options.engine ?? 'auto';
+            let effectiveMono = mono;
+            let wasm = null;
+            if (engineChoice === 'rust') {
+                if (mono.enabled) {
+                    log('engine: "rust" runs L0/L1/L1.5 only — L2 monomorphization (JS-only) is skipped');
+                    effectiveMono = DEFAULT_MONO_OPTIONS;
+                }
+                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.');
+            }
+            else if (engineChoice === 'auto' && !mono.enabled) {
+                // Auto: prefer the native engine on the L2-off path; fall back to JS silently.
+                wasm = tryLoadWasmEngine();
+            }
+            if (wasm) {
+                // Native Rust L0/L1/L1.5 — byte-identical to the JS engine (no L2 here).
+                shaken = await svelteShakerWasm(wasm, entries, resolve, read, getParse());
+                variantSources = new Map();
+                reportSizes(shaken, read, root, options.verbose === true, log);
+                return;
+            }
+            if (!effectiveMono.enabled) {
+                // JS engine, L2 off: byte-for-byte the L0/L1/L1.5 output.
                 shaken = await svelteShaker(entries, resolve, read, getParse());
                 variantSources = new Map();
                 reportSizes(shaken, read, root, options.verbose === true, log);
                 return;
             }
-            const result = await svelteShakerWithMono(entries, resolve, read, mono, variantSpecifier, getParse());
+            const result = await svelteShakerWithMono(entries, resolve, read, effectiveMono, variantSpecifier, getParse());
             shaken = result.files;
             variantSources = new Map();
             for (const v of result.mono.variants.values())

package/dist/wasm-engine.d.ts

@@ -0,0 +1,33 @@
+import { type ReadFile, type Resolve } from './analyze.js';
+import { type Parse } from './parse.js';
+import type { ComponentId } from './ir.js';
+/** The subset of the WASM exports the plugin uses (docs/RUST-MIGRATION.md M5). */
+interface WasmEngine {
+    /** Whole-program L0/L1/L1.5 shake: input JSON in, `{id: shakenCode}` JSON out. */
+    shake_program: (inputJson: string) => string;
+}
+/**
+ * Load the native Rust (WASM) engine, or `null` if it can't be loaded (no built
+ * artifact for this install).  Two locations are tried in order:
+ *  - `./svelte_shaker_engine.js` — the PUBLISHED layout, where `build` copies the
+ *    artifact next to `dist/wasm-engine.js` (wasm-pack's `pkg/.gitignore` of `*`
+ *    keeps `engine-rs/pkg` out of the npm tarball, so we ship it via `dist/`).
+ *  - `../engine-rs/pkg/svelte_shaker_engine.js` — the REPO layout, used when
+ *    running from source in the package's own tests (no copy step has run).
+ */
+export declare function tryLoadWasmEngine(): WasmEngine | null;
+/**
+ * Whole-program shake via the native Rust engine — the L0/L1/L1.5 counterpart of
+ * {@link svelteShaker} (L2 lives only in the JS engine).  The crawl/resolution
+ * stays in JS ({@link buildAnalyzeInput}); we hand the Rust engine the resolved
+ * graph plus each file's AST and source as JSON, exactly as the differential
+ * `wasm-shake` test does — so the output is byte-identical to the JS engine.
+ *
+ * The same parse cache feeds the crawl and the program input, so each file is
+ * parsed once.  A final self-check mirrors the JS engine's `revertUnparseable`:
+ * any emitted file that no longer parses is reverted to its original (a sound
+ * "did not shake this component"), so a single mishandled shape can never break
+ * the build.
+ */
+export declare function svelteShakerWasm(engine: WasmEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parse?: Parse): Promise<Record<ComponentId, string>>;
+export {};

package/dist/wasm-engine.js

@@ -0,0 +1,69 @@
+import { createRequire } from 'node:module';
+import { buildAnalyzeInput } from './analyze.js';
+import { parseCached, parseSvelte } from './parse.js';
+// NODE-ONLY: loads the native Rust (WASM) engine and drives it from the Vite
+// plugin.  Imported only by `vite.ts` (a Node entry), never by the environment-free
+// engine (`index.ts`/`analyze.ts`), so the browser playground build stays clean.
+const require = createRequire(import.meta.url);
+/**
+ * Load the native Rust (WASM) engine, or `null` if it can't be loaded (no built
+ * artifact for this install).  Two locations are tried in order:
+ *  - `./svelte_shaker_engine.js` — the PUBLISHED layout, where `build` copies the
+ *    artifact next to `dist/wasm-engine.js` (wasm-pack's `pkg/.gitignore` of `*`
+ *    keeps `engine-rs/pkg` out of the npm tarball, so we ship it via `dist/`).
+ *  - `../engine-rs/pkg/svelte_shaker_engine.js` — the REPO layout, used when
+ *    running from source in the package's own tests (no copy step has run).
+ */
+export function tryLoadWasmEngine() {
+    for (const spec of ['./svelte_shaker_engine.js', '../engine-rs/pkg/svelte_shaker_engine.js']) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = require(spec);
+            if (typeof mod.shake_program === 'function')
+                return { shake_program: mod.shake_program.bind(mod) };
+        }
+        catch {
+            // Try the next location.
+        }
+    }
+    return null;
+}
+/**
+ * Whole-program shake via the native Rust engine — the L0/L1/L1.5 counterpart of
+ * {@link svelteShaker} (L2 lives only in the JS engine).  The crawl/resolution
+ * stays in JS ({@link buildAnalyzeInput}); we hand the Rust engine the resolved
+ * graph plus each file's AST and source as JSON, exactly as the differential
+ * `wasm-shake` test does — so the output is byte-identical to the JS engine.
+ *
+ * The same parse cache feeds the crawl and the program input, so each file is
+ * parsed once.  A final self-check mirrors the JS engine's `revertUnparseable`:
+ * any emitted file that no longer parses is reverted to its original (a sound
+ * "did not shake this component"), so a single mishandled shape can never break
+ * the build.
+ */
+export async function svelteShakerWasm(engine, entries, resolve, readFile, parse) {
+    const cache = new Map();
+    const input = await buildAnalyzeInput(entries, resolve, readFile, cache, parse);
+    const programInput = {
+        files: input.files.map((f) => ({
+            id: f.id,
+            ast: parseCached(f.id, f.code, cache, parse),
+            code: f.code,
+        })),
+        edges: input.edges,
+        entries: input.entries,
+    };
+    const out = JSON.parse(engine.shake_program(JSON.stringify(programInput)));
+    for (const file of input.files) {
+        const code = out[file.id];
+        if (code === undefined || code === file.code)
+            continue;
+        try {
+            parseSvelte(code, file.id);
+        }
+        catch {
+            out[file.id] = file.code;
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",
@@ -69,7 +69,7 @@
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-wasm.mjs",
     "build:wasm": "wasm-pack build engine-rs --target nodejs --release --out-dir pkg",
     "dev": "tsc -p tsconfig.build.json -w",
     "test:watch": "vitest",