svelte-shaker 0.7.0 → 0.9.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
+
+// Engine: the native Rust (WASM) engine runs the whole shake INCLUDING L2 (it
+// calls back to JS only for the net-win gate's compiled-size proxy) and is
+// differentially tested to be byte-identical to the JS engine, so it only changes
+// speed. It is the default ('auto'); force it (or the JS engine) explicitly with:
+shaker({ include: ['src'], engine: 'rust' }); // or engine: 'js'
 
 // 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/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/svelte_shaker_engine.js

@@ -0,0 +1,244 @@
+/* @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;
+
+/**
+ * Whole-program shake WITH L2 monomorphization.  `input` is the same shape as
+ * `shake_program`; `options_json` is `{enabled, maxVariants, minSavings}`;
+ * `own_size(source) -> number | null` is the per-module compiled-byte proxy the
+ * net-win gate uses (the JS side runs svelte/compiler, so decisions match the TS
+ * engine).  Returns `{ files: {id: code}, variants: {specifier: code} }`.
+ * @param {string} input_json
+ * @param {string} options_json
+ * @param {Function} own_size
+ * @returns {string}
+ */
+function shake_program_with_mono(input_json, options_json, own_size) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.shake_program_with_mono(ptr0, len0, ptr1, len1, own_size);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.shake_program_with_mono = shake_program_with_mono;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_number_get_9bb1761122181af2: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_40e4174f169eaca7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __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 addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+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 handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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,35 @@ 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.
      */
     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 whole shake (analysis + transform, INCLUDING L2).
+     * Default `'auto'`.  The native Rust (WASM) engine implements every level — for
+     * L2 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 when it can be loaded; otherwise fall
+     *    back to the JS engine.
+     *  - `'rust'` — force the Rust engine; throws if the WASM module can't be loaded.
+     *  - `'js'` — force the JS engine.
+     * Both engines are differentially tested to produce byte-identical output, 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

@@ -6,6 +6,7 @@ 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, svelteShakerWasmWithMono, 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`;
@@ -87,11 +88,13 @@ function reportSizes(shaken, read, root, verbose, log) {
 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 };
@@ -266,8 +269,38 @@ export function shaker(options = {}) {
                     return null;
                 return resolved.id.split('?')[0];
             };
+            // Decide the engine.  The native Rust engine now implements every level
+            // INCLUDING L2 (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.
+            const engineChoice = options.engine ?? 'auto';
+            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.');
+            }
+            else if (engineChoice === 'auto') {
+                wasm = tryLoadWasmEngine();
+            }
+            if (wasm) {
+                // Native Rust engine — byte-identical to the JS engine, including L2.
+                if (mono.enabled) {
+                    const result = await svelteShakerWasmWithMono(wasm, entries, resolve, read, mono, getParse());
+                    shaken = result.files;
+                    variantSources = result.variants;
+                }
+                else {
+                    shaken = await svelteShakerWasm(wasm, entries, resolve, read, getParse());
+                    variantSources = new Map();
+                }
+                reportSizes(shaken, read, root, options.verbose === true, log);
+                return;
+            }
             if (!mono.enabled) {
-                // Default path: byte-for-byte the L0/L1/L1.5 output (no L2 at all).
+                // 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);

package/dist/wasm-engine.d.ts

@@ -0,0 +1,56 @@
+import { type ReadFile, type Resolve } from './analyze.js';
+import { type Parse } from './parse.js';
+import { type MonomorphizeOptions } 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 {
+    /** Whole-program L0/L1/L1.5 shake: input JSON in, `{id: shakenCode}` JSON out. */
+    shake_program: (inputJson: string) => string;
+    /**
+     * Whole-program shake WITH L2 monomorphization.  `ownSize(id, source)` is the
+     * per-module compiled-byte proxy the net-win gate calls back into JS for (the
+     * Svelte compiler has no in-WASM equivalent); returns
+     * `{ files: {id: code}, variants: {specifier: code} }` JSON.
+     */
+    shake_program_with_mono: (inputJson: string, optionsJson: string, ownSize: (id: string, source: string) => number | null) => 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>>;
+/** The output of a Rust L2 shake: the wired owner files + the variant residuals
+ * keyed by their request specifier (what the Shell's `load` hook serves). */
+export interface WasmMonoResult {
+    files: Record<ComponentId, string>;
+    variants: Map<string, string>;
+}
+/**
+ * Whole-program shake WITH L2 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 L2 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).
+ */
+export declare function svelteShakerWasmWithMono(engine: WasmEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono: MonomorphizeOptions, parse?: Parse): Promise<WasmMonoResult>;
+export {};

package/dist/wasm-engine.js

@@ -0,0 +1,120 @@
+import { createRequire } from 'node:module';
+import { compile } from 'svelte/compiler';
+import { buildAnalyzeInput } from './analyze.js';
+import { parseCached, parseSvelte } from './parse.js';
+import {} from './mono.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' &&
+                typeof mod.shake_program_with_mono === 'function')
+                return {
+                    shake_program: mod.shake_program.bind(mod),
+                    shake_program_with_mono: mod.shake_program_with_mono.bind(mod),
+                };
+        }
+        catch {
+            // Try the next location.
+        }
+    }
+    return null;
+}
+/** The compiled-byte size proxy the L2 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 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)));
+    revertUnparseable(out, input.files);
+    return out;
+}
+/**
+ * Whole-program shake WITH L2 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 L2 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).
+ */
+export async function svelteShakerWasmWithMono(engine, entries, resolve, readFile, mono, 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 options = JSON.stringify({
+        enabled: mono.enabled,
+        maxVariants: mono.maxVariants,
+        minSavings: mono.minSavings,
+    });
+    const result = JSON.parse(engine.shake_program_with_mono(JSON.stringify(programInput), options, ownSize));
+    revertUnparseable(result.files, input.files);
+    return { files: result.files, variants: new Map(Object.entries(result.variants)) };
+}
+/** Self-check: revert any emitted file that no longer parses to its original — a
+ * sound "did not shake this component", mirroring the JS engine's last line of
+ * defense ({@link svelteShaker}'s `revertUnparseable`). */
+function revertUnparseable(out, files) {
+    for (const file of files) {
+        const code = out[file.id];
+        if (code === undefined || code === file.code)
+            continue;
+        try {
+            parseSvelte(code, file.id);
+        }
+        catch {
+            out[file.id] = file.code;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.7.0",
+  "version": "0.9.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",