@pixagram/renderart 0.1.3 → 0.2.1

package/README.md

@@ -4,15 +4,9 @@ High-performance pixel art rendering engines with GPU (WebGL2) and CPU (WASM) su
 
 ## Features
 
-- **CRT Effect** (2-32x) - Classic CRT display simulation with barrel distortion, scanlines, and shadow mask
-- **HEX Upscaling** (2-32x) - Transform pixel art into hexagonal grid representations
-- **XBRZ Scaling** (2-6x) - Edge-preserving pixel art scaling algorithm
-
-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
+- **CRT Effect** (2-32x) - Classic CRT display simulation
+- **HEX Upscaling** (2-32x) - Hexagonal grid transformation
+- **XBRZ Scaling** (2-6x) - Edge-preserving pixel art scaling
 
 ## Installation
 
@@ -22,174 +16,130 @@ npm install @pixagram/renderart
 
 ## Quick Start
 
-```typescript
-import { RenderArt } from '@pixagram/renderart';
-
-// Initialize (loads WASM if needed)
-const renderer = await RenderArt.create();
-
-// 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 });
+### GPU-Only (Simplest - No WASM needed)
 
-// Apply hexagonal transformation
-const hexResult = await renderer.hex.render(imageData, { scale: 16 });
+```typescript
+import { CrtGpuRenderer } from '@pixagram/renderart';
 
-// Apply xBRZ scaling
-const xbrzResult = await renderer.xbrz.render(imageData, { scale: 4 });
+const crt = CrtGpuRenderer.create();
+const result = crt.render(imageData, { scale: 3 });
 
 // Use the result
-ctx.putImageData(new ImageData(crtResult.data, crtResult.width, crtResult.height), 0, 0);
+ctx.putImageData(new ImageData(result.data, result.width, result.height), 0, 0);
 ```
 
-## API Reference
+### With CPU Fallback (Auto WASM loading)
 
-### RenderArt
+```typescript
+import { RenderArt, setWasmUrl } from '@pixagram/renderart';
 
-Main class providing access to all rendering engines.
+// Configure WASM path (copy renderart_wasm.wasm to your public folder)
+setWasmUrl('/wasm/renderart_wasm.wasm');
 
-```typescript
-const renderer = await RenderArt.create();
+const renderer = RenderArt.create();
 
-// Access capabilities
-console.log(renderer.capabilities);
-// { gpu: true, cpu: true, maxTextureSize: 16384, recommendedBackend: 'gpu' }
+// GPU when available, auto-loads WASM for CPU fallback
+const result = await renderer.crt.render(imageData, { scale: 3 });
 
-// Cleanup when done
-renderer.dispose();
+// XBRZ is CPU-only (auto-loads WASM on first use)
+const xbrzResult = await renderer.xbrz.render(imageData, { scale: 4 });
 ```
 
-### CRT Engine
+### Pre-load WASM
 
 ```typescript
-// With options
-const result = await 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)
-  enableWarp: true,      // Enable barrel distortion
-  enableScanlines: true, // Enable scanlines
-  enableMask: true,      // Enable shadow mask
-  backend: 'auto',       // 'gpu', 'cpu', or 'auto'
-});
-
-// With preset
-const result = await renderer.crt.render(imageData, 'authentic');
-// Presets: 'default', 'authentic', 'subtle', 'flat'
+import { initWasm, setWasmUrl } from '@pixagram/renderart';
 
-// Synchronous GPU-only rendering
-const result = renderer.crt.renderSync(imageData, { scale: 3 });
+// Pre-load WASM for faster first CPU render
+setWasmUrl('/wasm/renderart_wasm.wasm');
+await initWasm();
 ```
 
-### HEX Engine
+## WASM Setup
 
-```typescript
-// With options
-const result = await 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
-  backend: 'auto',
-});
+1. Build the WASM module:
+   ```bash
+   cd node_modules/@pixagram/renderart
+   npm run build:wasm
+   ```
 
-// With preset
-const result = await renderer.hex.render(imageData, 'bordered');
-// Presets: 'default', 'bordered', 'pointy'
+2. Copy `wasm/renderart_wasm.wasm` to your public folder
 
-// Get output dimensions
-const dims = renderer.hex.getDimensions(64, 64, { scale: 16 });
-// { width: 123, height: 134 }
-```
+3. Configure the path:
+   ```typescript
+   import { setWasmUrl } from '@pixagram/renderart';
+   setWasmUrl('/your/path/renderart_wasm.wasm');
+   ```
 
-### XBRZ Engine
+## API Reference
+
+### CRT Options
 
 ```typescript
-// With options
-const result = await 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
-});
-
-// With preset
-const result = await renderer.xbrz.render(imageData, 'sharp');
-// Presets: 'default', 'sharp', 'smooth'
-
-// Get output dimensions
-const dims = renderer.xbrz.getDimensions(64, 64, 4);
-// { width: 256, height: 256 }
+{
+  scale: 3,              // 2-32
+  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,
+  enableScanlines: true,
+  enableMask: true,
+  backend: 'auto',       // 'gpu', 'cpu', or 'auto'
+}
 ```
 
-## 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     |
+### HEX Options
 
-Force a specific backend:
 ```typescript
-// Force GPU
-const result = await renderer.crt.render(imageData, { backend: 'gpu' });
-
-// Force CPU
-const result = await renderer.crt.render(imageData, { backend: 'cpu' });
+{
+  scale: 16,                    // 2-32
+  orientation: 'flat-top',      // 'flat-top' or 'pointy-top'
+  drawBorders: false,
+  borderColor: '#282828',
+  borderThickness: 1,
+  backgroundColor: 'transparent',
+  backend: 'auto',
+}
 ```
 
-## Browser Support
-
-- Chrome 79+
-- Firefox 75+
-- Safari 15+
-- Edge 79+
-
-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
+### XBRZ Options
 
-## Building from Source
-
-```bash
-# Install dependencies
-npm install
-
-# Build WASM module
-npm run build:wasm
-
-# Build TypeScript
-npm run build:ts
+```typescript
+{
+  scale: 4,                          // 2-6
+  luminanceWeight: 1.0,
+  equalColorTolerance: 30,
+  dominantDirectionThreshold: 4.4,
+  steepDirectionThreshold: 2.2,
+}
+```
 
-# Full build
-npm run build
+## Presets
 
-# Run tests
-npm test
+```typescript
+// CRT presets
+renderer.crt.render(imageData, 'authentic');  // Strong CRT look
+renderer.crt.render(imageData, 'subtle');     // Light CRT effect
+renderer.crt.render(imageData, 'flat');       // No curvature
+
+// HEX presets
+renderer.hex.render(imageData, 'bordered');   // With borders
+renderer.hex.render(imageData, 'pointy');     // Pointy-top orientation
+
+// XBRZ presets
+renderer.xbrz.render(imageData, 'sharp');     // Sharp edges
+renderer.xbrz.render(imageData, 'smooth');    // Smoother output
 ```
 
-Requirements:
-- Node.js 16+
-- Rust toolchain
-- wasm-pack
+## Backend Selection
+
+| Engine | GPU | CPU |
+|--------|-----|-----|
+| CRT    | ✅  | ✅  |
+| HEX    | ✅  | ✅  |
+| XBRZ   | ❌  | ✅  |
 
 ## License
 

package/dist/index.d.mts

@@ -190,55 +190,56 @@ declare const HEX_PRESETS: Record<string, Partial<HexOptions>>;
 /**
  * WASM Module Loader
  *
- * Handles loading and initialization of the Rust WASM module.
+ * Auto-initializes WASM from URL. Works with any bundler.
  */
 
-/** Load WASM module */
-declare function loadWasm(): Promise<any>;
+/**
+ * Configure WASM loading path
+ * Call this before using any CPU renderer if you need a custom path.
+ *
+ * @param url - URL to the renderart_wasm_bg.wasm file
+ *
+ * @example
+ * ```typescript
+ * setWasmUrl('/static/wasm/renderart_wasm_bg.wasm');
+ * ```
+ */
+declare function setWasmUrl(url: string): void;
+/**
+ * Initialize WASM module
+ * Called automatically on first CPU renderer use.
+ * Can be called manually for preloading.
+ */
+declare function initWasm(customUrl?: string): Promise<void>;
 /** Check if WASM is loaded */
 declare function isWasmLoaded(): boolean;
 /** CRT CPU Renderer using WASM */
 declare class CrtCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
+    /** Create and initialize renderer (auto-loads WASM) */
     static create(): Promise<CrtCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render CRT effect */
     render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** HEX CPU Renderer using WASM */
 declare class HexCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
     static create(): Promise<HexCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render hexagonal effect */
     render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale: number, orientation?: HexOrientation): {
         width: number;
         height: number;
     };
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ CPU Renderer using WASM */
 declare class XbrzCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
     static create(): Promise<XbrzCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render xBRZ scaling */
     render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ presets */
@@ -247,63 +248,47 @@ declare const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>>;
 /**
  * RenderArt - Unified Pixel Art Rendering Engine
  *
- * Provides a unified API for all rendering engines (CRT, HEX, XBRZ)
- * with automatic backend selection (GPU/CPU).
+ * GPU renderers work standalone. CPU renderers auto-initialize WASM.
  */
 
-/** CRT rendering engine with GPU/CPU backend support */
+/** CRT rendering engine */
 declare class CrtEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
-    /** Initialize GPU renderer */
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
-    /** Initialize CPU renderer */
     private ensureCpu;
     /** Render with automatic backend selection */
     render(input: ImageInput | ImageData, options?: CrtOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): Promise<ImageOutput>;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
-/** HEX rendering engine with GPU/CPU backend support */
+/** HEX rendering engine */
 declare class HexEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
     private ensureCpu;
-    /** Render with automatic backend selection */
     render(input: ImageInput | ImageData, options?: HexOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): Promise<ImageOutput>;
-    /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, options?: HexOptions): {
         width: number;
         height: number;
     };
     dispose(): void;
 }
-/** XBRZ rendering engine (CPU only - algorithm too complex for efficient GPU) */
+/** XBRZ rendering engine (CPU only) */
 declare class XbrzEngine {
     private cpuRenderer;
-    private cpuAvailable;
-    constructor(cpuAvailable: boolean);
     private ensureCpu;
-    /** Render xBRZ scaling */
     render(input: ImageInput | ImageData, options?: XbrzOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): Promise<ImageOutput>;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale?: number): {
         width: number;
         height: number;
@@ -312,20 +297,19 @@ declare class XbrzEngine {
 }
 /** RenderArt - Unified Pixel Art Rendering Engine */
 declare class RenderArt {
-    /** CRT effect renderer */
     readonly crt: CrtEngine;
-    /** Hexagonal pixel renderer */
     readonly hex: HexEngine;
-    /** xBRZ scaling renderer */
     readonly xbrz: XbrzEngine;
     private _capabilities;
     private constructor();
-    /** Create and initialize RenderArt instance */
-    static create(): Promise<RenderArt>;
-    /** Get renderer capabilities */
+    /** Create RenderArt instance */
+    static create(): RenderArt;
+    /** Create GPU-only instance */
+    static createGpuOnly(): RenderArt;
+    /** Pre-initialize WASM for faster first CPU render */
+    preloadWasm(wasmUrl?: string): Promise<void>;
     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, hexGetDimensions, initWasm, isWasmLoaded, setWasmUrl };

package/dist/index.d.ts

@@ -190,55 +190,56 @@ declare const HEX_PRESETS: Record<string, Partial<HexOptions>>;
 /**
  * WASM Module Loader
  *
- * Handles loading and initialization of the Rust WASM module.
+ * Auto-initializes WASM from URL. Works with any bundler.
  */
 
-/** Load WASM module */
-declare function loadWasm(): Promise<any>;
+/**
+ * Configure WASM loading path
+ * Call this before using any CPU renderer if you need a custom path.
+ *
+ * @param url - URL to the renderart_wasm_bg.wasm file
+ *
+ * @example
+ * ```typescript
+ * setWasmUrl('/static/wasm/renderart_wasm_bg.wasm');
+ * ```
+ */
+declare function setWasmUrl(url: string): void;
+/**
+ * Initialize WASM module
+ * Called automatically on first CPU renderer use.
+ * Can be called manually for preloading.
+ */
+declare function initWasm(customUrl?: string): Promise<void>;
 /** Check if WASM is loaded */
 declare function isWasmLoaded(): boolean;
 /** CRT CPU Renderer using WASM */
 declare class CrtCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
+    /** Create and initialize renderer (auto-loads WASM) */
     static create(): Promise<CrtCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render CRT effect */
     render(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** HEX CPU Renderer using WASM */
 declare class HexCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
     static create(): Promise<HexCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render hexagonal effect */
     render(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale: number, orientation?: HexOrientation): {
         width: number;
         height: number;
     };
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ CPU Renderer using WASM */
 declare class XbrzCpuRenderer {
     private ready;
-    /** Create and initialize renderer */
     static create(): Promise<XbrzCpuRenderer>;
-    private init;
-    /** Check if renderer is ready */
     isReady(): boolean;
-    /** Render xBRZ scaling */
     render(input: ImageInput | ImageData, options?: XbrzOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
 /** XBRZ presets */
@@ -247,63 +248,47 @@ declare const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>>;
 /**
  * RenderArt - Unified Pixel Art Rendering Engine
  *
- * Provides a unified API for all rendering engines (CRT, HEX, XBRZ)
- * with automatic backend selection (GPU/CPU).
+ * GPU renderers work standalone. CPU renderers auto-initialize WASM.
  */
 
-/** CRT rendering engine with GPU/CPU backend support */
+/** CRT rendering engine */
 declare class CrtEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
-    /** Initialize GPU renderer */
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
-    /** Initialize CPU renderer */
     private ensureCpu;
     /** Render with automatic backend selection */
     render(input: ImageInput | ImageData, options?: CrtOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: CrtPreset, overrides?: Partial<CrtOptions>): Promise<ImageOutput>;
     /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: CrtOptions): ImageOutput;
-    /** Dispose resources */
     dispose(): void;
 }
-/** HEX rendering engine with GPU/CPU backend support */
+/** HEX rendering engine */
 declare class HexEngine {
     private gpuRenderer;
     private cpuRenderer;
     private gpuAvailable;
-    private cpuAvailable;
-    constructor(gpuAvailable: boolean, cpuAvailable: boolean);
+    constructor(gpuAvailable: boolean);
     private ensureGpu;
     private ensureCpu;
-    /** Render with automatic backend selection */
     render(input: ImageInput | ImageData, options?: HexOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: HexPreset, overrides?: Partial<HexOptions>): Promise<ImageOutput>;
-    /** Render synchronously (GPU only) */
     renderSync(input: ImageInput | ImageData, options?: HexOptions): ImageOutput;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, options?: HexOptions): {
         width: number;
         height: number;
     };
     dispose(): void;
 }
-/** XBRZ rendering engine (CPU only - algorithm too complex for efficient GPU) */
+/** XBRZ rendering engine (CPU only) */
 declare class XbrzEngine {
     private cpuRenderer;
-    private cpuAvailable;
-    constructor(cpuAvailable: boolean);
     private ensureCpu;
-    /** Render xBRZ scaling */
     render(input: ImageInput | ImageData, options?: XbrzOptions): Promise<ImageOutput>;
-    /** Render with preset */
     render(input: ImageInput | ImageData, preset: XbrzPreset, overrides?: Partial<XbrzOptions>): Promise<ImageOutput>;
-    /** Get output dimensions */
     getDimensions(srcWidth: number, srcHeight: number, scale?: number): {
         width: number;
         height: number;
@@ -312,20 +297,19 @@ declare class XbrzEngine {
 }
 /** RenderArt - Unified Pixel Art Rendering Engine */
 declare class RenderArt {
-    /** CRT effect renderer */
     readonly crt: CrtEngine;
-    /** Hexagonal pixel renderer */
     readonly hex: HexEngine;
-    /** xBRZ scaling renderer */
     readonly xbrz: XbrzEngine;
     private _capabilities;
     private constructor();
-    /** Create and initialize RenderArt instance */
-    static create(): Promise<RenderArt>;
-    /** Get renderer capabilities */
+    /** Create RenderArt instance */
+    static create(): RenderArt;
+    /** Create GPU-only instance */
+    static createGpuOnly(): RenderArt;
+    /** Pre-initialize WASM for faster first CPU render */
+    preloadWasm(wasmUrl?: string): Promise<void>;
     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, hexGetDimensions, initWasm, isWasmLoaded, setWasmUrl };