svelte-shaker 0.8.0 → 0.9.1

package/README.md

@@ -110,11 +110,11 @@ shaker({
 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' });
+// 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

package/dist/svelte_shaker_engine.js

@@ -73,9 +73,56 @@ function shake_program(input_json) {
     }
 }
 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);
@@ -92,6 +139,20 @@ function __wbg_get_imports() {
     };
 }
 
+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);
 }
@@ -104,6 +165,19 @@ function getUint8ArrayMemory0() {
     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);

package/dist/transform.js

@@ -274,12 +274,17 @@ outDead) {
  * or gain a space.
  */
 function foldIfBlocks(fragment, env, setEnv, code, s, dead) {
-    walk(fragment, { parent: null, preserve: hasPreserveWhitespaceOption(fragment) }, {
+    walk(fragment, { parent: null, preserve: hasPreserveWhitespaceOption(fragment), element: null }, {
         _(node, { state, next }) {
             if (node.type !== 'IfBlock') {
-                // Descend, recording this node as the children's parent and whether it
-                // opens a preserved-whitespace context for them.
-                next({ parent: node, preserve: state.preserve || isPreserveElement(node) });
+                // Descend, recording this node as the children's parent, whether it
+                // opens a preserved-whitespace context, and the content-model element
+                // their seam would land in (for the `{" "}` validity check).
+                next({
+                    parent: node,
+                    preserve: state.preserve || isPreserveElement(node),
+                    element: childParentElement(node, state.element),
+                });
                 return;
             }
             // `elseif` IfBlocks are the *continuation* of a chain we already own from
@@ -294,9 +299,12 @@ function foldIfBlocks(fragment, env, setEnv, code, s, dead) {
                 // node as its children's parent), so its `nodes` are the chain's siblings.
                 index: state.parent?.nodes?.indexOf(node) ?? -1,
                 preserve: state.preserve,
+                element: state.element,
             });
+            // kept head: descend for nested blocks. The `{#if}` is transparent to the
+            // content model, so children stay in the same parent element.
             if (decision.recurse)
-                next({ parent: node, preserve: state.preserve }); // kept head: descend for nested blocks
+                next({ parent: node, preserve: state.preserve, element: state.element });
             // otherwise the subtree is gone or re-emitted verbatim — do not recurse.
         },
     });
@@ -366,10 +374,12 @@ function isFullRemoval(decision) {
  * edge-trimmed, so it renders exactly one space wherever it lands, matching the
  * original.  Otherwise plain deletion already preserves space presence (only the
  * run LENGTH can differ, which the SSR oracle normalizes).  Never compensate
- * under preserved whitespace — there plain deletion is byte-exact.
+ * under preserved whitespace — there plain deletion is byte-exact — nor inside a
+ * text-free parent (`<tr>`, `<tbody>`, …), where Svelte rejects the `{" "}` text
+ * child outright and the whitespace rendered nothing to begin with.
  */
 function removeChain(removed, span, code, s, dead, ctx) {
-    if (!ctx.preserve && ctx.parent?.nodes && ctx.index >= 0) {
+    if (!ctx.preserve && !isTextFreeParent(ctx.element) && ctx.parent?.nodes && ctx.index >= 0) {
         const seam = analyzeSeam(ctx.parent.nodes, ctx.index, span, code, dead);
         if (seam) {
             s.overwrite(seam[0], seam[1], '{" "}');
@@ -431,6 +441,49 @@ function isRenderingSibling(node, code) {
 function isPreserveElement(node) {
     return node.type === 'RegularElement' && (node.name === 'pre' || node.name === 'textarea');
 }
+/**
+ * Parent elements whose HTML content model forbids a text child: Svelte's
+ * `is_tag_valid_with_parent('#text', …)` rejects a `#text`/`{" "}` here with
+ * `node_invalid_placement` — these are exactly its `disallowed_children` entries
+ * that carry an `only` list (html/head/frameset/#document can't appear as
+ * elements inside a component, so only the table parts remain).  Svelte never
+ * renders inter-child whitespace inside them either, so a removed chain's seam
+ * needs plain deletion: emitting the `{" "}` compensation would produce a
+ * component that fails to compile. See {@link removeChain}.
+ */
+const TEXT_FREE_PARENTS = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr', 'colgroup']);
+/**
+ * Node types that reset the content-model parent to "unknown" (text allowed
+ * again), mirroring svelte's `parent_element: null` reset in the SvelteElement /
+ * SvelteFragment / SnippetBlock / Component visitors.  A `{" "}` seam in any of
+ * these contexts is valid, so the seam compensation may proceed.
+ */
+const PARENT_ELEMENT_RESET = new Set([
+    'SvelteElement',
+    'SvelteFragment',
+    'SnippetBlock',
+    'Component',
+    'SvelteSelf',
+    'SvelteComponent',
+]);
+/**
+ * The content-model parent element a seam would land in for `node`'s children,
+ * given the element the walk is currently inside.  Mirrors svelte's
+ * `parent_element` threading: a `RegularElement` becomes the parent, the reset
+ * node types clear it, and every other node (Fragment, blocks, …) is transparent
+ * and inherits.  `null` means "text allowed" (root or a reset context).
+ */
+function childParentElement(node, current) {
+    if (node.type === 'RegularElement')
+        return node.name ?? null;
+    if (PARENT_ELEMENT_RESET.has(node.type))
+        return null;
+    return current;
+}
+/** True when an `{" "}` seam would be an invalid text child of `element`. */
+function isTextFreeParent(element) {
+    return element !== null && TEXT_FREE_PARENTS.has(element);
+}
 /** Does the component opt into preserved whitespace via `<svelte:options>`? */
 function hasPreserveWhitespaceOption(fragment) {
     let preserve = false;

package/dist/vite.d.ts

@@ -14,8 +14,7 @@ export interface ShakerOptions {
      * 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).
+     * trade a little compression for faster builds.
      */
     level?: 0 | 1 | 2;
     /**
@@ -28,17 +27,16 @@ export interface ShakerOptions {
      */
     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.
+     * 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';
     /**

package/dist/vite.js

@@ -6,7 +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, tryLoadWasmEngine } from './wasm-engine.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`;
@@ -269,41 +269,44 @@ export function shaker(options = {}) {
                     return null;
                 return resolved.id.split('?')[0];
             };
-            // 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.
+            // 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 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.
+            else if (engineChoice === 'auto') {
                 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();
+                // 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 (!effectiveMono.enabled) {
+            if (!mono.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, effectiveMono, variantSpecifier, getParse());
+            const result = await svelteShakerWithMono(entries, resolve, read, mono, variantSpecifier, getParse());
             shaken = result.files;
             variantSources = new Map();
             for (const v of result.mono.variants.values())

package/dist/wasm-engine.d.ts

@@ -1,10 +1,18 @@
 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). */
+/** 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
@@ -30,4 +38,19 @@ export declare function tryLoadWasmEngine(): WasmEngine | null;
  * 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

@@ -1,6 +1,8 @@
 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.
@@ -19,8 +21,12 @@ export function tryLoadWasmEngine() {
         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) };
+            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.
@@ -28,6 +34,16 @@ export function tryLoadWasmEngine() {
     }
     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
@@ -54,7 +70,43 @@ export async function svelteShakerWasm(engine, entries, resolve, readFile, parse
         entries: input.entries,
     };
     const out = JSON.parse(engine.shake_program(JSON.stringify(programInput)));
-    for (const file of input.files) {
+    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;
@@ -65,5 +117,4 @@ export async function svelteShakerWasm(engine, entries, resolve, readFile, parse
             out[file.id] = file.code;
         }
     }
-    return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",