@pixagram/renderart 0.1.2 → 0.2.0

package/README.md

@@ -12,7 +12,7 @@ All engines support:
 - ⚡ **GPU acceleration** via WebGL2 (CRT, HEX)
 - 🦀 **CPU fallback** via Rust/WASM (all engines)
 - 🎨 **Customizable presets** and fine-grained options
-- 📦 **Zero dependencies** - everything bundled
+- 📦 **Zero dependencies** in core bundle
 
 ## Installation
 
@@ -22,42 +22,76 @@ npm install @pixagram/renderart
 
 ## Quick Start
 
+### GPU-Only Mode (Simplest - No WASM)
+
 ```typescript
 import { RenderArt } from '@pixagram/renderart';
 
-// Initialize (loads WASM if needed)
-const renderer = await RenderArt.create();
+// Create GPU-only renderer (no WASM loading required)
+const renderer = RenderArt.createGpuOnly();
 
 // Get your image data
 const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
 
-// Apply CRT effect
-const crtResult = await renderer.crt.render(imageData, { scale: 3 });
-
-// Apply hexagonal transformation
-const hexResult = await renderer.hex.render(imageData, { scale: 16 });
+// Apply CRT effect (GPU)
+const crtResult = renderer.crt.renderSync(imageData, { scale: 3 });
 
-// Apply xBRZ scaling
-const xbrzResult = await renderer.xbrz.render(imageData, { scale: 4 });
+// Apply HEX effect (GPU)
+const hexResult = renderer.hex.renderSync(imageData, { scale: 16 });
 
 // Use the result
 ctx.putImageData(new ImageData(crtResult.data, crtResult.width, crtResult.height), 0, 0);
 ```
 
-## API Reference
+### With CPU Fallback (Requires WASM)
+
+```typescript
+import { RenderArt, initWasm } from '@pixagram/renderart';
+import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+
+// Initialize WASM module first
+await initWasm(() => init(), wasm);
+
+// Create renderer with CPU fallback
+const renderer = RenderArt.create();
 
-### RenderArt
+// Now all engines work, including XBRZ (CPU-only)
+const xbrzResult = renderer.xbrz.render(imageData, { scale: 4 });
+```
 
-Main class providing access to all rendering engines.
+### Direct GPU Renderer Usage
 
 ```typescript
-const renderer = await RenderArt.create();
+import { CrtGpuRenderer, HexGpuRenderer } from '@pixagram/renderart';
+
+// Use GPU renderers directly (no WASM needed)
+const crt = CrtGpuRenderer.create();
+const result = crt.render(imageData, {
+  scale: 3,
+  warpX: 0.02,
+  scanOpacity: 0.6,
+});
+
+// Clean up
+crt.dispose();
+```
+
+## API Reference
+
+### RenderArt (Unified API)
+
+```typescript
+// GPU-only mode
+const renderer = RenderArt.createGpuOnly();
+
+// With CPU fallback (requires WASM init first)
+const renderer = RenderArt.create();
 
 // Access capabilities
 console.log(renderer.capabilities);
 // { gpu: true, cpu: true, maxTextureSize: 16384, recommendedBackend: 'gpu' }
 
-// Cleanup when done
+// Cleanup
 renderer.dispose();
 ```
 
@@ -65,13 +99,13 @@ renderer.dispose();
 
 ```typescript
 // With options
-const result = await renderer.crt.render(imageData, {
+const result = renderer.crt.render(imageData, {
   scale: 3,              // 2-32 (default: 3)
-  warpX: 0.015,          // Horizontal curvature (default: 0.015)
-  warpY: 0.02,           // Vertical curvature (default: 0.02)
-  scanHardness: -4.0,    // Scanline sharpness (default: -4.0)
-  scanOpacity: 0.5,      // Scanline intensity (default: 0.5)
-  maskOpacity: 0.3,      // Shadow mask intensity (default: 0.3)
+  warpX: 0.015,          // Horizontal curvature
+  warpY: 0.02,           // Vertical curvature
+  scanHardness: -4.0,    // Scanline sharpness
+  scanOpacity: 0.5,      // Scanline intensity
+  maskOpacity: 0.3,      // Shadow mask intensity
   enableWarp: true,      // Enable barrel distortion
   enableScanlines: true, // Enable scanlines
   enableMask: true,      // Enable shadow mask
@@ -79,7 +113,7 @@ const result = await renderer.crt.render(imageData, {
 });
 
 // With preset
-const result = await renderer.crt.render(imageData, 'authentic');
+const result = renderer.crt.render(imageData, 'authentic');
 // Presets: 'default', 'authentic', 'subtle', 'flat'
 
 // Synchronous GPU-only rendering
@@ -90,63 +124,60 @@ const result = renderer.crt.renderSync(imageData, { scale: 3 });
 
 ```typescript
 // With options
-const result = await renderer.hex.render(imageData, {
+const result = renderer.hex.render(imageData, {
   scale: 16,                    // 2-32 (default: 16)
   orientation: 'flat-top',      // 'flat-top' or 'pointy-top'
   drawBorders: true,            // Draw hexagon borders
-  borderColor: '#282828',       // Border color (CSS or 0xRRGGBBAA)
-  borderThickness: 1,           // Border thickness in pixels
-  backgroundColor: 'transparent', // Background color
+  borderColor: '#282828',       // Border color
+  borderThickness: 1,           // Border thickness
+  backgroundColor: 'transparent',
   backend: 'auto',
 });
 
 // With preset
-const result = await renderer.hex.render(imageData, 'bordered');
+const result = renderer.hex.render(imageData, 'bordered');
 // Presets: 'default', 'bordered', 'pointy'
 
 // Get output dimensions
 const dims = renderer.hex.getDimensions(64, 64, { scale: 16 });
-// { width: 123, height: 134 }
 ```
 
-### XBRZ Engine
+### XBRZ Engine (CPU Only)
 
 ```typescript
-// With options
-const result = await renderer.xbrz.render(imageData, {
+// Requires WASM initialization
+const result = renderer.xbrz.render(imageData, {
   scale: 4,                          // 2-6 (default: 2)
-  luminanceWeight: 1.0,              // Edge detection weight
-  equalColorTolerance: 30,           // Color matching tolerance
-  dominantDirectionThreshold: 4.4,   // Edge direction threshold
-  steepDirectionThreshold: 2.2,      // Steep edge threshold
+  luminanceWeight: 1.0,
+  equalColorTolerance: 30,
+  dominantDirectionThreshold: 4.4,
+  steepDirectionThreshold: 2.2,
 });
 
 // With preset
-const result = await renderer.xbrz.render(imageData, 'sharp');
+const result = renderer.xbrz.render(imageData, 'sharp');
 // Presets: 'default', 'sharp', 'smooth'
-
-// Get output dimensions
-const dims = renderer.xbrz.getDimensions(64, 64, 4);
-// { width: 256, height: 256 }
 ```
 
 ## Backend Selection
 
-Each engine automatically selects the best available backend:
-
 | Engine | GPU (WebGL2) | CPU (WASM) |
 |--------|--------------|------------|
 | CRT    | ✅ Primary   | ✅ Fallback |
 | HEX    | ✅ Primary   | ✅ Fallback |
 | XBRZ   | ❌ N/A       | ✅ Only     |
 
-Force a specific backend:
-```typescript
-// Force GPU
-const result = await renderer.crt.render(imageData, { backend: 'gpu' });
+## WASM Loading with Custom Path
 
-// Force CPU
-const result = await renderer.crt.render(imageData, { backend: 'cpu' });
+```typescript
+import { initWasm } from '@pixagram/renderart';
+import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+
+// Load WASM from custom URL
+await initWasm(
+  () => init('/static/wasm/renderart_wasm_bg.wasm'),
+  wasm
+);
 ```
 
 ## Browser Support
@@ -160,20 +191,13 @@ Requires:
 - WebGL2 for GPU rendering
 - WebAssembly for CPU rendering
 
-## Performance Tips
-
-1. **Reuse the renderer instance** - initialization is expensive
-2. **Use GPU when available** - significantly faster for CRT and HEX
-3. **Choose appropriate scale** - larger scales need more GPU memory
-4. **Consider XBRZ scale limits** - 2-6x only, higher factors use more CPU
-
 ## Building from Source
 
 ```bash
 # Install dependencies
 npm install
 
-# Build WASM module
+# Build WASM module (requires Rust + wasm-pack)
 npm run build:wasm
 
 # Build TypeScript
@@ -181,16 +205,8 @@ npm run build:ts
 
 # Full build
 npm run build
-
-# Run tests
-npm test
 ```
 
-Requirements:
-- Node.js 16+
-- Rust toolchain
-- wasm-pack
-
 ## License
 
 MIT © Pixagram SA

package/dist/index.d.mts

@@ -191,18 +191,45 @@ declare const HEX_PRESETS: Record<string, Partial<HexOptions>>;
  * WASM Module Loader
  *
  * Handles loading and initialization of the Rust WASM module.
+ * Requires explicit initialization - does NOT auto-import WASM.
+ *
+ * @example
+ * ```typescript
+ * import { initWasm } from '@pixagram/renderart';
+ * import init from '@pixagram/renderart/pkg/renderart_wasm.js';
+ *
+ * // Initialize with the WASM module
+ * await initWasm(init);
+ * ```
  */
 
-/** Load WASM module */
-declare function loadWasm(): Promise<any>;
+/**
+ * Initialize WASM module
+ *
+ * @param wasmInit - The init function from renderart_wasm.js
+ * @param wasmUrl - Optional URL to the .wasm file (for custom loading)
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Let wasm-pack handle loading
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(init, wasm);
+ *
+ * // Option 2: With custom WASM URL
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(() => init('/path/to/renderart_wasm_bg.wasm'), wasm);
+ * ```
+ */
+declare function initWasm(wasmInit: () => Promise<void>, wasm: any): Promise<void>;
 /** Check if WASM is loaded */
 declare function isWasmLoaded(): boolean;
+/** Get the WASM module (throws if not initialized) */
+declare function getWasmModule(): any;
 /** CRT CPU Renderer using WASM */
 declare class CrtCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<CrtCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): CrtCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render CRT effect */
@@ -213,9 +240,8 @@ declare class CrtCpuRenderer {
 /** HEX CPU Renderer using WASM */
 declare class HexCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<HexCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): HexCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render hexagonal effect */
@@ -231,9 +257,8 @@ declare class HexCpuRenderer {
 /** XBRZ CPU Renderer using WASM */
 declare class XbrzCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<XbrzCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): XbrzCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render xBRZ scaling */
@@ -249,6 +274,20 @@ declare const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>>;
  *
  * Provides a unified API for all rendering engines (CRT, HEX, XBRZ)
  * with automatic backend selection (GPU/CPU).
+ *
+ * GPU renderers work standalone. CPU renderers require WASM initialization.
+ *
+ * @example
+ * ```typescript
+ * // GPU-only (no WASM needed)
+ * const renderer = RenderArt.createGpuOnly();
+ * const result = renderer.crt.renderSync(imageData, { scale: 3 });
+ *
+ * // With CPU fallback (requires WASM init)
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(init, wasm);
+ * const renderer = RenderArt.create();
+ * ```
  */
 
 /** CRT rendering engine with GPU/CPU backend support */
@@ -263,9 +302,9 @@ declare class CrtEngine {
     /** Initialize CPU renderer */
     private ensureCpu;
     /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: CrtOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): ImageOutput;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
     /** Dispose resources */
@@ -281,9 +320,9 @@ declare class HexEngine {
     private ensureGpu;
     private ensureCpu;
     /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: HexOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): ImageOutput;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
     /** Get output dimensions */
@@ -300,9 +339,9 @@ declare class XbrzEngine {
     constructor(cpuAvailable: boolean);
     private ensureCpu;
     /** Render xBRZ scaling */
-    render(input: ImageInput | ImageData, options?: XbrzOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): ImageOutput;
     /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale?: number): {
         width: number;
@@ -320,12 +359,21 @@ declare class RenderArt {
     readonly xbrz: XbrzEngine;
     private _capabilities;
     private constructor();
-    /** Create and initialize RenderArt instance */
-    static create(): Promise<RenderArt>;
+    /**
+     * Create RenderArt instance
+     * GPU renderers always available if WebGL2 supported.
+     * CPU renderers require WASM to be initialized via initWasm() first.
+     */
+    static create(): RenderArt;
+    /**
+     * Create GPU-only RenderArt instance (no WASM required)
+     * CPU fallback will not be available.
+     */
+    static createGpuOnly(): RenderArt;
     /** Get renderer capabilities */
     get capabilities(): RendererCapabilities;
     /** Dispose all resources */
     dispose(): void;
 }
 
-export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, type XbrzOptions, type XbrzPreset, hexGetDimensions, isWasmLoaded, loadWasm };
+export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, type XbrzOptions, type XbrzPreset, getWasmModule, hexGetDimensions, initWasm, isWasmLoaded };

package/dist/index.d.ts

@@ -191,18 +191,45 @@ declare const HEX_PRESETS: Record<string, Partial<HexOptions>>;
  * WASM Module Loader
  *
  * Handles loading and initialization of the Rust WASM module.
+ * Requires explicit initialization - does NOT auto-import WASM.
+ *
+ * @example
+ * ```typescript
+ * import { initWasm } from '@pixagram/renderart';
+ * import init from '@pixagram/renderart/pkg/renderart_wasm.js';
+ *
+ * // Initialize with the WASM module
+ * await initWasm(init);
+ * ```
  */
 
-/** Load WASM module */
-declare function loadWasm(): Promise<any>;
+/**
+ * Initialize WASM module
+ *
+ * @param wasmInit - The init function from renderart_wasm.js
+ * @param wasmUrl - Optional URL to the .wasm file (for custom loading)
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Let wasm-pack handle loading
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(init, wasm);
+ *
+ * // Option 2: With custom WASM URL
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(() => init('/path/to/renderart_wasm_bg.wasm'), wasm);
+ * ```
+ */
+declare function initWasm(wasmInit: () => Promise<void>, wasm: any): Promise<void>;
 /** Check if WASM is loaded */
 declare function isWasmLoaded(): boolean;
+/** Get the WASM module (throws if not initialized) */
+declare function getWasmModule(): any;
 /** CRT CPU Renderer using WASM */
 declare class CrtCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<CrtCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): CrtCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render CRT effect */
@@ -213,9 +240,8 @@ declare class CrtCpuRenderer {
 /** HEX CPU Renderer using WASM */
 declare class HexCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<HexCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): HexCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render hexagonal effect */
@@ -231,9 +257,8 @@ declare class HexCpuRenderer {
 /** XBRZ CPU Renderer using WASM */
 declare class XbrzCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
-    static create(): Promise<XbrzCpuRenderer>;
-    private init;
+    /** Create renderer (WASM must be initialized first via initWasm) */
+    static create(): XbrzCpuRenderer;
     /** Check if renderer is ready */
     isReady(): boolean;
     /** Render xBRZ scaling */
@@ -249,6 +274,20 @@ declare const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>>;
  *
  * Provides a unified API for all rendering engines (CRT, HEX, XBRZ)
  * with automatic backend selection (GPU/CPU).
+ *
+ * GPU renderers work standalone. CPU renderers require WASM initialization.
+ *
+ * @example
+ * ```typescript
+ * // GPU-only (no WASM needed)
+ * const renderer = RenderArt.createGpuOnly();
+ * const result = renderer.crt.renderSync(imageData, { scale: 3 });
+ *
+ * // With CPU fallback (requires WASM init)
+ * import init, * as wasm from '@pixagram/renderart/pkg/renderart_wasm.js';
+ * await initWasm(init, wasm);
+ * const renderer = RenderArt.create();
+ * ```
  */
 
 /** CRT rendering engine with GPU/CPU backend support */
@@ -263,9 +302,9 @@ declare class CrtEngine {
     /** Initialize CPU renderer */
     private ensureCpu;
     /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: CrtOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): ImageOutput;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
     /** Dispose resources */
@@ -281,9 +320,9 @@ declare class HexEngine {
     private ensureGpu;
     private ensureCpu;
     /** Render with automatic backend selection */
-    render(input: ImageInput | ImageData, options?: HexOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): ImageOutput;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
     /** Get output dimensions */
@@ -300,9 +339,9 @@ declare class XbrzEngine {
     constructor(cpuAvailable: boolean);
     private ensureCpu;
     /** Render xBRZ scaling */
-    render(input: ImageInput | ImageData, options?: XbrzOptions): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
     /** Render with preset */
-    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): Promise<ImageOutput>;
+    render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): ImageOutput;
     /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale?: number): {
         width: number;
@@ -320,12 +359,21 @@ declare class RenderArt {
     readonly xbrz: XbrzEngine;
     private _capabilities;
     private constructor();
-    /** Create and initialize RenderArt instance */
-    static create(): Promise<RenderArt>;
+    /**
+     * Create RenderArt instance
+     * GPU renderers always available if WebGL2 supported.
+     * CPU renderers require WASM to be initialized via initWasm() first.
+     */
+    static create(): RenderArt;
+    /**
+     * Create GPU-only RenderArt instance (no WASM required)
+     * CPU fallback will not be available.
+     */
+    static createGpuOnly(): RenderArt;
     /** Get renderer capabilities */
     get capabilities(): RendererCapabilities;
     /** Dispose all resources */
     dispose(): void;
 }
 
-export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, type XbrzOptions, type XbrzPreset, hexGetDimensions, isWasmLoaded, loadWasm };
+export { type Backend, CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, type CrtOptions, type CrtPreset, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, type HexOptions, type HexOrientation, type HexPreset, type ImageInput, type ImageOutput, type PixelData, RenderArt, type RenderStats, type Renderer, type RendererCapabilities, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, type XbrzOptions, type XbrzPreset, getWasmModule, hexGetDimensions, initWasm, isWasmLoaded };