svelte-shaker 0.16.1 → 0.17.0

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/mono.d.ts

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

package/dist/mono.js

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

package/dist/native-engine.d.ts

@@ -1,16 +1,26 @@
 import { type ReadFile, type Resolve } from './analyze.js';
 import { type MonomorphizeOptions } from './mono.js';
 import type { ComponentId } from './ir.js';
-/** The long-lived native session: parse + retain ASTs, then shake to edits. */
+/** The long-lived native session: parse + retain ASTs, then shake to edits. The
+ * shake needs no size callback — the monomorphization net-win gate's compiled-byte
+ * proxy is computed in-process by rsvelte (`session::own_size`), so the native path
+ * never calls back into a JS compiler. */
 interface ShakeSession {
     parse: (inputJson: string) => string;
     parseMore: (inputJson: string) => string;
-    shake: (configJson: string, ownSize: (payload: string) => number | null) => string;
+    shake: (configJson: string) => string;
 }
 /** The subset of the napi addon the plugin uses. */
 interface NativeEngine {
     ShakeSession: new () => ShakeSession;
+    engineApiVersion: () => number;
 }
+/** Whether a loaded module is a native addon this engine can drive: the right ABI
+ * generation AND the `ShakeSession` shape (`parse` + `parseMore` + `shake`). An OLDER
+ * published `svelte-shaker-engine-scan-native` — one with no `engineApiVersion`, a
+ * different generation, or predating `parseMore` — is REJECTED so the caller degrades
+ * to WASM/JS instead of mis-calling an incompatible binary and crashing the build. */
+export declare function hasSessionApi(mod: Partial<NativeEngine>): mod is NativeEngine;
 /**
  * Load the native Rust (napi) engine, or `null` if it can't be loaded (then the caller
  * falls back to the WASM / JS engine). Two locations are tried in order:
@@ -39,9 +49,11 @@ export interface NativeMonoResult {
  * parse); the crawl then resolves edges reading those facts instead of re-parsing in
  * JS, parsing any file discovered outside the seed on demand (`parseMore`). The
  * session retains every AST, so the shake needs no AST at the boundary — only the
- * resolved graph and the `ownSize` callback cross. A final svelte/compiler revert
- * cascade (the AUTHORITY) force-bails any residual unparseable output; the session's
- * own inner rsvelte cascade means valid programs settle in one outer pass.
+ * resolved graph crosses, and the monomorphization size proxy is computed in-process
+ * by rsvelte (`session::own_size`), so nothing calls back into a JS compiler. A final
+ * svelte/compiler revert cascade (the AUTHORITY) force-bails any residual unparseable
+ * output; the session's own inner rsvelte cascade means valid programs settle in one
+ * outer pass.
  */
 export declare function svelteShakerNativeWithMono(engine: NativeEngine, entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono: MonomorphizeOptions, escaped?: ComponentId[]): Promise<NativeMonoResult>;
 export {};

package/dist/native-engine.js

@@ -1,5 +1,4 @@
 import { createRequire } from 'node:module';
-import { compile } from 'svelte/compiler';
 import { buildAnalyzeInput, } from './analyze.js';
 import {} from './mono.js';
 import { revertCascade } from './revert-cascade.js';
@@ -10,12 +9,23 @@ import { revertCascade } from './revert-cascade.js';
 // whole-program AST ever crosses the JS boundary — the crawl reads per-file FACTS from
 // the session instead of re-parsing in JS (docs/RUST-MIGRATION.md M3).
 const require = createRequire(import.meta.url);
-/** Whether a loaded module exposes the `ShakeSession` API this engine drives —
- * `parse` + `parseMore` + `shake` on the prototype. Guards against an OLDER published
- * `svelte-shaker-engine-scan-native` (e.g. one predating `parseMore`) being resolved:
- * an API-incompatible binary is rejected so the caller falls back to WASM/JS rather
- * than crashing on a missing method. */
-function hasSessionApi(mod) {
+/** The addon ABI generation this driver speaks (native `engine_api_version`). Bump
+ * in lockstep with a breaking change to the exported methods. The 0.2.x addon's
+ * `shake` took a JS `ownSize` callback; 0.3.x computes the size proxy in Rust and
+ * `shake` takes ONE argument — calling a 0.2.x binary the 0.3.x way throws a napi
+ * TypeError that crashes `vite build`, so a version mismatch MUST be rejected here. */
+const EXPECTED_ENGINE_API_VERSION = 3;
+/** Whether a loaded module is a native addon this engine can drive: the right ABI
+ * generation AND the `ShakeSession` shape (`parse` + `parseMore` + `shake`). An OLDER
+ * published `svelte-shaker-engine-scan-native` — one with no `engineApiVersion`, a
+ * different generation, or predating `parseMore` — is REJECTED so the caller degrades
+ * to WASM/JS instead of mis-calling an incompatible binary and crashing the build. */
+export function hasSessionApi(mod) {
+    const versionFn = mod.engineApiVersion;
+    // The 0.2.x addon has no `engineApiVersion` export, so this rejects it — the exact
+    // skew that would otherwise throw on the new one-argument `shake` call.
+    if (typeof versionFn !== 'function' || versionFn() !== EXPECTED_ENGINE_API_VERSION)
+        return false;
     const ctor = mod.ShakeSession;
     const proto = ctor?.prototype;
     return (typeof ctor === 'function' &&
@@ -41,7 +51,7 @@ export function tryLoadNativeEngine() {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             const mod = require(spec);
             if (hasSessionApi(mod))
-                return { ShakeSession: mod.ShakeSession };
+                return { ShakeSession: mod.ShakeSession, engineApiVersion: mod.engineApiVersion };
         }
         catch {
             // Not resolvable here — try the next location.
@@ -49,22 +59,6 @@ export function tryLoadNativeEngine() {
     }
     return null;
 }
-/** The compiled-byte size proxy the monomorphization net-win gate uses — the same call
- * `mono.ts` / the WASM engine make, so the Rust gate decides byte-for-byte alike. */
-function ownSize(id, source) {
-    try {
-        return compile(source, { generate: 'client', dev: false, filename: id }).js.code.length;
-    }
-    catch {
-        return null;
-    }
-}
-/** `ShakeSession.shake`'s single-arg `ownSize` form: `[id, source]` JSON in (a napi
- * multi-arg marshaling bug makes the single-arg payload the reliable shape). */
-function ownSizePayload(payload) {
-    const [id, source] = JSON.parse(payload);
-    return ownSize(id, source);
-}
 /**
  * One native facts record → the crawl's {@link CrawlFacts}. An unparseable file is
  * treated as contributing nothing (its retained AST is Null, so the shake skips it —
@@ -89,9 +83,11 @@ function toCrawlFacts(f) {
  * parse); the crawl then resolves edges reading those facts instead of re-parsing in
  * JS, parsing any file discovered outside the seed on demand (`parseMore`). The
  * session retains every AST, so the shake needs no AST at the boundary — only the
- * resolved graph and the `ownSize` callback cross. A final svelte/compiler revert
- * cascade (the AUTHORITY) force-bails any residual unparseable output; the session's
- * own inner rsvelte cascade means valid programs settle in one outer pass.
+ * resolved graph crosses, and the monomorphization size proxy is computed in-process
+ * by rsvelte (`session::own_size`), so nothing calls back into a JS compiler. A final
+ * svelte/compiler revert cascade (the AUTHORITY) force-bails any residual unparseable
+ * output; the session's own inner rsvelte cascade means valid programs settle in one
+ * outer pass.
  */
 export async function svelteShakerNativeWithMono(engine, entries, resolve, readFile, mono, escaped = []) {
     const seedIds = Array.isArray(entries) ? entries : [entries];
@@ -135,7 +131,7 @@ export async function svelteShakerNativeWithMono(engine, entries, resolve, readF
     };
     let last;
     const files = revertCascade(input.files, (forceBail) => {
-        last = JSON.parse(session.shake(JSON.stringify({ ...config, forceBail: [...forceBail] }), ownSizePayload));
+        last = JSON.parse(session.shake(JSON.stringify({ ...config, forceBail: [...forceBail] })));
         return last.files;
     });
     // The engine already keys each variant by its `?shaker_variant=` request specifier

package/dist/rsvelte-parse.d.ts

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

package/dist/rsvelte-parse.js

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

package/dist/vite.js

@@ -10,7 +10,7 @@ import { compileExclude } from './exclude.js';
 // Re-export so a user can extend the default dev-only list: `devOnly: [...DEFAULT_DEV_ONLY, '…']`.
 export { DEFAULT_DEV_ONLY } from './dev-only.js';
 import { DEFAULT_MONO_OPTIONS } from './mono.js';
-import { tryLoadRsvelteParser } from './rsvelte-parse.js';
+import { tryLoadRsvelteParser, tryLoadRsvelteOwnSize } from './rsvelte-parse.js';
 import { svelteShakerWasm, svelteShakerWasmWithMono, tryLoadWasmEngine } from './wasm-engine.js';
 import { svelteShakerNativeWithMono, tryLoadNativeEngine } from './native-engine.js';
 /** kB with two decimals, the unit Vite itself uses in its build size report. */
@@ -474,6 +474,13 @@ export function shaker(options = {}) {
             });
             reportEscapeDiagnostics(escapeScan);
             const escaped = escapeScan.escaped;
+            // The monomorphization net-win gate's size proxy, computed by rsvelte's client
+            // codegen (`@rsvelte/compiler`), for the JS and WASM engines so their gate decides
+            // byte-for-byte like the native engine (which computes the SAME proxy in-process).
+            // Loaded lazily by the js/wasm mono branches only — the native path sizes in Rust
+            // and never needs it. If `@rsvelte/compiler` can't load, sizing returns null and
+            // the gate specializes nothing — sound (never bloat), just unoptimized.
+            const loadOwnSize = () => tryLoadRsvelteOwnSize() ?? (() => null);
             // Decide the engine.  The native Rust engine now implements every pass
             // INCLUDING monomorphization (it calls back to JS only for the compiled-size
             // proxy), so it
@@ -518,17 +525,31 @@ export function shaker(options = {}) {
                 // retained ASTs, and returns only the edits — byte-identical to the JS engine,
                 // monomorphization included (mono off -> an empty variant set). The `parser`
                 // option does not apply here (the session always parses in-process rsvelte).
-                const result = await svelteShakerNativeWithMono(native, entryComponents, resolve, read, mono, escaped);
-                shaken = result.files;
-                variantSources = result.variants;
-                reportSizes(shaken, read, root, options.verbose === true, log);
-                return;
+                //
+                // Defense in depth: `tryLoadNativeEngine` already rejects an ABI-incompatible
+                // binary (`engineApiVersion`), but any OTHER native failure (a napi marshaling
+                // error, an unforeseen throw) must NOT crash the build — degrade to the JS
+                // engine with a warning. `session.shake` is `catch_unwind`, so a native panic
+                // surfaces here as a throw rather than aborting the process.
+                try {
+                    const result = await svelteShakerNativeWithMono(native, entryComponents, resolve, read, mono, escaped);
+                    shaken = result.files;
+                    variantSources = result.variants;
+                    reportSizes(shaken, read, root, options.verbose === true, log);
+                    return;
+                }
+                catch (err) {
+                    warn(`the native engine failed at runtime (${err instanceof Error ? err.message : String(err)}); ` +
+                        `falling back to the JS engine for this build`);
+                    native = null;
+                    wasm = null; // fall through to the always-available JS engine below
+                }
             }
             if (wasm) {
                 // Native Rust engine — byte-identical to the JS engine, including
                 // monomorphization.
                 if (mono.enabled) {
-                    const result = await svelteShakerWasmWithMono(wasm, entryComponents, resolve, read, mono, getParse(true), escaped);
+                    const result = await svelteShakerWasmWithMono(wasm, entryComponents, resolve, read, mono, loadOwnSize(), getParse(true), escaped);
                     shaken = result.files;
                     variantSources = result.variants;
                 }
@@ -547,7 +568,7 @@ export function shaker(options = {}) {
                 reportSizes(shaken, read, root, options.verbose === true, log);
                 return;
             }
-            const result = await svelteShakerWithMono(entryComponents, resolve, read, mono, variantSpecifier, getParse(false), escaped);
+            const result = await svelteShakerWithMono(entryComponents, resolve, read, mono, variantSpecifier, getParse(false), escaped, loadOwnSize());
             shaken = result.files;
             variantSources = new Map();
             for (const v of result.mono.variants.values())

package/dist/wasm-engine.d.ts

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

package/dist/wasm-engine.js

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

package/package.json

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