smart-downscaler 0.6.1 → 0.6.3

package/README.md

@@ -35,7 +35,10 @@ A high-performance Rust library for intelligent image downscaling with pixel art
 | **Edge-Aware Processing** | Sobel/Scharr detection preserves boundaries |
 | **Spatial Coherence** | Neighbor and region voting for smooth results |
 | **K-Centroid Tile Logic** | Advanced dominant color extraction per tile |
-| **Rare-Color Preservation** | Saliency weighting + slot reservation keeps small, important colors (lips, eyes) |
+| **Rare-Color Preservation** | Saliency weighting + slot reservation keeps small important colors (lips, eyes) |
+| **Chroma Recovery** | Restores saturation lost to color merging, by perceptual difference |
+| **Skin-Tone Isolation** | Keeps skin and non-skin colors in separate palette domains |
+| **Reusable Preprocessing** | Prepare an image once, downscale to many sizes cheaply |
 | **Performance Preprocessing** | Resolution capping and color pre-quantization |
 | **WebAssembly Support** | Full browser compatibility with near-native speed |
 
@@ -171,10 +174,12 @@ println!("Palette: {} colors", result.palette.len());
 | **Tile Processing** |||||
 | `k_centroid` | `usize` | `1` | `1`, `2`, `3`, `4` | Tile color extraction mode |
 | `k_centroid_iterations` | `usize` | `0` | `0-10` | K-Means iterations for tile color |
-| **Rare-Color Preservation** |||||
-| `color_rarity` | `f32` | `0.0` | `0.0-1.0` | Damps frequency vote so large flat areas stop dominating (`0`=area, `1`=`count^0.5`) |
-| `detail_boost` | `f32` | `0.0` | `0.0-2.0` | Boosts colors in detail-rich regions via a local-contrast saliency map (`0`=off) |
-| `reserve_colors` | `usize` | `0` | `0 - palette_size` | Reserve N palette slots for distinct, important, under-represented source colors (`0`=off) |
+| **Rare-Color & Saturation** |||||
+| `color_rarity` | `f32` | `0.0` | `0.0-1.0` | Damps frequency vote so flat areas stop dominating (`0`=area, `1`=`count^0.5`) |
+| `detail_boost` | `f32` | `0.0` | `0.0-2.0` | Boosts colors in detail-rich regions via local-contrast saliency (`0`=off) |
+| `reserve_colors` | `usize` | `0` | `0 - palette_size` | Reserve N slots for distinct, important, under-represented source colors (`0`=off) |
+| `chroma_recovery` | `f32` | `0.0` | `0.0-1.0+` | Restore chroma lost to merging toward source mean chroma, constant hue, gamut-clamped (`0`=off) |
+| `skin_protection` | `f32` | `0.0` | `0.0-1.0` | Isolate skin vs non-skin into separate palette domains + quantization penalty (`0`=off) |
 
 ---
 
@@ -231,7 +236,7 @@ Controls how each source tile is reduced to a single representative color:
 | **Foremost** | `3` | K-Means (k=3), finer dominant detection | Complex textures, detailed sprites |
 | **Salient** | `4` | K-Means (k=2), keeps a distinctly-more-chromatic minority | Thin colorful features (lips, eyes, makeup) |
 
-> **Note:** Mode `2` (Dominant) snaps a mixed tile to its *larger* cluster, which discards thin minority colors — a tile that is 60% skin / 40% lip becomes pure skin. For faces and other artwork with small colorful features, prefer mode `4`, which keeps the colorful minority when it is non-trivial (≥22% of the tile) and clearly more chromatic than the majority.
+> **Note:** Mode `2` (Dominant) snaps a mixed tile to its *larger* cluster, discarding thin minority colors — a tile that is 60% skin / 40% lip becomes pure skin. For faces and artwork with small colorful features, prefer mode `4`, which keeps the colorful minority when it is non-trivial (≥22% of the tile) and clearly more chromatic than the majority.
 
 ```javascript
 // Mode 1: Average (default) - smooth results
@@ -323,6 +328,36 @@ const result = downscale_with_palette(
 
 ---
 
+### Prepare / Reuse Functions
+
+#### `prepare(data, width, height, config?)` / `prepare_rgba(data, width, height, config?)`
+
+Run target-independent work (resolution cap, color pre-quantization, segmentation)
+once and return a reusable handle. `prepare` takes `Uint8Array`; `prepare_rgba` takes
+`Uint8ClampedArray` (from canvas `getImageData`).
+
+```javascript
+const prepared = prepare_rgba(imageData.data, imageData.width, imageData.height, config);
+// prepared.width / prepared.height — dimensions after any resolution cap
+prepared.free(); // release WASM memory when finished
+```
+
+#### `downscale_prepared(prepared, targetWidth, targetHeight, config?)`
+
+Downscale a prepared image. The optional `config` overrides per-target knobs
+(`palette_size`, `k_centroid`, `chroma_recovery`, `skin_protection`, …); preprocess
+and segmentation settings always come from prepare time.
+
+```javascript
+const result = downscale_prepared(prepared, 128, 128, sizeConfig);
+```
+
+#### `downscale_prepared_with_palette(prepared, targetWidth, targetHeight, palette, config?)`
+
+As above, with a caller-supplied `Uint8Array` RGB palette.
+
+---
+
 ### Palette Functions
 
 #### `extract_palette_from_image(data, width, height, numColors, iterations, strategy?)`
@@ -508,58 +543,140 @@ const exact = WasmDownscaleConfig.exact_colors();
 
 ### Preset Comparison
 
-| Preset | Palette | K-Means | Segmentation | K-Centroid | Rare-Color¹ | Speed |
-|--------|---------|---------|--------------|------------|-------------|-------|
+| Preset | Palette | K-Means | Segmentation | K-Centroid | Rare/Sat/Skin¹ | Speed |
+|--------|---------|---------|--------------|------------|----------------|-------|
 | `fast()` | 16 | 3 | none | 1 (avg) | off | ⚡⚡⚡ |
 | `default` | 16 | 5 | hierarchy_fast | 1 (avg) | off | ⚡⚡ |
-| `vibrant()` | 24 | 8 | hierarchy_fast | 2 (dom) | on (3 slots) | ⚡ |
-| `quality()` | 32 | 10 | hierarchy | 2 (dom) | on (4 slots) | 🐢 |
+| `vibrant()` | 24 | 8 | hierarchy_fast | 2 (dom) | reserve+rarity+chroma(0.7) | ⚡ |
+| `quality()` | 32 | 10 | hierarchy | 2 (dom) | reserve+rarity+chroma(0.6)+skin(0.5) | 🐢 |
 | `exact_colors()` | 16 | 0 | hierarchy_fast | 1 (avg) | off | ⚡⚡ |
 
-¹ `vibrant()` and `quality()` enable `reserve_colors` + `detail_boost` + `color_rarity`. For the strongest thin-feature retention (faces), additionally set `k_centroid = 4`.
+¹ For the strongest thin-feature retention on faces, additionally set `k_centroid = 4`.
 
 ---
 
 ## Advanced Usage
 
+### Reusing Preprocessing Across Sizes (Performance)
+
+Resolution capping, color pre-quantization, and region segmentation depend only on
+the **source** image, not the target size. When you downscale the same source to
+several sizes (e.g. multiple previews), repeating that work each time is wasted.
+`prepare` runs it **once**; `downscale_prepared` then only does palette extraction
+and tiling per size.
+
+```javascript
+import init, { prepare_rgba, downscale_prepared, WasmDownscaleConfig } from 'smart-downscaler';
+await init();
+
+const base = new WasmDownscaleConfig();
+base.segmentation_method = 'hierarchy_fast';
+base.max_resolution_mp = 2.048;
+base.max_color_preprocess = 4096;
+
+// Once per source image:
+const prepared = prepare_rgba(imageData.data, imageData.width, imageData.height, base);
+
+// Many times, cheaply — palette_size and target size may differ each call:
+for (const { w, h, colors } of sizes) {
+  const cfg = new WasmDownscaleConfig();
+  cfg.palette_size = colors;
+  cfg.k_centroid = 4;
+  cfg.reserve_colors = Math.round(colors / 8);
+  cfg.chroma_recovery = 0.6;
+  cfg.skin_protection = 0.5;
+  const result = downscale_prepared(prepared, w, h, cfg);
+  // ... use result ...
+}
+
+prepared.free(); // release WASM memory when done (also freed on GC)
+```
+
+**Contract:** the prepared image fixes `max_resolution_mp`, `max_color_preprocess`,
+and `segmentation_*` at prepare time. `downscale_prepared` overlays per-target knobs
+(`palette_size`, `k_centroid`, `chroma_recovery`, `skin_protection`, …) but never
+re-runs preprocessing or segmentation. Change any of the prepare-time settings →
+call `prepare` again. `prepare` / `prepare_rgba` and `downscale_prepared` /
+`downscale_prepared_with_palette` mirror the one-shot functions.
+
+In Rust:
+
+```rust
+use smart_downscaler::{prepare_image, smart_downscale_prepared, DownscaleConfig};
+
+let prepared = prepare_image(&pixels, w, h, &config);          // once
+let small = smart_downscale_prepared(&prepared, 128, 128, &config_s);  // reuse
+let large = smart_downscale_prepared(&prepared, 256, 256, &config_l);  // reuse
+```
+
 ### Preserving Rare / Important Colors
 
-Palette extraction is **area-weighted**: a color that covers a large region gets
-many "votes", so small but perceptually important colors — lips, eyes, a logo,
-a colored highlight — are easily merged into the dominant tones (e.g. lips into
-skin) at low palette sizes (16–64). Three knobs counteract this:
+Palette extraction is **area-weighted**: a color covering a large region gets many
+"votes", so small but important colors — lips, eyes, a logo, a highlight — easily
+merge into dominant tones at low palette sizes (16–64). Counteract this with:
 
 | Knob | What it does | When to raise it |
 |------|--------------|------------------|
-| `reserve_colors` | **Hard guarantee.** Reserves N slots, filled with exact source colors that are far from the rest of the palette *and* important. The most reliable fix. | Always, for portraits/artwork with small features. ~`palette_size / 8`. |
-| `detail_boost` | Weights extraction toward colors in **detail-rich regions** using a local-contrast saliency map (measured at the downscale radius, so it targets features thin enough to be averaged away — and picks their *clean* interior color, not muddy edge blends). | When the important color sits in a high-detail area (most facial features). `0.8–1.0`. |
+| `reserve_colors` | **Hard guarantee.** Reserves N slots filled with exact source colors that are far from the rest of the palette *and* important. Most reliable fix. | Always, for portraits. ~`palette_size / 8`. |
+| `detail_boost` | Weights extraction toward **detail-rich regions** via a local-contrast saliency map (measured at the downscale radius, so it targets features thin enough to be averaged away). | When the important color is in a high-detail area. `0.8–1.0`. |
 | `color_rarity` | Damps the frequency vote (`count^p`, `p = 1 − 0.5·rarity`) so large flat regions stop monopolizing the palette. | Mild assist alongside the above. `0.3–0.4`. |
 
-Pair these with `k_centroid = 4` (Salient), which stops the *tile* stage from
-discarding the same minority colors. A correct palette is wasted if a 60% skin /
-40% lip tile is still snapped to skin.
+Pair these with `k_centroid = 4` (Salient) so the *tile* stage doesn't discard the
+same minority colors a correct palette preserved.
+
+### Restoring Saturation (Chroma Recovery)
+
+Averaging colors in Oklab during median-cut/k-means pulls the result *inward* — the
+mean of two hues is less colorful than either. `chroma_recovery` undoes this **by
+perceptual difference**: each palette color is pushed back toward the count-weighted
+**mean chroma of the source colors it represents**, at constant hue and lightness,
+then clamped to the sRGB gamut. It only ever *increases* saturation, never reduces it.
+
+```javascript
+config.chroma_recovery = 0.6;  // 0 = off, ~0.6 natural, 1.0 = full restoration, >1 = punchy
+```
+
+This is a global de-wash that fixes the "muddy" look of low-palette output; it is
+independent of (and composes with) the rare-color knobs above.
+
+### Isolating Skin Tones
+
+Skin clusters tightly in the YCbCr chroma plane (`80 ≤ Cb ≤ 120`, `133 ≤ Cr ≤ 173`).
+With `skin_protection > 0`, skin and non-skin colors are extracted in **separate
+domains** — a single palette bucket never mixes the two, so skin never picks up a
+muddy blend with hair/background and vice-versa. Palette slots are split between the
+domains by population (each guaranteed at least one). The same value also acts as a
+**quantization penalty**: a skin tile prefers skin palette colors, a non-skin tile
+prefers non-skin.
+
+```javascript
+config.skin_protection = 0.5;  // 0 = off, ~0.5 typical
+```
+
+> Lips are reddish and usually pass the skin test, so they live in the *skin* domain
+> — `skin_protection` won't separate lips from skin. Use `reserve_colors` /
+> `k_centroid = 4` for that; they operate *within* the skin domain, so the two
+> features compose: skin gets its own budget, and a distinct lip is preserved inside it.
+
+### Recommended Config for Faces / Portraits
 
 ```javascript
-// Recommended for faces / portraits at 16–64 colors
 const config = new WasmDownscaleConfig();
 config.palette_size      = 32;
-config.palette_strategy  = 'oklab';     // honors color_rarity / detail_boost in median-cut
-config.k_centroid        = 4;           // salient tile color (keep colorful minorities)
+config.palette_strategy  = 'oklab';     // honors color_rarity / detail_boost
+config.k_centroid        = 4;           // salient tile color
 config.k_centroid_iterations = 2;
 config.reserve_colors    = 4;           // ~palette_size / 8 — the guarantee
 config.detail_boost      = 0.9;         // saliency targeting
 config.color_rarity      = 0.35;        // frequency damping
+config.chroma_recovery   = 0.6;         // restore saturation lost to merging
+config.skin_protection   = 0.5;         // separate skin / non-skin
 config.neighbor_weight   = 0.18;        // lower = less erosion of thin features
 ```
 
-> **Trade-off:** at very small palettes, reserving slots for rare colors costs
-> some gradient smoothness elsewhere. Scale `reserve_colors` with `palette_size`
-> (16→2, 32→4, 64→8) and lean on it harder at the high end.
->
-> **Strategy note:** `bitmask` ignores frequency weights during its initial
-> split, so with `bitmask` only `reserve_colors` is active. Use `oklab` (or
-> `saturation`) if you also want `color_rarity` / `detail_boost` to shape the
-> main palette.
+> **Strategy note:** `bitmask` ignores frequency weights during its initial split, so
+> with `bitmask` only `reserve_colors` is active. Use `oklab` (or `saturation`) if you
+> also want `color_rarity` / `detail_boost` to shape the main palette.
 
 ### Custom Palette Workflow
 

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "smart-downscaler",
-  "type": "module",
   "collaborators": [
     "Pixagram"
   ],
   "description": "Intelligent pixel art downscaler with region-aware color quantization",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -18,9 +17,6 @@
   ],
   "main": "smart_downscaler.js",
   "types": "smart_downscaler.d.ts",
-  "sideEffects": [
-    "./snippets/*"
-  ],
   "keywords": [
     "pixel-art",
     "image-processing",

package/smart_downscaler.d.ts

@@ -33,6 +33,10 @@ export class WasmDownscaleConfig {
     constructor();
     static quality(): WasmDownscaleConfig;
     static vibrant(): WasmDownscaleConfig;
+    /**
+     * Restore chroma lost to merging (constant hue, gamut-clamped). 0.0 = off, ~0.6 natural.
+     */
+    chroma_recovery: number;
     /**
      * Rare-color preservation: 0.0 = pure area weighting, 1.0 = strong (count^0.5).
      */
@@ -57,6 +61,10 @@ export class WasmDownscaleConfig {
      * Reserve N palette slots for distinct, important, under-represented colors. 0 = off.
      */
     reserve_colors: number;
+    /**
+     * Isolate skin tones from non-skin (separate domains + mismatch penalty). 0.0 = off, ~0.5.
+     */
+    skin_protection: number;
     slic_compactness: number;
     slic_superpixels: number;
     two_pass_refinement: boolean;
@@ -77,6 +85,22 @@ export class WasmDownscaleResult {
     readonly width: number;
 }
 
+/**
+ * Opaque handle holding the prepared (preprocessed + segmented) source image.
+ * Build with [`prepare`] / [`prepare_rgba`], reuse with [`downscale_prepared`].
+ *
+ * The segmentation is fixed at prepare time from the config you pass. Palette
+ * size and target dimensions may differ on every [`downscale_prepared`] call.
+ * If you change resolution / color-preprocess / segmentation settings, prepare again.
+ */
+export class WasmPreparedImage {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly height: number;
+    readonly width: number;
+}
+
 /**
  * Analyze colors — FIX: uses HashMap<u32, usize> for O(1) lookup (was O(n) linear scan)
  */
@@ -86,6 +110,19 @@ export function color_distance(r1: number, g1: number, b1: number, r2: number, g
 
 export function downscale(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
 
+/**
+ * Downscale a prepared image. Pass an optional `config` to override per-target
+ * knobs (palette_size, k_centroid, chroma_recovery, skin_protection, …). The
+ * preprocess/segmentation settings always come from prepare time. When `config`
+ * is omitted, the prepare-time config is reused as-is.
+ */
+export function downscale_prepared(prepared: WasmPreparedImage, target_width: number, target_height: number, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
+
+/**
+ * Downscale a prepared image with a caller-supplied palette.
+ */
+export function downscale_prepared_with_palette(prepared: WasmPreparedImage, target_width: number, target_height: number, palette_data: Uint8Array, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
+
 export function downscale_rgba(image_data: Uint8ClampedArray, width: number, height: number, target_width: number, target_height: number, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
 
 export function downscale_simple(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, num_colors: number): WasmDownscaleResult;
@@ -107,130 +144,20 @@ export function log(message: string): void;
 export function oklab_to_rgb(l: number, a: number, b: number): Uint8Array;
 
 /**
- * Quantize to palette — FIX: compute Oklab once per pixel (was twice)
+ * Prepare from a `Uint8Array` (RGBA).
  */
-export function quantize_to_palette(image_data: Uint8Array, width: number, height: number, palette_data: Uint8Array): WasmDownscaleResult;
-
-export function rgb_to_oklab(r: number, g: number, b: number): Float32Array;
-
-export function version(): string;
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-    readonly memory: WebAssembly.Memory;
-    readonly __wbg_coloranalysisresult_free: (a: number, b: number) => void;
-    readonly __wbg_colorentry_free: (a: number, b: number) => void;
-    readonly __wbg_get_wasmdownscaleconfig_color_rarity: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_detail_boost: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_edge_weight: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_hierarchy_min_size: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_hierarchy_threshold: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_k_centroid: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_k_centroid_iterations: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_kmeans_iterations: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_max_color_preprocess: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_max_resolution_mp: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_neighbor_weight: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_palette_size: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_refinement_iterations: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_region_weight: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_reserve_colors: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_slic_compactness: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_slic_superpixels: (a: number) => number;
-    readonly __wbg_get_wasmdownscaleconfig_two_pass_refinement: (a: number) => number;
-    readonly __wbg_set_wasmdownscaleconfig_color_rarity: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_detail_boost: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_edge_weight: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_hierarchy_min_size: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_hierarchy_threshold: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_k_centroid: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_k_centroid_iterations: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_kmeans_iterations: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_max_color_preprocess: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_max_resolution_mp: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_neighbor_weight: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_palette_size: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_refinement_iterations: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_region_weight: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_reserve_colors: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_slic_compactness: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_slic_superpixels: (a: number, b: number) => void;
-    readonly __wbg_set_wasmdownscaleconfig_two_pass_refinement: (a: number, b: number) => void;
-    readonly __wbg_wasmdownscaleconfig_free: (a: number, b: number) => void;
-    readonly __wbg_wasmdownscaleresult_free: (a: number, b: number) => void;
-    readonly analyze_colors: (a: any, b: number, c: number, d: number) => [number, number, number];
-    readonly color_distance: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-    readonly coloranalysisresult_color_count: (a: number) => number;
-    readonly coloranalysisresult_get_color: (a: number, b: number) => number;
-    readonly coloranalysisresult_get_colors_flat: (a: number) => any;
-    readonly coloranalysisresult_success: (a: number) => number;
-    readonly coloranalysisresult_to_json: (a: number) => [number, number, number];
-    readonly coloranalysisresult_total_pixels: (a: number) => number;
-    readonly colorentry_b: (a: number) => number;
-    readonly colorentry_count: (a: number) => number;
-    readonly colorentry_g: (a: number) => number;
-    readonly colorentry_hex: (a: number) => [number, number];
-    readonly colorentry_percentage: (a: number) => number;
-    readonly colorentry_r: (a: number) => number;
-    readonly downscale: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
-    readonly downscale_rgba: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
-    readonly downscale_simple: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
-    readonly downscale_with_palette: (a: any, b: number, c: number, d: number, e: number, f: any, g: number) => [number, number, number];
-    readonly extract_palette_from_image: (a: any, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
-    readonly get_chroma: (a: number, b: number, c: number) => number;
-    readonly get_lightness: (a: number, b: number, c: number) => number;
-    readonly get_palette_strategies: () => any;
-    readonly init: () => void;
-    readonly log: (a: number, b: number) => void;
-    readonly oklab_to_rgb: (a: number, b: number, c: number) => any;
-    readonly quantize_to_palette: (a: any, b: number, c: number, d: any) => [number, number, number];
-    readonly rgb_to_oklab: (a: number, b: number, c: number) => any;
-    readonly version: () => [number, number];
-    readonly wasmdownscaleconfig_exact_colors: () => number;
-    readonly wasmdownscaleconfig_fast: () => number;
-    readonly wasmdownscaleconfig_new: () => number;
-    readonly wasmdownscaleconfig_palette_strategy: (a: number) => [number, number];
-    readonly wasmdownscaleconfig_quality: () => number;
-    readonly wasmdownscaleconfig_segmentation_method: (a: number) => [number, number];
-    readonly wasmdownscaleconfig_set_palette_strategy: (a: number, b: number, c: number) => void;
-    readonly wasmdownscaleconfig_set_segmentation_method: (a: number, b: number, c: number) => void;
-    readonly wasmdownscaleconfig_vibrant: () => number;
-    readonly wasmdownscaleresult_data: (a: number) => any;
-    readonly wasmdownscaleresult_height: (a: number) => number;
-    readonly wasmdownscaleresult_indices: (a: number) => any;
-    readonly wasmdownscaleresult_palette: (a: number) => any;
-    readonly wasmdownscaleresult_palette_size: (a: number) => number;
-    readonly wasmdownscaleresult_rgb_data: (a: number) => any;
-    readonly wasmdownscaleresult_width: (a: number) => number;
-    readonly __wbindgen_exn_store: (a: number) => void;
-    readonly __externref_table_alloc: () => number;
-    readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_malloc: (a: number, b: number) => number;
-    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-    readonly __externref_table_dealloc: (a: number) => void;
-    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-    readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
+export function prepare(image_data: Uint8Array, width: number, height: number, config?: WasmDownscaleConfig | null): WasmPreparedImage;
 
 /**
- * Instantiates the given `module`, which can either be bytes or
- * a precompiled `WebAssembly.Module`.
- *
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
- *
- * @returns {InitOutput}
+ * Prepare from a `Uint8ClampedArray` (canvas `getImageData`).
  */
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+export function prepare_rgba(image_data: Uint8ClampedArray, width: number, height: number, config?: WasmDownscaleConfig | null): WasmPreparedImage;
 
 /**
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
- * for everything else, calls `WebAssembly.instantiate` directly.
- *
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
- *
- * @returns {Promise<InitOutput>}
+ * Quantize to palette — FIX: compute Oklab once per pixel (was twice)
  */
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
+export function quantize_to_palette(image_data: Uint8Array, width: number, height: number, palette_data: Uint8Array): WasmDownscaleResult;
+
+export function rgb_to_oklab(r: number, g: number, b: number): Float32Array;
+
+export function version(): string;

package/smart_downscaler.js

@@ -1,6 +1,6 @@
 /* @ts-self-types="./smart_downscaler.d.ts" */
 
-export class ColorAnalysisResult {
+class ColorAnalysisResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(ColorAnalysisResult.prototype);
@@ -66,8 +66,9 @@ export class ColorAnalysisResult {
     }
 }
 if (Symbol.dispose) ColorAnalysisResult.prototype[Symbol.dispose] = ColorAnalysisResult.prototype.free;
+exports.ColorAnalysisResult = ColorAnalysisResult;
 
-export class ColorEntry {
+class ColorEntry {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(ColorEntry.prototype);
@@ -137,8 +138,9 @@ export class ColorEntry {
     }
 }
 if (Symbol.dispose) ColorEntry.prototype[Symbol.dispose] = ColorEntry.prototype.free;
+exports.ColorEntry = ColorEntry;
 
-export class WasmDownscaleConfig {
+class WasmDownscaleConfig {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(WasmDownscaleConfig.prototype);
@@ -156,6 +158,14 @@ export class WasmDownscaleConfig {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmdownscaleconfig_free(ptr, 0);
     }
+    /**
+     * Restore chroma lost to merging (constant hue, gamut-clamped). 0.0 = off, ~0.6 natural.
+     * @returns {number}
+     */
+    get chroma_recovery() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_chroma_recovery(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Rare-color preservation: 0.0 = pure area weighting, 1.0 = strong (count^0.5).
      * @returns {number}
@@ -264,6 +274,14 @@ export class WasmDownscaleConfig {
         const ret = wasm.__wbg_get_wasmdownscaleconfig_reserve_colors(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Isolate skin tones from non-skin (separate domains + mismatch penalty). 0.0 = off, ~0.5.
+     * @returns {number}
+     */
+    get skin_protection() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_skin_protection(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -285,6 +303,13 @@ export class WasmDownscaleConfig {
         const ret = wasm.__wbg_get_wasmdownscaleconfig_two_pass_refinement(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Restore chroma lost to merging (constant hue, gamut-clamped). 0.0 = off, ~0.6 natural.
+     * @param {number} arg0
+     */
+    set chroma_recovery(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_chroma_recovery(this.__wbg_ptr, arg0);
+    }
     /**
      * Rare-color preservation: 0.0 = pure area weighting, 1.0 = strong (count^0.5).
      * @param {number} arg0
@@ -378,6 +403,13 @@ export class WasmDownscaleConfig {
     set reserve_colors(arg0) {
         wasm.__wbg_set_wasmdownscaleconfig_reserve_colors(this.__wbg_ptr, arg0);
     }
+    /**
+     * Isolate skin tones from non-skin (separate domains + mismatch penalty). 0.0 = off, ~0.5.
+     * @param {number} arg0
+     */
+    set skin_protection(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_skin_protection(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {number} arg0
      */
@@ -478,8 +510,9 @@ export class WasmDownscaleConfig {
     }
 }
 if (Symbol.dispose) WasmDownscaleConfig.prototype[Symbol.dispose] = WasmDownscaleConfig.prototype.free;
+exports.WasmDownscaleConfig = WasmDownscaleConfig;
 
-export class WasmDownscaleResult {
+class WasmDownscaleResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(WasmDownscaleResult.prototype);
@@ -548,6 +581,51 @@ export class WasmDownscaleResult {
     }
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
+exports.WasmDownscaleResult = WasmDownscaleResult;
+
+/**
+ * Opaque handle holding the prepared (preprocessed + segmented) source image.
+ * Build with [`prepare`] / [`prepare_rgba`], reuse with [`downscale_prepared`].
+ *
+ * The segmentation is fixed at prepare time from the config you pass. Palette
+ * size and target dimensions may differ on every [`downscale_prepared`] call.
+ * If you change resolution / color-preprocess / segmentation settings, prepare again.
+ */
+class WasmPreparedImage {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPreparedImage.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPreparedImageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPreparedImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpreparedimage_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmpreparedimage_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmpreparedimage_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WasmPreparedImage.prototype[Symbol.dispose] = WasmPreparedImage.prototype.free;
+exports.WasmPreparedImage = WasmPreparedImage;
 
 /**
  * Analyze colors — FIX: uses HashMap<u32, usize> for O(1) lookup (was O(n) linear scan)
@@ -556,7 +634,7 @@ if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscal
  * @param {string} sort_method
  * @returns {ColorAnalysisResult}
  */
-export function analyze_colors(image_data, max_colors, sort_method) {
+function analyze_colors(image_data, max_colors, sort_method) {
     const ptr0 = passStringToWasm0(sort_method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.analyze_colors(image_data, max_colors, ptr0, len0);
@@ -565,6 +643,7 @@ export function analyze_colors(image_data, max_colors, sort_method) {
     }
     return ColorAnalysisResult.__wrap(ret[0]);
 }
+exports.analyze_colors = analyze_colors;
 
 /**
  * @param {number} r1
@@ -575,10 +654,11 @@ export function analyze_colors(image_data, max_colors, sort_method) {
  * @param {number} b2
  * @returns {number}
  */
-export function color_distance(r1, g1, b1, r2, g2, b2) {
+function color_distance(r1, g1, b1, r2, g2, b2) {
     const ret = wasm.color_distance(r1, g1, b1, r2, g2, b2);
     return ret;
 }
+exports.color_distance = color_distance;
 
 /**
  * @param {Uint8Array} image_data
@@ -589,7 +669,7 @@ export function color_distance(r1, g1, b1, r2, g2, b2) {
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-export function downscale(image_data, width, height, target_width, target_height, config) {
+function downscale(image_data, width, height, target_width, target_height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -601,6 +681,57 @@ export function downscale(image_data, width, height, target_width, target_height
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
+exports.downscale = downscale;
+
+/**
+ * Downscale a prepared image. Pass an optional `config` to override per-target
+ * knobs (palette_size, k_centroid, chroma_recovery, skin_protection, …). The
+ * preprocess/segmentation settings always come from prepare time. When `config`
+ * is omitted, the prepare-time config is reused as-is.
+ * @param {WasmPreparedImage} prepared
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+function downscale_prepared(prepared, target_width, target_height, config) {
+    _assertClass(prepared, WasmPreparedImage);
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.downscale_prepared(prepared.__wbg_ptr, target_width, target_height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+exports.downscale_prepared = downscale_prepared;
+
+/**
+ * Downscale a prepared image with a caller-supplied palette.
+ * @param {WasmPreparedImage} prepared
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {Uint8Array} palette_data
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+function downscale_prepared_with_palette(prepared, target_width, target_height, palette_data, config) {
+    _assertClass(prepared, WasmPreparedImage);
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.downscale_prepared_with_palette(prepared.__wbg_ptr, target_width, target_height, palette_data, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+exports.downscale_prepared_with_palette = downscale_prepared_with_palette;
 
 /**
  * @param {Uint8ClampedArray} image_data
@@ -611,7 +742,7 @@ export function downscale(image_data, width, height, target_width, target_height
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-export function downscale_rgba(image_data, width, height, target_width, target_height, config) {
+function downscale_rgba(image_data, width, height, target_width, target_height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -623,6 +754,7 @@ export function downscale_rgba(image_data, width, height, target_width, target_h
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
+exports.downscale_rgba = downscale_rgba;
 
 /**
  * @param {Uint8Array} image_data
@@ -633,13 +765,14 @@ export function downscale_rgba(image_data, width, height, target_width, target_h
  * @param {number} num_colors
  * @returns {WasmDownscaleResult}
  */
-export function downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
+function downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
     const ret = wasm.downscale_simple(image_data, width, height, target_width, target_height, num_colors);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
+exports.downscale_simple = downscale_simple;
 
 /**
  * @param {Uint8Array} image_data
@@ -651,7 +784,7 @@ export function downscale_simple(image_data, width, height, target_width, target
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-export function downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, config) {
+function downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -663,6 +796,7 @@ export function downscale_with_palette(image_data, width, height, target_width,
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
+exports.downscale_with_palette = downscale_with_palette;
 
 /**
  * @param {Uint8Array} image_data
@@ -673,7 +807,7 @@ export function downscale_with_palette(image_data, width, height, target_width,
  * @param {string | null} [strategy]
  * @returns {Uint8Array}
  */
-export function extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, strategy) {
+function extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, strategy) {
     var ptr0 = isLikeNone(strategy) ? 0 : passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len0 = WASM_VECTOR_LEN;
     const ret = wasm.extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, ptr0, len0);
@@ -682,6 +816,7 @@ export function extract_palette_from_image(image_data, _width, _height, num_colo
     }
     return takeFromExternrefTable0(ret[0]);
 }
+exports.extract_palette_from_image = extract_palette_from_image;
 
 /**
  * @param {number} r
@@ -689,10 +824,11 @@ export function extract_palette_from_image(image_data, _width, _height, num_colo
  * @param {number} b
  * @returns {number}
  */
-export function get_chroma(r, g, b) {
+function get_chroma(r, g, b) {
     const ret = wasm.get_chroma(r, g, b);
     return ret;
 }
+exports.get_chroma = get_chroma;
 
 /**
  * @param {number} r
@@ -700,31 +836,35 @@ export function get_chroma(r, g, b) {
  * @param {number} b
  * @returns {number}
  */
-export function get_lightness(r, g, b) {
+function get_lightness(r, g, b) {
     const ret = wasm.get_lightness(r, g, b);
     return ret;
 }
+exports.get_lightness = get_lightness;
 
 /**
  * @returns {Array<any>}
  */
-export function get_palette_strategies() {
+function get_palette_strategies() {
     const ret = wasm.get_palette_strategies();
     return ret;
 }
+exports.get_palette_strategies = get_palette_strategies;
 
-export function init() {
+function init() {
     wasm.init();
 }
+exports.init = init;
 
 /**
  * @param {string} message
  */
-export function log(message) {
+function log(message) {
     const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.log(ptr0, len0);
 }
+exports.log = log;
 
 /**
  * @param {number} l
@@ -732,10 +872,55 @@ export function log(message) {
  * @param {number} b
  * @returns {Uint8Array}
  */
-export function oklab_to_rgb(l, a, b) {
+function oklab_to_rgb(l, a, b) {
     const ret = wasm.oklab_to_rgb(l, a, b);
     return ret;
 }
+exports.oklab_to_rgb = oklab_to_rgb;
+
+/**
+ * Prepare from a `Uint8Array` (RGBA).
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmPreparedImage}
+ */
+function prepare(image_data, width, height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.prepare(image_data, width, height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedImage.__wrap(ret[0]);
+}
+exports.prepare = prepare;
+
+/**
+ * Prepare from a `Uint8ClampedArray` (canvas `getImageData`).
+ * @param {Uint8ClampedArray} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmPreparedImage}
+ */
+function prepare_rgba(image_data, width, height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.prepare_rgba(image_data, width, height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPreparedImage.__wrap(ret[0]);
+}
+exports.prepare_rgba = prepare_rgba;
 
 /**
  * Quantize to palette — FIX: compute Oklab once per pixel (was twice)
@@ -745,13 +930,14 @@ export function oklab_to_rgb(l, a, b) {
  * @param {Uint8Array} palette_data
  * @returns {WasmDownscaleResult}
  */
-export function quantize_to_palette(image_data, width, height, palette_data) {
+function quantize_to_palette(image_data, width, height, palette_data) {
     const ret = wasm.quantize_to_palette(image_data, width, height, palette_data);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
+exports.quantize_to_palette = quantize_to_palette;
 
 /**
  * @param {number} r
@@ -759,15 +945,16 @@ export function quantize_to_palette(image_data, width, height, palette_data) {
  * @param {number} b
  * @returns {Float32Array}
  */
-export function rgb_to_oklab(r, g, b) {
+function rgb_to_oklab(r, g, b) {
     const ret = wasm.rgb_to_oklab(r, g, b);
     return ret;
 }
+exports.rgb_to_oklab = rgb_to_oklab;
 
 /**
  * @returns {string}
  */
-export function version() {
+function version() {
     let deferred1_0;
     let deferred1_1;
     try {
@@ -779,6 +966,7 @@ export function version() {
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
+exports.version = version;
 
 function __wbg_get_imports() {
     const import0 = {
@@ -876,6 +1064,9 @@ const WasmDownscaleConfigFinalization = (typeof FinalizationRegistry === 'undefi
 const WasmDownscaleResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleresult_free(ptr >>> 0, 1));
+const WasmPreparedImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpreparedimage_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -965,15 +1156,7 @@ function takeFromExternrefTable0(idx) {
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
 function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
@@ -992,94 +1175,8 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-let wasmModule, wasm;
-function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    wasmModule = module;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
-}
-
-async function __wbg_load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-            } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
-
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else { throw e; }
-            }
-        }
-
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
-    } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-        } else {
-            return instance;
-        }
-    }
-
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
-        }
-        return false;
-    }
-}
-
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module !== undefined) {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
-    }
-
-    const imports = __wbg_get_imports();
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-    const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance, module);
-}
-
-async function __wbg_init(module_or_path) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module_or_path !== undefined) {
-        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path)
-        } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
-        }
-    }
-
-    if (module_or_path === undefined) {
-        module_or_path = new URL('smart_downscaler_bg.wasm', import.meta.url);
-    }
-    const imports = __wbg_get_imports();
-
-    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
-        module_or_path = fetch(module_or_path);
-    }
-
-    const { instance, module } = await __wbg_load(await module_or_path, imports);
-
-    return __wbg_finalize_init(instance, module);
-}
-
-export { initSync, __wbg_init as default };
+const wasmPath = `${__dirname}/smart_downscaler_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();