From b3ed697b798cd7acfd3789c4b36e9999e360b1a4 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:02:40 -0400
Subject: [PATCH 01/26] Add AGENTS.md file

This commit adds the AGENTS.md file, which contains guidelines for contributing to the project. This includes information on project
structure, build and test commands, coding style, testing guidelines, and commit/pull request guidelines.
---
 AGENTS.md | 28 ++++++++++++++++++++++++++++
 CLAUDE.md |  1 +
 2 files changed, 29 insertions(+)
 create mode 100644 AGENTS.md
 create mode 120000 CLAUDE.md

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..dec89dc
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,28 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+libansilove is a C library that converts ANSI and related art files to PNG. Core headers live in `include/`, while the implementation sits in `src/` with `loaders/` containing format-specific decoders and `fonts/` bundling built-in typefaces. Cross-platform fallbacks are under `compat/`. The `example/` directory shows how to invoke the API end-to-end, and `man/` provides installed manual pages. Dedicated fuzzing harnesses reside in `fuzz/`; build them only when running sanitizer-heavy tests.
+
+## Build, Test, and Development Commands
+- `cmake -S . -B build -DCMAKE_BUILD_TYPE=Release`: configure the project after installing GD headers and libs.
+- `cmake --build build`: compile shared and static variants of the library.
+- `cmake --build build --target install`: install artifacts into the default prefix.
+- `cmake -S fuzz -B fuzz-build`: set up clang-based libFuzzer targets.
+- `cmake --build fuzz-build`: produce fuzz binaries such as `ansi` and `tundra`.
+
+## Coding Style & Naming Conventions
+- Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
+- Indent with tabs for blocks; align wrapped parameters using spaces as needed, and avoid trailing whitespace.
+- Public APIs stay in `include/ansilove.h` and use the `ansilove_*` prefix; internal helpers remain lowercase with underscores and `static` linkage.
+- Mirror existing filenames (`loadfile.c`, `savefile.c`) when adding new modules or loaders.
+
+## Testing Guidelines
+- There is no unit-test harness; validate behavior with the example app and fuzzers.
+- After building, run `build/example/ansilove_example <input.ans>` to confirm PNG output.
+- For fuzzing, execute `./fuzz-build/ansi -runs=10000 corpus/` (seed the corpus with representative art files). Investigate sanitizer reports immediately and add reproducer samples.
+- Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
+
+## Commit & Pull Request Guidelines
+- Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).
+- Keep functional changes and formatting adjustments in separate commits and ensure files build before pushing.
+- Pull requests should summarize the change, call out impacted loaders, and link tracking issues. Note which build or fuzz commands were run, and attach PNG outputs or screenshots when visual diffs help reviewers.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 0000000..47dc3e3
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file

From 0308363e77734c364e1eaa238e7134ad7f1f4142 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:03:59 -0400
Subject: [PATCH 02/26] Add flake.nix for Nix development environment

Introduces a flake.nix file to manage the development environment for libansilove using Nix Flakes. This includes defining packages and a
development shell with necessary build tools and libraries.
---
 .envrc    |  1 +
 flake.nix | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 .envrc
 create mode 100644 flake.nix

diff --git a/.envrc b/.envrc
new file mode 100644
index 0000000..3550a30
--- /dev/null
+++ b/.envrc
@@ -0,0 +1 @@
+use flake
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000..003b959
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,56 @@
+{
+  description = "Development environment for libansilove";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+        version = "1.4.2";
+      in {
+        packages.default = pkgs.stdenv.mkDerivation {
+          pname = "libansilove";
+          inherit version;
+          src = ./.;
+          nativeBuildInputs = [
+            pkgs.cmake
+            pkgs.pkg-config
+          ];
+          buildInputs = [
+            pkgs.libgd
+          ];
+          cmakeFlags = [
+            "-DCMAKE_BUILD_TYPE=Release"
+          ];
+          meta = with pkgs.lib; {
+            description = "Library to convert ANSI and artscene formats to PNG";
+            homepage = "https://www.ansilove.org";
+            license = licenses.bsd2;
+            maintainers = [];
+            platforms = platforms.unix;
+          };
+        };
+
+        devShells.default = pkgs.mkShell {
+          packages = [
+            pkgs.cmake
+            pkgs.ninja
+            pkgs.pkg-config
+            pkgs.libgd
+            pkgs.clang
+            pkgs.clang-tools
+            pkgs.gdb
+          ];
+          shellHook = ''
+            export CC=${pkgs.clang}/bin/clang
+            export CXX=${pkgs.clang}/bin/clang++
+            echo "libansilove dev shell loaded."
+          '';
+        };
+      }
+    );
+}

From cfebe513910a28cd5f66a628ade0df88861f05a2 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:04:27 -0400
Subject: [PATCH 03/26] Refactor flake.nix for readability

---
 flake.nix | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/flake.nix b/flake.nix
index 003b959..9907316 100644
--- a/flake.nix
+++ b/flake.nix
@@ -6,10 +6,14 @@
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = import nixpkgs { inherit system; };
+  outputs = {
+    self,
+    nixpkgs,
+    flake-utils,
+  }:
+    flake-utils.lib.eachDefaultSystem (
+      system: let
+        pkgs = import nixpkgs {inherit system;};
         version = "1.4.2";
       in {
         packages.default = pkgs.stdenv.mkDerivation {

From d64a8bac22087122ef1451f2302b630dea9e0a26 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:05:16 -0400
Subject: [PATCH 04/26] Add flake.lock file

This commit introduces the `flake.lock` file, which pins the exact versions of the dependencies used by the Nix flake. This ensures
reproducible builds by locking down the revisions of `nixpkgs`, `flake-utils`, and `nix-systems`.
---
 flake.lock | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 flake.lock

diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000..2468070
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1735563628,
+        "narHash": "sha256-OnSAY7XDSx7CtDoqNh8jwVwh4xNL/2HaJxGjryLWzX8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b134951a4c9f3c995fd7be05f3243f8ecd65d798",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-24.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

From 695c512c86b08e6a75543fabebba6f7b147da3db Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:09:32 -0400
Subject: [PATCH 05/26] Refactor: Use gd instead of libgd

Updates the flake.nix to use the `gd` package instead of the deprecated `libgd`. Also conditionally adds `gdb` for non-Darwin systems and
`lldb` for Darwin systems.
---
 flake.nix | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/flake.nix b/flake.nix
index 9907316..64795ac 100644
--- a/flake.nix
+++ b/flake.nix
@@ -25,7 +25,7 @@
             pkgs.pkg-config
           ];
           buildInputs = [
-            pkgs.libgd
+            pkgs.gd
           ];
           cmakeFlags = [
             "-DCMAKE_BUILD_TYPE=Release"
@@ -40,15 +40,21 @@
         };
 
         devShells.default = pkgs.mkShell {
-          packages = [
-            pkgs.cmake
-            pkgs.ninja
-            pkgs.pkg-config
-            pkgs.libgd
-            pkgs.clang
-            pkgs.clang-tools
-            pkgs.gdb
-          ];
+          packages =
+            [
+              pkgs.cmake
+              pkgs.ninja
+              pkgs.pkg-config
+              pkgs.gd
+              pkgs.clang
+              pkgs.clang-tools
+            ]
+            ++ pkgs.lib.optionals (!pkgs.stdenv.isDarwin) [
+              pkgs.gdb
+            ]
+            ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
+              pkgs.lldb
+            ];
           shellHook = ''
             export CC=${pkgs.clang}/bin/clang
             export CXX=${pkgs.clang}/bin/clang++

From af32bf3cb1265f8f54b51e2a72bf8bb2a6a2c7fc Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:15:40 -0400
Subject: [PATCH 06/26] Add Nix and direnv ignores to .gitignore

---
 .gitignore | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.gitignore b/.gitignore
index 131152d..1659e4d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,13 @@
 # build products
 build/
 
+# Nix
+result
+result-*/
+
+# direnv
+.direnv/
+
 # CMake
 CMakeFiles
 CMakeCache.txt

From 3bc03666a16325560425e09506b4ffe9da0763d0 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 19:23:13 -0400
Subject: [PATCH 07/26] Add Nix flake instructions

Include commands for entering the dev shell, building, and checking the flake. Also add a note about updating the flake.lock file.
---
 AGENTS.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/AGENTS.md b/AGENTS.md
index dec89dc..086b1e4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,6 +9,9 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `cmake --build build --target install`: install artifacts into the default prefix.
 - `cmake -S fuzz -B fuzz-build`: set up clang-based libFuzzer targets.
 - `cmake --build fuzz-build`: produce fuzz binaries such as `ansi` and `tundra`.
+- `nix develop`: enter the flake-backed dev shell with clang, pkg-config, GD, and platform-appropriate debugger preinstalled.
+- `nix build`: build the default flake package (shared/static library) without touching your host toolchain.
+- `nix flake check`: validate the flake packages and dev shell evaluate cleanly across supported systems.
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
@@ -21,6 +24,7 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - After building, run `build/example/ansilove_example <input.ans>` to confirm PNG output.
 - For fuzzing, execute `./fuzz-build/ansi -runs=10000 corpus/` (seed the corpus with representative art files). Investigate sanitizer reports immediately and add reproducer samples.
 - Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
+- If you touch the flake, rerun `nix build` and `nix flake check` and commit the updated `flake.lock` (keep changes reproducible).
 
 ## Commit & Pull Request Guidelines
 - Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).

From efa017dd459e531b9f50d95985dcfa92e89a6fd9 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 20:22:31 -0400
Subject: [PATCH 08/26] feat: Add WebAssembly target

This commit introduces a WebAssembly target for the ansilove library. It includes: - CMakeLists.txt modifications to conditionally build the
WASM target. - New source files in `wasm/` for the WASM wrapper and a minimal GD implementation. - A Node.js script for smoke testing the
WASM build. - A shell script to automate the WASM build process using `emcmake`. - Updated documentation and `.gitignore` to reflect the new
target.
---
 .gitignore                |    6 +
 AGENTS.md                 |    4 +
 CMakeLists.txt            |  103 ++-
 README.md                 |   22 +
 example/wasm/index.html   |   72 ++
 flake.nix                 |    1 +
 scripts/test-wasm-node.js |   58 ++
 scripts/test-wasm.sh      |   31 +
 src/clean.c               |   10 +-
 src/init.c                |    6 +
 wasm/ansilove_wasm.c      |   98 +++
 wasm/gd.h                 |   46 +
 wasm/minigd.c             |  436 ++++++++++
 wasm/stb_image_write.h    | 1724 +++++++++++++++++++++++++++++++++++++
 14 files changed, 2584 insertions(+), 33 deletions(-)
 create mode 100644 example/wasm/index.html
 create mode 100644 scripts/test-wasm-node.js
 create mode 100755 scripts/test-wasm.sh
 create mode 100644 wasm/ansilove_wasm.c
 create mode 100644 wasm/gd.h
 create mode 100644 wasm/minigd.c
 create mode 100644 wasm/stb_image_write.h

diff --git a/.gitignore b/.gitignore
index 1659e4d..02ce47d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 
 # build products
 build/
+build-wasm/
 
 # Nix
 result
@@ -18,3 +19,8 @@ CMakeFiles
 CMakeCache.txt
 Makefile
 cmake_install.cmake
+
+# WASM artefacts
+example/wasm/libansilove.js
+example/wasm/libansilove.wasm
+build-wasm/wasm/test-output.png
diff --git a/AGENTS.md b/AGENTS.md
index 086b1e4..0add4dd 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,6 +12,8 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `nix develop`: enter the flake-backed dev shell with clang, pkg-config, GD, and platform-appropriate debugger preinstalled.
 - `nix build`: build the default flake package (shared/static library) without touching your host toolchain.
 - `nix flake check`: validate the flake packages and dev shell evaluate cleanly across supported systems.
+- `nix develop --command bash scripts/test-wasm.sh`: configure via `emcmake`, build the wasm wrapper, and assert the JS/WASM artefacts exist.
+- `python3 -m http.server 8765 --directory example/wasm`: serve the browser demo locally (after running `scripts/test-wasm.sh`).
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
@@ -25,6 +27,8 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - For fuzzing, execute `./fuzz-build/ansi -runs=10000 corpus/` (seed the corpus with representative art files). Investigate sanitizer reports immediately and add reproducer samples.
 - Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
 - If you touch the flake, rerun `nix build` and `nix flake check` and commit the updated `flake.lock` (keep changes reproducible).
+- For the wasm target, keep `scripts/test-wasm.sh` passing under `nix develop`; it wipes `build-wasm/` on each invocation.
+- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper script in `scripts/test-wasm.sh` copies `libansilove.{js,wasm}` into `example/wasm/` so you can smoke-test via `python3 -m http.server` and the JXA snippet from this branch.
 
 ## Commit & Pull Request Guidelines
 - Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d494d52..d3c5d1a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,6 +14,13 @@ project(ansilove C)
 include(CheckFunctionExists)
 include(GNUInstallDirs)
 
+option(ANSILOVE_BUILD_WASM "Build the WebAssembly wrapper" OFF)
+
+set(IS_EMSCRIPTEN OFF)
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  set(IS_EMSCRIPTEN ON)
+endif()
+
 # Check if system has strtonum
 check_function_exists(strtonum HAVE_STRTONUM)
 check_function_exists(reallocarray HAVE_REALLOCARRAY)
@@ -21,10 +28,12 @@ check_function_exists(reallocarray HAVE_REALLOCARRAY)
 # Additional include directories for compat functions and headers
 include_directories("compat" "include" "src")
 
-# GD
-find_path(GD_INCLUDE_DIRS gd.h)
-find_library(GD_LIBRARIES NAMES gd REQUIRED)
-include_directories(${GD_INCLUDE_DIRS})
+if(NOT IS_EMSCRIPTEN)
+  # GD
+  find_path(GD_INCLUDE_DIRS gd.h)
+  find_library(GD_LIBRARIES NAMES gd REQUIRED)
+  include_directories(${GD_INCLUDE_DIRS})
+endif()
 
 set(SRC src/clean.c src/drawchar.c src/fonts.c src/error.c src/loadfile.c src/init.c src/output.c src/savefile.c)
 set(LOADERS src/loaders/ansi.c src/loaders/artworx.c src/loaders/binary.c src/loaders/icedraw.c src/loaders/pcboard.c src/loaders/tundra.c src/loaders/xbin.c)
@@ -39,31 +48,61 @@ endif()
 
 add_definitions(-D_GNU_SOURCE -Wall -Wextra -pedantic)
 
-add_library(objlib OBJECT ${SRC} ${LOADERS})
-set_property(TARGET objlib PROPERTY POSITION_INDEPENDENT_CODE ON)
-
-add_library(ansilove SHARED $<TARGET_OBJECTS:objlib>)
-add_library(ansilove-static STATIC $<TARGET_OBJECTS:objlib>)
-
-target_link_libraries(ansilove ${GD_LIBRARIES} m)
-
-set_target_properties(ansilove PROPERTIES
-  VERSION ${LIB_VERSION_STRING} SOVERSION ${LIB_VERSION_MAJOR}
-  C_VISIBILITY_PRESET hidden)
-
-install(TARGETS ansilove DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(TARGETS ansilove-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(FILES include/ansilove.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES man/libansilove.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_clean.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_error.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_init.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_loadfile.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_savefile.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_ansi.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_artworx.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_binary.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_icedraw.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_pcboard.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_tundra.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
-install(FILES man/ansilove_xbin.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+if(NOT IS_EMSCRIPTEN)
+  add_library(objlib OBJECT ${SRC} ${LOADERS})
+  set_property(TARGET objlib PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+  add_library(ansilove SHARED $<TARGET_OBJECTS:objlib>)
+  add_library(ansilove-static STATIC $<TARGET_OBJECTS:objlib>)
+
+  target_link_libraries(ansilove ${GD_LIBRARIES} m)
+
+  set_target_properties(ansilove PROPERTIES
+    VERSION ${LIB_VERSION_STRING} SOVERSION ${LIB_VERSION_MAJOR}
+    C_VISIBILITY_PRESET hidden)
+
+  install(TARGETS ansilove DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  install(TARGETS ansilove-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  install(FILES include/ansilove.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  install(FILES man/libansilove.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_clean.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_error.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_init.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_loadfile.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_savefile.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_ansi.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_artworx.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_binary.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_icedraw.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_pcboard.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_tundra.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+  install(FILES man/ansilove_xbin.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
+endif()
+
+if(ANSILOVE_BUILD_WASM)
+  if(NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    message(FATAL_ERROR "ANSILOVE_BUILD_WASM requires the Emscripten toolchain (use emcmake).")
+  endif()
+
+  add_library(objlib_wasm OBJECT ${SRC} ${LOADERS})
+  target_include_directories(objlib_wasm PRIVATE include src compat wasm)
+  target_compile_definitions(objlib_wasm PRIVATE ANSILOVE_WASM)
+
+  add_executable(ansilove_wasm
+    wasm/ansilove_wasm.c
+    wasm/minigd.c
+    $<TARGET_OBJECTS:objlib_wasm>)
+  target_include_directories(ansilove_wasm PRIVATE include src compat wasm)
+  target_compile_definitions(ansilove_wasm PRIVATE ANSILOVE_WASM)
+  set_target_properties(ansilove_wasm PROPERTIES
+    OUTPUT_NAME "libansilove"
+    SUFFIX ".js"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
+  target_link_options(ansilove_wasm PRIVATE
+    "-sMODULARIZE=1"
+    "-sEXPORT_NAME=Libansilove"
+    "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
+    "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
+    "-sENVIRONMENT=web,worker,node"
+    "-sALLOW_MEMORY_GROWTH=1")
+endif()
diff --git a/README.md b/README.md
index 99d11f8..196cb7c 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,28 @@ header files.
 
 	make install
 
+# WebAssembly
+
+An experimental WebAssembly wrapper ships in `wasm/`. Use the Nix
+environment to ensure Emscripten is available:
+
+	nix develop --command bash scripts/test-wasm.sh
+
+The script configures the project via `emcmake`, produces
+`build-wasm/wasm/libansilove.{js,wasm}`, and exports
+`ansilove_wasm_version()` for browser consumers. It also runs a Node-based
+smoke test that renders a sample ANSI string to
+`build-wasm/wasm/test-output.png` and copies the runtime artefacts into
+`example/wasm/`.
+
+Serve the demo page with, for example,
+
+	python3 -m http.server 8765 --directory example/wasm
+
+Then open `http://localhost:8765/` in a browser (Safari requires the developer
+setting “Allow JavaScript from Apple Events” for scripted verification) to see
+the PNG preview rendered via WebAssembly.
+
 # Packages
 
 libansilove packages are available for:
diff --git a/example/wasm/index.html b/example/wasm/index.html
new file mode 100644
index 0000000..afd5398
--- /dev/null
+++ b/example/wasm/index.html
@@ -0,0 +1,72 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>libansilove wasm smoke test</title>
+  <script src="libansilove.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      var status = document.getElementById('status');
+      var preview = document.getElementById('preview');
+
+      function boot() {
+        if (typeof Libansilove !== 'function') {
+          status.textContent = 'Waiting for Libansilove factory…';
+          setTimeout(boot, 100);
+          return;
+        }
+
+        Libansilove({ locateFile: function (path) { return path; } })
+          .then(function (Module) {
+            var getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
+            var renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+            var getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
+            var getLength = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
+            var freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
+
+            status.textContent = 'libansilove wasm version: ' + getVersion();
+
+            var encoder = new TextEncoder();
+            var input = encoder.encode('Hello from libansilove!\r\n');
+            var ptr = Module._malloc(input.length);
+            Module.HEAPU8.set(input, ptr);
+
+            var rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
+            Module._free(ptr);
+            if (rc !== 0) {
+              status.textContent = 'Render failed with error code ' + rc;
+              return;
+            }
+
+            var pngPtr = getPtr();
+            var pngLen = getLength();
+            var pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLen);
+            freePng();
+
+            var blob = new Blob([pngData], { type: 'image/png' });
+            var url = URL.createObjectURL(blob);
+            preview.src = url;
+            preview.alt = 'Rendered ANSI sample';
+          })
+          .catch(function (error) {
+            status.textContent = 'Libansilove failed: ' + error;
+          });
+      }
+
+      boot();
+    });
+  </script>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; margin: 2rem; }
+    main { max-width: 40rem; }
+    #status { font-weight: bold; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>libansilove wasm smoke test</h1>
+    <p id="status">waiting for module…</p>
+    <img id="preview" alt="" style="display:block; margin-top: 1rem; max-width: 100%;" />
+  </main>
+</body>
+</html>
diff --git a/flake.nix b/flake.nix
index 64795ac..2ad6481 100644
--- a/flake.nix
+++ b/flake.nix
@@ -46,6 +46,7 @@
               pkgs.ninja
               pkgs.pkg-config
               pkgs.gd
+              pkgs.emscripten
               pkgs.clang
               pkgs.clang-tools
             ]
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
new file mode 100644
index 0000000..94b6aef
--- /dev/null
+++ b/scripts/test-wasm-node.js
@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { TextEncoder } = require('util');
+
+async function main() {
+  const buildDir = path.resolve(process.argv[2] || 'build-wasm/wasm');
+  const outputPath = path.resolve(process.argv[3] || path.join(buildDir, 'test-output.png'));
+  const factoryPath = path.join(buildDir, 'libansilove.js');
+
+  if (!fs.existsSync(factoryPath)) {
+    throw new Error(`expected ${factoryPath} (run scripts/test-wasm.sh first)`);
+  }
+
+  const factory = require(factoryPath);
+  if (typeof factory !== 'function') {
+    throw new Error('libansilove.js did not export an initialization function');
+  }
+
+  const Module = await factory();
+  const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
+  const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+  const getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
+  const getLen = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
+  const freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
+
+  const sample = process.argv[4] || 'Hello from libansilove!\r\n';
+  const encoder = new TextEncoder();
+  const input = encoder.encode(sample);
+  const ptr = Module._malloc(input.length);
+  Module.HEAPU8.set(input, ptr);
+
+  const rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
+  Module._free(ptr);
+  if (rc !== 0) {
+    throw new Error(`ansilove_wasm_render_ansi returned ${rc}`);
+  }
+
+  const pngPtr = getPtr();
+  const pngLength = getLen();
+  if (!pngPtr || pngLength <= 8) {
+    throw new Error(`unexpected PNG length ${pngLength}`);
+  }
+
+  const pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
+  freePng();
+
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, Buffer.from(pngData));
+
+  const version = getVersion();
+  console.log(`Generated ${path.relative(process.cwd(), outputPath)} (${pngData.length} bytes) using libansilove wasm ${version}.`);
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
new file mode 100755
index 0000000..be42cb7
--- /dev/null
+++ b/scripts/test-wasm.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if ! command -v emcmake >/dev/null; then
+  echo "error: emcmake is required (enter via 'nix develop')." >&2
+  exit 2
+fi
+
+build_dir="${1:-build-wasm}"
+artifacts_dir="$build_dir/wasm"
+rm -rf "$build_dir"
+
+emcmake cmake -S . -B "$build_dir" -DANSILOVE_BUILD_WASM=ON
+cmake --build "$build_dir" --target ansilove_wasm
+
+if [ ! -f "$artifacts_dir/libansilove.wasm" ]; then
+  echo "error: expected $artifacts_dir/libansilove.wasm to exist" >&2
+  exit 3
+fi
+
+if [ ! -f "$artifacts_dir/libansilove.js" ]; then
+  echo "error: expected $artifacts_dir/libansilove.js to exist" >&2
+  exit 4
+fi
+
+node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png"
+
+cp "$artifacts_dir/libansilove.js" example/wasm/
+cp "$artifacts_dir/libansilove.wasm" example/wasm/
+
+echo "WASM artefacts found in $artifacts_dir" >&2
diff --git a/src/clean.c b/src/clean.c
index 09fc9ca..bd173de 100644
--- a/src/clean.c
+++ b/src/clean.c
@@ -12,7 +12,9 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#ifndef ANSILOVE_WASM
 #include <sys/mman.h>
+#endif
 
 #include <stddef.h>
 #include "ansilove.h"
@@ -27,11 +29,17 @@ ansilove_clean(struct ansilove_ctx *ctx)
 	if (ctx->png.buffer != NULL)
 		gdFree(ctx->png.buffer);
 
-	if (ctx->buffer != MAP_FAILED)
+#ifndef ANSILOVE_WASM
+	if (ctx->buffer != MAP_FAILED && ctx->maplen)
 		(void)munmap(ctx->buffer, ctx->maplen);
+	ctx->buffer = MAP_FAILED;
+#else
+	ctx->buffer = NULL;
+#endif
 
 	ctx->maplen = ctx->length = 0;
 	ctx->png.length = 0;
+	ctx->png.buffer = NULL;
 
 	return 0;
 }
diff --git a/src/init.c b/src/init.c
index 7c4c67c..36f665a 100644
--- a/src/init.c
+++ b/src/init.c
@@ -12,7 +12,9 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#ifndef ANSILOVE_WASM
 #include <sys/mman.h>
+#endif
 
 #include <string.h>
 #include "ansilove.h"
@@ -30,7 +32,11 @@ ansilove_init(struct ansilove_ctx *ctx, struct ansilove_options *options)
 	memset(ctx, 0, sizeof(*ctx));
 	memset(options, 0, sizeof(*options));
 
+#ifdef ANSILOVE_WASM
+	ctx->buffer = NULL;
+#else
 	ctx->buffer = MAP_FAILED;
+#endif
 
 	/* default to 8 if bits option is not specified */
 	options->bits = 8;
diff --git a/wasm/ansilove_wasm.c b/wasm/ansilove_wasm.c
new file mode 100644
index 0000000..7f3d229
--- /dev/null
+++ b/wasm/ansilove_wasm.c
@@ -0,0 +1,98 @@
+#include "ansilove.h"
+#include <emscripten/emscripten.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct wasm_png_result {
+	uint8_t *data;
+	size_t length;
+};
+
+static struct wasm_png_result wasm_result;
+
+static void
+wasm_clear_result(void)
+{
+	if (wasm_result.data != NULL) {
+		free(wasm_result.data);
+		wasm_result.data = NULL;
+	}
+	wasm_result.length = 0;
+}
+
+static void
+wasm_stash_result(struct ansilove_ctx *ctx)
+{
+	wasm_result.data = ctx->png.buffer;
+	wasm_result.length = (size_t)ctx->png.length;
+	ctx->png.buffer = NULL;
+	ctx->png.length = 0;
+}
+
+EMSCRIPTEN_KEEPALIVE
+const char *
+ansilove_wasm_version(void)
+{
+	return ANSILOVE_VERSION;
+}
+
+EMSCRIPTEN_KEEPALIVE
+int
+ansilove_wasm_render_ansi(uintptr_t data_ptr, size_t length, int columns,
+	int icecolors, int dos, int scale_factor)
+{
+	struct ansilove_ctx ctx;
+	struct ansilove_options options;
+	int result;
+
+	wasm_clear_result();
+
+	if (ansilove_init(&ctx, &options) != 0)
+		return -ANSILOVE_INVALID_PARAM;
+
+	ctx.buffer = (uint8_t *)data_ptr;
+	ctx.length = length;
+	ctx.maplen = 0;
+
+	if (columns > 0)
+		options.columns = columns;
+	options.icecolors = icecolors ? true : false;
+	options.dos = dos ? true : false;
+	if (scale_factor >= 0 && scale_factor <= 8)
+		options.scale_factor = (uint8_t)scale_factor;
+
+	result = ansilove_ansi(&ctx, &options);
+	if (result != 0) {
+		int error = ctx.error;
+		ansilove_clean(&ctx);
+		return -error;
+	}
+
+	wasm_stash_result(&ctx);
+	ansilove_clean(&ctx);
+	return 0;
+}
+
+EMSCRIPTEN_KEEPALIVE
+uintptr_t
+ansilove_wasm_get_png_ptr(void)
+{
+	return (uintptr_t)wasm_result.data;
+}
+
+EMSCRIPTEN_KEEPALIVE
+size_t
+ansilove_wasm_get_png_length(void)
+{
+	return wasm_result.length;
+}
+
+EMSCRIPTEN_KEEPALIVE
+void
+ansilove_wasm_free_png(void)
+{
+	wasm_clear_result();
+}
diff --git a/wasm/gd.h b/wasm/gd.h
new file mode 100644
index 0000000..a353bc0
--- /dev/null
+++ b/wasm/gd.h
@@ -0,0 +1,46 @@
+#ifndef GD_H
+#define GD_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct gdImage {
+	int sx;
+	int sy;
+	int trueColor;
+	int transparent;
+	int colorsTotal;
+	unsigned int palette[256];
+	unsigned char *pixels;
+	unsigned int *tpixels;
+};
+
+typedef struct gdImage *gdImagePtr;
+
+gdImagePtr gdImageCreate(int sx, int sy);
+gdImagePtr gdImageCreateTrueColor(int sx, int sy);
+int gdImageColorAllocate(gdImagePtr im, int r, int g, int b);
+void gdImageFill(gdImagePtr im, int x, int y, int color);
+void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+void gdImageSetPixel(gdImagePtr im, int x, int y, int color);
+void gdImageCopyResized(gdImagePtr dst, gdImagePtr src,
+    int dstX, int dstY, int srcX, int srcY,
+    int dstW, int dstH, int srcW, int srcH);
+void gdImageCopyResampled(gdImagePtr dst, gdImagePtr src,
+    int dstX, int dstY, int srcX, int srcY,
+    int dstW, int dstH, int srcW, int srcH);
+int gdImageTrueColor(gdImagePtr im);
+void gdImageColorTransparent(gdImagePtr im, int color);
+unsigned char *gdImagePngPtr(gdImagePtr im, int *out_size);
+void gdImageDestroy(gdImagePtr im);
+void gdFree(void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GD_H */
diff --git a/wasm/minigd.c b/wasm/minigd.c
new file mode 100644
index 0000000..3d5441c
--- /dev/null
+++ b/wasm/minigd.c
@@ -0,0 +1,436 @@
+#include "gd.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_STATIC
+#define STBI_WRITE_NO_STDIO
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+#include "stb_image_write.h"
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+static gdImagePtr
+allocate_image(int sx, int sy, int trueColor)
+{
+    if (sx <= 0 || sy <= 0)
+        return NULL;
+
+    gdImagePtr im = (gdImagePtr)calloc(1, sizeof(*im));
+    if (!im)
+        return NULL;
+
+    im->sx = sx;
+    im->sy = sy;
+    im->trueColor = trueColor;
+    im->transparent = -1;
+
+    if (trueColor) {
+        im->tpixels = (unsigned int *)calloc((size_t)sx * (size_t)sy, sizeof(unsigned int));
+        if (!im->tpixels) {
+            free(im);
+            return NULL;
+        }
+    } else {
+        im->pixels = (unsigned char *)calloc((size_t)sx * (size_t)sy, sizeof(unsigned char));
+        if (!im->pixels) {
+            free(im);
+            return NULL;
+        }
+    }
+
+    return im;
+}
+
+gdImagePtr
+gdImageCreate(int sx, int sy)
+{
+    return allocate_image(sx, sy, 0);
+}
+
+gdImagePtr
+gdImageCreateTrueColor(int sx, int sy)
+{
+    return allocate_image(sx, sy, 1);
+}
+
+static unsigned int
+pack_color(int r, int g, int b, int a)
+{
+    if (r < 0)
+        r = 0;
+    if (r > 255)
+        r = 255;
+    if (g < 0)
+        g = 0;
+    if (g > 255)
+        g = 255;
+    if (b < 0)
+        b = 0;
+    if (b > 255)
+        b = 255;
+    if (a < 0)
+        a = 0;
+    if (a > 255)
+        a = 255;
+    return ((unsigned int)a << 24) | ((unsigned int)r << 16) | ((unsigned int)g << 8) | (unsigned int)b;
+}
+
+int
+gdImageColorAllocate(gdImagePtr im, int r, int g, int b)
+{
+    if (!im)
+        return 0;
+
+    unsigned int color = pack_color(r, g, b, 255);
+
+    if (im->trueColor)
+        return (int)color;
+
+    for (int i = 0; i < im->colorsTotal; i++) {
+        if (im->palette[i] == color)
+            return i;
+    }
+
+    if (im->colorsTotal >= 256)
+        return 0;
+
+    int idx = im->colorsTotal++;
+    im->palette[idx] = color;
+    return idx;
+}
+
+static inline void
+set_palette_pixel(gdImagePtr im, int x, int y, int color)
+{
+    size_t offset = (size_t)y * (size_t)im->sx + (size_t)x;
+    if (offset < (size_t)im->sx * (size_t)im->sy)
+        im->pixels[offset] = (unsigned char)color;
+}
+
+static inline void
+set_truecolor_pixel(gdImagePtr im, int x, int y, unsigned int color)
+{
+    size_t offset = (size_t)y * (size_t)im->sx + (size_t)x;
+    if (offset < (size_t)im->sx * (size_t)im->sy)
+        im->tpixels[offset] = color;
+}
+
+void
+gdImageFill(gdImagePtr im, int x, int y, int color)
+{
+    (void)x;
+    (void)y;
+
+    if (!im)
+        return;
+
+    gdImageFilledRectangle(im, 0, 0, im->sx - 1, im->sy - 1, color);
+}
+
+static void
+normalize_rect(int *x1, int *y1, int *x2, int *y2)
+{
+    if (*x1 > *x2) {
+        int tmp = *x1;
+        *x1 = *x2;
+        *x2 = tmp;
+    }
+    if (*y1 > *y2) {
+        int tmp = *y1;
+        *y1 = *y2;
+        *y2 = tmp;
+    }
+}
+
+static inline int
+clamp(int value, int min, int max)
+{
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+
+void
+gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+    if (!im)
+        return;
+
+    normalize_rect(&x1, &y1, &x2, &y2);
+
+    x1 = clamp(x1, 0, im->sx - 1);
+    x2 = clamp(x2, 0, im->sx - 1);
+    y1 = clamp(y1, 0, im->sy - 1);
+    y2 = clamp(y2, 0, im->sy - 1);
+
+    if (im->trueColor) {
+        unsigned int packed = (unsigned int)color;
+        for (int y = y1; y <= y2; y++) {
+            for (int x = x1; x <= x2; x++)
+                set_truecolor_pixel(im, x, y, packed);
+        }
+    } else {
+        if (color >= im->colorsTotal)
+            color = im->colorsTotal ? im->colorsTotal - 1 : 0;
+        for (int y = y1; y <= y2; y++) {
+            for (int x = x1; x <= x2; x++)
+                set_palette_pixel(im, x, y, color);
+        }
+    }
+}
+
+void
+gdImageSetPixel(gdImagePtr im, int x, int y, int color)
+{
+    if (!im)
+        return;
+
+    if (x < 0 || x >= im->sx || y < 0 || y >= im->sy)
+        return;
+
+    if (im->trueColor)
+        set_truecolor_pixel(im, x, y, (unsigned int)color);
+    else
+        set_palette_pixel(im, x, y, color);
+}
+
+int
+gdImageTrueColor(gdImagePtr im)
+{
+    return im ? im->trueColor : 0;
+}
+
+void
+gdImageColorTransparent(gdImagePtr im, int color)
+{
+    if (!im)
+        return;
+
+    im->transparent = color;
+}
+
+static unsigned int
+get_pixel_color(gdImagePtr im, int x, int y)
+{
+    if (!im)
+        return 0;
+
+    x = clamp(x, 0, im->sx - 1);
+    y = clamp(y, 0, im->sy - 1);
+
+    size_t offset = (size_t)y * (size_t)im->sx + (size_t)x;
+
+    if (im->trueColor) {
+        return im->tpixels[offset];
+    } else {
+        int idx = im->pixels[offset];
+        if (idx < 0 || idx >= im->colorsTotal)
+            return 0;
+        return im->palette[idx];
+    }
+}
+
+static int
+ensure_palette_color(gdImagePtr im, unsigned int color)
+{
+    for (int i = 0; i < im->colorsTotal; i++) {
+        if (im->palette[i] == color)
+            return i;
+    }
+
+    if (im->colorsTotal >= 256)
+        return 0;
+
+    int idx = im->colorsTotal++;
+    im->palette[idx] = color;
+    return idx;
+}
+
+static void
+set_pixel_from_color(gdImagePtr im, int x, int y, unsigned int color)
+{
+    if (im->trueColor)
+        set_truecolor_pixel(im, x, y, color);
+    else {
+        int idx = ensure_palette_color(im, color);
+        set_palette_pixel(im, x, y, idx);
+    }
+}
+
+static void
+copy_scaled(gdImagePtr dst, gdImagePtr src,
+    int dstX, int dstY, int srcX, int srcY,
+    int dstW, int dstH, int srcW, int srcH)
+{
+    if (!dst || !src)
+        return;
+
+    if (dstW <= 0 || dstH <= 0 || srcW <= 0 || srcH <= 0)
+        return;
+
+    for (int y = 0; y < dstH; y++) {
+        int dy = dstY + y;
+        if (dy < 0 || dy >= dst->sy)
+            continue;
+
+        double srcYOffset = (double)y / (double)dstH;
+        double syf = srcYOffset * srcH;
+        int sy = clamp(srcY + (int)(syf + 0.5 - 0.5), srcY, srcY + srcH - 1);
+
+        for (int x = 0; x < dstW; x++) {
+            int dx = dstX + x;
+            if (dx < 0 || dx >= dst->sx)
+                continue;
+
+            double srcXOffset = (double)x / (double)dstW;
+            double sxf = srcXOffset * srcW;
+            int sx = clamp(srcX + (int)(sxf + 0.5 - 0.5), srcX, srcX + srcW - 1);
+
+            unsigned int color = get_pixel_color(src, sx, sy);
+            set_pixel_from_color(dst, dx, dy, color);
+        }
+    }
+}
+
+void
+gdImageCopyResized(gdImagePtr dst, gdImagePtr src,
+    int dstX, int dstY, int srcX, int srcY,
+    int dstW, int dstH, int srcW, int srcH)
+{
+    copy_scaled(dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
+}
+
+void
+gdImageCopyResampled(gdImagePtr dst, gdImagePtr src,
+    int dstX, int dstY, int srcX, int srcY,
+    int dstW, int dstH, int srcW, int srcH)
+{
+    copy_scaled(dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
+}
+
+static void
+rgba_from_color(unsigned int color, unsigned char *rgba)
+{
+    rgba[0] = (unsigned char)((color >> 16) & 0xFF);
+    rgba[1] = (unsigned char)((color >> 8) & 0xFF);
+    rgba[2] = (unsigned char)(color & 0xFF);
+    rgba[3] = (unsigned char)((color >> 24) & 0xFF);
+}
+
+struct png_buffer {
+    unsigned char *data;
+    size_t size;
+    size_t capacity;
+    int failed;
+};
+
+static void
+png_write(void *context, void *data, int size)
+{
+    struct png_buffer *buf = (struct png_buffer *)context;
+    if (buf->failed)
+        return;
+
+    size_t required = buf->size + (size_t)size;
+    if (required > buf->capacity) {
+        size_t new_capacity = buf->capacity ? buf->capacity * 2 : 1024;
+        while (new_capacity < required)
+            new_capacity *= 2;
+        unsigned char *new_data = (unsigned char *)realloc(buf->data, new_capacity);
+        if (!new_data) {
+            free(buf->data);
+            buf->data = NULL;
+            buf->size = buf->capacity = 0;
+            buf->failed = 1;
+            return;
+        }
+        buf->data = new_data;
+        buf->capacity = new_capacity;
+    }
+
+    memcpy(buf->data + buf->size, data, (size_t)size);
+    buf->size += (size_t)size;
+}
+
+unsigned char *
+gdImagePngPtr(gdImagePtr im, int *out_size)
+{
+    if (!im || !out_size)
+        return NULL;
+
+    size_t pixel_count = (size_t)im->sx * (size_t)im->sy;
+    unsigned char *rgba = (unsigned char *)malloc(pixel_count * 4);
+    if (!rgba)
+        return NULL;
+
+    for (size_t i = 0; i < pixel_count; i++) {
+        unsigned int color;
+        if (im->trueColor) {
+            color = im->tpixels[i];
+            if (im->transparent != -1 && (int)color == im->transparent)
+                color &= 0x00FFFFFF;
+        } else {
+            int idx = (int)im->pixels[i];
+            if (idx < 0 || idx >= im->colorsTotal)
+                idx = 0;
+            color = im->palette[idx];
+            if (idx == im->transparent)
+                color &= 0x00FFFFFF;
+        }
+
+        rgba_from_color(color, &rgba[i * 4]);
+
+        if (!im->trueColor) {
+            int idx = (int)im->pixels[i];
+            if (idx == im->transparent)
+                rgba[i * 4 + 3] = 0;
+            else
+                rgba[i * 4 + 3] = 255;
+        }
+    }
+
+    struct png_buffer buf = {0};
+    int stride = im->sx * 4;
+    int ok = stbi_write_png_to_func(png_write, &buf, im->sx, im->sy, 4, rgba, stride);
+    free(rgba);
+
+    if (!ok || !buf.data || buf.failed)
+        return NULL;
+
+    unsigned char *result = (unsigned char *)malloc(buf.size);
+    if (!result) {
+        free(buf.data);
+        return NULL;
+    }
+
+    memcpy(result, buf.data, buf.size);
+    free(buf.data);
+
+    *out_size = (int)buf.size;
+    return result;
+}
+
+void
+gdImageDestroy(gdImagePtr im)
+{
+    if (!im)
+        return;
+
+    free(im->pixels);
+    free(im->tpixels);
+    free(im);
+}
+
+void
+gdFree(void *ptr)
+{
+    free(ptr);
+}
diff --git a/wasm/stb_image_write.h b/wasm/stb_image_write.h
new file mode 100644
index 0000000..e4b32ed
--- /dev/null
+++ b/wasm/stb_image_write.h
@@ -0,0 +1,1724 @@
+/* stb_image_write - v1.16 - public domain - http://nothings.org/stb
+   writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
+                                     no warranty implied; use at your own risk
+
+   Before #including,
+
+       #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+   in the file that you want to have the implementation.
+
+   Will probably not work correctly with strict-aliasing optimizations.
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio or a callback.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation; though providing a custom
+   zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
+   This library is designed for source code compactness and simplicity,
+   not optimal image file size or run-time performance.
+
+BUILDING:
+
+   You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
+   You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
+   malloc,realloc,free.
+   You can #define STBIW_MEMMOVE() to replace memmove()
+   You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
+   for PNG compression (instead of the builtin one), it must have the following signature:
+   unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
+   The returned data will be freed with STBIW_FREE() (free() by default),
+   so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
+
+UNICODE:
+
+   If compiling for Windows and you wish to use Unicode filenames, compile
+   with
+       #define STBIW_WINDOWS_UTF8
+   and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
+   Windows wchar_t filenames to utf8.
+
+USAGE:
+
+   There are five functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);
+     int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+
+     void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
+
+   There are also five equivalent functions that use an arbitrary write function. You are
+   expected to open/close your file-equivalent before and after calling these:
+
+     int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data, int stride_in_bytes);
+     int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+     int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+     int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+     int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
+
+   where the callback is:
+      void stbi_write_func(void *context, void *data, int size);
+
+   You can configure it with these global variables:
+      int stbi_write_tga_with_rle;             // defaults to true; set to 0 to disable RLE
+      int stbi_write_png_compression_level;    // defaults to 8; set to higher for more compression
+      int stbi_write_force_png_filter;         // defaults to -1; set to 0..5 to force a filter mode
+
+
+   You can define STBI_WRITE_NO_STDIO to disable the file variant of these
+   functions, so the library will not use stdio.h at all. However, this will
+   also disable HDR writing, because it requires stdio for formatted output.
+
+   Each function returns 0 on failure and non-0 on success.
+
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP format expands Y to RGB in the file format and does not
+   output alpha.
+
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+
+   PNG allows you to set the deflate compression level by setting the global
+   variable 'stbi_write_png_compression_level' (it defaults to 8).
+
+   HDR expects linear float data. Since the format is always 32-bit rgb(e)
+   data, alpha (if provided) is discarded, and for monochrome data it is
+   replicated across all three channels.
+
+   TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
+   data, set the global variable 'stbi_write_tga_with_rle' to 0.
+
+   JPEG does ignore alpha channels in input data; quality is between 1 and 100.
+   Higher quality looks better but results in a bigger image.
+   JPEG baseline (no JPEG progressive).
+
+CREDITS:
+
+
+   Sean Barrett           -    PNG/BMP/TGA
+   Baldur Karlsson        -    HDR
+   Jean-Sebastien Guay    -    TGA monochrome
+   Tim Kelsey             -    misc enhancements
+   Alan Hickman           -    TGA RLE
+   Emmanuel Julien        -    initial file IO callback implementation
+   Jon Olick              -    original jo_jpeg.cpp code
+   Daniel Gibson          -    integrate JPEG, allow external zlib
+   Aarni Koskela          -    allow choosing PNG filter
+
+   bugfixes:
+      github:Chribba
+      Guillaume Chereau
+      github:jry2
+      github:romigrou
+      Sergio Gonzalez
+      Jonas Karlsson
+      Filip Wasil
+      Thatcher Ulrich
+      github:poppolopoppo
+      Patrick Boettcher
+      github:xeekworx
+      Cap Petschulat
+      Simon Rodriguez
+      Ivan Tikhonov
+      github:ignotion
+      Adam Schackart
+      Andrew Kensler
+
+LICENSE
+
+  See end of file for license information.
+
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#include <stdlib.h>
+
+// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
+#ifndef STBIWDEF
+#ifdef STB_IMAGE_WRITE_STATIC
+#define STBIWDEF  static
+#else
+#ifdef __cplusplus
+#define STBIWDEF  extern "C"
+#else
+#define STBIWDEF  extern
+#endif
+#endif
+#endif
+
+#ifndef STB_IMAGE_WRITE_STATIC  // C++ forbids static forward declarations
+STBIWDEF int stbi_write_tga_with_rle;
+STBIWDEF int stbi_write_png_compression_level;
+STBIWDEF int stbi_write_force_png_filter;
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void  *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void  *data, int quality);
+
+#ifdef STBIW_WINDOWS_UTF8
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+#endif
+
+typedef void stbi_write_func(void *context, void *data, int size);
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data, int stride_in_bytes);
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void  *data);
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void  *data, int quality);
+
+STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
+
+#endif//INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#ifdef _WIN32
+   #ifndef _CRT_SECURE_NO_WARNINGS
+   #define _CRT_SECURE_NO_WARNINGS
+   #endif
+   #ifndef _CRT_NONSTDC_NO_DEPRECATE
+   #define _CRT_NONSTDC_NO_DEPRECATE
+   #endif
+#endif
+
+#ifndef STBI_WRITE_NO_STDIO
+#include <stdio.h>
+#endif // STBI_WRITE_NO_STDIO
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
+// ok
+#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
+#endif
+
+#ifndef STBIW_MALLOC
+#define STBIW_MALLOC(sz)        malloc(sz)
+#define STBIW_REALLOC(p,newsz)  realloc(p,newsz)
+#define STBIW_FREE(p)           free(p)
+#endif
+
+#ifndef STBIW_REALLOC_SIZED
+#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
+#endif
+
+
+#ifndef STBIW_MEMMOVE
+#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
+#endif
+
+
+#ifndef STBIW_ASSERT
+#include <assert.h>
+#define STBIW_ASSERT(x) assert(x)
+#endif
+
+#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
+
+#ifdef STB_IMAGE_WRITE_STATIC
+static int stbi_write_png_compression_level = 8;
+static int stbi_write_tga_with_rle = 1;
+static int stbi_write_force_png_filter = -1;
+#else
+int stbi_write_png_compression_level = 8;
+int stbi_write_tga_with_rle = 1;
+int stbi_write_force_png_filter = -1;
+#endif
+
+static int stbi__flip_vertically_on_write = 0;
+
+STBIWDEF void stbi_flip_vertically_on_write(int flag)
+{
+   stbi__flip_vertically_on_write = flag;
+}
+
+typedef struct
+{
+   stbi_write_func *func;
+   void *context;
+   unsigned char buffer[64];
+   int buf_used;
+} stbi__write_context;
+
+// initialize a callback-based context
+static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)
+{
+   s->func    = c;
+   s->context = context;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbi__stdio_write(void *context, void *data, int size)
+{
+   fwrite(data,1,size,(FILE*) context);
+}
+
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+#ifdef __cplusplus
+#define STBIW_EXTERN extern "C"
+#else
+#define STBIW_EXTERN extern
+#endif
+STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+
+STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+   return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbiw__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+   if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+      return 0;
+
+   if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+      return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != _wfopen_s(&f, wFilename, wMode))
+      f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+static int stbi__start_write_file(stbi__write_context *s, const char *filename)
+{
+   FILE *f = stbiw__fopen(filename, "wb");
+   stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
+   return f != NULL;
+}
+
+static void stbi__end_write_file(stbi__write_context *s)
+{
+   fclose((FILE *)s->context);
+}
+
+#endif // !STBI_WRITE_NO_STDIO
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
+
+static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
+{
+   while (*fmt) {
+      switch (*fmt++) {
+         case ' ': break;
+         case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
+                     s->func(s->context,&x,1);
+                     break; }
+         case '2': { int x = va_arg(v,int);
+                     unsigned char b[2];
+                     b[0] = STBIW_UCHAR(x);
+                     b[1] = STBIW_UCHAR(x>>8);
+                     s->func(s->context,b,2);
+                     break; }
+         case '4': { stbiw_uint32 x = va_arg(v,int);
+                     unsigned char b[4];
+                     b[0]=STBIW_UCHAR(x);
+                     b[1]=STBIW_UCHAR(x>>8);
+                     b[2]=STBIW_UCHAR(x>>16);
+                     b[3]=STBIW_UCHAR(x>>24);
+                     s->func(s->context,b,4);
+                     break; }
+         default:
+            STBIW_ASSERT(0);
+            return;
+      }
+   }
+}
+
+static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
+{
+   va_list v;
+   va_start(v, fmt);
+   stbiw__writefv(s, fmt, v);
+   va_end(v);
+}
+
+static void stbiw__write_flush(stbi__write_context *s)
+{
+   if (s->buf_used) {
+      s->func(s->context, &s->buffer, s->buf_used);
+      s->buf_used = 0;
+   }
+}
+
+static void stbiw__putc(stbi__write_context *s, unsigned char c)
+{
+   s->func(s->context, &c, 1);
+}
+
+static void stbiw__write1(stbi__write_context *s, unsigned char a)
+{
+   if ((size_t)s->buf_used + 1 > sizeof(s->buffer))
+      stbiw__write_flush(s);
+   s->buffer[s->buf_used++] = a;
+}
+
+static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
+{
+   int n;
+   if ((size_t)s->buf_used + 3 > sizeof(s->buffer))
+      stbiw__write_flush(s);
+   n = s->buf_used;
+   s->buf_used = n+3;
+   s->buffer[n+0] = a;
+   s->buffer[n+1] = b;
+   s->buffer[n+2] = c;
+}
+
+static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
+{
+   unsigned char bg[3] = { 255, 0, 255}, px[3];
+   int k;
+
+   if (write_alpha < 0)
+      stbiw__write1(s, d[comp - 1]);
+
+   switch (comp) {
+      case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
+      case 1:
+         if (expand_mono)
+            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
+         else
+            stbiw__write1(s, d[0]);  // monochrome TGA
+         break;
+      case 4:
+         if (!write_alpha) {
+            // composite against pink background
+            for (k = 0; k < 3; ++k)
+               px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
+            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
+            break;
+         }
+         /* FALLTHROUGH */
+      case 3:
+         stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
+         break;
+   }
+   if (write_alpha > 0)
+      stbiw__write1(s, d[comp - 1]);
+}
+
+static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
+{
+   stbiw_uint32 zero = 0;
+   int i,j, j_end;
+
+   if (y <= 0)
+      return;
+
+   if (stbi__flip_vertically_on_write)
+      vdir *= -1;
+
+   if (vdir < 0) {
+      j_end = -1; j = y-1;
+   } else {
+      j_end =  y; j = 0;
+   }
+
+   for (; j != j_end; j += vdir) {
+      for (i=0; i < x; ++i) {
+         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
+         stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
+      }
+      stbiw__write_flush(s);
+      s->func(s->context, &zero, scanline_pad);
+   }
+}
+
+static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
+{
+   if (y < 0 || x < 0) {
+      return 0;
+   } else {
+      va_list v;
+      va_start(v, fmt);
+      stbiw__writefv(s, fmt, v);
+      va_end(v);
+      stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
+      return 1;
+   }
+}
+
+static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
+{
+   if (comp != 4) {
+      // write RGB bitmap
+      int pad = (-x*3) & 3;
+      return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
+              "11 4 22 4" "4 44 22 444444",
+              'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
+               40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
+   } else {
+      // RGBA bitmaps need a v4 header
+      // use BI_BITFIELDS mode with 32bpp and alpha mask
+      // (straight BI_RGB with alpha mask doesn't work in most readers)
+      return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0,
+         "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444",
+         'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header
+         108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header
+   }
+}
+
+STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s = { 0 };
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_bmp_core(&s, x, y, comp, data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s = { 0 };
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_bmp_core(&s, x, y, comp, data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif //!STBI_WRITE_NO_STDIO
+
+static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
+{
+   int has_alpha = (comp == 2 || comp == 4);
+   int colorbytes = has_alpha ? comp-1 : comp;
+   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
+
+   if (y < 0 || x < 0)
+      return 0;
+
+   if (!stbi_write_tga_with_rle) {
+      return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0,
+         "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+   } else {
+      int i,j,k;
+      int jend, jdir;
+
+      stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8);
+
+      if (stbi__flip_vertically_on_write) {
+         j = 0;
+         jend = y;
+         jdir = 1;
+      } else {
+         j = y-1;
+         jend = -1;
+         jdir = -1;
+      }
+      for (; j != jend; j += jdir) {
+         unsigned char *row = (unsigned char *) data + j * x * comp;
+         int len;
+
+         for (i = 0; i < x; i += len) {
+            unsigned char *begin = row + i * comp;
+            int diff = 1;
+            len = 1;
+
+            if (i < x - 1) {
+               ++len;
+               diff = memcmp(begin, row + (i + 1) * comp, comp);
+               if (diff) {
+                  const unsigned char *prev = begin;
+                  for (k = i + 2; k < x && len < 128; ++k) {
+                     if (memcmp(prev, row + k * comp, comp)) {
+                        prev += comp;
+                        ++len;
+                     } else {
+                        --len;
+                        break;
+                     }
+                  }
+               } else {
+                  for (k = i + 2; k < x && len < 128; ++k) {
+                     if (!memcmp(begin, row + k * comp, comp)) {
+                        ++len;
+                     } else {
+                        break;
+                     }
+                  }
+               }
+            }
+
+            if (diff) {
+               unsigned char header = STBIW_UCHAR(len - 1);
+               stbiw__write1(s, header);
+               for (k = 0; k < len; ++k) {
+                  stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
+               }
+            } else {
+               unsigned char header = STBIW_UCHAR(len - 129);
+               stbiw__write1(s, header);
+               stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
+            }
+         }
+      }
+      stbiw__write_flush(s);
+   }
+   return 1;
+}
+
+STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s = { 0 };
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_tga_core(&s, x, y, comp, (void *) data);
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+   stbi__write_context s = { 0 };
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR writer
+// by Baldur Karlsson
+
+#define stbiw__max(a, b)  ((a) > (b) ? (a) : (b))
+
+#ifndef STBI_WRITE_NO_STDIO
+
+static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
+{
+   int exponent;
+   float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
+
+   if (maxcomp < 1e-32f) {
+      rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+   } else {
+      float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;
+
+      rgbe[0] = (unsigned char)(linear[0] * normalize);
+      rgbe[1] = (unsigned char)(linear[1] * normalize);
+      rgbe[2] = (unsigned char)(linear[2] * normalize);
+      rgbe[3] = (unsigned char)(exponent + 128);
+   }
+}
+
+static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
+{
+   unsigned char lengthbyte = STBIW_UCHAR(length+128);
+   STBIW_ASSERT(length+128 <= 255);
+   s->func(s->context, &lengthbyte, 1);
+   s->func(s->context, &databyte, 1);
+}
+
+static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
+{
+   unsigned char lengthbyte = STBIW_UCHAR(length);
+   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
+   s->func(s->context, &lengthbyte, 1);
+   s->func(s->context, data, length);
+}
+
+static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
+{
+   unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
+   unsigned char rgbe[4];
+   float linear[3];
+   int x;
+
+   scanlineheader[2] = (width&0xff00)>>8;
+   scanlineheader[3] = (width&0x00ff);
+
+   /* skip RLE for images too small or large */
+   if (width < 8 || width >= 32768) {
+      for (x=0; x < width; x++) {
+         switch (ncomp) {
+            case 4: /* fallthrough */
+            case 3: linear[2] = scanline[x*ncomp + 2];
+                    linear[1] = scanline[x*ncomp + 1];
+                    linear[0] = scanline[x*ncomp + 0];
+                    break;
+            default:
+                    linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+                    break;
+         }
+         stbiw__linear_to_rgbe(rgbe, linear);
+         s->func(s->context, rgbe, 4);
+      }
+   } else {
+      int c,r;
+      /* encode into scratch buffer */
+      for (x=0; x < width; x++) {
+         switch(ncomp) {
+            case 4: /* fallthrough */
+            case 3: linear[2] = scanline[x*ncomp + 2];
+                    linear[1] = scanline[x*ncomp + 1];
+                    linear[0] = scanline[x*ncomp + 0];
+                    break;
+            default:
+                    linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
+                    break;
+         }
+         stbiw__linear_to_rgbe(rgbe, linear);
+         scratch[x + width*0] = rgbe[0];
+         scratch[x + width*1] = rgbe[1];
+         scratch[x + width*2] = rgbe[2];
+         scratch[x + width*3] = rgbe[3];
+      }
+
+      s->func(s->context, scanlineheader, 4);
+
+      /* RLE each component separately */
+      for (c=0; c < 4; c++) {
+         unsigned char *comp = &scratch[width*c];
+
+         x = 0;
+         while (x < width) {
+            // find first run
+            r = x;
+            while (r+2 < width) {
+               if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
+                  break;
+               ++r;
+            }
+            if (r+2 >= width)
+               r = width;
+            // dump up to first run
+            while (x < r) {
+               int len = r-x;
+               if (len > 128) len = 128;
+               stbiw__write_dump_data(s, len, &comp[x]);
+               x += len;
+            }
+            // if there's a run, output it
+            if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
+               // find next byte after run
+               while (r < width && comp[r] == comp[x])
+                  ++r;
+               // output run up to r
+               while (x < r) {
+                  int len = r-x;
+                  if (len > 127) len = 127;
+                  stbiw__write_run_data(s, len, comp[x]);
+                  x += len;
+               }
+            }
+         }
+      }
+   }
+}
+
+static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
+{
+   if (y <= 0 || x <= 0 || data == NULL)
+      return 0;
+   else {
+      // Each component is stored separately. Allocate scratch space for full output scanline.
+      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
+      int i, len;
+      char buffer[128];
+      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
+      s->func(s->context, header, sizeof(header)-1);
+
+#ifdef __STDC_LIB_EXT1__
+      len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#else
+      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
+#endif
+      s->func(s->context, buffer, len);
+
+      for(i=0; i < y; i++)
+         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
+      STBIW_FREE(scratch);
+      return 1;
+   }
+}
+
+STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
+{
+   stbi__write_context s = { 0 };
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+}
+
+STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
+{
+   stbi__write_context s = { 0 };
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif // STBI_WRITE_NO_STDIO
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PNG writer
+//
+
+#ifndef STBIW_ZLIB_COMPRESS
+// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
+#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
+#define stbiw__sbm(a)   stbiw__sbraw(a)[0]
+#define stbiw__sbn(a)   stbiw__sbraw(a)[1]
+
+#define stbiw__sbneedgrow(a,n)  ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))
+#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)
+#define stbiw__sbgrow(a,n)  stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))
+
+#define stbiw__sbpush(a, v)      (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))
+#define stbiw__sbcount(a)        ((a) ? stbiw__sbn(a) : 0)
+#define stbiw__sbfree(a)         ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
+
+static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
+{
+   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
+   void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
+   STBIW_ASSERT(p);
+   if (p) {
+      if (!*arr) ((int *) p)[1] = 0;
+      *arr = (void *) ((int *) p + 2);
+      stbiw__sbm(*arr) = m;
+   }
+   return *arr;
+}
+
+static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+   while (*bitcount >= 8) {
+      stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
+      *bitbuffer >>= 8;
+      *bitcount -= 8;
+   }
+   return data;
+}
+
+static int stbiw__zlib_bitrev(int code, int codebits)
+{
+   int res=0;
+   while (codebits--) {
+      res = (res << 1) | (code & 1);
+      code >>= 1;
+   }
+   return res;
+}
+
+static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+   int i;
+   for (i=0; i < limit && i < 258; ++i)
+      if (a[i] != b[i]) break;
+   return i;
+}
+
+static unsigned int stbiw__zhash(unsigned char *data)
+{
+   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+   return hash;
+}
+
+#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbiw__zlib_add(code,codebits) \
+      (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
+#define stbiw__zlib_huffa(b,c)  stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
+// default huffman tables
+#define stbiw__zlib_huff1(n)  stbiw__zlib_huffa(0x30 + (n), 8)
+#define stbiw__zlib_huff2(n)  stbiw__zlib_huffa(0x190 + (n)-144, 9)
+#define stbiw__zlib_huff3(n)  stbiw__zlib_huffa(0 + (n)-256,7)
+#define stbiw__zlib_huff4(n)  stbiw__zlib_huffa(0xc0 + (n)-280,8)
+#define stbiw__zlib_huff(n)  ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))
+#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
+
+#define stbiw__ZHASH   16384
+
+#endif // STBIW_ZLIB_COMPRESS
+
+STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+#ifdef STBIW_ZLIB_COMPRESS
+   // user provided a zlib compress implementation, use that
+   return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
+#else // use builtin
+   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
+   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
+   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
+   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
+   unsigned int bitbuf=0;
+   int i,j, bitcount=0;
+   unsigned char *out = NULL;
+   unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));
+   if (hash_table == NULL)
+      return NULL;
+   if (quality < 5) quality = 5;
+
+   stbiw__sbpush(out, 0x78);   // DEFLATE 32K window
+   stbiw__sbpush(out, 0x5e);   // FLEVEL = 1
+   stbiw__zlib_add(1,1);  // BFINAL = 1
+   stbiw__zlib_add(1,2);  // BTYPE = 1 -- fixed huffman
+
+   for (i=0; i < stbiw__ZHASH; ++i)
+      hash_table[i] = NULL;
+
+   i=0;
+   while (i < data_len-3) {
+      // hash next 3 bytes of data to be compressed
+      int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
+      unsigned char *bestloc = 0;
+      unsigned char **hlist = hash_table[h];
+      int n = stbiw__sbcount(hlist);
+      for (j=0; j < n; ++j) {
+         if (hlist[j]-data > i-32768) { // if entry lies within window
+            int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
+            if (d >= best) { best=d; bestloc=hlist[j]; }
+         }
+      }
+      // when hash table entry is too long, delete half the entries
+      if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
+         STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
+         stbiw__sbn(hash_table[h]) = quality;
+      }
+      stbiw__sbpush(hash_table[h],data+i);
+
+      if (bestloc) {
+         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+         h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
+         hlist = hash_table[h];
+         n = stbiw__sbcount(hlist);
+         for (j=0; j < n; ++j) {
+            if (hlist[j]-data > i-32767) {
+               int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
+               if (e > best) { // if next match is better, bail on current match
+                  bestloc = NULL;
+                  break;
+               }
+            }
+         }
+      }
+
+      if (bestloc) {
+         int d = (int) (data+i - bestloc); // distance back
+         STBIW_ASSERT(d <= 32767 && best <= 258);
+         for (j=0; best > lengthc[j+1]-1; ++j);
+         stbiw__zlib_huff(j+257);
+         if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
+         for (j=0; d > distc[j+1]-1; ++j);
+         stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);
+         if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
+         i += best;
+      } else {
+         stbiw__zlib_huffb(data[i]);
+         ++i;
+      }
+   }
+   // write out final bytes
+   for (;i < data_len; ++i)
+      stbiw__zlib_huffb(data[i]);
+   stbiw__zlib_huff(256); // end of block
+   // pad with 0 bits to byte boundary
+   while (bitcount)
+      stbiw__zlib_add(0,1);
+
+   for (i=0; i < stbiw__ZHASH; ++i)
+      (void) stbiw__sbfree(hash_table[i]);
+   STBIW_FREE(hash_table);
+
+   // store uncompressed instead if compression was worse
+   if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {
+      stbiw__sbn(out) = 2;  // truncate to DEFLATE 32K window and FLEVEL = 1
+      for (j = 0; j < data_len;) {
+         int blocklen = data_len - j;
+         if (blocklen > 32767) blocklen = 32767;
+         stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression
+         stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN
+         stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
+         stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN
+         stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));
+         memcpy(out+stbiw__sbn(out), data+j, blocklen);
+         stbiw__sbn(out) += blocklen;
+         j += blocklen;
+      }
+   }
+
+   {
+      // compute adler32 on input
+      unsigned int s1=1, s2=0;
+      int blocklen = (int) (data_len % 5552);
+      j=0;
+      while (j < data_len) {
+         for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }
+         s1 %= 65521; s2 %= 65521;
+         j += blocklen;
+         blocklen = 5552;
+      }
+      stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
+      stbiw__sbpush(out, STBIW_UCHAR(s2));
+      stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
+      stbiw__sbpush(out, STBIW_UCHAR(s1));
+   }
+   *out_len = stbiw__sbn(out);
+   // make returned pointer freeable
+   STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
+   return (unsigned char *) stbiw__sbraw(out);
+#endif // STBIW_ZLIB_COMPRESS
+}
+
+static unsigned int stbiw__crc32(unsigned char *buffer, int len)
+{
+#ifdef STBIW_CRC32
+    return STBIW_CRC32(buffer, len);
+#else
+   static unsigned int crc_table[256] =
+   {
+      0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+      0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+      0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+      0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+      0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+      0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+      0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+      0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+      0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+      0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+      0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+      0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+      0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+      0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+      0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+      0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+      0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+      0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+      0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+      0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+      0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+      0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+      0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+      0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+      0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+      0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+      0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+      0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+      0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+      0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+      0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+      0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+   };
+
+   unsigned int crc = ~0u;
+   int i;
+   for (i=0; i < len; ++i)
+      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+   return ~crc;
+#endif
+}
+
+#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)
+#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
+#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
+
+static void stbiw__wpcrc(unsigned char **data, int len)
+{
+   unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
+   stbiw__wp32(*data, crc);
+}
+
+static unsigned char stbiw__paeth(int a, int b, int c)
+{
+   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
+   if (pb <= pc) return STBIW_UCHAR(b);
+   return STBIW_UCHAR(c);
+}
+
+// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
+static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
+{
+   static int mapping[] = { 0,1,2,3,4 };
+   static int firstmap[] = { 0,1,0,5,6 };
+   int *mymap = (y != 0) ? mapping : firstmap;
+   int i;
+   int type = mymap[filter_type];
+   unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
+   int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
+
+   if (type==0) {
+      memcpy(line_buffer, z, width*n);
+      return;
+   }
+
+   // first loop isn't optimized since it's just one pixel
+   for (i = 0; i < n; ++i) {
+      switch (type) {
+         case 1: line_buffer[i] = z[i]; break;
+         case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
+         case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
+         case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;
+         case 5: line_buffer[i] = z[i]; break;
+         case 6: line_buffer[i] = z[i]; break;
+      }
+   }
+   switch (type) {
+      case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
+      case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
+      case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
+      case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
+      case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
+      case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
+   }
+}
+
+STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+   int force_filter = stbi_write_force_png_filter;
+   int ctype[5] = { -1, 0, 4, 2, 6 };
+   unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
+   unsigned char *out,*o, *filt, *zlib;
+   signed char *line_buffer;
+   int j,zlen;
+
+   if (stride_bytes == 0)
+      stride_bytes = x * n;
+
+   if (force_filter >= 5) {
+      force_filter = -1;
+   }
+
+   filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
+   line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
+   for (j=0; j < y; ++j) {
+      int filter_type;
+      if (force_filter > -1) {
+         filter_type = force_filter;
+         stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
+      } else { // Estimate the best filter by running through all of them:
+         int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
+         for (filter_type = 0; filter_type < 5; filter_type++) {
+            stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
+
+            // Estimate the entropy of the line using this filter; the less, the better.
+            est = 0;
+            for (i = 0; i < x*n; ++i) {
+               est += abs((signed char) line_buffer[i]);
+            }
+            if (est < best_filter_val) {
+               best_filter_val = est;
+               best_filter = filter_type;
+            }
+         }
+         if (filter_type != best_filter) {  // If the last iteration already got us the best filter, don't redo it
+            stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
+            filter_type = best_filter;
+         }
+      }
+      // when we get here, filter_type contains the filter type, and line_buffer contains the data
+      filt[j*(x*n+1)] = (unsigned char) filter_type;
+      STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
+   }
+   STBIW_FREE(line_buffer);
+   zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
+   STBIW_FREE(filt);
+   if (!zlib) return 0;
+
+   // each tag requires 12 bytes of overhead
+   out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
+   if (!out) return 0;
+   *out_len = 8 + 12+13 + 12+zlen + 12;
+
+   o=out;
+   STBIW_MEMMOVE(o,sig,8); o+= 8;
+   stbiw__wp32(o, 13); // header length
+   stbiw__wptag(o, "IHDR");
+   stbiw__wp32(o, x);
+   stbiw__wp32(o, y);
+   *o++ = 8;
+   *o++ = STBIW_UCHAR(ctype[n]);
+   *o++ = 0;
+   *o++ = 0;
+   *o++ = 0;
+   stbiw__wpcrc(&o,13);
+
+   stbiw__wp32(o, zlen);
+   stbiw__wptag(o, "IDAT");
+   STBIW_MEMMOVE(o, zlib, zlen);
+   o += zlen;
+   STBIW_FREE(zlib);
+   stbiw__wpcrc(&o, zlen);
+
+   stbiw__wp32(o,0);
+   stbiw__wptag(o, "IEND");
+   stbiw__wpcrc(&o,0);
+
+   STBIW_ASSERT(o == out + *out_len);
+
+   return out;
+}
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   FILE *f;
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+
+   f = stbiw__fopen(filename, "wb");
+   if (!f) { STBIW_FREE(png); return 0; }
+   fwrite(png, 1, len, f);
+   fclose(f);
+   STBIW_FREE(png);
+   return 1;
+}
+#endif
+
+STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (png == NULL) return 0;
+   func(context, png, len);
+   STBIW_FREE(png);
+   return 1;
+}
+
+
+/* ***************************************************************************
+ *
+ * JPEG writer
+ *
+ * This is based on Jon Olick's jo_jpeg.cpp:
+ * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
+ */
+
+static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,
+      24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };
+
+static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
+   int bitBuf = *bitBufP, bitCnt = *bitCntP;
+   bitCnt += bs[1];
+   bitBuf |= bs[0] << (24 - bitCnt);
+   while(bitCnt >= 8) {
+      unsigned char c = (bitBuf >> 16) & 255;
+      stbiw__putc(s, c);
+      if(c == 255) {
+         stbiw__putc(s, 0);
+      }
+      bitBuf <<= 8;
+      bitCnt -= 8;
+   }
+   *bitBufP = bitBuf;
+   *bitCntP = bitCnt;
+}
+
+static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
+   float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
+   float z1, z2, z3, z4, z5, z11, z13;
+
+   float tmp0 = d0 + d7;
+   float tmp7 = d0 - d7;
+   float tmp1 = d1 + d6;
+   float tmp6 = d1 - d6;
+   float tmp2 = d2 + d5;
+   float tmp5 = d2 - d5;
+   float tmp3 = d3 + d4;
+   float tmp4 = d3 - d4;
+
+   // Even part
+   float tmp10 = tmp0 + tmp3;   // phase 2
+   float tmp13 = tmp0 - tmp3;
+   float tmp11 = tmp1 + tmp2;
+   float tmp12 = tmp1 - tmp2;
+
+   d0 = tmp10 + tmp11;       // phase 3
+   d4 = tmp10 - tmp11;
+
+   z1 = (tmp12 + tmp13) * 0.707106781f; // c4
+   d2 = tmp13 + z1;       // phase 5
+   d6 = tmp13 - z1;
+
+   // Odd part
+   tmp10 = tmp4 + tmp5;       // phase 2
+   tmp11 = tmp5 + tmp6;
+   tmp12 = tmp6 + tmp7;
+
+   // The rotator is modified from fig 4-8 to avoid extra negations.
+   z5 = (tmp10 - tmp12) * 0.382683433f; // c6
+   z2 = tmp10 * 0.541196100f + z5; // c2-c6
+   z4 = tmp12 * 1.306562965f + z5; // c2+c6
+   z3 = tmp11 * 0.707106781f; // c4
+
+   z11 = tmp7 + z3;      // phase 5
+   z13 = tmp7 - z3;
+
+   *d5p = z13 + z2;         // phase 6
+   *d3p = z13 - z2;
+   *d1p = z11 + z4;
+   *d7p = z11 - z4;
+
+   *d0p = d0;  *d2p = d2;  *d4p = d4;  *d6p = d6;
+}
+
+static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
+   int tmp1 = val < 0 ? -val : val;
+   val = val < 0 ? val-1 : val;
+   bits[1] = 1;
+   while(tmp1 >>= 1) {
+      ++bits[1];
+   }
+   bits[0] = val & ((1<<bits[1])-1);
+}
+
+static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
+   const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
+   const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
+   int dataOff, i, j, n, diff, end0pos, x, y;
+   int DU[64];
+
+   // DCT rows
+   for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
+      stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
+   }
+   // DCT columns
+   for(dataOff=0; dataOff<8; ++dataOff) {
+      stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
+                     &CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
+   }
+   // Quantize/descale/zigzag the coefficients
+   for(y = 0, j=0; y < 8; ++y) {
+      for(x = 0; x < 8; ++x,++j) {
+         float v;
+         i = y*du_stride+x;
+         v = CDU[i]*fdtbl[j];
+         // DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
+         // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
+         DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
+      }
+   }
+
+   // Encode DC
+   diff = DU[0] - DC;
+   if (diff == 0) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
+   } else {
+      unsigned short bits[2];
+      stbiw__jpg_calcBits(diff, bits);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+   }
+   // Encode ACs
+   end0pos = 63;
+   for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
+   }
+   // end0pos = first element in reverse order !=0
+   if(end0pos == 0) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+      return DU[0];
+   }
+   for(i = 1; i <= end0pos; ++i) {
+      int startpos = i;
+      int nrzeroes;
+      unsigned short bits[2];
+      for (; DU[i]==0 && i<=end0pos; ++i) {
+      }
+      nrzeroes = i-startpos;
+      if ( nrzeroes >= 16 ) {
+         int lng = nrzeroes>>4;
+         int nrmarker;
+         for (nrmarker=1; nrmarker <= lng; ++nrmarker)
+            stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
+         nrzeroes &= 15;
+      }
+      stbiw__jpg_calcBits(DU[i], bits);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
+   }
+   if(end0pos != 63) {
+      stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
+   }
+   return DU[0];
+}
+
+static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
+   // Constants that don't pollute global namespace
+   static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
+   static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+   static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
+   static const unsigned char std_ac_luminance_values[] = {
+      0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
+      0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
+      0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
+      0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
+      0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
+      0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
+      0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+   };
+   static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};
+   static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
+   static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};
+   static const unsigned char std_ac_chrominance_values[] = {
+      0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
+      0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
+      0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
+      0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
+      0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
+      0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
+      0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
+   };
+   // Huffman tables
+   static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};
+   static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};
+   static const unsigned short YAC_HT[256][2] = {
+      {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+   };
+   static const unsigned short UVAC_HT[256][2] = {
+      {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0},
+      {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}
+   };
+   static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,
+                             37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};
+   static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,
+                              99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};
+   static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
+                                 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
+
+   int row, col, i, k, subsample;
+   float fdtbl_Y[64], fdtbl_UV[64];
+   unsigned char YTable[64], UVTable[64];
+
+   if(!data || !width || !height || comp > 4 || comp < 1) {
+      return 0;
+   }
+
+   quality = quality ? quality : 90;
+   subsample = quality <= 90 ? 1 : 0;
+   quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
+   quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
+
+   for(i = 0; i < 64; ++i) {
+      int uvti, yti = (YQT[i]*quality+50)/100;
+      YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);
+      uvti = (UVQT[i]*quality+50)/100;
+      UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
+   }
+
+   for(row = 0, k = 0; row < 8; ++row) {
+      for(col = 0; col < 8; ++col, ++k) {
+         fdtbl_Y[k]  = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+         fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
+      }
+   }
+
+   // Write Headers
+   {
+      static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
+      static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
+      const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
+                                      3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
+      s->func(s->context, (void*)head0, sizeof(head0));
+      s->func(s->context, (void*)YTable, sizeof(YTable));
+      stbiw__putc(s, 1);
+      s->func(s->context, UVTable, sizeof(UVTable));
+      s->func(s->context, (void*)head1, sizeof(head1));
+      s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
+      s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
+      stbiw__putc(s, 0x10); // HTYACinfo
+      s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
+      s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
+      stbiw__putc(s, 1); // HTUDCinfo
+      s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
+      s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
+      stbiw__putc(s, 0x11); // HTUACinfo
+      s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
+      s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
+      s->func(s->context, (void*)head2, sizeof(head2));
+   }
+
+   // Encode 8x8 macroblocks
+   {
+      static const unsigned short fillBits[] = {0x7F, 7};
+      int DCY=0, DCU=0, DCV=0;
+      int bitBuf=0, bitCnt=0;
+      // comp == 2 is grey+alpha (alpha is ignored)
+      int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
+      const unsigned char *dataR = (const unsigned char *)data;
+      const unsigned char *dataG = dataR + ofsG;
+      const unsigned char *dataB = dataR + ofsB;
+      int x, y, pos;
+      if(subsample) {
+         for(y = 0; y < height; y += 16) {
+            for(x = 0; x < width; x += 16) {
+               float Y[256], U[256], V[256];
+               for(row = y, pos = 0; row < y+16; ++row) {
+                  // row >= height => use last input row
+                  int clamped_row = (row < height) ? row : height - 1;
+                  int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
+                  for(col = x; col < x+16; ++col, ++pos) {
+                     // if col >= width => use pixel from last input column
+                     int p = base_p + ((col < width) ? col : (width-1))*comp;
+                     float r = dataR[p], g = dataG[p], b = dataB[p];
+                     Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
+                     U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
+                     V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
+                  }
+               }
+               DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0,   16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+               DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8,   16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+               DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+               DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+
+               // subsample U,V
+               {
+                  float subU[64], subV[64];
+                  int yy, xx;
+                  for(yy = 0, pos = 0; yy < 8; ++yy) {
+                     for(xx = 0; xx < 8; ++xx, ++pos) {
+                        int j = yy*32+xx*2;
+                        subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;
+                        subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;
+                     }
+                  }
+                  DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+                  DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+               }
+            }
+         }
+      } else {
+         for(y = 0; y < height; y += 8) {
+            for(x = 0; x < width; x += 8) {
+               float Y[64], U[64], V[64];
+               for(row = y, pos = 0; row < y+8; ++row) {
+                  // row >= height => use last input row
+                  int clamped_row = (row < height) ? row : height - 1;
+                  int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
+                  for(col = x; col < x+8; ++col, ++pos) {
+                     // if col >= width => use pixel from last input column
+                     int p = base_p + ((col < width) ? col : (width-1))*comp;
+                     float r = dataR[p], g = dataG[p], b = dataB[p];
+                     Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
+                     U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
+                     V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
+                  }
+               }
+
+               DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y,  DCY, YDC_HT, YAC_HT);
+               DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+               DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+            }
+         }
+      }
+
+      // Do the bit alignment of the EOI marker
+      stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
+   }
+
+   // EOI
+   stbiw__putc(s, 0xFF);
+   stbiw__putc(s, 0xD9);
+
+   return 1;
+}
+
+STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
+{
+   stbi__write_context s = { 0 };
+   stbi__start_write_callbacks(&s, func, context);
+   return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
+}
+
+
+#ifndef STBI_WRITE_NO_STDIO
+STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
+{
+   stbi__write_context s = { 0 };
+   if (stbi__start_write_file(&s,filename)) {
+      int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
+      stbi__end_write_file(&s);
+      return r;
+   } else
+      return 0;
+}
+#endif
+
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+      1.16  (2021-07-11)
+             make Deflate code emit uncompressed blocks when it would otherwise expand
+             support writing BMPs with alpha channel
+      1.15  (2020-07-13) unknown
+      1.14  (2020-02-02) updated JPEG writer to downsample chroma channels
+      1.13
+      1.12
+      1.11  (2019-08-11)
+
+      1.10  (2019-02-07)
+             support utf8 filenames in Windows; fix warnings and platform ifdefs
+      1.09  (2018-02-11)
+             fix typo in zlib quality API, improve STB_I_W_STATIC in C++
+      1.08  (2018-01-29)
+             add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
+      1.07  (2017-07-24)
+             doc fix
+      1.06 (2017-07-23)
+             writing JPEG (using Jon Olick's code)
+      1.05   ???
+      1.04 (2017-03-03)
+             monochrome BMP expansion
+      1.03   ???
+      1.02 (2016-04-02)
+             avoid allocating large structures on the stack
+      1.01 (2016-01-16)
+             STBIW_REALLOC_SIZED: support allocators with no realloc support
+             avoid race-condition in crc initialization
+             minor compile issues
+      1.00 (2015-09-14)
+             installable file IO function
+      0.99 (2015-09-13)
+             warning fixes; TGA rle support
+      0.98 (2015-04-08)
+             added STBIW_MALLOC, STBIW_ASSERT etc
+      0.97 (2015-01-18)
+             fixed HDR asserts, rewrote HDR rle logic
+      0.96 (2015-01-17)
+             add HDR output
+             fix monochrome BMP
+      0.95 (2014-08-17)
+             add monochrome TGA output
+      0.94 (2014-05-31)
+             rename private functions to avoid conflicts with stb_image.h
+      0.93 (2014-05-27)
+             warning fixes
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

From 1ea95dc5ee46264a8037483a1c48356e894c62ab Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 20:26:11 -0400
Subject: [PATCH 09/26] Add Node.js and Safari helpers for WASM

Introduce two new helper scripts to test the WASM build: - `test-wasm-node.js`: Reruns the WASM smoke test via Node.js, useful for quick
iteration. - `test-wasm-browser.sh`: Launches a local server and drives Safari via JXA to perform an end-to-end smoke test.

This provides more robust testing for the WebAssembly build.
---
 AGENTS.md                    |  6 ++-
 README.md                    |  8 +++
 scripts/safari-wasm-smoke.js | 98 ++++++++++++++++++++++++++++++++++++
 scripts/test-wasm-browser.sh | 40 +++++++++++++++
 scripts/test-wasm-node.js    |  0
 5 files changed, 150 insertions(+), 2 deletions(-)
 create mode 100755 scripts/safari-wasm-smoke.js
 create mode 100755 scripts/test-wasm-browser.sh
 mode change 100644 => 100755 scripts/test-wasm-node.js

diff --git a/AGENTS.md b/AGENTS.md
index 0add4dd..4fc34dc 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -13,7 +13,9 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `nix build`: build the default flake package (shared/static library) without touching your host toolchain.
 - `nix flake check`: validate the flake packages and dev shell evaluate cleanly across supported systems.
 - `nix develop --command bash scripts/test-wasm.sh`: configure via `emcmake`, build the wasm wrapper, and assert the JS/WASM artefacts exist.
-- `python3 -m http.server 8765 --directory example/wasm`: serve the browser demo locally (after running `scripts/test-wasm.sh`).
+- `node scripts/test-wasm-node.js build-wasm/wasm`: rerun the wasm smoke test via Node (outputs `test-output.png`).
+- `scripts/test-wasm-browser.sh`: launch a local server and exercise the Safari smoke test end-to-end.
+- `python3 -m http.server 8765 --directory example/wasm`: manual alternative to serve the browser demo (after running `scripts/test-wasm.sh`).
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
@@ -28,7 +30,7 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
 - If you touch the flake, rerun `nix build` and `nix flake check` and commit the updated `flake.lock` (keep changes reproducible).
 - For the wasm target, keep `scripts/test-wasm.sh` passing under `nix develop`; it wipes `build-wasm/` on each invocation.
-- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper script in `scripts/test-wasm.sh` copies `libansilove.{js,wasm}` into `example/wasm/` so you can smoke-test via `python3 -m http.server` and the JXA snippet from this branch.
+- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper scripts copy `libansilove.{js,wasm}` into `example/wasm/` so you can smoke-test via the provided browser script or a manual `python3 -m http.server` session.
 
 ## Commit & Pull Request Guidelines
 - Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).
diff --git a/README.md b/README.md
index 196cb7c..01ef889 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,14 @@ Then open `http://localhost:8765/` in a browser (Safari requires the developer
 setting “Allow JavaScript from Apple Events” for scripted verification) to see
 the PNG preview rendered via WebAssembly.
 
+Additional helpers:
+
+- `node scripts/test-wasm-node.js build-wasm/wasm` reruns the Node smoke test on
+  an existing wasm build and refreshes `test-output.png`.
+- `scripts/test-wasm-browser.sh` starts a local server and drives Safari via
+  JXA, ensuring the demo page renders successfully (requires the Safari
+  automation toggle mentioned above).
+
 # Packages
 
 libansilove packages are available for:
diff --git a/scripts/safari-wasm-smoke.js b/scripts/safari-wasm-smoke.js
new file mode 100755
index 0000000..bc3af48
--- /dev/null
+++ b/scripts/safari-wasm-smoke.js
@@ -0,0 +1,98 @@
+#!/usr/bin/osascript -l JavaScript
+ObjC.import('Foundation');
+
+function getArgs() {
+  const processInfo = $.NSProcessInfo.processInfo;
+  const objcArgs = processInfo.arguments;
+  const count = objcArgs.count;
+  const raw = [];
+  for (let i = 0; i < count; i++) {
+    raw.push(ObjC.unwrap(objcArgs.objectAtIndex(i)));
+  }
+
+  const filtered = [];
+  for (let i = 1; i < raw.length; i++) { // drop process name at index 0
+    const value = raw[i];
+    if (value === '-l') { // skip interpreter language flag and its value
+      i++;
+      continue;
+    }
+    if (value === 'JavaScript') {
+      continue;
+    }
+    filtered.push(value);
+  }
+
+  if (filtered.length > 0) {
+    filtered.shift(); // drop script path
+  }
+
+  return filtered;
+}
+
+function waitFor(fn, attempts, delaySeconds) {
+  for (let i = 0; i < attempts; i++) {
+    const value = fn();
+    if (value)
+      return value;
+    delay(delaySeconds);
+  }
+  return null;
+}
+
+function runScript(safari, doc, source) {
+  try {
+    return safari.doJavaScript(source, { in: doc });
+  } catch (error) {
+    const message = String(error);
+    if (message.indexOf('Allow JavaScript from Apple Events') !== -1) {
+      throw new Error('Safari blocked automation. Enable "Allow JavaScript from Apple Events" in Safari ▸ Settings ▸ Advanced.');
+    }
+    throw error;
+  }
+}
+
+(function main() {
+  const args = getArgs();
+  const targetUrl = args[0] || 'http://localhost:8765/index.html';
+
+  const safari = Application('Safari');
+  safari.includeStandardAdditions = true;
+  safari.activate();
+  safari.openLocation(targetUrl);
+
+  function findDoc() {
+    const docs = safari.documents;
+    for (let i = 0; i < docs.length; i++) {
+      const doc = docs[i];
+      try {
+        const url = doc.url();
+        if (url && url.indexOf(targetUrl.split('?')[0]) === 0)
+          return doc;
+      } catch (e) {
+        // document may not be ready; ignore and retry
+      }
+    }
+    return null;
+  }
+
+  const doc = waitFor(findDoc, 40, 0.5);
+  if (!doc)
+    throw new Error('Unable to find Safari tab for ' + targetUrl);
+
+  const statusText = waitFor(() => runScript(safari, doc,
+    "(function () { var el = document.getElementById('status'); return el ? el.textContent : ''; })();"),
+    80, 0.5);
+
+  if (!statusText || statusText.indexOf('libansilove wasm version:') !== 0)
+    throw new Error('Unexpected status text: ' + statusText);
+
+  const previewSrc = waitFor(() => runScript(safari, doc,
+    "(function () { var el = document.getElementById('preview'); return el && el.src ? el.src : ''; })();"),
+    80, 0.5);
+
+  if (!previewSrc || previewSrc.indexOf('blob:') !== 0)
+    throw new Error('Preview image not initialised: ' + previewSrc);
+
+  statusText + '\n' + previewSrc;
+})();
diff --git a/scripts/test-wasm-browser.sh b/scripts/test-wasm-browser.sh
new file mode 100755
index 0000000..65f11e8
--- /dev/null
+++ b/scripts/test-wasm-browser.sh
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PORT="${PORT:-8765}"
+DOC_ROOT="example/wasm"
+URL="http://localhost:${PORT}/index.html"
+
+if ! command -v osascript >/dev/null; then
+  echo "error: osascript is required on macOS to drive Safari." >&2
+  exit 2
+fi
+
+if ! command -v python3 >/dev/null; then
+  echo "error: python3 is required to start the local web server." >&2
+  exit 2
+fi
+
+if [ ! -f "${DOC_ROOT}/libansilove.js" ]; then
+  echo "error: ${DOC_ROOT}/libansilove.js not found; run scripts/test-wasm.sh first." >&2
+  exit 3
+fi
+
+LOG_FILE=$(mktemp -t ansilove-wasm-http.XXXXXX.log)
+cleanup() {
+  if [ -n "${SERVER_PID:-}" ]; then
+    kill "${SERVER_PID}" 2>/dev/null || true
+  fi
+  rm -f "$LOG_FILE"
+}
+trap cleanup EXIT
+
+python3 -m http.server "${PORT}" --directory "${DOC_ROOT}" >"$LOG_FILE" 2>&1 &
+SERVER_PID=$!
+
+# Give the server a moment to come up
+sleep 1
+
+"$(dirname "$0")/safari-wasm-smoke.js" "$URL"
+
+echo "Safari smoke test passed for $URL"
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
old mode 100644
new mode 100755

From 8f3e1d4a38843c2d30fb5eac452e5dca795c3190 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 21:02:12 -0400
Subject: [PATCH 10/26] Update documentation and configuration for npm packages

This commit introduces significant changes related to the packaging and documentation of libansilove for npm distribution.

Key changes include:

- **New npm package structure:** A dedicated `npm/libansilove-wasm` directory has been created for the WebAssembly build, including a
TypeScript wrapper, build scripts, and testing utilities. - **Bun integration:** A new `npm/packages/libansilove-demo-bun` package
demonstrates a basic React application built with Bun, showcasing its capabilities. - **Updated documentation:** README files and AGENTS.md
have been updated to reflect the new npm packages, usage instructions, and development workflows. - **Build and verification scripts:** New
scripts for cleaning, compiling, copying WASM artifacts, and verifying the npm distribution have been added. - **Version synchronization:**
A script to automatically synchronize the npm package version with the C header definition is now included. - **`.gitignore` updates:**
Added patterns to ignore common npm build artifacts and dependencies.
---
 .gitignore                                    |   5 +
 AGENTS.md                                     |   3 +
 README.md                                     |  18 ++
 npm/.gitignore                                |  34 ++++
 npm/AGENTS.md                                 | 105 ++++++++++
 npm/bun.lock                                  | 100 ++++++++++
 npm/package.json                              |  14 ++
 npm/packages/libansilove-demo-bun/.gitignore  |  34 ++++
 npm/packages/libansilove-demo-bun/README.md   |  21 ++
 .../libansilove-demo-bun/bun-env.d.ts         |  17 ++
 npm/packages/libansilove-demo-bun/bunfig.toml |   2 +
 .../libansilove-demo-bun/package.json         |  21 ++
 .../libansilove-demo-bun/src/APITester.tsx    |  39 ++++
 npm/packages/libansilove-demo-bun/src/App.tsx |  24 +++
 .../libansilove-demo-bun/src/frontend.tsx     |  26 +++
 .../libansilove-demo-bun/src/index.css        | 187 ++++++++++++++++++
 .../libansilove-demo-bun/src/index.html       |  13 ++
 .../libansilove-demo-bun/src/index.tsx        |  41 ++++
 .../libansilove-demo-bun/tsconfig.json        |  36 ++++
 npm/packages/libansilove-wasm/LICENSE         |   1 +
 npm/packages/libansilove-wasm/README.md       |  47 +++++
 npm/packages/libansilove-wasm/package.json    |  64 ++++++
 .../libansilove-wasm/scripts/clean.mjs        |  10 +
 .../libansilove-wasm/scripts/copy-wasm.mjs    |  33 ++++
 .../libansilove-wasm/scripts/sync-version.mjs |  61 ++++++
 .../libansilove-wasm/scripts/verify-dist.mjs  |  24 +++
 npm/packages/libansilove-wasm/src/index.ts    | 103 ++++++++++
 .../libansilove-wasm/src/libansilove.cjs.d.ts |   4 +
 .../libansilove-wasm/src/libansilove.d.ts     |   4 +
 npm/packages/libansilove-wasm/src/types.ts    |  35 ++++
 .../libansilove-wasm/test/render.test.ts      |  23 +++
 npm/packages/libansilove-wasm/tsconfig.json   |  17 ++
 .../libansilove-wasm/tsconfig.test.json       |   8 +
 scripts/test-wasm-browser.sh                  |   2 +-
 scripts/test-wasm-node.js                     |  32 ++-
 35 files changed, 1202 insertions(+), 6 deletions(-)
 create mode 100644 npm/.gitignore
 create mode 100644 npm/AGENTS.md
 create mode 100644 npm/bun.lock
 create mode 100644 npm/package.json
 create mode 100644 npm/packages/libansilove-demo-bun/.gitignore
 create mode 100644 npm/packages/libansilove-demo-bun/README.md
 create mode 100644 npm/packages/libansilove-demo-bun/bun-env.d.ts
 create mode 100644 npm/packages/libansilove-demo-bun/bunfig.toml
 create mode 100644 npm/packages/libansilove-demo-bun/package.json
 create mode 100644 npm/packages/libansilove-demo-bun/src/APITester.tsx
 create mode 100644 npm/packages/libansilove-demo-bun/src/App.tsx
 create mode 100644 npm/packages/libansilove-demo-bun/src/frontend.tsx
 create mode 100644 npm/packages/libansilove-demo-bun/src/index.css
 create mode 100644 npm/packages/libansilove-demo-bun/src/index.html
 create mode 100644 npm/packages/libansilove-demo-bun/src/index.tsx
 create mode 100644 npm/packages/libansilove-demo-bun/tsconfig.json
 create mode 100644 npm/packages/libansilove-wasm/LICENSE
 create mode 100644 npm/packages/libansilove-wasm/README.md
 create mode 100644 npm/packages/libansilove-wasm/package.json
 create mode 100644 npm/packages/libansilove-wasm/scripts/clean.mjs
 create mode 100644 npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
 create mode 100644 npm/packages/libansilove-wasm/scripts/sync-version.mjs
 create mode 100644 npm/packages/libansilove-wasm/scripts/verify-dist.mjs
 create mode 100644 npm/packages/libansilove-wasm/src/index.ts
 create mode 100644 npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts
 create mode 100644 npm/packages/libansilove-wasm/src/libansilove.d.ts
 create mode 100644 npm/packages/libansilove-wasm/src/types.ts
 create mode 100644 npm/packages/libansilove-wasm/test/render.test.ts
 create mode 100644 npm/packages/libansilove-wasm/tsconfig.json
 create mode 100644 npm/packages/libansilove-wasm/tsconfig.test.json

diff --git a/.gitignore b/.gitignore
index 02ce47d..358b3d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,8 @@ cmake_install.cmake
 example/wasm/libansilove.js
 example/wasm/libansilove.wasm
 build-wasm/wasm/test-output.png
+
+# npm package build
+npm/libansilove-wasm/node_modules/
+npm/libansilove-wasm/dist/
+npm/libansilove-wasm/package-lock.json
diff --git a/AGENTS.md b/AGENTS.md
index 4fc34dc..dad8e44 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -16,6 +16,9 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `node scripts/test-wasm-node.js build-wasm/wasm`: rerun the wasm smoke test via Node (outputs `test-output.png`).
 - `scripts/test-wasm-browser.sh`: launch a local server and exercise the Safari smoke test end-to-end.
 - `python3 -m http.server 8765 --directory example/wasm`: manual alternative to serve the browser demo (after running `scripts/test-wasm.sh`).
+- `cd npm/libansilove-wasm && npm install && npm run build`: compile the TypeScript wrapper and stage artefacts for publishing.
+- `cd npm/libansilove-wasm && npm run verify`: ensure the npm distribution passes file and runtime checks before publishing.
+- `cd npm/libansilove-wasm && npm run sync-version`: align the npm package version with `ANSILOVE_VERSION` (use `--bump-patch` to increment the patch component).
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
diff --git a/README.md b/README.md
index 01ef889..fc66db4 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,24 @@ Additional helpers:
   JXA, ensuring the demo page renders successfully (requires the Safari
   automation toggle mentioned above).
 
+# npm package
+
+The `npm/libansilove-wasm` directory contains a TypeScript wrapper and packaging
+scripts for distributing the WebAssembly build on npm:
+
+```
+nix develop --command bash scripts/test-wasm.sh
+cd npm/libansilove-wasm
+npm install
+npm run build
+npm run verify
+```
+
+`npm run sync-version` keeps the package version aligned with
+`include/ansilove.h`. Use `npm run version:patch` to bump the patch level when
+preparing a publication. The `prepack` hook rebuilds and verifies artefacts to
+ensure the tarball is reproducible.
+
 # Packages
 
 libansilove packages are available for:
diff --git a/npm/.gitignore b/npm/.gitignore
new file mode 100644
index 0000000..a14702c
--- /dev/null
+++ b/npm/.gitignore
@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store
diff --git a/npm/AGENTS.md b/npm/AGENTS.md
new file mode 100644
index 0000000..5fa3f4d
--- /dev/null
+++ b/npm/AGENTS.md
@@ -0,0 +1,105 @@
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
+- Bun.$`ls` instead of execa.
+
+## Testing
+
+Use `bun test` to run tests.
+
+```ts#index.test.ts
+import { test, expect } from "bun:test";
+
+test("hello world", () => {
+  expect(1).toBe(1);
+});
+```
+
+## Frontend
+
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+
+Server:
+
+```ts#index.ts
+import index from "./index.html"
+
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+
+With the following `frontend.tsx`:
+
+```tsx#frontend.tsx
+import React from "react";
+
+// import .css files directly and it works
+import './index.css';
+
+import { createRoot } from "react-dom/client";
+
+const root = createRoot(document.body);
+
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+
+root.render(<Frontend />);
+```
+
+Then, run index.ts
+
+```sh
+bun --hot ./index.ts
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.md`.
diff --git a/npm/bun.lock b/npm/bun.lock
new file mode 100644
index 0000000..390f611
--- /dev/null
+++ b/npm/bun.lock
@@ -0,0 +1,100 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "libansilove-workspace",
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+    "packages/libansilove-demo-bun": {
+      "name": "bun-react-template",
+      "version": "0.1.0",
+      "dependencies": {
+        "libansilove": "workspace:^",
+        "react": "^19",
+        "react-dom": "^19",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "@types/react": "^19",
+        "@types/react-dom": "^19",
+      },
+    },
+    "packages/libansilove-wasm": {
+      "name": "libansilove",
+      "version": "1.4.2",
+      "dependencies": {
+        "ts-node": "^10.9.2",
+      },
+      "devDependencies": {
+        "@types/node": "^20.10.0",
+        "typescript": "^5.4.0",
+      },
+    },
+  },
+  "packages": {
+    "@cspotcode/source-map-support": ["@cspotcode/source-map-support@0.8.1", "", { "dependencies": { "@jridgewell/trace-mapping": "0.3.9" } }, "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.9", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ=="],
+
+    "@tsconfig/node10": ["@tsconfig/node10@1.0.11", "", {}, "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw=="],
+
+    "@tsconfig/node12": ["@tsconfig/node12@1.0.11", "", {}, "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag=="],
+
+    "@tsconfig/node14": ["@tsconfig/node14@1.0.3", "", {}, "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow=="],
+
+    "@tsconfig/node16": ["@tsconfig/node16@1.0.4", "", {}, "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA=="],
+
+    "@types/bun": ["@types/bun@1.2.22", "", { "dependencies": { "bun-types": "1.2.22" } }, "sha512-5A/KrKos2ZcN0c6ljRSOa1fYIyCKhZfIVYeuyb4snnvomnpFqC0tTsEkdqNxbAgExV384OETQ//WAjl3XbYqQA=="],
+
+    "@types/node": ["@types/node@20.19.17", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ=="],
+
+    "@types/react": ["@types/react@19.1.13", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-hHkbU/eoO3EG5/MZkuFSKmYqPbSVk5byPFa3e7y/8TybHiLMACgI8seVYlicwk7H5K/rI2px9xrQp/C+AUDTiQ=="],
+
+    "@types/react-dom": ["@types/react-dom@19.1.9", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-qXRuZaOsAdXKFyOhRBg6Lqqc0yay13vN7KrIg4L7N4aaHN68ma9OK3NE1BoDFgFOTfM7zg+3/8+2n8rLUH3OKQ=="],
+
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "acorn-walk": ["acorn-walk@8.3.4", "", { "dependencies": { "acorn": "^8.11.0" } }, "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g=="],
+
+    "arg": ["arg@4.1.3", "", {}, "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA=="],
+
+    "bun-react-template": ["bun-react-template@workspace:packages/libansilove-demo-bun"],
+
+    "bun-types": ["bun-types@1.2.22", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-hwaAu8tct/Zn6Zft4U9BsZcXkYomzpHJX28ofvx7k0Zz2HNz54n1n+tDgxoWFGB4PcFvJXJQloPhaV2eP3Q6EA=="],
+
+    "create-require": ["create-require@1.1.1", "", {}, "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "diff": ["diff@4.0.2", "", {}, "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A=="],
+
+    "libansilove": ["libansilove@workspace:packages/libansilove-wasm"],
+
+    "make-error": ["make-error@1.3.6", "", {}, "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw=="],
+
+    "react": ["react@19.1.1", "", {}, "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ=="],
+
+    "react-dom": ["react-dom@19.1.1", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.1" } }, "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw=="],
+
+    "scheduler": ["scheduler@0.26.0", "", {}, "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="],
+
+    "ts-node": ["ts-node@10.9.2", "", { "dependencies": { "@cspotcode/source-map-support": "^0.8.0", "@tsconfig/node10": "^1.0.7", "@tsconfig/node12": "^1.0.7", "@tsconfig/node14": "^1.0.0", "@tsconfig/node16": "^1.0.2", "acorn": "^8.4.1", "acorn-walk": "^8.1.1", "arg": "^4.1.0", "create-require": "^1.1.0", "diff": "^4.0.1", "make-error": "^1.1.1", "v8-compile-cache-lib": "^3.0.1", "yn": "3.1.1" }, "peerDependencies": { "@swc/core": ">=1.2.50", "@swc/wasm": ">=1.2.50", "@types/node": "*", "typescript": ">=2.7" }, "optionalPeers": ["@swc/core", "@swc/wasm"], "bin": { "ts-node": "dist/bin.js", "ts-script": "dist/bin-script-deprecated.js", "ts-node-cwd": "dist/bin-cwd.js", "ts-node-esm": "dist/bin-esm.js", "ts-node-script": "dist/bin-script.js", "ts-node-transpile-only": "dist/bin-transpile.js" } }, "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ=="],
+
+    "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "v8-compile-cache-lib": ["v8-compile-cache-lib@3.0.1", "", {}, "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg=="],
+
+    "yn": ["yn@3.1.1", "", {}, "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q=="],
+  }
+}
diff --git a/npm/package.json b/npm/package.json
new file mode 100644
index 0000000..6d8f0c1
--- /dev/null
+++ b/npm/package.json
@@ -0,0 +1,14 @@
+{
+	"name": "libansilove-workspace",
+	"type": "module",
+	"private": true,
+	"devDependencies": {
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"workspaces": [
+		"packages/*"
+	]
+}
diff --git a/npm/packages/libansilove-demo-bun/.gitignore b/npm/packages/libansilove-demo-bun/.gitignore
new file mode 100644
index 0000000..a14702c
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/.gitignore
@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store
diff --git a/npm/packages/libansilove-demo-bun/README.md b/npm/packages/libansilove-demo-bun/README.md
new file mode 100644
index 0000000..b3fefc1
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/README.md
@@ -0,0 +1,21 @@
+# bun-react-template
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To start a development server:
+
+```bash
+bun dev
+```
+
+To run for production:
+
+```bash
+bun start
+```
+
+This project was created using `bun init` in bun v1.2.22. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
diff --git a/npm/packages/libansilove-demo-bun/bun-env.d.ts b/npm/packages/libansilove-demo-bun/bun-env.d.ts
new file mode 100644
index 0000000..72f1c26
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/bun-env.d.ts
@@ -0,0 +1,17 @@
+// Generated by `bun init`
+
+declare module "*.svg" {
+  /**
+   * A path to the SVG file
+   */
+  const path: `${string}.svg`;
+  export = path;
+}
+
+declare module "*.module.css" {
+  /**
+   * A record of class names to their corresponding CSS module classes
+   */
+  const classes: { readonly [key: string]: string };
+  export = classes;
+}
diff --git a/npm/packages/libansilove-demo-bun/bunfig.toml b/npm/packages/libansilove-demo-bun/bunfig.toml
new file mode 100644
index 0000000..9819bf6
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/bunfig.toml
@@ -0,0 +1,2 @@
+[serve.static]
+env = "BUN_PUBLIC_*"
\ No newline at end of file
diff --git a/npm/packages/libansilove-demo-bun/package.json b/npm/packages/libansilove-demo-bun/package.json
new file mode 100644
index 0000000..a6a1c35
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "bun-react-template",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "bun --hot src/index.tsx",
+    "build": "bun build ./src/index.html --outdir=dist --sourcemap --target=browser --minify --define:process.env.NODE_ENV='\"production\"' --env='BUN_PUBLIC_*'",
+    "start": "NODE_ENV=production bun src/index.tsx"
+  },
+  "dependencies": {
+    "libansilove": "workspace:*",
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "devDependencies": {
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@types/bun": "latest"
+  }
+}
diff --git a/npm/packages/libansilove-demo-bun/src/APITester.tsx b/npm/packages/libansilove-demo-bun/src/APITester.tsx
new file mode 100644
index 0000000..fd2af48
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/APITester.tsx
@@ -0,0 +1,39 @@
+import { useRef, type FormEvent } from "react";
+
+export function APITester() {
+  const responseInputRef = useRef<HTMLTextAreaElement>(null);
+
+  const testEndpoint = async (e: FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+
+    try {
+      const form = e.currentTarget;
+      const formData = new FormData(form);
+      const endpoint = formData.get("endpoint") as string;
+      const url = new URL(endpoint, location.href);
+      const method = formData.get("method") as string;
+      const res = await fetch(url, { method });
+
+      const data = await res.json();
+      responseInputRef.current!.value = JSON.stringify(data, null, 2);
+    } catch (error) {
+      responseInputRef.current!.value = String(error);
+    }
+  };
+
+  return (
+    <div className="api-tester">
+      <form onSubmit={testEndpoint} className="endpoint-row">
+        <select name="method" className="method">
+          <option value="GET">GET</option>
+          <option value="PUT">PUT</option>
+        </select>
+        <input type="text" name="endpoint" defaultValue="/api/hello" className="url-input" placeholder="/api/hello" />
+        <button type="submit" className="send-button">
+          Send
+        </button>
+      </form>
+      <textarea ref={responseInputRef} readOnly placeholder="Response will appear here..." className="response-area" />
+    </div>
+  );
+}
diff --git a/npm/packages/libansilove-demo-bun/src/App.tsx b/npm/packages/libansilove-demo-bun/src/App.tsx
new file mode 100644
index 0000000..32e134d
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/App.tsx
@@ -0,0 +1,24 @@
+import { APITester } from "./APITester";
+import "./index.css";
+
+import logo from "./logo.svg";
+import reactLogo from "./react.svg";
+
+export function App() {
+  return (
+    <div className="app">
+      <div className="logo-container">
+        <img src={logo} alt="Bun Logo" className="logo bun-logo" />
+        <img src={reactLogo} alt="React Logo" className="logo react-logo" />
+      </div>
+
+      <h1>Bun + React</h1>
+      <p>
+        Edit <code>src/App.tsx</code> and save to test HMR
+      </p>
+      <APITester />
+    </div>
+  );
+}
+
+export default App;
diff --git a/npm/packages/libansilove-demo-bun/src/frontend.tsx b/npm/packages/libansilove-demo-bun/src/frontend.tsx
new file mode 100644
index 0000000..78a3776
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/frontend.tsx
@@ -0,0 +1,26 @@
+/**
+ * This file is the entry point for the React app, it sets up the root
+ * element and renders the App component to the DOM.
+ *
+ * It is included in `src/index.html`.
+ */
+
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
+
+const elem = document.getElementById("root")!;
+const app = (
+	<StrictMode>
+		<App />
+	</StrictMode>
+);
+
+if (import.meta.hot) {
+	// With hot module reloading, `import.meta.hot.data` is persisted.
+	const root = (import.meta.hot.data.root ??= createRoot(elem));
+	root.render(app);
+} else {
+	// The hot module reloading API is not available in production.
+	createRoot(elem).render(app);
+}
diff --git a/npm/packages/libansilove-demo-bun/src/index.css b/npm/packages/libansilove-demo-bun/src/index.css
new file mode 100644
index 0000000..774eb83
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/index.css
@@ -0,0 +1,187 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+}
+body {
+  margin: 0;
+  display: grid;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+  position: relative;
+}
+body::before {
+  content: "";
+  position: fixed;
+  inset: 0;
+  z-index: -1;
+  opacity: 0.05;
+  background: url("./logo.svg");
+  background-size: 256px;
+  transform: rotate(-12deg) scale(1.35);
+  animation: slide 30s linear infinite;
+  pointer-events: none;
+}
+@keyframes slide {
+  from {
+    background-position: 0 0;
+  }
+  to {
+    background-position: 256px 224px;
+  }
+}
+.app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+  position: relative;
+  z-index: 1;
+}
+.logo-container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  gap: 2rem;
+  margin-bottom: 2rem;
+}
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 0.3s;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.bun-logo {
+  transform: scale(1.2);
+}
+.bun-logo:hover {
+  filter: drop-shadow(0 0 2em #fbf0dfaa);
+}
+.react-logo {
+  animation: spin 20s linear infinite;
+}
+.react-logo:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+@keyframes spin {
+  from {
+    transform: rotate(0);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+code {
+  background-color: #1a1a1a;
+  padding: 0.2em 0.4em;
+  border-radius: 0.3em;
+  font-family: monospace;
+}
+.api-tester {
+  margin: 2rem auto 0;
+  width: 100%;
+  max-width: 600px;
+  text-align: left;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+.endpoint-row {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  background: #1a1a1a;
+  padding: 0.75rem;
+  border-radius: 12px;
+  font: monospace;
+  border: 2px solid #fbf0df;
+  transition: 0.3s;
+  width: 100%;
+  box-sizing: border-box;
+}
+.endpoint-row:focus-within {
+  border-color: #f3d5a3;
+}
+.method {
+  background: #fbf0df;
+  color: #1a1a1a;
+  padding: 0.3rem 0.7rem;
+  border-radius: 8px;
+  font-weight: 700;
+  font-size: 0.9em;
+  appearance: none;
+  margin: 0;
+  width: min-content;
+  display: block;
+  flex-shrink: 0;
+  border: none;
+}
+.method option {
+  text-align: left;
+}
+.url-input {
+  width: 100%;
+  flex: 1;
+  background: 0;
+  border: 0;
+  color: #fbf0df;
+  font: 1em monospace;
+  padding: 0.2rem;
+  outline: 0;
+}
+.url-input:focus {
+  color: #fff;
+}
+.url-input::placeholder {
+  color: rgba(251, 240, 223, 0.4);
+}
+.send-button {
+  background: #fbf0df;
+  color: #1a1a1a;
+  border: 0;
+  padding: 0.4rem 1.2rem;
+  border-radius: 8px;
+  font-weight: 700;
+  transition: 0.1s;
+  cursor: var(--bun-cursor);
+}
+.send-button:hover {
+  background: #f3d5a3;
+  transform: translateY(-1px);
+  cursor: pointer;
+}
+.response-area {
+  width: 100%;
+  min-height: 120px;
+  background: #1a1a1a;
+  border: 2px solid #fbf0df;
+  border-radius: 12px;
+  padding: 0.75rem;
+  color: #fbf0df;
+  font: monospace;
+  resize: vertical;
+  box-sizing: border-box;
+}
+.response-area:focus {
+  border-color: #f3d5a3;
+}
+.response-area::placeholder {
+  color: rgba(251, 240, 223, 0.4);
+}
+@media (prefers-reduced-motion) {
+  *,
+  ::before,
+  ::after {
+    animation: none !important;
+  }
+}
diff --git a/npm/packages/libansilove-demo-bun/src/index.html b/npm/packages/libansilove-demo-bun/src/index.html
new file mode 100644
index 0000000..2a957d0
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/svg+xml" href="./logo.svg" />
+    <title>Bun + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
diff --git a/npm/packages/libansilove-demo-bun/src/index.tsx b/npm/packages/libansilove-demo-bun/src/index.tsx
new file mode 100644
index 0000000..863f069
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/index.tsx
@@ -0,0 +1,41 @@
+import { serve } from "bun";
+import index from "./index.html";
+
+const server = serve({
+  routes: {
+    // Serve index.html for all unmatched routes.
+    "/*": index,
+
+    "/api/hello": {
+      async GET(req) {
+        return Response.json({
+          message: "Hello, world!",
+          method: "GET",
+        });
+      },
+      async PUT(req) {
+        return Response.json({
+          message: "Hello, world!",
+          method: "PUT",
+        });
+      },
+    },
+
+    "/api/hello/:name": async req => {
+      const name = req.params.name;
+      return Response.json({
+        message: `Hello, ${name}!`,
+      });
+    },
+  },
+
+  development: process.env.NODE_ENV !== "production" && {
+    // Enable browser hot reloading in development
+    hmr: true,
+
+    // Echo console logs from the browser to the server
+    console: true,
+  },
+});
+
+console.log(`🚀 Server running at ${server.url}`);
diff --git a/npm/packages/libansilove-demo-bun/tsconfig.json b/npm/packages/libansilove-demo-bun/tsconfig.json
new file mode 100644
index 0000000..632a36f
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/tsconfig.json
@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/npm/packages/libansilove-wasm/LICENSE b/npm/packages/libansilove-wasm/LICENSE
new file mode 100644
index 0000000..a8639ac
--- /dev/null
+++ b/npm/packages/libansilove-wasm/LICENSE
@@ -0,0 +1 @@
+See ../../LICENSE
diff --git a/npm/packages/libansilove-wasm/README.md b/npm/packages/libansilove-wasm/README.md
new file mode 100644
index 0000000..83be8ad
--- /dev/null
+++ b/npm/packages/libansilove-wasm/README.md
@@ -0,0 +1,47 @@
+# @effect-native/libansilove-wasm
+
+WebAssembly build of [libansilove](https://www.ansilove.org) packaged for Node.js
+and modern bundlers. The package re-exports the generated Emscripten module along
+with a small TypeScript helper that renders ANSI art to PNG buffers.
+
+## Usage
+
+```ts
+import { load } from '@effect-native/libansilove-wasm';
+
+const wasm = await load();
+const result = wasm.renderAnsi('Hello from libansilove!\r\n');
+console.log(`Generated ${result.png.length} bytes from libansilove ${wasm.version}`);
+```
+
+### Rendering options
+
+```ts
+const output = wasm.renderAnsi(ansiText, {
+  columns: 80,
+  icecolors: true,
+  dos: false,
+  scaleFactor: 2,
+});
+```
+
+## Development
+
+1. Build the wasm artefacts from the repository root:
+   ```
+   nix develop --command bash scripts/test-wasm.sh
+   ```
+2. Install dependencies and build the package:
+   ```
+   cd npm/libansilove-wasm
+   npm install
+   npm run build
+   ```
+3. Verify the distribution before publishing:
+   ```
+   npm run verify
+   ```
+
+`npm run sync-version` keeps the package version aligned with `ANSILOVE_VERSION`
+inside `include/ansilove.h`. Use `npm run version:patch` to bump the patch level
+when preparing releases.
diff --git a/npm/packages/libansilove-wasm/package.json b/npm/packages/libansilove-wasm/package.json
new file mode 100644
index 0000000..6b51f2d
--- /dev/null
+++ b/npm/packages/libansilove-wasm/package.json
@@ -0,0 +1,64 @@
+{
+	"name": "libansilove",
+	"version": "1.4.2",
+	"description": "WebAssembly build of libansilove with TypeScript bindings.",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"require": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./libansilove.cjs": {
+			"default": "./dist/libansilove.cjs"
+		}
+	},
+	"files": [
+		"dist/index.js",
+		"dist/index.d.ts",
+		"dist/libansilove.js",
+		"dist/libansilove.cjs",
+		"dist/libansilove.wasm",
+		"dist/LICENSE"
+	],
+	"scripts": {
+		"clean": "node scripts/clean.mjs",
+		"compile": "tsc -p tsconfig.json",
+		"copy:wasm": "node scripts/copy-wasm.mjs",
+		"build": "npm run clean && npm run compile && npm run copy:wasm",
+		"test": "ts-node --project tsconfig.test.json test/render.test.ts",
+		"verify:files": "node scripts/verify-dist.mjs",
+		"verify:node": "node ../../scripts/test-wasm-node.js dist",
+		"verify": "npm run verify:files && npm run verify:node",
+		"prepack": "npm run build && npm run verify && npm test",
+		"sync-version": "node scripts/sync-version.mjs",
+		"version:patch": "node scripts/sync-version.mjs --bump-patch"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"devDependencies": {
+		"@types/node": "^20.10.0",
+		"typescript": "^5.4.0"
+	},
+	"keywords": [
+		"ansi",
+		"ansilove",
+		"wasm",
+		"ansi-art",
+		"libansilove"
+	],
+	"author": "effect-native",
+	"license": "BSD-2-Clause",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/effect-native/libansilove",
+		"directory": "npm/libansilove-wasm"
+	},
+	"dependencies": {
+		"ts-node": "^10.9.2"
+	}
+}
diff --git a/npm/packages/libansilove-wasm/scripts/clean.mjs b/npm/packages/libansilove-wasm/scripts/clean.mjs
new file mode 100644
index 0000000..d52b82e
--- /dev/null
+++ b/npm/packages/libansilove-wasm/scripts/clean.mjs
@@ -0,0 +1,10 @@
+import { rm } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageDir = resolve(__dirname, '..');
+const distDir = resolve(packageDir, 'dist');
+
+await rm(distDir, { recursive: true, force: true });
diff --git a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
new file mode 100644
index 0000000..d5cba44
--- /dev/null
+++ b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
@@ -0,0 +1,33 @@
+import { copyFile, mkdir, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageDir = resolve(__dirname, '..');
+const repoRoot = resolve(packageDir, '..', '..');
+const sourceDir = resolve(repoRoot, 'build-wasm', 'wasm');
+const distDir = resolve(packageDir, 'dist');
+
+await mkdir(distDir, { recursive: true });
+
+async function copyArtefact(file, target) {
+  const source = resolve(sourceDir, file);
+  try {
+    await copyFile(source, target);
+  } catch (error) {
+    throw new Error(`Failed to copy ${file} from ${source}. Run 'scripts/test-wasm.sh' from the repository root first.\n${error}`);
+  }
+}
+
+await copyArtefact('libansilove.wasm', resolve(distDir, 'libansilove.wasm'));
+await copyArtefact('libansilove.js', resolve(distDir, 'libansilove.cjs'));
+
+const esmWrapper = `import { createRequire } from 'node:module';\nconst require = createRequire(import.meta.url);\nconst factory = require('./libansilove.cjs');\nexport default factory;\n`;
+await writeFile(resolve(distDir, 'libansilove.js'), esmWrapper);
+
+try {
+  await copyFile(resolve(repoRoot, 'LICENSE'), resolve(distDir, 'LICENSE'));
+} catch (error) {
+  throw new Error(`Failed to copy repository LICENSE into npm dist.\n${error}`);
+}
diff --git a/npm/packages/libansilove-wasm/scripts/sync-version.mjs b/npm/packages/libansilove-wasm/scripts/sync-version.mjs
new file mode 100644
index 0000000..80a1836
--- /dev/null
+++ b/npm/packages/libansilove-wasm/scripts/sync-version.mjs
@@ -0,0 +1,61 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packagePath = resolve(__dirname, '..', 'package.json');
+const headerPath = resolve(__dirname, '..', '..', '..', 'include', 'ansilove.h');
+
+const args = process.argv.slice(2);
+const bumpPatch = args.includes('--bump-patch');
+
+function parseLibraryVersion(contents) {
+  const match = contents.match(/#define\s+ANSILOVE_VERSION\s+"([0-9]+\.[0-9]+\.[0-9]+)"/);
+  if (!match) {
+    throw new Error('Unable to parse ANSILOVE_VERSION from include/ansilove.h');
+  }
+  return match[1];
+}
+
+function compareSemver(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return 1;
+    if (pa[i] < pb[i]) return -1;
+  }
+  return 0;
+}
+
+function bumpPatchVersion(version) {
+  const parts = version.split('.').map((value) => Number.parseInt(value, 10));
+  if (parts.length !== 3 || parts.some(Number.isNaN)) {
+    throw new Error(`Invalid semantic version: ${version}`);
+  }
+  parts[2] += 1;
+  return parts.join('.');
+}
+
+const [packageJsonRaw, headerRaw] = await Promise.all([
+  readFile(packagePath, 'utf8'),
+  readFile(headerPath, 'utf8'),
+]);
+
+const pkg = JSON.parse(packageJsonRaw);
+const libraryVersion = parseLibraryVersion(headerRaw);
+let targetVersion = libraryVersion;
+
+if (bumpPatch) {
+  const baseline = pkg.version && compareSemver(pkg.version, libraryVersion) > 0 ? pkg.version : libraryVersion;
+  targetVersion = bumpPatchVersion(baseline);
+}
+
+if (pkg.version === targetVersion) {
+  console.log(`package.json already at ${targetVersion}`);
+  process.exit(0);
+}
+
+pkg.version = targetVersion;
+await writeFile(packagePath, `${JSON.stringify(pkg, null, 2)}\n`);
+console.log(`Updated npm package version to ${targetVersion}`);
diff --git a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
new file mode 100644
index 0000000..ee329ae
--- /dev/null
+++ b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
@@ -0,0 +1,24 @@
+import { access } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distDir = resolve(__dirname, '..', 'dist');
+
+async function ensure(file) {
+  try {
+    await access(resolve(distDir, file));
+  } catch (error) {
+    throw new Error(`Missing dist artefact: ${file}\n${error}`);
+  }
+}
+
+await Promise.all([
+  ensure('index.js'),
+  ensure('index.d.ts'),
+  ensure('libansilove.js'),
+  ensure('libansilove.cjs'),
+  ensure('libansilove.wasm'),
+  ensure('LICENSE'),
+]);
diff --git a/npm/packages/libansilove-wasm/src/index.ts b/npm/packages/libansilove-wasm/src/index.ts
new file mode 100644
index 0000000..f1854c4
--- /dev/null
+++ b/npm/packages/libansilove-wasm/src/index.ts
@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { TextEncoder } from 'node:util';
+import type { LoadOptions, RenderOptions, AnsiloveWasm, RenderResult } from './types.js';
+
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Minimal shape of the Emscripten factory output we rely on.
+interface LibansiloveModule {
+  readonly HEAPU8: Uint8Array;
+  _malloc(size: number): number;
+  _free(ptr: number): void;
+  cwrap(
+    name: string,
+    returnType: 'number' | 'string' | null,
+    argTypes: ('number')[],
+  ): (...args: number[]) => number | string | void;
+}
+
+type LibansiloveFactory = (overrides?: Record<string, unknown>) => Promise<LibansiloveModule>;
+
+function resolveWasmPath(file: string, wasmDir?: string): string {
+  const base = wasmDir ?? __dirname;
+  return path.join(base, file);
+}
+
+function toUint8Array(input: string | Uint8Array): Uint8Array {
+  if (typeof input === 'string') {
+    return new TextEncoder().encode(input);
+  }
+  return input;
+}
+
+async function loadFactory(): Promise<LibansiloveFactory> {
+  const maybeFactory = require('./libansilove.cjs');
+  if (typeof maybeFactory === 'function') {
+    return maybeFactory as LibansiloveFactory;
+  }
+  if (maybeFactory && typeof maybeFactory.default === 'function') {
+    return maybeFactory.default as LibansiloveFactory;
+  }
+  throw new Error('Failed to load libansilove wasm factory.');
+}
+
+export async function load(options: LoadOptions = {}): Promise<AnsiloveWasm> {
+  const factory = await loadFactory();
+
+  const module = await factory({
+    locateFile: (file: string) => resolveWasmPath(file, options.wasmDir),
+    ...(options.moduleOverrides ?? {}),
+  });
+
+  const renderAnsiFn = module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+  const getPtr = module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
+  const getLen = module.cwrap('ansilove_wasm_get_png_length', 'number', []);
+  const freePng = module.cwrap('ansilove_wasm_free_png', null, []);
+  const versionFn = module.cwrap('ansilove_wasm_version', 'string', []);
+
+  const renderAnsi = (input: string | Uint8Array, renderOptions: RenderOptions = {}): RenderResult => {
+    const data = toUint8Array(input);
+    const ptr = module._malloc(data.length);
+    try {
+      module.HEAPU8.set(data, ptr);
+
+      const result = renderAnsiFn(
+        ptr,
+        data.length,
+        renderOptions.columns ?? 0,
+        renderOptions.icecolors ? 1 : 0,
+        renderOptions.dos ? 1 : 0,
+        renderOptions.scaleFactor ?? 0,
+      ) as number;
+
+      if (result !== 0) {
+        throw new Error(`ansilove_wasm_render_ansi failed with error code ${result}`);
+      }
+
+      const pngPtr = getPtr() as number;
+      const pngLength = getLen() as number;
+      if (!pngPtr || !pngLength) {
+        throw new Error('ansilove_wasm_get_png_length returned zero bytes.');
+      }
+
+      const png = module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
+      freePng();
+      return { png: new Uint8Array(png) };
+    } finally {
+      module._free(ptr);
+    }
+  };
+
+  const version = versionFn() as string;
+
+  return {
+    version,
+    renderAnsi,
+  };
+}
+
+export type { AnsiloveWasm, LoadOptions, RenderOptions, RenderResult } from './types.js';
diff --git a/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts b/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts
new file mode 100644
index 0000000..653da60
--- /dev/null
+++ b/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts
@@ -0,0 +1,4 @@
+declare const factory: ((overrides?: Record<string, unknown>) => Promise<unknown>) & {
+  ready?: Promise<unknown>;
+};
+export = factory;
diff --git a/npm/packages/libansilove-wasm/src/libansilove.d.ts b/npm/packages/libansilove-wasm/src/libansilove.d.ts
new file mode 100644
index 0000000..09c5df7
--- /dev/null
+++ b/npm/packages/libansilove-wasm/src/libansilove.d.ts
@@ -0,0 +1,4 @@
+declare const factory: ((overrides?: Record<string, unknown>) => Promise<unknown>) & {
+  ready?: Promise<unknown>;
+};
+export default factory;
diff --git a/npm/packages/libansilove-wasm/src/types.ts b/npm/packages/libansilove-wasm/src/types.ts
new file mode 100644
index 0000000..b33fdef
--- /dev/null
+++ b/npm/packages/libansilove-wasm/src/types.ts
@@ -0,0 +1,35 @@
+export interface RenderOptions {
+  /** Override the number of columns (defaults to ANSI metadata). */
+  columns?: number;
+  /** Enable IceColor behavior. */
+  icecolors?: boolean;
+  /** Apply DOS aspect correction. */
+  dos?: boolean;
+  /** Scale factor multiplier (0 keeps original size). */
+  scaleFactor?: number;
+}
+
+export interface LoadOptions {
+  /**
+   * Directory that contains `libansilove.wasm`. Defaults to the package `dist` folder.
+   */
+  wasmDir?: string;
+  /**
+   * Optional overrides passed through to the underlying Emscripten module factory.
+   */
+  moduleOverrides?: Record<string, unknown>;
+}
+
+export interface RenderResult {
+  /** Raw PNG bytes rendered by libansilove. */
+  png: Uint8Array;
+}
+
+export interface AnsiloveWasm {
+  /** libansilove semantic version string. */
+  version: string;
+  /**
+   * Render an ANSI input (string or bytes) into a PNG image.
+   */
+  renderAnsi(input: string | Uint8Array, options?: RenderOptions): RenderResult;
+}
diff --git a/npm/packages/libansilove-wasm/test/render.test.ts b/npm/packages/libansilove-wasm/test/render.test.ts
new file mode 100644
index 0000000..e04904c
--- /dev/null
+++ b/npm/packages/libansilove-wasm/test/render.test.ts
@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { load } from '../dist/index.js';
+import { strict as assert } from 'node:assert';
+
+async function main() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const wasmDir = path.resolve(__dirname, '..', 'dist');
+
+  const wasm = await load({ wasmDir });
+  assert.match(wasm.version, /^\d+\.\d+\.\d+$/, 'Version should be semver');
+
+  const result = wasm.renderAnsi('Hello from libansilove!\r\n');
+  assert.ok(result.png.byteLength > 16, 'PNG output should be non-empty');
+  assert.equal(result.png[0], 0x89, 'PNG signature should start with 0x89');
+  assert.equal(result.png[1], 0x50, 'PNG signature should include P');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
diff --git a/npm/packages/libansilove-wasm/tsconfig.json b/npm/packages/libansilove-wasm/tsconfig.json
new file mode 100644
index 0000000..00a8325
--- /dev/null
+++ b/npm/packages/libansilove-wasm/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "declarationDir": "dist",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}
diff --git a/npm/packages/libansilove-wasm/tsconfig.test.json b/npm/packages/libansilove-wasm/tsconfig.test.json
new file mode 100644
index 0000000..ad2c2b6
--- /dev/null
+++ b/npm/packages/libansilove-wasm/tsconfig.test.json
@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext"
+  },
+  "include": ["src/**/*", "test/**/*"]
+}
diff --git a/scripts/test-wasm-browser.sh b/scripts/test-wasm-browser.sh
index 65f11e8..abcdc50 100755
--- a/scripts/test-wasm-browser.sh
+++ b/scripts/test-wasm-browser.sh
@@ -20,7 +20,7 @@ if [ ! -f "${DOC_ROOT}/libansilove.js" ]; then
   exit 3
 fi
 
-LOG_FILE=$(mktemp -t ansilove-wasm-http.XXXXXX.log)
+LOG_FILE=$(mktemp -t libansilove-wasm-http.XXXXXX.log)
 cleanup() {
   if [ -n "${SERVER_PID:-}" ]; then
     kill "${SERVER_PID}" 2>/dev/null || true
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
index 94b6aef..af414ae 100755
--- a/scripts/test-wasm-node.js
+++ b/scripts/test-wasm-node.js
@@ -2,6 +2,32 @@
 const fs = require('fs');
 const path = require('path');
 const { TextEncoder } = require('util');
+const { pathToFileURL } = require('url');
+
+async function loadFactory(factoryPath) {
+  try {
+    const required = require(factoryPath);
+    if (typeof required === 'function') {
+      return required;
+    }
+    if (required && typeof required.default === 'function') {
+      return required.default;
+    }
+  } catch (error) {
+    if (error && error.code !== 'ERR_REQUIRE_ESM') {
+      throw error;
+    }
+  }
+
+  const imported = await import(pathToFileURL(factoryPath).href);
+  if (imported && typeof imported.default === 'function') {
+    return imported.default;
+  }
+  if (typeof imported === 'function') {
+    return imported;
+  }
+  throw new Error('libansilove.js did not export an initialization function');
+}
 
 async function main() {
   const buildDir = path.resolve(process.argv[2] || 'build-wasm/wasm');
@@ -12,11 +38,7 @@ async function main() {
     throw new Error(`expected ${factoryPath} (run scripts/test-wasm.sh first)`);
   }
 
-  const factory = require(factoryPath);
-  if (typeof factory !== 'function') {
-    throw new Error('libansilove.js did not export an initialization function');
-  }
-
+  const factory = await loadFactory(factoryPath);
   const Module = await factory();
   const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
   const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);

From fa009432fd87eb05b2c117f85666fd3d27020607 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 21:21:28 -0400
Subject: [PATCH 11/26] Refactor wasm package structure

Adjust the npm package structure and imports to accommodate a dedicated browser entry point. This change ensures that the WebAssembly module
is correctly resolved and loaded in browser environments.

Additionally, this commit updates the build and testing scripts to reflect the new package structure and includes necessary CMake
configuration for ES6 module support. The `.gitignore` and documentation files have also been updated to align with these changes.
---
 .gitignore                                    |   5 +-
 AGENTS.md                                     |   3 +-
 CMakeLists.txt                                |   2 +
 README.md                                     |  10 +-
 npm/bun.lock                                  |   4 +-
 .../libansilove-demo-bun/src/APITester.tsx    |  39 ---
 .../libansilove-demo-bun/src/Ansiove.tsx      |  26 ++
 npm/packages/libansilove-demo-bun/src/App.tsx |  82 ++++--
 .../libansilove-demo-bun/src/index.css        | 250 +++++++++---------
 .../libansilove-demo-bun/src/index.html       |   1 -
 npm/packages/libansilove-wasm/README.md       |  39 ++-
 .../libansilove-wasm/examples/node-render.mjs |  21 ++
 npm/packages/libansilove-wasm/package.json    |  14 +-
 .../libansilove-wasm/scripts/copy-wasm.mjs    |  15 +-
 .../libansilove-wasm/scripts/verify-dist.mjs  |   1 -
 npm/packages/libansilove-wasm/src/browser.ts  |  97 +++++++
 npm/packages/libansilove-wasm/src/index.ts    |  14 +-
 .../libansilove-wasm/src/libansilove.cjs.d.ts |   4 -
 scripts/test-wasm-node.js                     |  26 +-
 19 files changed, 388 insertions(+), 265 deletions(-)
 delete mode 100644 npm/packages/libansilove-demo-bun/src/APITester.tsx
 create mode 100644 npm/packages/libansilove-demo-bun/src/Ansiove.tsx
 create mode 100644 npm/packages/libansilove-wasm/examples/node-render.mjs
 create mode 100644 npm/packages/libansilove-wasm/src/browser.ts
 delete mode 100644 npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts

diff --git a/.gitignore b/.gitignore
index 358b3d0..016d5aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,5 @@ example/wasm/libansilove.wasm
 build-wasm/wasm/test-output.png
 
 # npm package build
-npm/libansilove-wasm/node_modules/
-npm/libansilove-wasm/dist/
-npm/libansilove-wasm/package-lock.json
+node_modules/
+npm/packages/*/dist/
diff --git a/AGENTS.md b/AGENTS.md
index dad8e44..24d22c1 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -17,8 +17,9 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `scripts/test-wasm-browser.sh`: launch a local server and exercise the Safari smoke test end-to-end.
 - `python3 -m http.server 8765 --directory example/wasm`: manual alternative to serve the browser demo (after running `scripts/test-wasm.sh`).
 - `cd npm/libansilove-wasm && npm install && npm run build`: compile the TypeScript wrapper and stage artefacts for publishing.
-- `cd npm/libansilove-wasm && npm run verify`: ensure the npm distribution passes file and runtime checks before publishing.
+- `cd npm/libansilove-wasm && npm test && npm run verify`: run the Node smoke test and distribution checks before publishing.
 - `cd npm/libansilove-wasm && npm run sync-version`: align the npm package version with `ANSILOVE_VERSION` (use `--bump-patch` to increment the patch component).
+- `cd npm/libansilove-wasm && npm run build && npm test`: build the package and run the Node smoke test (see `examples/node-render.mjs`).
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d3c5d1a..6de1bf7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -101,6 +101,8 @@ if(ANSILOVE_BUILD_WASM)
   target_link_options(ansilove_wasm PRIVATE
     "-sMODULARIZE=1"
     "-sEXPORT_NAME=Libansilove"
+    "-sEXPORT_ES6=1"
+    "-sUSE_ES6_IMPORT_META=1"
     "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
     "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
     "-sENVIRONMENT=web,worker,node"
diff --git a/README.md b/README.md
index fc66db4..a04318d 100644
--- a/README.md
+++ b/README.md
@@ -62,17 +62,23 @@ Additional helpers:
 
 # npm package
 
-The `npm/libansilove-wasm` directory contains a TypeScript wrapper and packaging
-scripts for distributing the WebAssembly build on npm:
+The `npm/packages/libansilove-wasm` directory contains a TypeScript wrapper and
+packaging scripts for distributing the WebAssembly build on npm:
 
 ```
 nix develop --command bash scripts/test-wasm.sh
 cd npm/libansilove-wasm
 npm install
 npm run build
+npm test
 npm run verify
 ```
 
+- Node usage: `import { load } from 'libansilove';` (see
+  `npm/packages/libansilove-wasm/examples/node-render.mjs`).
+- Browser usage: `import { loadBrowser } from 'libansilove/browser';` which
+  auto-resolves the wasm asset via `import.meta.url`.
+
 `npm run sync-version` keeps the package version aligned with
 `include/ansilove.h`. Use `npm run version:patch` to bump the patch level when
 preparing a publication. The `prepack` hook rebuilds and verifies artefacts to
diff --git a/npm/bun.lock b/npm/bun.lock
index 390f611..e0d17a7 100644
--- a/npm/bun.lock
+++ b/npm/bun.lock
@@ -27,11 +27,9 @@
     "packages/libansilove-wasm": {
       "name": "libansilove",
       "version": "1.4.2",
-      "dependencies": {
-        "ts-node": "^10.9.2",
-      },
       "devDependencies": {
         "@types/node": "^20.10.0",
+        "ts-node": "^10.9.2",
         "typescript": "^5.4.0",
       },
     },
diff --git a/npm/packages/libansilove-demo-bun/src/APITester.tsx b/npm/packages/libansilove-demo-bun/src/APITester.tsx
deleted file mode 100644
index fd2af48..0000000
--- a/npm/packages/libansilove-demo-bun/src/APITester.tsx
+++ /dev/null
@@ -1,39 +0,0 @@
-import { useRef, type FormEvent } from "react";
-
-export function APITester() {
-  const responseInputRef = useRef<HTMLTextAreaElement>(null);
-
-  const testEndpoint = async (e: FormEvent<HTMLFormElement>) => {
-    e.preventDefault();
-
-    try {
-      const form = e.currentTarget;
-      const formData = new FormData(form);
-      const endpoint = formData.get("endpoint") as string;
-      const url = new URL(endpoint, location.href);
-      const method = formData.get("method") as string;
-      const res = await fetch(url, { method });
-
-      const data = await res.json();
-      responseInputRef.current!.value = JSON.stringify(data, null, 2);
-    } catch (error) {
-      responseInputRef.current!.value = String(error);
-    }
-  };
-
-  return (
-    <div className="api-tester">
-      <form onSubmit={testEndpoint} className="endpoint-row">
-        <select name="method" className="method">
-          <option value="GET">GET</option>
-          <option value="PUT">PUT</option>
-        </select>
-        <input type="text" name="endpoint" defaultValue="/api/hello" className="url-input" placeholder="/api/hello" />
-        <button type="submit" className="send-button">
-          Send
-        </button>
-      </form>
-      <textarea ref={responseInputRef} readOnly placeholder="Response will appear here..." className="response-area" />
-    </div>
-  );
-}
diff --git a/npm/packages/libansilove-demo-bun/src/Ansiove.tsx b/npm/packages/libansilove-demo-bun/src/Ansiove.tsx
new file mode 100644
index 0000000..731ee40
--- /dev/null
+++ b/npm/packages/libansilove-demo-bun/src/Ansiove.tsx
@@ -0,0 +1,26 @@
+import * as libansilove from "libansilove/browser";
+import React, { useMemo } from "react";
+
+export async function ansilove(_: { ansi: string }): Promise<string> {
+	const ansilove = await libansilove.loadBrowser();
+
+	const { png } = ansilove.renderAnsi(_.ansi);
+	const blob = new Blob([png], { type: "image/png" });
+	return URL.createObjectURL(blob);
+}
+
+export default function Ansiove(props: { ansi: string }) {
+	const urlPromise = useMemo(
+		() => ansilove({ ansi: props.ansi }),
+		[props.ansi],
+	);
+	return <LazyImg srcPromise={urlPromise} alt="Rendered ANSI art" />;
+}
+
+export function LazyImg(
+	props: {
+		srcPromise: Promise<string>;
+	} & React.ImgHTMLAttributes<HTMLImageElement>,
+) {
+	return <img alt="ANSI ART" {...props} src={React.use(props.srcPromise)} />;
+}
diff --git a/npm/packages/libansilove-demo-bun/src/App.tsx b/npm/packages/libansilove-demo-bun/src/App.tsx
index 32e134d..2b919d7 100644
--- a/npm/packages/libansilove-demo-bun/src/App.tsx
+++ b/npm/packages/libansilove-demo-bun/src/App.tsx
@@ -1,24 +1,64 @@
-import { APITester } from "./APITester";
+import { loadBrowser } from "libansilove/browser";
+import { useEffect, useState } from "react";
+
 import "./index.css";
 
-import logo from "./logo.svg";
-import reactLogo from "./react.svg";
-
-export function App() {
-  return (
-    <div className="app">
-      <div className="logo-container">
-        <img src={logo} alt="Bun Logo" className="logo bun-logo" />
-        <img src={reactLogo} alt="React Logo" className="logo react-logo" />
-      </div>
-
-      <h1>Bun + React</h1>
-      <p>
-        Edit <code>src/App.tsx</code> and save to test HMR
-      </p>
-      <APITester />
-    </div>
-  );
-}
+const SAMPLE_ANSI = `\x1b[1;36mHello from libansilove!\x1b[0m\r\n`;
+
+export default function App() {
+	const [pngUrl, setPngUrl] = useState<string | null>(null);
+	const [version, setVersion] = useState<string>("");
+	const [error, setError] = useState<string | null>(null);
+
+	useEffect(() => {
+		let objectUrl: string | null = null;
+
+		(async () => {
+			try {
+				const ansilove = await loadBrowser();
+				setVersion(ansilove.version);
 
-export default App;
+				const { png } = ansilove.renderAnsi(SAMPLE_ANSI);
+				const blob = new Blob([png], { type: "image/png" });
+				objectUrl = URL.createObjectURL(blob);
+				setPngUrl(objectUrl);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				setError(message);
+			}
+		})();
+
+		return () => {
+			if (objectUrl) {
+				URL.revokeObjectURL(objectUrl);
+			}
+		};
+	}, []);
+
+	return (
+		<div className="app">
+			<h1>Bun + React + libansilove</h1>
+			<p>
+				Edit <code>src/App.tsx</code> and save to test HMR
+			</p>
+
+			<section className="demo">
+				<h2>libansilove WebAssembly demo</h2>
+				{error ? (
+					<p className="error">Failed to render ANSI art: {error}</p>
+				) : pngUrl ? (
+					<figure>
+						<img
+							src={pngUrl}
+							alt="Rendered ANSI sample"
+							className="ansi-preview"
+						/>
+						<figcaption>Rendered with libansilove {version}</figcaption>
+					</figure>
+				) : (
+					<p>Rendering ANSI art…</p>
+				)}
+			</section>
+		</div>
+	);
+}
diff --git a/npm/packages/libansilove-demo-bun/src/index.css b/npm/packages/libansilove-demo-bun/src/index.css
index 774eb83..e243694 100644
--- a/npm/packages/libansilove-demo-bun/src/index.css
+++ b/npm/packages/libansilove-demo-bun/src/index.css
@@ -1,187 +1,175 @@
 :root {
-  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
+	font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+	line-height: 1.5;
+	color-scheme: light dark;
+	color: rgba(255, 255, 255, 0.87);
+	background-color: #242424;
 }
 body {
-  margin: 0;
-  display: grid;
-  place-items: center;
-  min-width: 320px;
-  min-height: 100vh;
-  position: relative;
-}
-body::before {
-  content: "";
-  position: fixed;
-  inset: 0;
-  z-index: -1;
-  opacity: 0.05;
-  background: url("./logo.svg");
-  background-size: 256px;
-  transform: rotate(-12deg) scale(1.35);
-  animation: slide 30s linear infinite;
-  pointer-events: none;
+	margin: 0;
+	display: grid;
+	place-items: center;
+	min-width: 320px;
+	min-height: 100vh;
+	position: relative;
 }
 @keyframes slide {
-  from {
-    background-position: 0 0;
-  }
-  to {
-    background-position: 256px 224px;
-  }
+	from {
+		background-position: 0 0;
+	}
+	to {
+		background-position: 256px 224px;
+	}
 }
 .app {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-  position: relative;
-  z-index: 1;
+	max-width: 1280px;
+	margin: 0 auto;
+	padding: 2rem;
+	text-align: center;
+	position: relative;
+	z-index: 1;
 }
 .logo-container {
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  gap: 2rem;
-  margin-bottom: 2rem;
+	display: flex;
+	justify-content: center;
+	align-items: center;
+	gap: 2rem;
+	margin-bottom: 2rem;
 }
 .logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-  transition: filter 0.3s;
+	height: 6em;
+	padding: 1.5em;
+	will-change: filter;
+	transition: filter 0.3s;
 }
 .logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
+	filter: drop-shadow(0 0 2em #646cffaa);
 }
 .bun-logo {
-  transform: scale(1.2);
+	transform: scale(1.2);
 }
 .bun-logo:hover {
-  filter: drop-shadow(0 0 2em #fbf0dfaa);
+	filter: drop-shadow(0 0 2em #fbf0dfaa);
 }
 .react-logo {
-  animation: spin 20s linear infinite;
+	animation: spin 20s linear infinite;
 }
 .react-logo:hover {
-  filter: drop-shadow(0 0 2em #61dafbaa);
+	filter: drop-shadow(0 0 2em #61dafbaa);
 }
 @keyframes spin {
-  from {
-    transform: rotate(0);
-  }
-  to {
-    transform: rotate(360deg);
-  }
+	from {
+		transform: rotate(0);
+	}
+	to {
+		transform: rotate(360deg);
+	}
 }
 h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
+	font-size: 3.2em;
+	line-height: 1.1;
 }
 code {
-  background-color: #1a1a1a;
-  padding: 0.2em 0.4em;
-  border-radius: 0.3em;
-  font-family: monospace;
+	background-color: #1a1a1a;
+	padding: 0.2em 0.4em;
+	border-radius: 0.3em;
+	font-family: monospace;
 }
 .api-tester {
-  margin: 2rem auto 0;
-  width: 100%;
-  max-width: 600px;
-  text-align: left;
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
+	margin: 2rem auto 0;
+	width: 100%;
+	max-width: 600px;
+	text-align: left;
+	display: flex;
+	flex-direction: column;
+	gap: 1rem;
 }
 .endpoint-row {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  background: #1a1a1a;
-  padding: 0.75rem;
-  border-radius: 12px;
-  font: monospace;
-  border: 2px solid #fbf0df;
-  transition: 0.3s;
-  width: 100%;
-  box-sizing: border-box;
+	display: flex;
+	align-items: center;
+	gap: 0.5rem;
+	background: #1a1a1a;
+	padding: 0.75rem;
+	border-radius: 12px;
+	font: monospace;
+	border: 2px solid #fbf0df;
+	transition: 0.3s;
+	width: 100%;
+	box-sizing: border-box;
 }
 .endpoint-row:focus-within {
-  border-color: #f3d5a3;
+	border-color: #f3d5a3;
 }
 .method {
-  background: #fbf0df;
-  color: #1a1a1a;
-  padding: 0.3rem 0.7rem;
-  border-radius: 8px;
-  font-weight: 700;
-  font-size: 0.9em;
-  appearance: none;
-  margin: 0;
-  width: min-content;
-  display: block;
-  flex-shrink: 0;
-  border: none;
+	background: #fbf0df;
+	color: #1a1a1a;
+	padding: 0.3rem 0.7rem;
+	border-radius: 8px;
+	font-weight: 700;
+	font-size: 0.9em;
+	appearance: none;
+	margin: 0;
+	width: min-content;
+	display: block;
+	flex-shrink: 0;
+	border: none;
 }
 .method option {
-  text-align: left;
+	text-align: left;
 }
 .url-input {
-  width: 100%;
-  flex: 1;
-  background: 0;
-  border: 0;
-  color: #fbf0df;
-  font: 1em monospace;
-  padding: 0.2rem;
-  outline: 0;
+	width: 100%;
+	flex: 1;
+	background: 0;
+	border: 0;
+	color: #fbf0df;
+	font: 1em monospace;
+	padding: 0.2rem;
+	outline: 0;
 }
 .url-input:focus {
-  color: #fff;
+	color: #fff;
 }
 .url-input::placeholder {
-  color: rgba(251, 240, 223, 0.4);
+	color: rgba(251, 240, 223, 0.4);
 }
 .send-button {
-  background: #fbf0df;
-  color: #1a1a1a;
-  border: 0;
-  padding: 0.4rem 1.2rem;
-  border-radius: 8px;
-  font-weight: 700;
-  transition: 0.1s;
-  cursor: var(--bun-cursor);
+	background: #fbf0df;
+	color: #1a1a1a;
+	border: 0;
+	padding: 0.4rem 1.2rem;
+	border-radius: 8px;
+	font-weight: 700;
+	transition: 0.1s;
+	cursor: var(--bun-cursor);
 }
 .send-button:hover {
-  background: #f3d5a3;
-  transform: translateY(-1px);
-  cursor: pointer;
+	background: #f3d5a3;
+	transform: translateY(-1px);
+	cursor: pointer;
 }
 .response-area {
-  width: 100%;
-  min-height: 120px;
-  background: #1a1a1a;
-  border: 2px solid #fbf0df;
-  border-radius: 12px;
-  padding: 0.75rem;
-  color: #fbf0df;
-  font: monospace;
-  resize: vertical;
-  box-sizing: border-box;
+	width: 100%;
+	min-height: 120px;
+	background: #1a1a1a;
+	border: 2px solid #fbf0df;
+	border-radius: 12px;
+	padding: 0.75rem;
+	color: #fbf0df;
+	font: monospace;
+	resize: vertical;
+	box-sizing: border-box;
 }
 .response-area:focus {
-  border-color: #f3d5a3;
+	border-color: #f3d5a3;
 }
 .response-area::placeholder {
-  color: rgba(251, 240, 223, 0.4);
+	color: rgba(251, 240, 223, 0.4);
 }
 @media (prefers-reduced-motion) {
-  *,
-  ::before,
-  ::after {
-    animation: none !important;
-  }
+	*,
+	::before,
+	::after {
+		animation: none !important;
+	}
 }
diff --git a/npm/packages/libansilove-demo-bun/src/index.html b/npm/packages/libansilove-demo-bun/src/index.html
index 2a957d0..5416d6f 100644
--- a/npm/packages/libansilove-demo-bun/src/index.html
+++ b/npm/packages/libansilove-demo-bun/src/index.html
@@ -3,7 +3,6 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="icon" type="image/svg+xml" href="./logo.svg" />
     <title>Bun + React</title>
   </head>
   <body>
diff --git a/npm/packages/libansilove-wasm/README.md b/npm/packages/libansilove-wasm/README.md
index 83be8ad..89776f4 100644
--- a/npm/packages/libansilove-wasm/README.md
+++ b/npm/packages/libansilove-wasm/README.md
@@ -1,30 +1,40 @@
-# @effect-native/libansilove-wasm
+# libansilove
 
 WebAssembly build of [libansilove](https://www.ansilove.org) packaged for Node.js
 and modern bundlers. The package re-exports the generated Emscripten module along
 with a small TypeScript helper that renders ANSI art to PNG buffers.
 
-## Usage
+## Usage (Node.js)
 
 ```ts
-import { load } from '@effect-native/libansilove-wasm';
+import { load } from 'libansilove';
 
-const wasm = await load();
-const result = wasm.renderAnsi('Hello from libansilove!\r\n');
-console.log(`Generated ${result.png.length} bytes from libansilove ${wasm.version}`);
+async function main() {
+  const wasm = await load();
+  const { png } = wasm.renderAnsi('\u001b[1;36mHello from libansilove!\u001b[0m\r\n');
+  console.log(`libansilove ${wasm.version} produced ${png.byteLength} bytes.`);
+}
+
+main();
 ```
 
-### Rendering options
+See `examples/node-render.mjs` for a full script that writes the PNG to disk.
+
+## Usage (browser / bundlers)
 
 ```ts
-const output = wasm.renderAnsi(ansiText, {
-  columns: 80,
-  icecolors: true,
-  dos: false,
-  scaleFactor: 2,
-});
+import { loadBrowser } from 'libansilove/browser';
+
+const wasm = await loadBrowser();
+const { png } = wasm.renderAnsi('Hello from libansilove!\r\n');
+const blob = new Blob([png], { type: 'image/png' });
+const url = URL.createObjectURL(blob);
 ```
 
+By default `loadBrowser` resolves the wasm binary via `new URL('./libansilove.wasm',
+import.meta.url)`, so bundlers that understand `import.meta.url` will copy the
+asset automatically.
+
 ## Development
 
 1. Build the wasm artefacts from the repository root:
@@ -37,8 +47,9 @@ const output = wasm.renderAnsi(ansiText, {
    npm install
    npm run build
    ```
-3. Verify the distribution before publishing:
+3. Run the example test and verification suite before publishing:
    ```
+   npm test
    npm run verify
    ```
 
diff --git a/npm/packages/libansilove-wasm/examples/node-render.mjs b/npm/packages/libansilove-wasm/examples/node-render.mjs
new file mode 100644
index 0000000..9ad3be7
--- /dev/null
+++ b/npm/packages/libansilove-wasm/examples/node-render.mjs
@@ -0,0 +1,21 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { load } from 'libansilove';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+  const wasm = await load();
+  const { png } = wasm.renderAnsi('\u001b[1;35mHello from libansilove!\u001b[0m\r\n');
+
+  const outputPath = path.resolve(__dirname, 'hello.png');
+  await writeFile(outputPath, png);
+  console.log(`Rendered ANSI art using libansilove ${wasm.version} -> ${outputPath}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
diff --git a/npm/packages/libansilove-wasm/package.json b/npm/packages/libansilove-wasm/package.json
index 6b51f2d..bee3ecb 100644
--- a/npm/packages/libansilove-wasm/package.json
+++ b/npm/packages/libansilove-wasm/package.json
@@ -12,15 +12,17 @@
 			"require": "./dist/index.js",
 			"types": "./dist/index.d.ts"
 		},
-		"./libansilove.cjs": {
-			"default": "./dist/libansilove.cjs"
+		"./browser": {
+			"import": "./dist/browser.js",
+			"types": "./dist/browser.d.ts"
 		}
 	},
 	"files": [
 		"dist/index.js",
 		"dist/index.d.ts",
+		"dist/browser.js",
+		"dist/browser.d.ts",
 		"dist/libansilove.js",
-		"dist/libansilove.cjs",
 		"dist/libansilove.wasm",
 		"dist/LICENSE"
 	],
@@ -31,7 +33,7 @@
 		"build": "npm run clean && npm run compile && npm run copy:wasm",
 		"test": "ts-node --project tsconfig.test.json test/render.test.ts",
 		"verify:files": "node scripts/verify-dist.mjs",
-		"verify:node": "node ../../scripts/test-wasm-node.js dist",
+		"verify:node": "node ../../../scripts/test-wasm-node.js dist",
 		"verify": "npm run verify:files && npm run verify:node",
 		"prepack": "npm run build && npm run verify && npm test",
 		"sync-version": "node scripts/sync-version.mjs",
@@ -42,6 +44,7 @@
 	},
 	"devDependencies": {
 		"@types/node": "^20.10.0",
+		"ts-node": "^10.9.2",
 		"typescript": "^5.4.0"
 	},
 	"keywords": [
@@ -57,8 +60,5 @@
 		"type": "git",
 		"url": "https://github.com/effect-native/libansilove",
 		"directory": "npm/libansilove-wasm"
-	},
-	"dependencies": {
-		"ts-node": "^10.9.2"
 	}
 }
diff --git a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
index d5cba44..2513a51 100644
--- a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
+++ b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
@@ -1,12 +1,14 @@
-import { copyFile, mkdir, writeFile } from 'node:fs/promises';
+import { copyFile, mkdir } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageDir = resolve(__dirname, '..');
-const repoRoot = resolve(packageDir, '..', '..');
-const sourceDir = resolve(repoRoot, 'build-wasm', 'wasm');
+const workspaceRoot = resolve(packageDir, '..');
+const repoRoot = resolve(workspaceRoot, '..');
+const projectRoot = resolve(repoRoot, '..');
+const sourceDir = resolve(projectRoot, 'build-wasm', 'wasm');
 const distDir = resolve(packageDir, 'dist');
 
 await mkdir(distDir, { recursive: true });
@@ -21,13 +23,10 @@ async function copyArtefact(file, target) {
 }
 
 await copyArtefact('libansilove.wasm', resolve(distDir, 'libansilove.wasm'));
-await copyArtefact('libansilove.js', resolve(distDir, 'libansilove.cjs'));
-
-const esmWrapper = `import { createRequire } from 'node:module';\nconst require = createRequire(import.meta.url);\nconst factory = require('./libansilove.cjs');\nexport default factory;\n`;
-await writeFile(resolve(distDir, 'libansilove.js'), esmWrapper);
+await copyArtefact('libansilove.js', resolve(distDir, 'libansilove.js'));
 
 try {
-  await copyFile(resolve(repoRoot, 'LICENSE'), resolve(distDir, 'LICENSE'));
+  await copyFile(resolve(projectRoot, 'LICENSE'), resolve(distDir, 'LICENSE'));
 } catch (error) {
   throw new Error(`Failed to copy repository LICENSE into npm dist.\n${error}`);
 }
diff --git a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
index ee329ae..5e4f3ba 100644
--- a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
+++ b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
@@ -18,7 +18,6 @@ await Promise.all([
   ensure('index.js'),
   ensure('index.d.ts'),
   ensure('libansilove.js'),
-  ensure('libansilove.cjs'),
   ensure('libansilove.wasm'),
   ensure('LICENSE'),
 ]);
diff --git a/npm/packages/libansilove-wasm/src/browser.ts b/npm/packages/libansilove-wasm/src/browser.ts
new file mode 100644
index 0000000..9648909
--- /dev/null
+++ b/npm/packages/libansilove-wasm/src/browser.ts
@@ -0,0 +1,97 @@
+import type { AnsiloveWasm, RenderOptions, RenderResult } from './types.js';
+
+type ModuleOverrides = Record<string, unknown>;
+
+type Factory = (overrides?: ModuleOverrides) => Promise<LibansiloveModule>;
+
+interface LibansiloveModule {
+  readonly HEAPU8: Uint8Array;
+  _malloc(size: number): number;
+  _free(ptr: number): void;
+  cwrap(
+    name: string,
+    returnType: 'number' | 'string' | null,
+    argTypes: ('number')[],
+  ): (...args: number[]) => number | string | void;
+}
+
+export interface BrowserLoadOptions {
+  moduleOverrides?: ModuleOverrides;
+  locateFile?: (file: string) => string;
+}
+
+function toUint8Array(input: string | Uint8Array): Uint8Array {
+  if (typeof input === 'string') {
+    return new TextEncoder().encode(input);
+  }
+  return input;
+}
+
+async function loadFactory(): Promise<Factory> {
+  const factoryModule = await import('./libansilove.js');
+  const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
+  if (typeof factory !== 'function') {
+    throw new Error('Failed to load libansilove wasm factory for browser.');
+  }
+  return factory as Factory;
+}
+
+function defaultLocateFile(file: string): string {
+  return new URL(`./${file}`, import.meta.url).href;
+}
+
+export async function loadBrowser(options: BrowserLoadOptions = {}): Promise<AnsiloveWasm> {
+  const factory = await loadFactory();
+  const module = await factory({
+    locateFile: (file: string) => (options.locateFile ?? defaultLocateFile)(file),
+    ...(options.moduleOverrides ?? {}),
+  });
+
+  const renderAnsiFn = module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+  const getPtr = module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
+  const getLen = module.cwrap('ansilove_wasm_get_png_length', 'number', []);
+  const freePng = module.cwrap('ansilove_wasm_free_png', null, []);
+  const versionFn = module.cwrap('ansilove_wasm_version', 'string', []);
+
+  const renderAnsi = (input: string | Uint8Array, renderOptions: RenderOptions = {}): RenderResult => {
+    const data = toUint8Array(input);
+    const ptr = module._malloc(data.length);
+    try {
+      module.HEAPU8.set(data, ptr);
+
+      const result = renderAnsiFn(
+        ptr,
+        data.length,
+        renderOptions.columns ?? 0,
+        renderOptions.icecolors ? 1 : 0,
+        renderOptions.dos ? 1 : 0,
+        renderOptions.scaleFactor ?? 0,
+      ) as number;
+
+      if (result !== 0) {
+        throw new Error(`ansilove_wasm_render_ansi failed with error code ${result}`);
+      }
+
+      const pngPtr = getPtr() as number;
+      const pngLength = getLen() as number;
+      if (!pngPtr || !pngLength) {
+        throw new Error('ansilove_wasm_get_png_length returned zero bytes.');
+      }
+
+      const png = module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
+      freePng();
+      return { png: new Uint8Array(png) };
+    } finally {
+      module._free(ptr);
+    }
+  };
+
+  const version = versionFn() as string;
+
+  return {
+    version,
+    renderAnsi,
+  };
+}
+
+export type { RenderOptions, RenderResult } from './types.js';
diff --git a/npm/packages/libansilove-wasm/src/index.ts b/npm/packages/libansilove-wasm/src/index.ts
index f1854c4..c78019a 100644
--- a/npm/packages/libansilove-wasm/src/index.ts
+++ b/npm/packages/libansilove-wasm/src/index.ts
@@ -1,10 +1,8 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
 import { TextEncoder } from 'node:util';
 import type { LoadOptions, RenderOptions, AnsiloveWasm, RenderResult } from './types.js';
 
-const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -35,14 +33,12 @@ function toUint8Array(input: string | Uint8Array): Uint8Array {
 }
 
 async function loadFactory(): Promise<LibansiloveFactory> {
-  const maybeFactory = require('./libansilove.cjs');
-  if (typeof maybeFactory === 'function') {
-    return maybeFactory as LibansiloveFactory;
+  const factoryModule = await import('./libansilove.js');
+  const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
+  if (typeof factory !== 'function') {
+    throw new Error('Failed to load libansilove wasm factory.');
   }
-  if (maybeFactory && typeof maybeFactory.default === 'function') {
-    return maybeFactory.default as LibansiloveFactory;
-  }
-  throw new Error('Failed to load libansilove wasm factory.');
+  return factory as LibansiloveFactory;
 }
 
 export async function load(options: LoadOptions = {}): Promise<AnsiloveWasm> {
diff --git a/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts b/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts
deleted file mode 100644
index 653da60..0000000
--- a/npm/packages/libansilove-wasm/src/libansilove.cjs.d.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-declare const factory: ((overrides?: Record<string, unknown>) => Promise<unknown>) & {
-  ready?: Promise<unknown>;
-};
-export = factory;
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
index af414ae..2382b2f 100755
--- a/scripts/test-wasm-node.js
+++ b/scripts/test-wasm-node.js
@@ -5,28 +5,12 @@ const { TextEncoder } = require('util');
 const { pathToFileURL } = require('url');
 
 async function loadFactory(factoryPath) {
-  try {
-    const required = require(factoryPath);
-    if (typeof required === 'function') {
-      return required;
-    }
-    if (required && typeof required.default === 'function') {
-      return required.default;
-    }
-  } catch (error) {
-    if (error && error.code !== 'ERR_REQUIRE_ESM') {
-      throw error;
-    }
+  const module = await import(pathToFileURL(factoryPath).href);
+  const factory = module.default ?? module;
+  if (typeof factory !== 'function') {
+    throw new Error('libansilove.js did not export an initialization function');
   }
-
-  const imported = await import(pathToFileURL(factoryPath).href);
-  if (imported && typeof imported.default === 'function') {
-    return imported.default;
-  }
-  if (typeof imported === 'function') {
-    return imported;
-  }
-  throw new Error('libansilove.js did not export an initialization function');
+  return factory;
 }
 
 async function main() {

From f5bef9807b136e656b5e849c6c652ab77b9cbe0e Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 21:28:39 -0400
Subject: [PATCH 12/26] Add Ansiove component to demo

---
 npm/packages/libansilove-demo-bun/src/App.tsx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/npm/packages/libansilove-demo-bun/src/App.tsx b/npm/packages/libansilove-demo-bun/src/App.tsx
index 2b919d7..d235951 100644
--- a/npm/packages/libansilove-demo-bun/src/App.tsx
+++ b/npm/packages/libansilove-demo-bun/src/App.tsx
@@ -2,6 +2,7 @@ import { loadBrowser } from "libansilove/browser";
 import { useEffect, useState } from "react";
 
 import "./index.css";
+import Ansiove from "./Ansiove";
 
 const SAMPLE_ANSI = `\x1b[1;36mHello from libansilove!\x1b[0m\r\n`;
 
@@ -44,6 +45,7 @@ export default function App() {
 
 			<section className="demo">
 				<h2>libansilove WebAssembly demo</h2>
+				<Ansiove ansi={SAMPLE_ANSI} />
 				{error ? (
 					<p className="error">Failed to render ANSI art: {error}</p>
 				) : pngUrl ? (

From dd390eb3b40b7b54fe073a2c846445fdf7b43252 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 21:49:23 -0400
Subject: [PATCH 13/26] Refactor: Split WASM builds for browser and Node.js

This commit splits the WASM build into two separate targets: one for the browser and one for Node.js.

The browser build uses `-sENVIRONMENT=web,worker` and outputs `libansilove.browser.js` and `libansilove.browser.wasm`. It also updates the
`example/wasm/index.html` to use the new browser-specific output.

The Node.js build uses `-sENVIRONMENT=node` and outputs `libansilove.node.cjs` and `libansilove.node.wasm`.

This separation allows for more targeted builds and avoids potential compatibility issues between different environments. The `.gitignore`
and package files have been updated accordingly.
---
 .gitignore                                    |    8 +-
 CMakeLists.txt                                |   34 +-
 example/wasm/index.html                       |   78 +-
 example/wasm/libansilove.js                   | 1820 +++++++++++++++++
 example/wasm/libansilove.wasm                 |  Bin 0 -> 172316 bytes
 npm/packages/libansilove-wasm/package.json    |    6 +-
 .../libansilove-wasm/scripts/copy-wasm.mjs    |    6 +-
 .../libansilove-wasm/scripts/verify-dist.mjs  |    8 +-
 npm/packages/libansilove-wasm/src/browser.ts  |   23 +-
 npm/packages/libansilove-wasm/src/index.ts    |    5 +-
 scripts/test-wasm-node.js                     |   10 +-
 scripts/test-wasm.sh                          |   21 +-
 12 files changed, 1941 insertions(+), 78 deletions(-)
 create mode 100644 example/wasm/libansilove.js
 create mode 100755 example/wasm/libansilove.wasm

diff --git a/.gitignore b/.gitignore
index 016d5aa..c27e532 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,9 +21,13 @@ Makefile
 cmake_install.cmake
 
 # WASM artefacts
-example/wasm/libansilove.js
-example/wasm/libansilove.wasm
+example/wasm/libansilove.browser.js
+example/wasm/libansilove.browser.wasm
 build-wasm/wasm/test-output.png
+build-wasm/wasm/libansilove.browser.js
+build-wasm/wasm/libansilove.browser.wasm
+build-wasm/wasm/libansilove.node.cjs
+build-wasm/wasm/libansilove.node.wasm
 
 # npm package build
 node_modules/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6de1bf7..3788a3c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,23 +88,41 @@ if(ANSILOVE_BUILD_WASM)
   target_include_directories(objlib_wasm PRIVATE include src compat wasm)
   target_compile_definitions(objlib_wasm PRIVATE ANSILOVE_WASM)
 
-  add_executable(ansilove_wasm
+  add_executable(ansilove_wasm_browser
     wasm/ansilove_wasm.c
     wasm/minigd.c
     $<TARGET_OBJECTS:objlib_wasm>)
-  target_include_directories(ansilove_wasm PRIVATE include src compat wasm)
-  target_compile_definitions(ansilove_wasm PRIVATE ANSILOVE_WASM)
-  set_target_properties(ansilove_wasm PROPERTIES
-    OUTPUT_NAME "libansilove"
+  target_include_directories(ansilove_wasm_browser PRIVATE include src compat wasm)
+  target_compile_definitions(ansilove_wasm_browser PRIVATE ANSILOVE_WASM)
+  set_target_properties(ansilove_wasm_browser PROPERTIES
+    OUTPUT_NAME "libansilove.browser"
     SUFFIX ".js"
     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
-  target_link_options(ansilove_wasm PRIVATE
+  target_link_options(ansilove_wasm_browser PRIVATE
     "-sMODULARIZE=1"
-    "-sEXPORT_NAME=Libansilove"
+    "-sEXPORT_NAME=LibansiloveBrowser"
     "-sEXPORT_ES6=1"
     "-sUSE_ES6_IMPORT_META=1"
     "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
     "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
-    "-sENVIRONMENT=web,worker,node"
+    "-sENVIRONMENT=web,worker"
+    "-sALLOW_MEMORY_GROWTH=1")
+
+  add_executable(ansilove_wasm_node
+    wasm/ansilove_wasm.c
+    wasm/minigd.c
+    $<TARGET_OBJECTS:objlib_wasm>)
+  target_include_directories(ansilove_wasm_node PRIVATE include src compat wasm)
+  target_compile_definitions(ansilove_wasm_node PRIVATE ANSILOVE_WASM)
+  set_target_properties(ansilove_wasm_node PROPERTIES
+    OUTPUT_NAME "libansilove.node"
+    SUFFIX ".cjs"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
+  target_link_options(ansilove_wasm_node PRIVATE
+    "-sMODULARIZE=1"
+    "-sEXPORT_NAME=LibansiloveNode"
+    "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
+    "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
+    "-sENVIRONMENT=node"
     "-sALLOW_MEMORY_GROWTH=1")
 endif()
diff --git a/example/wasm/index.html b/example/wasm/index.html
index afd5398..b8b358d 100644
--- a/example/wasm/index.html
+++ b/example/wasm/index.html
@@ -3,58 +3,50 @@
 <head>
   <meta charset="utf-8">
   <title>libansilove wasm smoke test</title>
-  <script src="libansilove.js"></script>
-  <script>
-    document.addEventListener('DOMContentLoaded', function () {
-      var status = document.getElementById('status');
-      var preview = document.getElementById('preview');
+  <script type="module">
+    import LibansiloveBrowser from './libansilove.browser.js';
 
-      function boot() {
-        if (typeof Libansilove !== 'function') {
-          status.textContent = 'Waiting for Libansilove factory…';
-          setTimeout(boot, 100);
-          return;
-        }
+    const status = document.getElementById('status');
+    const preview = document.getElementById('preview');
 
-        Libansilove({ locateFile: function (path) { return path; } })
-          .then(function (Module) {
-            var getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
-            var renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-            var getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
-            var getLength = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
-            var freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
+    async function render() {
+      try {
+        const Module = await LibansiloveBrowser({ locateFile: (path) => path });
+        const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
+        const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+        const getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
+        const getLength = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
+        const freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
 
-            status.textContent = 'libansilove wasm version: ' + getVersion();
+        status.textContent = 'libansilove wasm version: ' + getVersion();
 
-            var encoder = new TextEncoder();
-            var input = encoder.encode('Hello from libansilove!\r\n');
-            var ptr = Module._malloc(input.length);
-            Module.HEAPU8.set(input, ptr);
+        const encoder = new TextEncoder();
+        const input = encoder.encode('Hello from libansilove!\r\n');
+        const ptr = Module._malloc(input.length);
+        Module.HEAPU8.set(input, ptr);
 
-            var rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
-            Module._free(ptr);
-            if (rc !== 0) {
-              status.textContent = 'Render failed with error code ' + rc;
-              return;
-            }
+        const rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
+        Module._free(ptr);
+        if (rc !== 0) {
+          status.textContent = 'Render failed with error code ' + rc;
+          return;
+        }
 
-            var pngPtr = getPtr();
-            var pngLen = getLength();
-            var pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLen);
-            freePng();
+        const pngPtr = getPtr();
+        const pngLen = getLength();
+        const pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLen);
+        freePng();
 
-            var blob = new Blob([pngData], { type: 'image/png' });
-            var url = URL.createObjectURL(blob);
-            preview.src = url;
-            preview.alt = 'Rendered ANSI sample';
-          })
-          .catch(function (error) {
-            status.textContent = 'Libansilove failed: ' + error;
-          });
+        const blob = new Blob([pngData], { type: 'image/png' });
+        const url = URL.createObjectURL(blob);
+        preview.src = url;
+        preview.alt = 'Rendered ANSI sample';
+      } catch (error) {
+        status.textContent = 'Libansilove failed: ' + error;
       }
+    }
 
-      boot();
-    });
+    render();
   </script>
   <style>
     body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; margin: 2rem; }
diff --git a/example/wasm/libansilove.js b/example/wasm/libansilove.js
new file mode 100644
index 0000000..6599c63
--- /dev/null
+++ b/example/wasm/libansilove.js
@@ -0,0 +1,1820 @@
+
+var Libansilove = (() => {
+  var _scriptDir = import.meta.url;
+  
+  return (
+async function(moduleArg = {}) {
+
+// include: shell.js
+// The Module object: Our interface to the outside world. We import
+// and export values on it. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to check if Module already exists (e.g. case 3 above).
+// Substitution will be replaced with actual code on later stage of the build,
+// this way Closure Compiler will not mangle it (e.g. case 4. above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define   var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module = moduleArg;
+
+// Set up the promise that indicates the Module is initialized
+var readyPromiseResolve, readyPromiseReject;
+Module['ready'] = new Promise((resolve, reject) => {
+  readyPromiseResolve = resolve;
+  readyPromiseReject = reject;
+});
+["_ansilove_wasm_version","_ansilove_wasm_render_ansi","_ansilove_wasm_get_png_ptr","_ansilove_wasm_get_png_length","_ansilove_wasm_free_png","_malloc","_free","_memory","___indirect_function_table","_fflush","onRuntimeInitialized"].forEach((prop) => {
+  if (!Object.getOwnPropertyDescriptor(Module['ready'], prop)) {
+    Object.defineProperty(Module['ready'], prop, {
+      get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
+      set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
+    });
+  }
+});
+
+// --pre-jses are emitted after the Module integration code, so that they can
+// refer to Module (if they choose; they can also define Module)
+
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = Object.assign({}, Module);
+
+var arguments_ = [];
+var thisProgram = './this.program';
+var quit_ = (status, toThrow) => {
+  throw toThrow;
+};
+
+// Determine the runtime environment we are in. You can customize this by
+// setting the ENVIRONMENT setting at compile time (see settings.js).
+
+// Attempt to auto-detect the environment
+var ENVIRONMENT_IS_WEB = typeof window == 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
+// N.b. Electron.js environment is simultaneously a NODE-environment, but
+// also a web environment.
+var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (Module['ENVIRONMENT']) {
+  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
+}
+
+// `/` should be present at the end if `scriptDirectory` is not empty
+var scriptDirectory = '';
+function locateFile(path) {
+  if (Module['locateFile']) {
+    return Module['locateFile'](path, scriptDirectory);
+  }
+  return scriptDirectory + path;
+}
+
+// Hooks that are implemented differently in different runtime environments.
+var read_,
+    readAsync,
+    readBinary;
+
+if (ENVIRONMENT_IS_NODE) {
+  if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+
+  var nodeVersion = process.versions.node;
+  var numericVersion = nodeVersion.split('.').slice(0, 3);
+  numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1);
+  var minVersion = 160000;
+  if (numericVersion < 160000) {
+    throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')');
+  }
+
+  // `require()` is no-op in an ESM module, use `createRequire()` to construct
+  // the require()` function.  This is only necessary for multi-environment
+  // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
+  // TODO: Swap all `require()`'s with `import()`'s?
+  const { createRequire } = await import('module');
+  /** @suppress{duplicate} */
+  var require = createRequire(import.meta.url);
+  // These modules will usually be used on Node.js. Load them eagerly to avoid
+  // the complexity of lazy-loading.
+  var fs = require('fs');
+  var nodePath = require('path');
+
+  if (ENVIRONMENT_IS_WORKER) {
+    scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
+  } else {
+    // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url,
+    // since there's no way getting the current absolute path of the module when
+    // support for that is not available.
+    scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url)); // includes trailing slash
+  }
+
+// include: node_shell_read.js
+read_ = (filename, binary) => {
+  // We need to re-wrap `file://` strings to URLs. Normalizing isn't
+  // necessary in that case, the path should already be absolute.
+  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+  return fs.readFileSync(filename, binary ? undefined : 'utf8');
+};
+
+readBinary = (filename) => {
+  var ret = read_(filename, true);
+  if (!ret.buffer) {
+    ret = new Uint8Array(ret);
+  }
+  assert(ret.buffer);
+  return ret;
+};
+
+readAsync = (filename, onload, onerror, binary = true) => {
+  // See the comment in the `read_` function.
+  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+  fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
+    if (err) onerror(err);
+    else onload(binary ? data.buffer : data);
+  });
+};
+// end include: node_shell_read.js
+  if (!Module['thisProgram'] && process.argv.length > 1) {
+    thisProgram = process.argv[1].replace(/\\/g, '/');
+  }
+
+  arguments_ = process.argv.slice(2);
+
+  // MODULARIZE will export the module in the proper place outside, we don't need to export here
+
+  quit_ = (status, toThrow) => {
+    process.exitCode = status;
+    throw toThrow;
+  };
+
+  Module['inspect'] = () => '[Emscripten Module object]';
+
+} else
+if (ENVIRONMENT_IS_SHELL) {
+
+  if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+
+  if (typeof read != 'undefined') {
+    read_ = read;
+  }
+
+  readBinary = (f) => {
+    if (typeof readbuffer == 'function') {
+      return new Uint8Array(readbuffer(f));
+    }
+    let data = read(f, 'binary');
+    assert(typeof data == 'object');
+    return data;
+  };
+
+  readAsync = (f, onload, onerror) => {
+    setTimeout(() => onload(readBinary(f)));
+  };
+
+  if (typeof clearTimeout == 'undefined') {
+    globalThis.clearTimeout = (id) => {};
+  }
+
+  if (typeof setTimeout == 'undefined') {
+    // spidermonkey lacks setTimeout but we use it above in readAsync.
+    globalThis.setTimeout = (f) => (typeof f == 'function') ? f() : abort();
+  }
+
+  if (typeof scriptArgs != 'undefined') {
+    arguments_ = scriptArgs;
+  } else if (typeof arguments != 'undefined') {
+    arguments_ = arguments;
+  }
+
+  if (typeof quit == 'function') {
+    quit_ = (status, toThrow) => {
+      // Unlike node which has process.exitCode, d8 has no such mechanism. So we
+      // have no way to set the exit code and then let the program exit with
+      // that code when it naturally stops running (say, when all setTimeouts
+      // have completed). For that reason, we must call `quit` - the only way to
+      // set the exit code - but quit also halts immediately.  To increase
+      // consistency with node (and the web) we schedule the actual quit call
+      // using a setTimeout to give the current stack and any exception handlers
+      // a chance to run.  This enables features such as addOnPostRun (which
+      // expected to be able to run code after main returns).
+      setTimeout(() => {
+        if (!(toThrow instanceof ExitStatus)) {
+          let toLog = toThrow;
+          if (toThrow && typeof toThrow == 'object' && toThrow.stack) {
+            toLog = [toThrow, toThrow.stack];
+          }
+          err(`exiting due to exception: ${toLog}`);
+        }
+        quit(status);
+      });
+      throw toThrow;
+    };
+  }
+
+  if (typeof print != 'undefined') {
+    // Prefer to use print/printErr where they exist, as they usually work better.
+    if (typeof console == 'undefined') console = /** @type{!Console} */({});
+    console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
+    console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print);
+  }
+
+} else
+
+// Note that this includes Node.js workers when relevant (pthreads is enabled).
+// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
+// ENVIRONMENT_IS_NODE.
+if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
+    scriptDirectory = self.location.href;
+  } else if (typeof document != 'undefined' && document.currentScript) { // web
+    scriptDirectory = document.currentScript.src;
+  }
+  // When MODULARIZE, this JS may be executed later, after document.currentScript
+  // is gone, so we saved it, and we use it here instead of any other info.
+  if (_scriptDir) {
+    scriptDirectory = _scriptDir;
+  }
+  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
+  // otherwise, slice off the final part of the url to find the script directory.
+  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
+  // and scriptDirectory will correctly be replaced with an empty string.
+  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
+  // they are removed because they could contain a slash.
+  if (scriptDirectory.indexOf('blob:') !== 0) {
+    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1);
+  } else {
+    scriptDirectory = '';
+  }
+
+  if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+
+  // Differentiate the Web Worker from the Node Worker case, as reading must
+  // be done differently.
+  {
+// include: web_or_worker_shell_read.js
+read_ = (url) => {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, false);
+    xhr.send(null);
+    return xhr.responseText;
+  }
+
+  if (ENVIRONMENT_IS_WORKER) {
+    readBinary = (url) => {
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', url, false);
+      xhr.responseType = 'arraybuffer';
+      xhr.send(null);
+      return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
+    };
+  }
+
+  readAsync = (url, onload, onerror) => {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, true);
+    xhr.responseType = 'arraybuffer';
+    xhr.onload = () => {
+      if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+        onload(xhr.response);
+        return;
+      }
+      onerror();
+    };
+    xhr.onerror = onerror;
+    xhr.send(null);
+  }
+
+// end include: web_or_worker_shell_read.js
+  }
+} else
+{
+  throw new Error('environment detection error');
+}
+
+var out = Module['print'] || console.log.bind(console);
+var err = Module['printErr'] || console.error.bind(console);
+
+// Merge back in the overrides
+Object.assign(Module, moduleOverrides);
+// Free the object hierarchy contained in the overrides, this lets the GC
+// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
+moduleOverrides = null;
+checkIncomingModuleAPI();
+
+// Emit code to handle expected values on the Module object. This applies Module.x
+// to the proper local x. This has two benefits: first, we only emit it if it is
+// expected to arrive, and second, by using a local everywhere else that can be
+// minified.
+
+if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');
+
+if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');
+
+if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');
+
+// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
+// Assertions on removed incoming Module JS APIs.
+assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)');
+assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
+assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
+assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');
+assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
+legacyModuleProp('asm', 'wasmExports');
+legacyModuleProp('read', 'read_');
+legacyModuleProp('readAsync', 'readAsync');
+legacyModuleProp('readBinary', 'readBinary');
+legacyModuleProp('setWindowTitle', 'setWindowTitle');
+var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
+var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';
+var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';
+var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';
+var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';
+var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';
+var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';
+
+var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
+
+assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.");
+
+
+// end include: shell.js
+// include: preamble.js
+// === Preamble library stuff ===
+
+// Documentation for the public APIs defined in this file must be updated in:
+//    site/source/docs/api_reference/preamble.js.rst
+// A prebuilt local version of the documentation is available at:
+//    site/build/text/docs/api_reference/preamble.js.txt
+// You can also build docs locally as HTML or other formats in site/
+// An online HTML version (which may be of a different version of Emscripten)
+//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
+
+var wasmBinary; 
+if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');
+
+if (typeof WebAssembly != 'object') {
+  abort('no native wasm support detected');
+}
+
+// Wasm globals
+
+var wasmMemory;
+
+//========================================
+// Runtime essentials
+//========================================
+
+// whether we are quitting the application. no code should run after this.
+// set in exit() and abort()
+var ABORT = false;
+
+// set by exit() and abort().  Passed to 'onExit' handler.
+// NOTE: This is also used as the process return code code in shell environments
+// but only when noExitRuntime is false.
+var EXITSTATUS;
+
+// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
+// don't define it at all in release modes.  This matches the behaviour of
+// MINIMAL_RUNTIME.
+// TODO(sbc): Make this the default even without STRICT enabled.
+/** @type {function(*, string=)} */
+function assert(condition, text) {
+  if (!condition) {
+    abort('Assertion failed' + (text ? ': ' + text : ''));
+  }
+}
+
+// We used to include malloc/free by default in the past. Show a helpful error in
+// builds with assertions.
+
+// Memory management
+
+var HEAP,
+/** @type {!Int8Array} */
+  HEAP8,
+/** @type {!Uint8Array} */
+  HEAPU8,
+/** @type {!Int16Array} */
+  HEAP16,
+/** @type {!Uint16Array} */
+  HEAPU16,
+/** @type {!Int32Array} */
+  HEAP32,
+/** @type {!Uint32Array} */
+  HEAPU32,
+/** @type {!Float32Array} */
+  HEAPF32,
+/** @type {!Float64Array} */
+  HEAPF64;
+
+function updateMemoryViews() {
+  var b = wasmMemory.buffer;
+  Module['HEAP8'] = HEAP8 = new Int8Array(b);
+  Module['HEAP16'] = HEAP16 = new Int16Array(b);
+  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
+  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
+  Module['HEAP32'] = HEAP32 = new Int32Array(b);
+  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
+  Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
+  Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
+}
+
+assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')
+
+assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,
+       'JS engine does not provide full typed array support');
+
+// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
+assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');
+assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');
+
+// include: runtime_stack_check.js
+// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
+function writeStackCookie() {
+  var max = _emscripten_stack_get_end();
+  assert((max & 3) == 0);
+  // If the stack ends at address zero we write our cookies 4 bytes into the
+  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
+  // monitor writes to address zero.
+  if (max == 0) {
+    max += 4;
+  }
+  // The stack grow downwards towards _emscripten_stack_get_end.
+  // We write cookies to the final two words in the stack and detect if they are
+  // ever overwritten.
+  HEAPU32[((max)>>2)] = 0x02135467;
+  HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;
+  // Also test the global address 0 for integrity.
+  HEAPU32[((0)>>2)] = 1668509029;
+}
+
+function checkStackCookie() {
+  if (ABORT) return;
+  var max = _emscripten_stack_get_end();
+  // See writeStackCookie().
+  if (max == 0) {
+    max += 4;
+  }
+  var cookie1 = HEAPU32[((max)>>2)];
+  var cookie2 = HEAPU32[(((max)+(4))>>2)];
+  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {
+    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
+  }
+  // Also test the global address 0 for integrity.
+  if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) {
+    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
+  }
+}
+// end include: runtime_stack_check.js
+// include: runtime_assertions.js
+// Endianness check
+(function() {
+  var h16 = new Int16Array(1);
+  var h8 = new Int8Array(h16.buffer);
+  h16[0] = 0x6373;
+  if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
+})();
+
+// end include: runtime_assertions.js
+var __ATPRERUN__  = []; // functions called before the runtime is initialized
+var __ATINIT__    = []; // functions called during startup
+var __ATEXIT__    = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the main() is called
+
+var runtimeInitialized = false;
+
+function preRun() {
+  if (Module['preRun']) {
+    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+    while (Module['preRun'].length) {
+      addOnPreRun(Module['preRun'].shift());
+    }
+  }
+  callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function initRuntime() {
+  assert(!runtimeInitialized);
+  runtimeInitialized = true;
+
+  checkStackCookie();
+
+  
+  callRuntimeCallbacks(__ATINIT__);
+}
+
+function postRun() {
+  checkStackCookie();
+
+  if (Module['postRun']) {
+    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+    while (Module['postRun'].length) {
+      addOnPostRun(Module['postRun'].shift());
+    }
+  }
+
+  callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+  __ATPRERUN__.unshift(cb);
+}
+
+function addOnInit(cb) {
+  __ATINIT__.unshift(cb);
+}
+
+function addOnExit(cb) {
+}
+
+function addOnPostRun(cb) {
+  __ATPOSTRUN__.unshift(cb);
+}
+
+// include: runtime_math.js
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
+
+assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+// end include: runtime_math.js
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// Module.preRun (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+var runDependencyTracking = {};
+
+function getUniqueRunDependency(id) {
+  var orig = id;
+  while (1) {
+    if (!runDependencyTracking[id]) return id;
+    id = orig + Math.random();
+  }
+}
+
+function addRunDependency(id) {
+  runDependencies++;
+
+  Module['monitorRunDependencies']?.(runDependencies);
+
+  if (id) {
+    assert(!runDependencyTracking[id]);
+    runDependencyTracking[id] = 1;
+    if (runDependencyWatcher === null && typeof setInterval != 'undefined') {
+      // Check for missing dependencies every few seconds
+      runDependencyWatcher = setInterval(() => {
+        if (ABORT) {
+          clearInterval(runDependencyWatcher);
+          runDependencyWatcher = null;
+          return;
+        }
+        var shown = false;
+        for (var dep in runDependencyTracking) {
+          if (!shown) {
+            shown = true;
+            err('still waiting on run dependencies:');
+          }
+          err(`dependency: ${dep}`);
+        }
+        if (shown) {
+          err('(end of list)');
+        }
+      }, 10000);
+    }
+  } else {
+    err('warning: run dependency added without ID');
+  }
+}
+
+function removeRunDependency(id) {
+  runDependencies--;
+
+  Module['monitorRunDependencies']?.(runDependencies);
+
+  if (id) {
+    assert(runDependencyTracking[id]);
+    delete runDependencyTracking[id];
+  } else {
+    err('warning: run dependency removed without ID');
+  }
+  if (runDependencies == 0) {
+    if (runDependencyWatcher !== null) {
+      clearInterval(runDependencyWatcher);
+      runDependencyWatcher = null;
+    }
+    if (dependenciesFulfilled) {
+      var callback = dependenciesFulfilled;
+      dependenciesFulfilled = null;
+      callback(); // can add another dependenciesFulfilled
+    }
+  }
+}
+
+/** @param {string|number=} what */
+function abort(what) {
+  Module['onAbort']?.(what);
+
+  what = 'Aborted(' + what + ')';
+  // TODO(sbc): Should we remove printing and leave it up to whoever
+  // catches the exception?
+  err(what);
+
+  ABORT = true;
+  EXITSTATUS = 1;
+
+  // Use a wasm runtime error, because a JS error might be seen as a foreign
+  // exception, which means we'd run destructors on it. We need the error to
+  // simply make the program stop.
+  // FIXME This approach does not work in Wasm EH because it currently does not assume
+  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
+  // a trap or not based on a hidden field within the object. So at the moment
+  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
+  // allows this in the wasm spec.
+
+  // Suppress closure compiler warning here. Closure compiler's builtin extern
+  // defintion for WebAssembly.RuntimeError claims it takes no arguments even
+  // though it can.
+  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
+  /** @suppress {checkTypes} */
+  var e = new WebAssembly.RuntimeError(what);
+
+  readyPromiseReject(e);
+  // Throw the error whether or not MODULARIZE is set because abort is used
+  // in code paths apart from instantiation where an exception is expected
+  // to be thrown when abort is called.
+  throw e;
+}
+
+// include: memoryprofiler.js
+// end include: memoryprofiler.js
+// show errors on likely calls to FS when it was not included
+var FS = {
+  error() {
+    abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');
+  },
+  init() { FS.error() },
+  createDataFile() { FS.error() },
+  createPreloadedFile() { FS.error() },
+  createLazyFile() { FS.error() },
+  open() { FS.error() },
+  mkdev() { FS.error() },
+  registerDevice() { FS.error() },
+  analyzePath() { FS.error() },
+
+  ErrnoError() { FS.error() },
+};
+Module['FS_createDataFile'] = FS.createDataFile;
+Module['FS_createPreloadedFile'] = FS.createPreloadedFile;
+
+// include: URIUtils.js
+// Prefix of data URIs emitted by SINGLE_FILE and related options.
+var dataURIPrefix = 'data:application/octet-stream;base64,';
+
+/**
+ * Indicates whether filename is a base64 data URI.
+ * @noinline
+ */
+var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+
+/**
+ * Indicates whether filename is delivered via file protocol (as opposed to http/https)
+ * @noinline
+ */
+var isFileURI = (filename) => filename.startsWith('file://');
+// end include: URIUtils.js
+function createExportWrapper(name) {
+  return function() {
+    assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
+    var f = wasmExports[name];
+    assert(f, `exported native function \`${name}\` not found`);
+    return f.apply(null, arguments);
+  };
+}
+
+// include: runtime_exceptions.js
+// end include: runtime_exceptions.js
+var wasmBinaryFile;
+if (Module['locateFile']) {
+  wasmBinaryFile = 'libansilove.wasm';
+  if (!isDataURI(wasmBinaryFile)) {
+    wasmBinaryFile = locateFile(wasmBinaryFile);
+  }
+} else {
+  // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
+  wasmBinaryFile = new URL('libansilove.wasm', import.meta.url).href;
+}
+
+function getBinarySync(file) {
+  if (file == wasmBinaryFile && wasmBinary) {
+    return new Uint8Array(wasmBinary);
+  }
+  if (readBinary) {
+    return readBinary(file);
+  }
+  throw "both async and sync fetching of the wasm failed";
+}
+
+function getBinaryPromise(binaryFile) {
+  // If we don't have the binary yet, try to load it asynchronously.
+  // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
+  // See https://github.com/github/fetch/pull/92#issuecomment-140665932
+  // Cordova or Electron apps are typically loaded from a file:// url.
+  // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
+  if (!wasmBinary
+      && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+    if (typeof fetch == 'function'
+    ) {
+      return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
+        if (!response['ok']) {
+          throw "failed to load wasm binary file at '" + binaryFile + "'";
+        }
+        return response['arrayBuffer']();
+      }).catch(() => getBinarySync(binaryFile));
+    }
+  }
+
+  // Otherwise, getBinarySync should be able to get it synchronously
+  return Promise.resolve().then(() => getBinarySync(binaryFile));
+}
+
+function instantiateArrayBuffer(binaryFile, imports, receiver) {
+  return getBinaryPromise(binaryFile).then((binary) => {
+    return WebAssembly.instantiate(binary, imports);
+  }).then((instance) => {
+    return instance;
+  }).then(receiver, (reason) => {
+    err(`failed to asynchronously prepare wasm: ${reason}`);
+
+    // Warn on some common problems.
+    if (isFileURI(wasmBinaryFile)) {
+      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
+    }
+    abort(reason);
+  });
+}
+
+function instantiateAsync(binary, binaryFile, imports, callback) {
+  if (!binary &&
+      typeof WebAssembly.instantiateStreaming == 'function' &&
+      !isDataURI(binaryFile) &&
+      // Avoid instantiateStreaming() on Node.js environment for now, as while
+      // Node.js v18.1.0 implements it, it does not have a full fetch()
+      // implementation yet.
+      //
+      // Reference:
+      //   https://github.com/emscripten-core/emscripten/pull/16917
+      !ENVIRONMENT_IS_NODE &&
+      typeof fetch == 'function') {
+    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
+      // Suppress closure warning here since the upstream definition for
+      // instantiateStreaming only allows Promise<Repsponse> rather than
+      // an actual Response.
+      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
+      /** @suppress {checkTypes} */
+      var result = WebAssembly.instantiateStreaming(response, imports);
+
+      return result.then(
+        callback,
+        function(reason) {
+          // We expect the most common failure cause to be a bad MIME type for the binary,
+          // in which case falling back to ArrayBuffer instantiation should work.
+          err(`wasm streaming compile failed: ${reason}`);
+          err('falling back to ArrayBuffer instantiation');
+          return instantiateArrayBuffer(binaryFile, imports, callback);
+        });
+    });
+  }
+  return instantiateArrayBuffer(binaryFile, imports, callback);
+}
+
+// Create the wasm instance.
+// Receives the wasm imports, returns the exports.
+function createWasm() {
+  // prepare imports
+  var info = {
+    'env': wasmImports,
+    'wasi_snapshot_preview1': wasmImports,
+  };
+  // Load the wasm module and create an instance of using native support in the JS engine.
+  // handle a generated wasm instance, receiving its exports and
+  // performing other necessary setup
+  /** @param {WebAssembly.Module=} module*/
+  function receiveInstance(instance, module) {
+    wasmExports = instance.exports;
+
+    
+
+    wasmMemory = wasmExports['memory'];
+    
+    assert(wasmMemory, "memory not found in wasm exports");
+    // This assertion doesn't hold when emscripten is run in --post-link
+    // mode.
+    // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
+    //assert(wasmMemory.buffer.byteLength === 16777216);
+    updateMemoryViews();
+
+    addOnInit(wasmExports['__wasm_call_ctors']);
+
+    removeRunDependency('wasm-instantiate');
+    return wasmExports;
+  }
+  // wait for the pthread pool (if any)
+  addRunDependency('wasm-instantiate');
+
+  // Prefer streaming instantiation if available.
+  // Async compilation can be confusing when an error on the page overwrites Module
+  // (for example, if the order of elements is wrong, and the one defining Module is
+  // later), so we save Module and check it later.
+  var trueModule = Module;
+  function receiveInstantiationResult(result) {
+    // 'result' is a ResultObject object which has both the module and instance.
+    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+    assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');
+    trueModule = null;
+    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
+    // When the regression is fixed, can restore the above PTHREADS-enabled path.
+    receiveInstance(result['instance']);
+  }
+
+  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
+  // to manually instantiate the Wasm module themselves. This allows pages to
+  // run the instantiation parallel to any other async startup actions they are
+  // performing.
+  // Also pthreads and wasm workers initialize the wasm instance through this
+  // path.
+  if (Module['instantiateWasm']) {
+
+    try {
+      return Module['instantiateWasm'](info, receiveInstance);
+    } catch(e) {
+      err(`Module.instantiateWasm callback failed with error: ${e}`);
+        // If instantiation fails, reject the module ready promise.
+        readyPromiseReject(e);
+    }
+  }
+
+  // If instantiation fails, reject the module ready promise.
+  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
+  return {}; // no exports yet; we'll fill them in later
+}
+
+// Globals used by JS i64 conversions (see makeSetValue)
+var tempDouble;
+var tempI64;
+
+// include: runtime_debug.js
+function legacyModuleProp(prop, newName, incomming=true) {
+  if (!Object.getOwnPropertyDescriptor(Module, prop)) {
+    Object.defineProperty(Module, prop, {
+      configurable: true,
+      get() {
+        let extra = incomming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : '';
+        abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
+
+      }
+    });
+  }
+}
+
+function ignoredModuleProp(prop) {
+  if (Object.getOwnPropertyDescriptor(Module, prop)) {
+    abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
+  }
+}
+
+// forcing the filesystem exports a few things by default
+function isExportedByForceFilesystem(name) {
+  return name === 'FS_createPath' ||
+         name === 'FS_createDataFile' ||
+         name === 'FS_createPreloadedFile' ||
+         name === 'FS_unlink' ||
+         name === 'addRunDependency' ||
+         // The old FS has some functionality that WasmFS lacks.
+         name === 'FS_createLazyFile' ||
+         name === 'FS_createDevice' ||
+         name === 'removeRunDependency';
+}
+
+function missingGlobal(sym, msg) {
+  if (typeof globalThis !== 'undefined') {
+    Object.defineProperty(globalThis, sym, {
+      configurable: true,
+      get() {
+        warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
+        return undefined;
+      }
+    });
+  }
+}
+
+missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');
+missingGlobal('asm', 'Please use wasmExports instead');
+
+function missingLibrarySymbol(sym) {
+  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
+    Object.defineProperty(globalThis, sym, {
+      configurable: true,
+      get() {
+        // Can't `abort()` here because it would break code that does runtime
+        // checks.  e.g. `if (typeof SDL === 'undefined')`.
+        var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
+        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
+        // library.js, which means $name for a JS name with no prefix, or name
+        // for a JS name like _name.
+        var librarySymbol = sym;
+        if (!librarySymbol.startsWith('_')) {
+          librarySymbol = '$' + sym;
+        }
+        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
+        if (isExportedByForceFilesystem(sym)) {
+          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
+        }
+        warnOnce(msg);
+        return undefined;
+      }
+    });
+  }
+  // Any symbol that is not included from the JS libary is also (by definition)
+  // not exported on the Module object.
+  unexportedRuntimeSymbol(sym);
+}
+
+function unexportedRuntimeSymbol(sym) {
+  if (!Object.getOwnPropertyDescriptor(Module, sym)) {
+    Object.defineProperty(Module, sym, {
+      configurable: true,
+      get() {
+        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
+        if (isExportedByForceFilesystem(sym)) {
+          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
+        }
+        abort(msg);
+      }
+    });
+  }
+}
+
+// Used by XXXXX_DEBUG settings to output debug messages.
+function dbg(text) {
+  // TODO(sbc): Make this configurable somehow.  Its not always convenient for
+  // logging to show up as warnings.
+  console.warn.apply(console, arguments);
+}
+// end include: runtime_debug.js
+// === Body ===
+
+// end include: preamble.js
+
+  /** @constructor */
+  function ExitStatus(status) {
+      this.name = 'ExitStatus';
+      this.message = `Program terminated with exit(${status})`;
+      this.status = status;
+    }
+
+  var callRuntimeCallbacks = (callbacks) => {
+      while (callbacks.length > 0) {
+        // Pass the module as the first argument.
+        callbacks.shift()(Module);
+      }
+    };
+
+  
+    /**
+     * @param {number} ptr
+     * @param {string} type
+     */
+  function getValue(ptr, type = 'i8') {
+    if (type.endsWith('*')) type = '*';
+    switch (type) {
+      case 'i1': return HEAP8[((ptr)>>0)];
+      case 'i8': return HEAP8[((ptr)>>0)];
+      case 'i16': return HEAP16[((ptr)>>1)];
+      case 'i32': return HEAP32[((ptr)>>2)];
+      case 'i64': abort('to do getValue(i64) use WASM_BIGINT');
+      case 'float': return HEAPF32[((ptr)>>2)];
+      case 'double': return HEAPF64[((ptr)>>3)];
+      case '*': return HEAPU32[((ptr)>>2)];
+      default: abort(`invalid type for getValue: ${type}`);
+    }
+  }
+
+  var noExitRuntime = Module['noExitRuntime'] || true;
+
+  var ptrToString = (ptr) => {
+      assert(typeof ptr === 'number');
+      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+      ptr >>>= 0;
+      return '0x' + ptr.toString(16).padStart(8, '0');
+    };
+
+  
+    /**
+     * @param {number} ptr
+     * @param {number} value
+     * @param {string} type
+     */
+  function setValue(ptr, value, type = 'i8') {
+    if (type.endsWith('*')) type = '*';
+    switch (type) {
+      case 'i1': HEAP8[((ptr)>>0)] = value; break;
+      case 'i8': HEAP8[((ptr)>>0)] = value; break;
+      case 'i16': HEAP16[((ptr)>>1)] = value; break;
+      case 'i32': HEAP32[((ptr)>>2)] = value; break;
+      case 'i64': abort('to do setValue(i64) use WASM_BIGINT');
+      case 'float': HEAPF32[((ptr)>>2)] = value; break;
+      case 'double': HEAPF64[((ptr)>>3)] = value; break;
+      case '*': HEAPU32[((ptr)>>2)] = value; break;
+      default: abort(`invalid type for setValue: ${type}`);
+    }
+  }
+
+  var warnOnce = (text) => {
+      warnOnce.shown ||= {};
+      if (!warnOnce.shown[text]) {
+        warnOnce.shown[text] = 1;
+        if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text;
+        err(text);
+      }
+    };
+
+  var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+  
+    /**
+     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
+     * array that contains uint8 values, returns a copy of that string as a
+     * Javascript String object.
+     * heapOrArray is either a regular array, or a JavaScript typed array view.
+     * @param {number} idx
+     * @param {number=} maxBytesToRead
+     * @return {string}
+     */
+  var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      // TextDecoder needs to know the byte length in advance, it doesn't stop on
+      // null terminator by itself.  Also, use the length info to avoid running tiny
+      // strings through TextDecoder, since .subarray() allocates garbage.
+      // (As a tiny code save trick, compare endPtr against endIdx using a negation,
+      // so that undefined means Infinity)
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+  
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = '';
+      // If building with TextDecoder, we have already computed the string length
+      // above, so test loop end condition against that
+      while (idx < endPtr) {
+        // For UTF8 byte structure, see:
+        // http://en.wikipedia.org/wiki/UTF-8#Description
+        // https://www.ietf.org/rfc/rfc2279.txt
+        // https://tools.ietf.org/html/rfc3629
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 0xF0) == 0xE0) {
+          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+        } else {
+          if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');
+          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+        }
+  
+        if (u0 < 0x10000) {
+          str += String.fromCharCode(u0);
+        } else {
+          var ch = u0 - 0x10000;
+          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+        }
+      }
+      return str;
+    };
+  
+    /**
+     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+     * emscripten HEAP, returns a copy of that string as a Javascript String object.
+     *
+     * @param {number} ptr
+     * @param {number=} maxBytesToRead - An optional length that specifies the
+     *   maximum number of bytes to read. You can omit this parameter to scan the
+     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
+     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+     *   string will cut short at that byte index (i.e. maxBytesToRead will not
+     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+     *   JS JIT optimizations off, so it is worth to consider consistently using one
+     * @return {string}
+     */
+  var UTF8ToString = (ptr, maxBytesToRead) => {
+      assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`);
+      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+    };
+  var ___assert_fail = (condition, filename, line, func) => {
+      abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
+    };
+
+  var _emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
+
+  var getHeapMax = () =>
+      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+      // for any code that deals with heap sizes, which would require special
+      // casing all heap size related code to treat 0 specially.
+      2147483648;
+  
+  var growMemory = (size) => {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 65535) / 65536;
+      try {
+        // round size grow request up to wasm page size (fixed 64KB per spec)
+        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+        updateMemoryViews();
+        return 1 /*success*/;
+      } catch(e) {
+        err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);
+      }
+      // implicit 0 return to save code size (caller will cast "undefined" into 0
+      // anyhow)
+    };
+  var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+      requestedSize >>>= 0;
+      // With multithreaded builds, races can happen (another thread might increase the size
+      // in between), so return a failure, and let the caller retry.
+      assert(requestedSize > oldSize);
+  
+      // Memory resize rules:
+      // 1.  Always increase heap size to at least the requested size, rounded up
+      //     to next page multiple.
+      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+      //     geometrically: increase the heap size according to
+      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+      //     linearly: increase the heap size by at least
+      //     MEMORY_GROWTH_LINEAR_STEP bytes.
+      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+      // 4.  If we were unable to allocate as much memory, it may be due to
+      //     over-eager decision to excessively reserve due to (3) above.
+      //     Hence if an allocation fails, cut down on the amount of excess
+      //     growth, in an attempt to succeed to perform a smaller allocation.
+  
+      // A limit is set for how much we can grow. We should not exceed that
+      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
+        return false;
+      }
+  
+      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+  
+      // Loop through potential heap size increases. If we attempt a too eager
+      // reservation that fails, cut down on the attempted size and reserve a
+      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+        // but limit overreserving (default to capping at +96MB overgrowth at most)
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );
+  
+        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+  
+        var replacement = growMemory(newSize);
+        if (replacement) {
+  
+          return true;
+        }
+      }
+      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
+      return false;
+    };
+
+  var getCFunc = (ident) => {
+      var func = Module['_' + ident]; // closure exported function
+      assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
+      return func;
+    };
+  
+  
+  var writeArrayToMemory = (array, buffer) => {
+      assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)')
+      HEAP8.set(array, buffer);
+    };
+  
+  var lengthBytesUTF8 = (str) => {
+      var len = 0;
+      for (var i = 0; i < str.length; ++i) {
+        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+        // unit, not a Unicode code point of the character! So decode
+        // UTF16->UTF32->UTF8.
+        // See http://unicode.org/faq/utf_bom.html#utf16-3
+        var c = str.charCodeAt(i); // possibly a lead surrogate
+        if (c <= 0x7F) {
+          len++;
+        } else if (c <= 0x7FF) {
+          len += 2;
+        } else if (c >= 0xD800 && c <= 0xDFFF) {
+          len += 4; ++i;
+        } else {
+          len += 3;
+        }
+      }
+      return len;
+    };
+  
+  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+      assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`);
+      // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
+      // undefined and false each don't write out any bytes.
+      if (!(maxBytesToWrite > 0))
+        return 0;
+  
+      var startIdx = outIdx;
+      var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+      for (var i = 0; i < str.length; ++i) {
+        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+        // unit, not a Unicode code point of the character! So decode
+        // UTF16->UTF32->UTF8.
+        // See http://unicode.org/faq/utf_bom.html#utf16-3
+        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
+        // and https://www.ietf.org/rfc/rfc2279.txt
+        // and https://tools.ietf.org/html/rfc3629
+        var u = str.charCodeAt(i); // possibly a lead surrogate
+        if (u >= 0xD800 && u <= 0xDFFF) {
+          var u1 = str.charCodeAt(++i);
+          u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
+        }
+        if (u <= 0x7F) {
+          if (outIdx >= endIdx) break;
+          heap[outIdx++] = u;
+        } else if (u <= 0x7FF) {
+          if (outIdx + 1 >= endIdx) break;
+          heap[outIdx++] = 0xC0 | (u >> 6);
+          heap[outIdx++] = 0x80 | (u & 63);
+        } else if (u <= 0xFFFF) {
+          if (outIdx + 2 >= endIdx) break;
+          heap[outIdx++] = 0xE0 | (u >> 12);
+          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+          heap[outIdx++] = 0x80 | (u & 63);
+        } else {
+          if (outIdx + 3 >= endIdx) break;
+          if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');
+          heap[outIdx++] = 0xF0 | (u >> 18);
+          heap[outIdx++] = 0x80 | ((u >> 12) & 63);
+          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+          heap[outIdx++] = 0x80 | (u & 63);
+        }
+      }
+      // Null-terminate the pointer to the buffer.
+      heap[outIdx] = 0;
+      return outIdx - startIdx;
+    };
+  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
+      assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
+      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    };
+  var stringToUTF8OnStack = (str) => {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = stackAlloc(size);
+      stringToUTF8(str, ret, size);
+      return ret;
+    };
+  
+  
+    /**
+     * @param {string|null=} returnType
+     * @param {Array=} argTypes
+     * @param {Arguments|Array=} args
+     * @param {Object=} opts
+     */
+  var ccall = (ident, returnType, argTypes, args, opts) => {
+      // For fast lookup of conversion functions
+      var toC = {
+        'string': (str) => {
+          var ret = 0;
+          if (str !== null && str !== undefined && str !== 0) { // null string
+            // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
+            ret = stringToUTF8OnStack(str);
+          }
+          return ret;
+        },
+        'array': (arr) => {
+          var ret = stackAlloc(arr.length);
+          writeArrayToMemory(arr, ret);
+          return ret;
+        }
+      };
+  
+      function convertReturnValue(ret) {
+        if (returnType === 'string') {
+          
+          return UTF8ToString(ret);
+        }
+        if (returnType === 'boolean') return Boolean(ret);
+        return ret;
+      }
+  
+      var func = getCFunc(ident);
+      var cArgs = [];
+      var stack = 0;
+      assert(returnType !== 'array', 'Return type should not be "array".');
+      if (args) {
+        for (var i = 0; i < args.length; i++) {
+          var converter = toC[argTypes[i]];
+          if (converter) {
+            if (stack === 0) stack = stackSave();
+            cArgs[i] = converter(args[i]);
+          } else {
+            cArgs[i] = args[i];
+          }
+        }
+      }
+      var ret = func.apply(null, cArgs);
+      function onDone(ret) {
+        if (stack !== 0) stackRestore(stack);
+        return convertReturnValue(ret);
+      }
+  
+      ret = onDone(ret);
+      return ret;
+    };
+  
+    /**
+     * @param {string=} returnType
+     * @param {Array=} argTypes
+     * @param {Object=} opts
+     */
+  var cwrap = (ident, returnType, argTypes, opts) => {
+      return function() {
+        return ccall(ident, returnType, argTypes, arguments, opts);
+      }
+    };
+
+
+function checkIncomingModuleAPI() {
+  ignoredModuleProp('fetchSettings');
+}
+var wasmImports = {
+  /** @export */
+  __assert_fail: ___assert_fail,
+  /** @export */
+  emscripten_memcpy_js: _emscripten_memcpy_js,
+  /** @export */
+  emscripten_resize_heap: _emscripten_resize_heap
+};
+var wasmExports = createWasm();
+var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors');
+var _ansilove_wasm_version = Module['_ansilove_wasm_version'] = createExportWrapper('ansilove_wasm_version');
+var _ansilove_wasm_render_ansi = Module['_ansilove_wasm_render_ansi'] = createExportWrapper('ansilove_wasm_render_ansi');
+var _free = Module['_free'] = createExportWrapper('free');
+var _ansilove_wasm_get_png_ptr = Module['_ansilove_wasm_get_png_ptr'] = createExportWrapper('ansilove_wasm_get_png_ptr');
+var _ansilove_wasm_get_png_length = Module['_ansilove_wasm_get_png_length'] = createExportWrapper('ansilove_wasm_get_png_length');
+var _ansilove_wasm_free_png = Module['_ansilove_wasm_free_png'] = createExportWrapper('ansilove_wasm_free_png');
+var _malloc = Module['_malloc'] = createExportWrapper('malloc');
+var ___errno_location = createExportWrapper('__errno_location');
+var _fflush = Module['_fflush'] = createExportWrapper('fflush');
+var _emscripten_builtin_memalign = createExportWrapper('emscripten_builtin_memalign');
+var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();
+var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();
+var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();
+var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();
+var stackSave = createExportWrapper('stackSave');
+var stackRestore = createExportWrapper('stackRestore');
+var stackAlloc = createExportWrapper('stackAlloc');
+var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])();
+
+
+// include: postamble.js
+// === Auto-generated postamble setup entry stuff ===
+
+Module['ccall'] = ccall;
+Module['cwrap'] = cwrap;
+Module['UTF8ToString'] = UTF8ToString;
+var missingLibrarySymbols = [
+  'writeI53ToI64',
+  'writeI53ToI64Clamped',
+  'writeI53ToI64Signaling',
+  'writeI53ToU64Clamped',
+  'writeI53ToU64Signaling',
+  'readI53FromI64',
+  'readI53FromU64',
+  'convertI32PairToI53',
+  'convertI32PairToI53Checked',
+  'convertU32PairToI53',
+  'zeroMemory',
+  'exitJS',
+  'isLeapYear',
+  'ydayFromDate',
+  'arraySum',
+  'addDays',
+  'setErrNo',
+  'inetPton4',
+  'inetNtop4',
+  'inetPton6',
+  'inetNtop6',
+  'readSockaddr',
+  'writeSockaddr',
+  'getHostByName',
+  'initRandomFill',
+  'randomFill',
+  'getCallstack',
+  'emscriptenLog',
+  'convertPCtoSourceLocation',
+  'readEmAsmArgs',
+  'jstoi_q',
+  'jstoi_s',
+  'getExecutableName',
+  'listenOnce',
+  'autoResumeAudioContext',
+  'dynCallLegacy',
+  'getDynCaller',
+  'dynCall',
+  'handleException',
+  'keepRuntimeAlive',
+  'runtimeKeepalivePush',
+  'runtimeKeepalivePop',
+  'callUserCallback',
+  'maybeExit',
+  'asmjsMangle',
+  'asyncLoad',
+  'alignMemory',
+  'mmapAlloc',
+  'handleAllocatorInit',
+  'HandleAllocator',
+  'getNativeTypeSize',
+  'STACK_SIZE',
+  'STACK_ALIGN',
+  'POINTER_SIZE',
+  'ASSERTIONS',
+  'uleb128Encode',
+  'sigToWasmTypes',
+  'generateFuncType',
+  'convertJsFunctionToWasm',
+  'getEmptyTableSlot',
+  'updateTableMap',
+  'getFunctionAddress',
+  'addFunction',
+  'removeFunction',
+  'reallyNegative',
+  'unSign',
+  'strLen',
+  'reSign',
+  'formatString',
+  'intArrayFromString',
+  'intArrayToString',
+  'AsciiToString',
+  'stringToAscii',
+  'UTF16ToString',
+  'stringToUTF16',
+  'lengthBytesUTF16',
+  'UTF32ToString',
+  'stringToUTF32',
+  'lengthBytesUTF32',
+  'stringToNewUTF8',
+  'registerKeyEventCallback',
+  'maybeCStringToJsString',
+  'findEventTarget',
+  'findCanvasEventTarget',
+  'getBoundingClientRect',
+  'fillMouseEventData',
+  'registerMouseEventCallback',
+  'registerWheelEventCallback',
+  'registerUiEventCallback',
+  'registerFocusEventCallback',
+  'fillDeviceOrientationEventData',
+  'registerDeviceOrientationEventCallback',
+  'fillDeviceMotionEventData',
+  'registerDeviceMotionEventCallback',
+  'screenOrientation',
+  'fillOrientationChangeEventData',
+  'registerOrientationChangeEventCallback',
+  'fillFullscreenChangeEventData',
+  'registerFullscreenChangeEventCallback',
+  'JSEvents_requestFullscreen',
+  'JSEvents_resizeCanvasForFullscreen',
+  'registerRestoreOldStyle',
+  'hideEverythingExceptGivenElement',
+  'restoreHiddenElements',
+  'setLetterbox',
+  'softFullscreenResizeWebGLRenderTarget',
+  'doRequestFullscreen',
+  'fillPointerlockChangeEventData',
+  'registerPointerlockChangeEventCallback',
+  'registerPointerlockErrorEventCallback',
+  'requestPointerLock',
+  'fillVisibilityChangeEventData',
+  'registerVisibilityChangeEventCallback',
+  'registerTouchEventCallback',
+  'fillGamepadEventData',
+  'registerGamepadEventCallback',
+  'disableGamepadApiIfItThrows',
+  'registerBeforeUnloadEventCallback',
+  'fillBatteryEventData',
+  'battery',
+  'registerBatteryEventCallback',
+  'setCanvasElementSize',
+  'getCanvasElementSize',
+  'demangle',
+  'demangleAll',
+  'jsStackTrace',
+  'stackTrace',
+  'getEnvStrings',
+  'checkWasiClock',
+  'flush_NO_FILESYSTEM',
+  'wasiRightsToMuslOFlags',
+  'wasiOFlagsToMuslOFlags',
+  'createDyncallWrapper',
+  'safeSetTimeout',
+  'setImmediateWrapped',
+  'clearImmediateWrapped',
+  'polyfillSetImmediate',
+  'getPromise',
+  'makePromise',
+  'idsToPromises',
+  'makePromiseCallback',
+  'ExceptionInfo',
+  'findMatchingCatch',
+  'Browser_asyncPrepareDataCounter',
+  'setMainLoop',
+  'getSocketFromFD',
+  'getSocketAddress',
+  'FS_createPreloadedFile',
+  'FS_modeStringToFlags',
+  'FS_getMode',
+  'FS_stdin_getChar',
+  'FS_createDataFile',
+  'FS_unlink',
+  'FS_mkdirTree',
+  '_setNetworkCallback',
+  'heapObjectForWebGLType',
+  'heapAccessShiftForWebGLHeap',
+  'webgl_enable_ANGLE_instanced_arrays',
+  'webgl_enable_OES_vertex_array_object',
+  'webgl_enable_WEBGL_draw_buffers',
+  'webgl_enable_WEBGL_multi_draw',
+  'emscriptenWebGLGet',
+  'computeUnpackAlignedImageSize',
+  'colorChannelsInGlTextureFormat',
+  'emscriptenWebGLGetTexPixelData',
+  '__glGenObject',
+  'emscriptenWebGLGetUniform',
+  'webglGetUniformLocation',
+  'webglPrepareUniformLocationsBeforeFirstUse',
+  'webglGetLeftBracePos',
+  'emscriptenWebGLGetVertexAttrib',
+  '__glGetActiveAttribOrUniform',
+  'writeGLArray',
+  'registerWebGlEventCallback',
+  'runAndAbortIfError',
+  'SDL_unicode',
+  'SDL_ttfContext',
+  'SDL_audio',
+  'ALLOC_NORMAL',
+  'ALLOC_STACK',
+  'allocate',
+  'writeStringToMemory',
+  'writeAsciiToMemory',
+];
+missingLibrarySymbols.forEach(missingLibrarySymbol)
+
+var unexportedSymbols = [
+  'run',
+  'addOnPreRun',
+  'addOnInit',
+  'addOnPreMain',
+  'addOnExit',
+  'addOnPostRun',
+  'addRunDependency',
+  'removeRunDependency',
+  'FS_createFolder',
+  'FS_createPath',
+  'FS_createLazyFile',
+  'FS_createLink',
+  'FS_createDevice',
+  'FS_readFile',
+  'out',
+  'err',
+  'callMain',
+  'abort',
+  'wasmMemory',
+  'wasmExports',
+  'stackAlloc',
+  'stackSave',
+  'stackRestore',
+  'getTempRet0',
+  'setTempRet0',
+  'writeStackCookie',
+  'checkStackCookie',
+  'ptrToString',
+  'getHeapMax',
+  'growMemory',
+  'ENV',
+  'MONTH_DAYS_REGULAR',
+  'MONTH_DAYS_LEAP',
+  'MONTH_DAYS_REGULAR_CUMULATIVE',
+  'MONTH_DAYS_LEAP_CUMULATIVE',
+  'ERRNO_CODES',
+  'ERRNO_MESSAGES',
+  'DNS',
+  'Protocols',
+  'Sockets',
+  'timers',
+  'warnOnce',
+  'UNWIND_CACHE',
+  'readEmAsmArgsArray',
+  'wasmTable',
+  'noExitRuntime',
+  'getCFunc',
+  'freeTableIndexes',
+  'functionsInTableMap',
+  'setValue',
+  'getValue',
+  'PATH',
+  'PATH_FS',
+  'UTF8Decoder',
+  'UTF8ArrayToString',
+  'stringToUTF8Array',
+  'stringToUTF8',
+  'lengthBytesUTF8',
+  'UTF16Decoder',
+  'stringToUTF8OnStack',
+  'writeArrayToMemory',
+  'JSEvents',
+  'specialHTMLTargets',
+  'currentFullscreenStrategy',
+  'restoreOldWindowedStyle',
+  'ExitStatus',
+  'promiseMap',
+  'uncaughtExceptionCount',
+  'exceptionLast',
+  'exceptionCaught',
+  'Browser',
+  'wget',
+  'SYSCALLS',
+  'preloadPlugins',
+  'FS_stdin_getChar_buffer',
+  'FS',
+  'MEMFS',
+  'TTY',
+  'PIPEFS',
+  'SOCKFS',
+  'tempFixedLengthArray',
+  'miniTempWebGLFloatBuffers',
+  'miniTempWebGLIntBuffers',
+  'GL',
+  'emscripten_webgl_power_preferences',
+  'AL',
+  'GLUT',
+  'EGL',
+  'GLEW',
+  'IDBStore',
+  'SDL',
+  'SDL_gfx',
+  'allocateUTF8',
+  'allocateUTF8OnStack',
+];
+unexportedSymbols.forEach(unexportedRuntimeSymbol);
+
+
+
+var calledRun;
+
+dependenciesFulfilled = function runCaller() {
+  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+  if (!calledRun) run();
+  if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+};
+
+function stackCheckInit() {
+  // This is normally called automatically during __wasm_call_ctors but need to
+  // get these values before even running any of the ctors so we call it redundantly
+  // here.
+  _emscripten_stack_init();
+  // TODO(sbc): Move writeStackCookie to native to to avoid this.
+  writeStackCookie();
+}
+
+function run() {
+
+  if (runDependencies > 0) {
+    return;
+  }
+
+    stackCheckInit();
+
+  preRun();
+
+  // a preRun added a dependency, run will be called later
+  if (runDependencies > 0) {
+    return;
+  }
+
+  function doRun() {
+    // run may have just been called through dependencies being fulfilled just in this very frame,
+    // or while the async setStatus time below was happening
+    if (calledRun) return;
+    calledRun = true;
+    Module['calledRun'] = true;
+
+    if (ABORT) return;
+
+    initRuntime();
+
+    readyPromiseResolve(Module);
+    if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
+
+    assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
+
+    postRun();
+  }
+
+  if (Module['setStatus']) {
+    Module['setStatus']('Running...');
+    setTimeout(function() {
+      setTimeout(function() {
+        Module['setStatus']('');
+      }, 1);
+      doRun();
+    }, 1);
+  } else
+  {
+    doRun();
+  }
+  checkStackCookie();
+}
+
+function checkUnflushedContent() {
+  // Compiler settings do not allow exiting the runtime, so flushing
+  // the streams is not possible. but in ASSERTIONS mode we check
+  // if there was something to flush, and if so tell the user they
+  // should request that the runtime be exitable.
+  // Normally we would not even include flush() at all, but in ASSERTIONS
+  // builds we do so just for this check, and here we see if there is any
+  // content to flush, that is, we check if there would have been
+  // something a non-ASSERTIONS build would have not seen.
+  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
+  // mode (which has its own special function for this; otherwise, all
+  // the code is inside libc)
+  var oldOut = out;
+  var oldErr = err;
+  var has = false;
+  out = err = (x) => {
+    has = true;
+  }
+  try { // it doesn't matter if it fails
+    _fflush(0);
+  } catch(e) {}
+  out = oldOut;
+  err = oldErr;
+  if (has) {
+    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');
+    warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');
+  }
+}
+
+if (Module['preInit']) {
+  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+  while (Module['preInit'].length > 0) {
+    Module['preInit'].pop()();
+  }
+}
+
+run();
+
+
+// end include: postamble.js
+
+
+  return moduleArg.ready
+}
+);
+})();
+;
+export default Libansilove;
\ No newline at end of file
diff --git a/example/wasm/libansilove.wasm b/example/wasm/libansilove.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..44c4c8cadfd27dce3f54a9ad541b992f21f38385
GIT binary patch
literal 172316
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

literal 0
HcmV?d00001

diff --git a/npm/packages/libansilove-wasm/package.json b/npm/packages/libansilove-wasm/package.json
index bee3ecb..5b93713 100644
--- a/npm/packages/libansilove-wasm/package.json
+++ b/npm/packages/libansilove-wasm/package.json
@@ -22,8 +22,10 @@
 		"dist/index.d.ts",
 		"dist/browser.js",
 		"dist/browser.d.ts",
-		"dist/libansilove.js",
-		"dist/libansilove.wasm",
+		"dist/libansilove.browser.js",
+		"dist/libansilove.browser.wasm",
+		"dist/libansilove.node.cjs",
+		"dist/libansilove.node.wasm",
 		"dist/LICENSE"
 	],
 	"scripts": {
diff --git a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
index 2513a51..7851062 100644
--- a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
+++ b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
@@ -22,8 +22,10 @@ async function copyArtefact(file, target) {
   }
 }
 
-await copyArtefact('libansilove.wasm', resolve(distDir, 'libansilove.wasm'));
-await copyArtefact('libansilove.js', resolve(distDir, 'libansilove.js'));
+await copyArtefact('libansilove.browser.wasm', resolve(distDir, 'libansilove.browser.wasm'));
+await copyArtefact('libansilove.browser.js', resolve(distDir, 'libansilove.browser.js'));
+await copyArtefact('libansilove.node.wasm', resolve(distDir, 'libansilove.node.wasm'));
+await copyArtefact('libansilove.node.cjs', resolve(distDir, 'libansilove.node.cjs'));
 
 try {
   await copyFile(resolve(projectRoot, 'LICENSE'), resolve(distDir, 'LICENSE'));
diff --git a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
index 5e4f3ba..5685723 100644
--- a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
+++ b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
@@ -17,7 +17,11 @@ async function ensure(file) {
 await Promise.all([
   ensure('index.js'),
   ensure('index.d.ts'),
-  ensure('libansilove.js'),
-  ensure('libansilove.wasm'),
+  ensure('browser.js'),
+  ensure('browser.d.ts'),
+  ensure('libansilove.browser.js'),
+  ensure('libansilove.browser.wasm'),
+  ensure('libansilove.node.cjs'),
+  ensure('libansilove.node.wasm'),
   ensure('LICENSE'),
 ]);
diff --git a/npm/packages/libansilove-wasm/src/browser.ts b/npm/packages/libansilove-wasm/src/browser.ts
index 9648909..0949863 100644
--- a/npm/packages/libansilove-wasm/src/browser.ts
+++ b/npm/packages/libansilove-wasm/src/browser.ts
@@ -28,12 +28,24 @@ function toUint8Array(input: string | Uint8Array): Uint8Array {
 }
 
 async function loadFactory(): Promise<Factory> {
-  const factoryModule = await import('./libansilove.js');
-  const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
-  if (typeof factory !== 'function') {
-    throw new Error('Failed to load libansilove wasm factory for browser.');
+  const previousProcess = (globalThis as { process?: unknown }).process;
+  const hadProcess = Object.prototype.hasOwnProperty.call(globalThis, 'process');
+  (globalThis as { process?: unknown }).process = undefined;
+
+  try {
+    const factoryModule = await import('./libansilove.js');
+    const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
+    if (typeof factory !== 'function') {
+      throw new Error('Failed to load libansilove wasm factory for browser.');
+    }
+    return factory as Factory;
+  } finally {
+    if (hadProcess) {
+      (globalThis as { process?: unknown }).process = previousProcess;
+    } else {
+      delete (globalThis as { process?: unknown }).process;
+    }
   }
-  return factory as Factory;
 }
 
 function defaultLocateFile(file: string): string {
@@ -42,6 +54,7 @@ function defaultLocateFile(file: string): string {
 
 export async function loadBrowser(options: BrowserLoadOptions = {}): Promise<AnsiloveWasm> {
   const factory = await loadFactory();
+
   const module = await factory({
     locateFile: (file: string) => (options.locateFile ?? defaultLocateFile)(file),
     ...(options.moduleOverrides ?? {}),
diff --git a/npm/packages/libansilove-wasm/src/index.ts b/npm/packages/libansilove-wasm/src/index.ts
index c78019a..0541926 100644
--- a/npm/packages/libansilove-wasm/src/index.ts
+++ b/npm/packages/libansilove-wasm/src/index.ts
@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
 import { TextEncoder } from 'node:util';
 import type { LoadOptions, RenderOptions, AnsiloveWasm, RenderResult } from './types.js';
 
@@ -32,8 +33,10 @@ function toUint8Array(input: string | Uint8Array): Uint8Array {
   return input;
 }
 
+const require = createRequire(import.meta.url);
+
 async function loadFactory(): Promise<LibansiloveFactory> {
-  const factoryModule = await import('./libansilove.js');
+  const factoryModule = require('./libansilove.node.cjs');
   const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
   if (typeof factory !== 'function') {
     throw new Error('Failed to load libansilove wasm factory.');
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
index 2382b2f..07d507c 100755
--- a/scripts/test-wasm-node.js
+++ b/scripts/test-wasm-node.js
@@ -8,7 +8,7 @@ async function loadFactory(factoryPath) {
   const module = await import(pathToFileURL(factoryPath).href);
   const factory = module.default ?? module;
   if (typeof factory !== 'function') {
-    throw new Error('libansilove.js did not export an initialization function');
+    throw new Error('libansilove module did not export an initialization function');
   }
   return factory;
 }
@@ -16,10 +16,11 @@ async function loadFactory(factoryPath) {
 async function main() {
   const buildDir = path.resolve(process.argv[2] || 'build-wasm/wasm');
   const outputPath = path.resolve(process.argv[3] || path.join(buildDir, 'test-output.png'));
-  const factoryPath = path.join(buildDir, 'libansilove.js');
+  const factoryPath = path.resolve(process.argv[4] || path.join(buildDir, 'libansilove.node.cjs'));
+  const sampleText = process.argv[5] || 'Hello from libansilove!\r\n';
 
   if (!fs.existsSync(factoryPath)) {
-    throw new Error(`expected ${factoryPath} (run scripts/test-wasm.sh first)`);
+    throw new Error(`expected wasm factory at ${factoryPath} (run scripts/test-wasm.sh first)`);
   }
 
   const factory = await loadFactory(factoryPath);
@@ -30,9 +31,8 @@ async function main() {
   const getLen = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
   const freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
 
-  const sample = process.argv[4] || 'Hello from libansilove!\r\n';
   const encoder = new TextEncoder();
-  const input = encoder.encode(sample);
+  const input = encoder.encode(sampleText);
   const ptr = Module._malloc(input.length);
   Module.HEAPU8.set(input, ptr);
 
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
index be42cb7..71f00ab 100755
--- a/scripts/test-wasm.sh
+++ b/scripts/test-wasm.sh
@@ -11,21 +11,26 @@ artifacts_dir="$build_dir/wasm"
 rm -rf "$build_dir"
 
 emcmake cmake -S . -B "$build_dir" -DANSILOVE_BUILD_WASM=ON
-cmake --build "$build_dir" --target ansilove_wasm
+cmake --build "$build_dir" --target ansilove_wasm_browser ansilove_wasm_node
 
-if [ ! -f "$artifacts_dir/libansilove.wasm" ]; then
-  echo "error: expected $artifacts_dir/libansilove.wasm to exist" >&2
+browser_js="$artifacts_dir/libansilove.browser.js"
+browser_wasm="$artifacts_dir/libansilove.browser.wasm"
+node_js="$artifacts_dir/libansilove.node.cjs"
+node_wasm="$artifacts_dir/libansilove.node.wasm"
+
+if [ ! -f "$browser_js" ] || [ ! -f "$browser_wasm" ]; then
+  echo "error: expected browser artefacts ($browser_js, $browser_wasm)" >&2
   exit 3
 fi
 
-if [ ! -f "$artifacts_dir/libansilove.js" ]; then
-  echo "error: expected $artifacts_dir/libansilove.js to exist" >&2
+if [ ! -f "$node_js" ] || [ ! -f "$node_wasm" ]; then
+  echo "error: expected node artefacts ($node_js, $node_wasm)" >&2
   exit 4
 fi
 
-node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png"
+node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png" "$node_js"
 
-cp "$artifacts_dir/libansilove.js" example/wasm/
-cp "$artifacts_dir/libansilove.wasm" example/wasm/
+cp "$browser_js" example/wasm/libansilove.browser.js
+cp "$browser_wasm" example/wasm/libansilove.browser.wasm
 
 echo "WASM artefacts found in $artifacts_dir" >&2

From c2a5e897068bf38d62e3b10f38dc7dfac2ba1939 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 22:34:24 -0400
Subject: [PATCH 14/26] Refactor WASM build to use ES modules

This commit introduces several changes to improve the WASM build process and integration:

- The browser WASM output is now emitted as an ES module (`.mjs`), aligning with modern JavaScript practices. - A new
`npm/packages/libansilove` directory has been added to encapsulate the npm package for `libansilove`. - A `build-wasm.bun.ts` script within
the new npm package handles the WASM build process using Bun. - The README and example HTML have been updated to reflect the ES module
changes. - `.gitignore` has been updated to include the new `.wasm-build` directory. - `flake.nix` has been updated to include `bun` in the
development environment.
---
 .gitignore                                    |  1 +
 CMakeLists.txt                                |  2 +-
 README.md                                     | 15 ++++-
 example/wasm/index.html                       |  5 +-
 flake.nix                                     |  1 +
 npm/packages/libansilove/.gitignore           | 34 ++++++++++
 npm/packages/libansilove/README.md            | 15 +++++
 npm/packages/libansilove/generated/README.md  |  1 +
 npm/packages/libansilove/index.ts             |  1 +
 npm/packages/libansilove/package.json         | 14 +++++
 .../libansilove/scripts/build-wasm.bun.ts     | 62 +++++++++++++++++++
 npm/packages/libansilove/tsconfig.json        | 29 +++++++++
 scripts/test-wasm-browser.sh                  |  4 +-
 scripts/test-wasm.sh                          |  4 +-
 14 files changed, 179 insertions(+), 9 deletions(-)
 create mode 100644 npm/packages/libansilove/.gitignore
 create mode 100644 npm/packages/libansilove/README.md
 create mode 100644 npm/packages/libansilove/generated/README.md
 create mode 100644 npm/packages/libansilove/index.ts
 create mode 100644 npm/packages/libansilove/package.json
 create mode 100644 npm/packages/libansilove/scripts/build-wasm.bun.ts
 create mode 100644 npm/packages/libansilove/tsconfig.json

diff --git a/.gitignore b/.gitignore
index c27e532..69e6138 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@
 # build products
 build/
 build-wasm/
+npm/packages/libansilove/.wasm-build/
 
 # Nix
 result
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3788a3c..87caceb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -96,7 +96,7 @@ if(ANSILOVE_BUILD_WASM)
   target_compile_definitions(ansilove_wasm_browser PRIVATE ANSILOVE_WASM)
   set_target_properties(ansilove_wasm_browser PROPERTIES
     OUTPUT_NAME "libansilove.browser"
-    SUFFIX ".js"
+    SUFFIX ".mjs"
     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
   target_link_options(ansilove_wasm_browser PRIVATE
     "-sMODULARIZE=1"
diff --git a/README.md b/README.md
index a04318d..5538760 100644
--- a/README.md
+++ b/README.md
@@ -38,8 +38,19 @@ environment to ensure Emscripten is available:
 	nix develop --command bash scripts/test-wasm.sh
 
 The script configures the project via `emcmake`, produces
-`build-wasm/wasm/libansilove.{js,wasm}`, and exports
-`ansilove_wasm_version()` for browser consumers. It also runs a Node-based
+`build-wasm/wasm/libansilove.browser.{mjs,wasm}`, and exports
+`ansilove_wasm_version()` for browser consumers. The browser bundle is emitted
+as an ES module factory (`-sMODULARIZE=1 -sEXPORT_ES6=1`), so import the default
+export and await the resulting instance before calling into the runtime:
+
+```
+import createLibansilove from './libansilove.browser.mjs';
+
+const Module = await createLibansilove({ locateFile: (path) => path });
+const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
+```
+
+The helper also runs a Node-based
 smoke test that renders a sample ANSI string to
 `build-wasm/wasm/test-output.png` and copies the runtime artefacts into
 `example/wasm/`.
diff --git a/example/wasm/index.html b/example/wasm/index.html
index b8b358d..6db5133 100644
--- a/example/wasm/index.html
+++ b/example/wasm/index.html
@@ -4,14 +4,15 @@
   <meta charset="utf-8">
   <title>libansilove wasm smoke test</title>
   <script type="module">
-    import LibansiloveBrowser from './libansilove.browser.js';
+    import createLibansilove from './libansilove.browser.mjs';
 
     const status = document.getElementById('status');
     const preview = document.getElementById('preview');
 
     async function render() {
       try {
-        const Module = await LibansiloveBrowser({ locateFile: (path) => path });
+        const Module = await createLibansilove({ locateFile: (path) => path });
+
         const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
         const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
         const getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
diff --git a/flake.nix b/flake.nix
index 2ad6481..850f55d 100644
--- a/flake.nix
+++ b/flake.nix
@@ -47,6 +47,7 @@
               pkgs.pkg-config
               pkgs.gd
               pkgs.emscripten
+              pkgs.bun
               pkgs.clang
               pkgs.clang-tools
             ]
diff --git a/npm/packages/libansilove/.gitignore b/npm/packages/libansilove/.gitignore
new file mode 100644
index 0000000..a14702c
--- /dev/null
+++ b/npm/packages/libansilove/.gitignore
@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store
diff --git a/npm/packages/libansilove/README.md b/npm/packages/libansilove/README.md
new file mode 100644
index 0000000..23af782
--- /dev/null
+++ b/npm/packages/libansilove/README.md
@@ -0,0 +1,15 @@
+# libansilove
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.22. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
diff --git a/npm/packages/libansilove/generated/README.md b/npm/packages/libansilove/generated/README.md
new file mode 100644
index 0000000..12635f8
--- /dev/null
+++ b/npm/packages/libansilove/generated/README.md
@@ -0,0 +1 @@
+Emscripten output
diff --git a/npm/packages/libansilove/index.ts b/npm/packages/libansilove/index.ts
new file mode 100644
index 0000000..f67b2c6
--- /dev/null
+++ b/npm/packages/libansilove/index.ts
@@ -0,0 +1 @@
+console.log("Hello via Bun!");
\ No newline at end of file
diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
new file mode 100644
index 0000000..b493373
--- /dev/null
+++ b/npm/packages/libansilove/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "libansilove",
+  "module": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "bun run scripts/build-wasm.bun.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}
diff --git a/npm/packages/libansilove/scripts/build-wasm.bun.ts b/npm/packages/libansilove/scripts/build-wasm.bun.ts
new file mode 100644
index 0000000..33ec408
--- /dev/null
+++ b/npm/packages/libansilove/scripts/build-wasm.bun.ts
@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+import { rm, mkdir, access, copyFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { resolve, dirname, join, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const exitWith = (message: string, code = 1) => {
+  console.error(message);
+  process.exit(code);
+};
+
+const requireCommand = (cmd: string, hint: string, code: number) => {
+  if (!Bun.which(cmd)) {
+    exitWith(`error: ${cmd} is required (${hint}).`, code);
+  }
+};
+
+const ensureFile = async (path: string) => {
+  try {
+    await access(path, fsConstants.F_OK);
+  } catch {
+    exitWith(`error: missing expected artifact ${path}`, 4);
+  }
+};
+
+const main = async () => {
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const pkgDir = resolve(scriptDir, "..");
+  const rootDir = resolve(pkgDir, "../../..");
+  const buildDir = resolve(pkgDir, ".wasm-build");
+  const artifactsDir = resolve(buildDir, "wasm");
+  const outDir = resolve(pkgDir, "generated");
+
+  requireCommand("emcmake", "enter via 'nix develop' or activate emsdk", 2);
+  requireCommand("cmake", "ensure cmake is on PATH", 3);
+
+  await rm(buildDir, { recursive: true, force: true });
+  await mkdir(buildDir, { recursive: true });
+  await mkdir(outDir, { recursive: true });
+
+  const { $ } = Bun;
+
+  await $`emcmake cmake -S ${rootDir} -B ${buildDir} -DANSILOVE_BUILD_WASM=ON`;
+  await $`cmake --build ${buildDir} --target ansilove_wasm_browser ansilove_wasm_node`;
+
+  const artifacts = [
+    join(artifactsDir, "libansilove.browser.mjs"),
+    join(artifactsDir, "libansilove.browser.wasm"),
+    join(artifactsDir, "libansilove.node.cjs"),
+    join(artifactsDir, "libansilove.node.wasm"),
+  ];
+
+  await Promise.all(artifacts.map((path) => ensureFile(path)));
+
+  await Promise.all(
+    artifacts.map((src) => copyFile(src, join(outDir, basename(src))))
+  );
+
+  console.error(`WASM artifacts copied to ${outDir}`);
+};
+
+await main();
diff --git a/npm/packages/libansilove/tsconfig.json b/npm/packages/libansilove/tsconfig.json
new file mode 100644
index 0000000..bfa0fea
--- /dev/null
+++ b/npm/packages/libansilove/tsconfig.json
@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}
diff --git a/scripts/test-wasm-browser.sh b/scripts/test-wasm-browser.sh
index abcdc50..bc5043b 100755
--- a/scripts/test-wasm-browser.sh
+++ b/scripts/test-wasm-browser.sh
@@ -15,8 +15,8 @@ if ! command -v python3 >/dev/null; then
   exit 2
 fi
 
-if [ ! -f "${DOC_ROOT}/libansilove.js" ]; then
-  echo "error: ${DOC_ROOT}/libansilove.js not found; run scripts/test-wasm.sh first." >&2
+if [ ! -f "${DOC_ROOT}/libansilove.browser.mjs" ]; then
+  echo "error: ${DOC_ROOT}/libansilove.browser.mjs not found; run scripts/test-wasm.sh first." >&2
   exit 3
 fi
 
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
index 71f00ab..43cddce 100755
--- a/scripts/test-wasm.sh
+++ b/scripts/test-wasm.sh
@@ -13,7 +13,7 @@ rm -rf "$build_dir"
 emcmake cmake -S . -B "$build_dir" -DANSILOVE_BUILD_WASM=ON
 cmake --build "$build_dir" --target ansilove_wasm_browser ansilove_wasm_node
 
-browser_js="$artifacts_dir/libansilove.browser.js"
+browser_js="$artifacts_dir/libansilove.browser.mjs"
 browser_wasm="$artifacts_dir/libansilove.browser.wasm"
 node_js="$artifacts_dir/libansilove.node.cjs"
 node_wasm="$artifacts_dir/libansilove.node.wasm"
@@ -30,7 +30,7 @@ fi
 
 node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png" "$node_js"
 
-cp "$browser_js" example/wasm/libansilove.browser.js
+cp "$browser_js" example/wasm/libansilove.browser.mjs
 cp "$browser_wasm" example/wasm/libansilove.browser.wasm
 
 echo "WASM artefacts found in $artifacts_dir" >&2

From 2f3839c5fee4b58296134d7013d28cd91e766b37 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 22:34:30 -0400
Subject: [PATCH 15/26] Refactor: Migrate WASM output to ESM modules

This commit updates the build process to output WebAssembly modules as ESM (`.mjs`). This change simplifies module loading and ensures
better compatibility with modern JavaScript environments.

The `.gitignore` and CMake build system have been updated to reflect the new `.mjs` file extensions for the generated WASM JavaScript
wrappers and Node.js CJS modules. The `libansilove-wasm` npm package has been removed and its functionality integrated into the main
`libansilove` package.
---
 .gitignore                                    |   6 +-
 CMakeLists.txt                                |   4 +-
 PR_DESCRIPTION.md                             |  15 +++
 README.md                                     |   3 +-
 npm/bun.lock                                  |  56 ++-------
 npm/packages/libansilove-wasm/LICENSE         |   1 -
 npm/packages/libansilove-wasm/README.md       |  58 ---------
 .../libansilove-wasm/examples/node-render.mjs |  21 ----
 npm/packages/libansilove-wasm/package.json    |  66 -----------
 .../libansilove-wasm/scripts/clean.mjs        |  10 --
 .../libansilove-wasm/scripts/copy-wasm.mjs    |  34 ------
 .../libansilove-wasm/scripts/sync-version.mjs |  61 ----------
 .../libansilove-wasm/scripts/verify-dist.mjs  |  27 -----
 npm/packages/libansilove-wasm/src/browser.ts  | 110 ------------------
 npm/packages/libansilove-wasm/src/index.ts    | 102 ----------------
 .../libansilove-wasm/src/libansilove.d.ts     |   4 -
 npm/packages/libansilove-wasm/src/types.ts    |  35 ------
 .../libansilove-wasm/test/render.test.ts      |  23 ----
 npm/packages/libansilove-wasm/tsconfig.json   |  17 ---
 .../libansilove-wasm/tsconfig.test.json       |   8 --
 npm/packages/libansilove/.gitignore           |   2 +
 .../libansilove/scripts/build-wasm.bun.ts     |  74 ++++++------
 scripts/test-wasm-node.js                     |   2 +-
 scripts/test-wasm.sh                          |   2 +-
 24 files changed, 75 insertions(+), 666 deletions(-)
 create mode 100644 PR_DESCRIPTION.md
 delete mode 100644 npm/packages/libansilove-wasm/LICENSE
 delete mode 100644 npm/packages/libansilove-wasm/README.md
 delete mode 100644 npm/packages/libansilove-wasm/examples/node-render.mjs
 delete mode 100644 npm/packages/libansilove-wasm/package.json
 delete mode 100644 npm/packages/libansilove-wasm/scripts/clean.mjs
 delete mode 100644 npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
 delete mode 100644 npm/packages/libansilove-wasm/scripts/sync-version.mjs
 delete mode 100644 npm/packages/libansilove-wasm/scripts/verify-dist.mjs
 delete mode 100644 npm/packages/libansilove-wasm/src/browser.ts
 delete mode 100644 npm/packages/libansilove-wasm/src/index.ts
 delete mode 100644 npm/packages/libansilove-wasm/src/libansilove.d.ts
 delete mode 100644 npm/packages/libansilove-wasm/src/types.ts
 delete mode 100644 npm/packages/libansilove-wasm/test/render.test.ts
 delete mode 100644 npm/packages/libansilove-wasm/tsconfig.json
 delete mode 100644 npm/packages/libansilove-wasm/tsconfig.test.json

diff --git a/.gitignore b/.gitignore
index 69e6138..e7fe2cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,12 +22,12 @@ Makefile
 cmake_install.cmake
 
 # WASM artefacts
-example/wasm/libansilove.browser.js
+example/wasm/libansilove.browser.mjs
 example/wasm/libansilove.browser.wasm
 build-wasm/wasm/test-output.png
-build-wasm/wasm/libansilove.browser.js
+build-wasm/wasm/libansilove.browser.mjs
 build-wasm/wasm/libansilove.browser.wasm
-build-wasm/wasm/libansilove.node.cjs
+build-wasm/wasm/libansilove.node.mjs
 build-wasm/wasm/libansilove.node.wasm
 
 # npm package build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 87caceb..660a369 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -116,11 +116,13 @@ if(ANSILOVE_BUILD_WASM)
   target_compile_definitions(ansilove_wasm_node PRIVATE ANSILOVE_WASM)
   set_target_properties(ansilove_wasm_node PROPERTIES
     OUTPUT_NAME "libansilove.node"
-    SUFFIX ".cjs"
+    SUFFIX ".mjs"
     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
   target_link_options(ansilove_wasm_node PRIVATE
     "-sMODULARIZE=1"
     "-sEXPORT_NAME=LibansiloveNode"
+    "-sEXPORT_ES6=1"
+    "-sUSE_ES6_IMPORT_META=1"
     "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
     "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
     "-sENVIRONMENT=node"
diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md
new file mode 100644
index 0000000..2614cf2
--- /dev/null
+++ b/PR_DESCRIPTION.md
@@ -0,0 +1,15 @@
+
+# Add reproducible flake env and WebAssembly target.
+## Summary
+- keep the dev shell ergonomic by wiring in Emscripten alongside cmake/clang and documenting the workflow for future agents
+- teach the build to emit `libansilove.{js,wasm}` through a minimal GD-compatible raster backend so the existing loaders work in a browser
+- expose a wasm facade (`ansilove_wasm_render_ansi` etc.), ship a Node smoke test, and serve a demo HTML page that renders ANSI art in Safari
+- scaffold an `@effect-native/libansilove-wasm` package with TypeScript/ESM bindings (Node + browser), reproducible build scripts, and automated version syncing/bumping ready for publication, plus Bun demo integration
+- ignore transient Nix/wasm artefacts and refresh the README/AGENTS notes with the exact commands for building, testing, and verifying in Safari
+
+## Testing
+- nix flake check
+- nix develop --command bash scripts/test-wasm.sh
+- node scripts/test-wasm-node.js build-wasm/wasm
+- scripts/test-wasm-browser.sh (Safari with "Allow JavaScript from Apple Events")
+- cd npm/libansilove-wasm && npm run build && npm test && npm run verify
diff --git a/README.md b/README.md
index 5538760..4b7c79d 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,8 @@ environment to ensure Emscripten is available:
 	nix develop --command bash scripts/test-wasm.sh
 
 The script configures the project via `emcmake`, produces
-`build-wasm/wasm/libansilove.browser.{mjs,wasm}`, and exports
+`build-wasm/wasm/libansilove.browser.{mjs,wasm}` and
+`build-wasm/wasm/libansilove.node.{mjs,wasm}`, and exports
 `ansilove_wasm_version()` for browser consumers. The browser bundle is emitted
 as an ES module factory (`-sMODULARIZE=1 -sEXPORT_ES6=1`), so import the default
 export and await the resulting instance before calling into the runtime:
diff --git a/npm/bun.lock b/npm/bun.lock
index e0d17a7..b5977bf 100644
--- a/npm/bun.lock
+++ b/npm/bun.lock
@@ -10,11 +10,20 @@
         "typescript": "^5",
       },
     },
+    "packages/libansilove": {
+      "name": "libansilove",
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
     "packages/libansilove-demo-bun": {
       "name": "bun-react-template",
       "version": "0.1.0",
       "dependencies": {
-        "libansilove": "workspace:^",
+        "libansilove": "workspace:*",
         "react": "^19",
         "react-dom": "^19",
       },
@@ -24,33 +33,8 @@
         "@types/react-dom": "^19",
       },
     },
-    "packages/libansilove-wasm": {
-      "name": "libansilove",
-      "version": "1.4.2",
-      "devDependencies": {
-        "@types/node": "^20.10.0",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.4.0",
-      },
-    },
   },
   "packages": {
-    "@cspotcode/source-map-support": ["@cspotcode/source-map-support@0.8.1", "", { "dependencies": { "@jridgewell/trace-mapping": "0.3.9" } }, "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw=="],
-
-    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
-
-    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
-
-    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.9", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ=="],
-
-    "@tsconfig/node10": ["@tsconfig/node10@1.0.11", "", {}, "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw=="],
-
-    "@tsconfig/node12": ["@tsconfig/node12@1.0.11", "", {}, "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag=="],
-
-    "@tsconfig/node14": ["@tsconfig/node14@1.0.3", "", {}, "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow=="],
-
-    "@tsconfig/node16": ["@tsconfig/node16@1.0.4", "", {}, "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA=="],
-
     "@types/bun": ["@types/bun@1.2.22", "", { "dependencies": { "bun-types": "1.2.22" } }, "sha512-5A/KrKos2ZcN0c6ljRSOa1fYIyCKhZfIVYeuyb4snnvomnpFqC0tTsEkdqNxbAgExV384OETQ//WAjl3XbYqQA=="],
 
     "@types/node": ["@types/node@20.19.17", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ=="],
@@ -59,25 +43,13 @@
 
     "@types/react-dom": ["@types/react-dom@19.1.9", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-qXRuZaOsAdXKFyOhRBg6Lqqc0yay13vN7KrIg4L7N4aaHN68ma9OK3NE1BoDFgFOTfM7zg+3/8+2n8rLUH3OKQ=="],
 
-    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
-
-    "acorn-walk": ["acorn-walk@8.3.4", "", { "dependencies": { "acorn": "^8.11.0" } }, "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g=="],
-
-    "arg": ["arg@4.1.3", "", {}, "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA=="],
-
     "bun-react-template": ["bun-react-template@workspace:packages/libansilove-demo-bun"],
 
     "bun-types": ["bun-types@1.2.22", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-hwaAu8tct/Zn6Zft4U9BsZcXkYomzpHJX28ofvx7k0Zz2HNz54n1n+tDgxoWFGB4PcFvJXJQloPhaV2eP3Q6EA=="],
 
-    "create-require": ["create-require@1.1.1", "", {}, "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ=="],
-
     "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
 
-    "diff": ["diff@4.0.2", "", {}, "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A=="],
-
-    "libansilove": ["libansilove@workspace:packages/libansilove-wasm"],
-
-    "make-error": ["make-error@1.3.6", "", {}, "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw=="],
+    "libansilove": ["libansilove@workspace:packages/libansilove"],
 
     "react": ["react@19.1.1", "", {}, "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ=="],
 
@@ -85,14 +57,8 @@
 
     "scheduler": ["scheduler@0.26.0", "", {}, "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="],
 
-    "ts-node": ["ts-node@10.9.2", "", { "dependencies": { "@cspotcode/source-map-support": "^0.8.0", "@tsconfig/node10": "^1.0.7", "@tsconfig/node12": "^1.0.7", "@tsconfig/node14": "^1.0.0", "@tsconfig/node16": "^1.0.2", "acorn": "^8.4.1", "acorn-walk": "^8.1.1", "arg": "^4.1.0", "create-require": "^1.1.0", "diff": "^4.0.1", "make-error": "^1.1.1", "v8-compile-cache-lib": "^3.0.1", "yn": "3.1.1" }, "peerDependencies": { "@swc/core": ">=1.2.50", "@swc/wasm": ">=1.2.50", "@types/node": "*", "typescript": ">=2.7" }, "optionalPeers": ["@swc/core", "@swc/wasm"], "bin": { "ts-node": "dist/bin.js", "ts-script": "dist/bin-script-deprecated.js", "ts-node-cwd": "dist/bin-cwd.js", "ts-node-esm": "dist/bin-esm.js", "ts-node-script": "dist/bin-script.js", "ts-node-transpile-only": "dist/bin-transpile.js" } }, "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ=="],
-
     "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
 
     "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
-
-    "v8-compile-cache-lib": ["v8-compile-cache-lib@3.0.1", "", {}, "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg=="],
-
-    "yn": ["yn@3.1.1", "", {}, "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q=="],
   }
 }
diff --git a/npm/packages/libansilove-wasm/LICENSE b/npm/packages/libansilove-wasm/LICENSE
deleted file mode 100644
index a8639ac..0000000
--- a/npm/packages/libansilove-wasm/LICENSE
+++ /dev/null
@@ -1 +0,0 @@
-See ../../LICENSE
diff --git a/npm/packages/libansilove-wasm/README.md b/npm/packages/libansilove-wasm/README.md
deleted file mode 100644
index 89776f4..0000000
--- a/npm/packages/libansilove-wasm/README.md
+++ /dev/null
@@ -1,58 +0,0 @@
-# libansilove
-
-WebAssembly build of [libansilove](https://www.ansilove.org) packaged for Node.js
-and modern bundlers. The package re-exports the generated Emscripten module along
-with a small TypeScript helper that renders ANSI art to PNG buffers.
-
-## Usage (Node.js)
-
-```ts
-import { load } from 'libansilove';
-
-async function main() {
-  const wasm = await load();
-  const { png } = wasm.renderAnsi('\u001b[1;36mHello from libansilove!\u001b[0m\r\n');
-  console.log(`libansilove ${wasm.version} produced ${png.byteLength} bytes.`);
-}
-
-main();
-```
-
-See `examples/node-render.mjs` for a full script that writes the PNG to disk.
-
-## Usage (browser / bundlers)
-
-```ts
-import { loadBrowser } from 'libansilove/browser';
-
-const wasm = await loadBrowser();
-const { png } = wasm.renderAnsi('Hello from libansilove!\r\n');
-const blob = new Blob([png], { type: 'image/png' });
-const url = URL.createObjectURL(blob);
-```
-
-By default `loadBrowser` resolves the wasm binary via `new URL('./libansilove.wasm',
-import.meta.url)`, so bundlers that understand `import.meta.url` will copy the
-asset automatically.
-
-## Development
-
-1. Build the wasm artefacts from the repository root:
-   ```
-   nix develop --command bash scripts/test-wasm.sh
-   ```
-2. Install dependencies and build the package:
-   ```
-   cd npm/libansilove-wasm
-   npm install
-   npm run build
-   ```
-3. Run the example test and verification suite before publishing:
-   ```
-   npm test
-   npm run verify
-   ```
-
-`npm run sync-version` keeps the package version aligned with `ANSILOVE_VERSION`
-inside `include/ansilove.h`. Use `npm run version:patch` to bump the patch level
-when preparing releases.
diff --git a/npm/packages/libansilove-wasm/examples/node-render.mjs b/npm/packages/libansilove-wasm/examples/node-render.mjs
deleted file mode 100644
index 9ad3be7..0000000
--- a/npm/packages/libansilove-wasm/examples/node-render.mjs
+++ /dev/null
@@ -1,21 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { load } from 'libansilove';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-async function main() {
-  const wasm = await load();
-  const { png } = wasm.renderAnsi('\u001b[1;35mHello from libansilove!\u001b[0m\r\n');
-
-  const outputPath = path.resolve(__dirname, 'hello.png');
-  await writeFile(outputPath, png);
-  console.log(`Rendered ANSI art using libansilove ${wasm.version} -> ${outputPath}`);
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
diff --git a/npm/packages/libansilove-wasm/package.json b/npm/packages/libansilove-wasm/package.json
deleted file mode 100644
index 5b93713..0000000
--- a/npm/packages/libansilove-wasm/package.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
-	"name": "libansilove",
-	"version": "1.4.2",
-	"description": "WebAssembly build of libansilove with TypeScript bindings.",
-	"type": "module",
-	"main": "./dist/index.js",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"require": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		},
-		"./browser": {
-			"import": "./dist/browser.js",
-			"types": "./dist/browser.d.ts"
-		}
-	},
-	"files": [
-		"dist/index.js",
-		"dist/index.d.ts",
-		"dist/browser.js",
-		"dist/browser.d.ts",
-		"dist/libansilove.browser.js",
-		"dist/libansilove.browser.wasm",
-		"dist/libansilove.node.cjs",
-		"dist/libansilove.node.wasm",
-		"dist/LICENSE"
-	],
-	"scripts": {
-		"clean": "node scripts/clean.mjs",
-		"compile": "tsc -p tsconfig.json",
-		"copy:wasm": "node scripts/copy-wasm.mjs",
-		"build": "npm run clean && npm run compile && npm run copy:wasm",
-		"test": "ts-node --project tsconfig.test.json test/render.test.ts",
-		"verify:files": "node scripts/verify-dist.mjs",
-		"verify:node": "node ../../../scripts/test-wasm-node.js dist",
-		"verify": "npm run verify:files && npm run verify:node",
-		"prepack": "npm run build && npm run verify && npm test",
-		"sync-version": "node scripts/sync-version.mjs",
-		"version:patch": "node scripts/sync-version.mjs --bump-patch"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"devDependencies": {
-		"@types/node": "^20.10.0",
-		"ts-node": "^10.9.2",
-		"typescript": "^5.4.0"
-	},
-	"keywords": [
-		"ansi",
-		"ansilove",
-		"wasm",
-		"ansi-art",
-		"libansilove"
-	],
-	"author": "effect-native",
-	"license": "BSD-2-Clause",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/effect-native/libansilove",
-		"directory": "npm/libansilove-wasm"
-	}
-}
diff --git a/npm/packages/libansilove-wasm/scripts/clean.mjs b/npm/packages/libansilove-wasm/scripts/clean.mjs
deleted file mode 100644
index d52b82e..0000000
--- a/npm/packages/libansilove-wasm/scripts/clean.mjs
+++ /dev/null
@@ -1,10 +0,0 @@
-import { rm } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageDir = resolve(__dirname, '..');
-const distDir = resolve(packageDir, 'dist');
-
-await rm(distDir, { recursive: true, force: true });
diff --git a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs b/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
deleted file mode 100644
index 7851062..0000000
--- a/npm/packages/libansilove-wasm/scripts/copy-wasm.mjs
+++ /dev/null
@@ -1,34 +0,0 @@
-import { copyFile, mkdir } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageDir = resolve(__dirname, '..');
-const workspaceRoot = resolve(packageDir, '..');
-const repoRoot = resolve(workspaceRoot, '..');
-const projectRoot = resolve(repoRoot, '..');
-const sourceDir = resolve(projectRoot, 'build-wasm', 'wasm');
-const distDir = resolve(packageDir, 'dist');
-
-await mkdir(distDir, { recursive: true });
-
-async function copyArtefact(file, target) {
-  const source = resolve(sourceDir, file);
-  try {
-    await copyFile(source, target);
-  } catch (error) {
-    throw new Error(`Failed to copy ${file} from ${source}. Run 'scripts/test-wasm.sh' from the repository root first.\n${error}`);
-  }
-}
-
-await copyArtefact('libansilove.browser.wasm', resolve(distDir, 'libansilove.browser.wasm'));
-await copyArtefact('libansilove.browser.js', resolve(distDir, 'libansilove.browser.js'));
-await copyArtefact('libansilove.node.wasm', resolve(distDir, 'libansilove.node.wasm'));
-await copyArtefact('libansilove.node.cjs', resolve(distDir, 'libansilove.node.cjs'));
-
-try {
-  await copyFile(resolve(projectRoot, 'LICENSE'), resolve(distDir, 'LICENSE'));
-} catch (error) {
-  throw new Error(`Failed to copy repository LICENSE into npm dist.\n${error}`);
-}
diff --git a/npm/packages/libansilove-wasm/scripts/sync-version.mjs b/npm/packages/libansilove-wasm/scripts/sync-version.mjs
deleted file mode 100644
index 80a1836..0000000
--- a/npm/packages/libansilove-wasm/scripts/sync-version.mjs
+++ /dev/null
@@ -1,61 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packagePath = resolve(__dirname, '..', 'package.json');
-const headerPath = resolve(__dirname, '..', '..', '..', 'include', 'ansilove.h');
-
-const args = process.argv.slice(2);
-const bumpPatch = args.includes('--bump-patch');
-
-function parseLibraryVersion(contents) {
-  const match = contents.match(/#define\s+ANSILOVE_VERSION\s+"([0-9]+\.[0-9]+\.[0-9]+)"/);
-  if (!match) {
-    throw new Error('Unable to parse ANSILOVE_VERSION from include/ansilove.h');
-  }
-  return match[1];
-}
-
-function compareSemver(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if (pa[i] > pb[i]) return 1;
-    if (pa[i] < pb[i]) return -1;
-  }
-  return 0;
-}
-
-function bumpPatchVersion(version) {
-  const parts = version.split('.').map((value) => Number.parseInt(value, 10));
-  if (parts.length !== 3 || parts.some(Number.isNaN)) {
-    throw new Error(`Invalid semantic version: ${version}`);
-  }
-  parts[2] += 1;
-  return parts.join('.');
-}
-
-const [packageJsonRaw, headerRaw] = await Promise.all([
-  readFile(packagePath, 'utf8'),
-  readFile(headerPath, 'utf8'),
-]);
-
-const pkg = JSON.parse(packageJsonRaw);
-const libraryVersion = parseLibraryVersion(headerRaw);
-let targetVersion = libraryVersion;
-
-if (bumpPatch) {
-  const baseline = pkg.version && compareSemver(pkg.version, libraryVersion) > 0 ? pkg.version : libraryVersion;
-  targetVersion = bumpPatchVersion(baseline);
-}
-
-if (pkg.version === targetVersion) {
-  console.log(`package.json already at ${targetVersion}`);
-  process.exit(0);
-}
-
-pkg.version = targetVersion;
-await writeFile(packagePath, `${JSON.stringify(pkg, null, 2)}\n`);
-console.log(`Updated npm package version to ${targetVersion}`);
diff --git a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs b/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
deleted file mode 100644
index 5685723..0000000
--- a/npm/packages/libansilove-wasm/scripts/verify-dist.mjs
+++ /dev/null
@@ -1,27 +0,0 @@
-import { access } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const distDir = resolve(__dirname, '..', 'dist');
-
-async function ensure(file) {
-  try {
-    await access(resolve(distDir, file));
-  } catch (error) {
-    throw new Error(`Missing dist artefact: ${file}\n${error}`);
-  }
-}
-
-await Promise.all([
-  ensure('index.js'),
-  ensure('index.d.ts'),
-  ensure('browser.js'),
-  ensure('browser.d.ts'),
-  ensure('libansilove.browser.js'),
-  ensure('libansilove.browser.wasm'),
-  ensure('libansilove.node.cjs'),
-  ensure('libansilove.node.wasm'),
-  ensure('LICENSE'),
-]);
diff --git a/npm/packages/libansilove-wasm/src/browser.ts b/npm/packages/libansilove-wasm/src/browser.ts
deleted file mode 100644
index 0949863..0000000
--- a/npm/packages/libansilove-wasm/src/browser.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import type { AnsiloveWasm, RenderOptions, RenderResult } from './types.js';
-
-type ModuleOverrides = Record<string, unknown>;
-
-type Factory = (overrides?: ModuleOverrides) => Promise<LibansiloveModule>;
-
-interface LibansiloveModule {
-  readonly HEAPU8: Uint8Array;
-  _malloc(size: number): number;
-  _free(ptr: number): void;
-  cwrap(
-    name: string,
-    returnType: 'number' | 'string' | null,
-    argTypes: ('number')[],
-  ): (...args: number[]) => number | string | void;
-}
-
-export interface BrowserLoadOptions {
-  moduleOverrides?: ModuleOverrides;
-  locateFile?: (file: string) => string;
-}
-
-function toUint8Array(input: string | Uint8Array): Uint8Array {
-  if (typeof input === 'string') {
-    return new TextEncoder().encode(input);
-  }
-  return input;
-}
-
-async function loadFactory(): Promise<Factory> {
-  const previousProcess = (globalThis as { process?: unknown }).process;
-  const hadProcess = Object.prototype.hasOwnProperty.call(globalThis, 'process');
-  (globalThis as { process?: unknown }).process = undefined;
-
-  try {
-    const factoryModule = await import('./libansilove.js');
-    const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
-    if (typeof factory !== 'function') {
-      throw new Error('Failed to load libansilove wasm factory for browser.');
-    }
-    return factory as Factory;
-  } finally {
-    if (hadProcess) {
-      (globalThis as { process?: unknown }).process = previousProcess;
-    } else {
-      delete (globalThis as { process?: unknown }).process;
-    }
-  }
-}
-
-function defaultLocateFile(file: string): string {
-  return new URL(`./${file}`, import.meta.url).href;
-}
-
-export async function loadBrowser(options: BrowserLoadOptions = {}): Promise<AnsiloveWasm> {
-  const factory = await loadFactory();
-
-  const module = await factory({
-    locateFile: (file: string) => (options.locateFile ?? defaultLocateFile)(file),
-    ...(options.moduleOverrides ?? {}),
-  });
-
-  const renderAnsiFn = module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-  const getPtr = module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
-  const getLen = module.cwrap('ansilove_wasm_get_png_length', 'number', []);
-  const freePng = module.cwrap('ansilove_wasm_free_png', null, []);
-  const versionFn = module.cwrap('ansilove_wasm_version', 'string', []);
-
-  const renderAnsi = (input: string | Uint8Array, renderOptions: RenderOptions = {}): RenderResult => {
-    const data = toUint8Array(input);
-    const ptr = module._malloc(data.length);
-    try {
-      module.HEAPU8.set(data, ptr);
-
-      const result = renderAnsiFn(
-        ptr,
-        data.length,
-        renderOptions.columns ?? 0,
-        renderOptions.icecolors ? 1 : 0,
-        renderOptions.dos ? 1 : 0,
-        renderOptions.scaleFactor ?? 0,
-      ) as number;
-
-      if (result !== 0) {
-        throw new Error(`ansilove_wasm_render_ansi failed with error code ${result}`);
-      }
-
-      const pngPtr = getPtr() as number;
-      const pngLength = getLen() as number;
-      if (!pngPtr || !pngLength) {
-        throw new Error('ansilove_wasm_get_png_length returned zero bytes.');
-      }
-
-      const png = module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
-      freePng();
-      return { png: new Uint8Array(png) };
-    } finally {
-      module._free(ptr);
-    }
-  };
-
-  const version = versionFn() as string;
-
-  return {
-    version,
-    renderAnsi,
-  };
-}
-
-export type { RenderOptions, RenderResult } from './types.js';
diff --git a/npm/packages/libansilove-wasm/src/index.ts b/npm/packages/libansilove-wasm/src/index.ts
deleted file mode 100644
index 0541926..0000000
--- a/npm/packages/libansilove-wasm/src/index.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { TextEncoder } from 'node:util';
-import type { LoadOptions, RenderOptions, AnsiloveWasm, RenderResult } from './types.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Minimal shape of the Emscripten factory output we rely on.
-interface LibansiloveModule {
-  readonly HEAPU8: Uint8Array;
-  _malloc(size: number): number;
-  _free(ptr: number): void;
-  cwrap(
-    name: string,
-    returnType: 'number' | 'string' | null,
-    argTypes: ('number')[],
-  ): (...args: number[]) => number | string | void;
-}
-
-type LibansiloveFactory = (overrides?: Record<string, unknown>) => Promise<LibansiloveModule>;
-
-function resolveWasmPath(file: string, wasmDir?: string): string {
-  const base = wasmDir ?? __dirname;
-  return path.join(base, file);
-}
-
-function toUint8Array(input: string | Uint8Array): Uint8Array {
-  if (typeof input === 'string') {
-    return new TextEncoder().encode(input);
-  }
-  return input;
-}
-
-const require = createRequire(import.meta.url);
-
-async function loadFactory(): Promise<LibansiloveFactory> {
-  const factoryModule = require('./libansilove.node.cjs');
-  const factory = (factoryModule as { default?: unknown }).default ?? factoryModule;
-  if (typeof factory !== 'function') {
-    throw new Error('Failed to load libansilove wasm factory.');
-  }
-  return factory as LibansiloveFactory;
-}
-
-export async function load(options: LoadOptions = {}): Promise<AnsiloveWasm> {
-  const factory = await loadFactory();
-
-  const module = await factory({
-    locateFile: (file: string) => resolveWasmPath(file, options.wasmDir),
-    ...(options.moduleOverrides ?? {}),
-  });
-
-  const renderAnsiFn = module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-  const getPtr = module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
-  const getLen = module.cwrap('ansilove_wasm_get_png_length', 'number', []);
-  const freePng = module.cwrap('ansilove_wasm_free_png', null, []);
-  const versionFn = module.cwrap('ansilove_wasm_version', 'string', []);
-
-  const renderAnsi = (input: string | Uint8Array, renderOptions: RenderOptions = {}): RenderResult => {
-    const data = toUint8Array(input);
-    const ptr = module._malloc(data.length);
-    try {
-      module.HEAPU8.set(data, ptr);
-
-      const result = renderAnsiFn(
-        ptr,
-        data.length,
-        renderOptions.columns ?? 0,
-        renderOptions.icecolors ? 1 : 0,
-        renderOptions.dos ? 1 : 0,
-        renderOptions.scaleFactor ?? 0,
-      ) as number;
-
-      if (result !== 0) {
-        throw new Error(`ansilove_wasm_render_ansi failed with error code ${result}`);
-      }
-
-      const pngPtr = getPtr() as number;
-      const pngLength = getLen() as number;
-      if (!pngPtr || !pngLength) {
-        throw new Error('ansilove_wasm_get_png_length returned zero bytes.');
-      }
-
-      const png = module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
-      freePng();
-      return { png: new Uint8Array(png) };
-    } finally {
-      module._free(ptr);
-    }
-  };
-
-  const version = versionFn() as string;
-
-  return {
-    version,
-    renderAnsi,
-  };
-}
-
-export type { AnsiloveWasm, LoadOptions, RenderOptions, RenderResult } from './types.js';
diff --git a/npm/packages/libansilove-wasm/src/libansilove.d.ts b/npm/packages/libansilove-wasm/src/libansilove.d.ts
deleted file mode 100644
index 09c5df7..0000000
--- a/npm/packages/libansilove-wasm/src/libansilove.d.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-declare const factory: ((overrides?: Record<string, unknown>) => Promise<unknown>) & {
-  ready?: Promise<unknown>;
-};
-export default factory;
diff --git a/npm/packages/libansilove-wasm/src/types.ts b/npm/packages/libansilove-wasm/src/types.ts
deleted file mode 100644
index b33fdef..0000000
--- a/npm/packages/libansilove-wasm/src/types.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-export interface RenderOptions {
-  /** Override the number of columns (defaults to ANSI metadata). */
-  columns?: number;
-  /** Enable IceColor behavior. */
-  icecolors?: boolean;
-  /** Apply DOS aspect correction. */
-  dos?: boolean;
-  /** Scale factor multiplier (0 keeps original size). */
-  scaleFactor?: number;
-}
-
-export interface LoadOptions {
-  /**
-   * Directory that contains `libansilove.wasm`. Defaults to the package `dist` folder.
-   */
-  wasmDir?: string;
-  /**
-   * Optional overrides passed through to the underlying Emscripten module factory.
-   */
-  moduleOverrides?: Record<string, unknown>;
-}
-
-export interface RenderResult {
-  /** Raw PNG bytes rendered by libansilove. */
-  png: Uint8Array;
-}
-
-export interface AnsiloveWasm {
-  /** libansilove semantic version string. */
-  version: string;
-  /**
-   * Render an ANSI input (string or bytes) into a PNG image.
-   */
-  renderAnsi(input: string | Uint8Array, options?: RenderOptions): RenderResult;
-}
diff --git a/npm/packages/libansilove-wasm/test/render.test.ts b/npm/packages/libansilove-wasm/test/render.test.ts
deleted file mode 100644
index e04904c..0000000
--- a/npm/packages/libansilove-wasm/test/render.test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { load } from '../dist/index.js';
-import { strict as assert } from 'node:assert';
-
-async function main() {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
-  const wasmDir = path.resolve(__dirname, '..', 'dist');
-
-  const wasm = await load({ wasmDir });
-  assert.match(wasm.version, /^\d+\.\d+\.\d+$/, 'Version should be semver');
-
-  const result = wasm.renderAnsi('Hello from libansilove!\r\n');
-  assert.ok(result.png.byteLength > 16, 'PNG output should be non-empty');
-  assert.equal(result.png[0], 0x89, 'PNG signature should start with 0x89');
-  assert.equal(result.png[1], 0x50, 'PNG signature should include P');
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
diff --git a/npm/packages/libansilove-wasm/tsconfig.json b/npm/packages/libansilove-wasm/tsconfig.json
deleted file mode 100644
index 00a8325..0000000
--- a/npm/packages/libansilove-wasm/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2020", "DOM"],
-    "declaration": true,
-    "declarationDir": "dist",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*"]
-}
diff --git a/npm/packages/libansilove-wasm/tsconfig.test.json b/npm/packages/libansilove-wasm/tsconfig.test.json
deleted file mode 100644
index ad2c2b6..0000000
--- a/npm/packages/libansilove-wasm/tsconfig.test.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext"
-  },
-  "include": ["src/**/*", "test/**/*"]
-}
diff --git a/npm/packages/libansilove/.gitignore b/npm/packages/libansilove/.gitignore
index a14702c..f782e46 100644
--- a/npm/packages/libansilove/.gitignore
+++ b/npm/packages/libansilove/.gitignore
@@ -4,6 +4,8 @@ node_modules
 # output
 out
 dist
+generated/
+!generated/README.md
 *.tgz
 
 # code coverage
diff --git a/npm/packages/libansilove/scripts/build-wasm.bun.ts b/npm/packages/libansilove/scripts/build-wasm.bun.ts
index 33ec408..8a4ec91 100644
--- a/npm/packages/libansilove/scripts/build-wasm.bun.ts
+++ b/npm/packages/libansilove/scripts/build-wasm.bun.ts
@@ -1,62 +1,62 @@
 #!/usr/bin/env bun
-import { rm, mkdir, access, copyFile } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
-import { resolve, dirname, join, basename } from "node:path";
+import { access, copyFile, mkdir, rm } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const exitWith = (message: string, code = 1) => {
-  console.error(message);
-  process.exit(code);
+	console.error(message);
+	process.exit(code);
 };
 
 const requireCommand = (cmd: string, hint: string, code: number) => {
-  if (!Bun.which(cmd)) {
-    exitWith(`error: ${cmd} is required (${hint}).`, code);
-  }
+	if (!Bun.which(cmd)) {
+		exitWith(`error: ${cmd} is required (${hint}).`, code);
+	}
 };
 
 const ensureFile = async (path: string) => {
-  try {
-    await access(path, fsConstants.F_OK);
-  } catch {
-    exitWith(`error: missing expected artifact ${path}`, 4);
-  }
+	try {
+		await access(path, fsConstants.F_OK);
+	} catch {
+		exitWith(`error: missing expected artifact ${path}`, 4);
+	}
 };
 
 const main = async () => {
-  const scriptDir = dirname(fileURLToPath(import.meta.url));
-  const pkgDir = resolve(scriptDir, "..");
-  const rootDir = resolve(pkgDir, "../../..");
-  const buildDir = resolve(pkgDir, ".wasm-build");
-  const artifactsDir = resolve(buildDir, "wasm");
-  const outDir = resolve(pkgDir, "generated");
+	const scriptDir = dirname(fileURLToPath(import.meta.url));
+	const pkgDir = resolve(scriptDir, "..");
+	const rootDir = resolve(pkgDir, "../../..");
+	const buildDir = resolve(pkgDir, ".wasm-build");
+	const artifactsDir = resolve(buildDir, "wasm");
+	const outDir = resolve(pkgDir, "generated");
 
-  requireCommand("emcmake", "enter via 'nix develop' or activate emsdk", 2);
-  requireCommand("cmake", "ensure cmake is on PATH", 3);
+	requireCommand("emcmake", "enter via 'nix develop' or activate emsdk", 2);
+	requireCommand("cmake", "ensure cmake is on PATH", 3);
 
-  await rm(buildDir, { recursive: true, force: true });
-  await mkdir(buildDir, { recursive: true });
-  await mkdir(outDir, { recursive: true });
+	await rm(buildDir, { recursive: true, force: true });
+	await mkdir(buildDir, { recursive: true });
+	await mkdir(outDir, { recursive: true });
 
-  const { $ } = Bun;
+	const { $ } = Bun;
 
-  await $`emcmake cmake -S ${rootDir} -B ${buildDir} -DANSILOVE_BUILD_WASM=ON`;
-  await $`cmake --build ${buildDir} --target ansilove_wasm_browser ansilove_wasm_node`;
+	await $`emcmake cmake -S ${rootDir} -B ${buildDir} -DANSILOVE_BUILD_WASM=ON`;
+	await $`cmake --build ${buildDir} --target ansilove_wasm_browser ansilove_wasm_node`;
 
-  const artifacts = [
-    join(artifactsDir, "libansilove.browser.mjs"),
-    join(artifactsDir, "libansilove.browser.wasm"),
-    join(artifactsDir, "libansilove.node.cjs"),
-    join(artifactsDir, "libansilove.node.wasm"),
-  ];
+	const artifacts = [
+		join(artifactsDir, "libansilove.browser.mjs"),
+		join(artifactsDir, "libansilove.browser.wasm"),
+		join(artifactsDir, "libansilove.node.mjs"),
+		join(artifactsDir, "libansilove.node.wasm"),
+	];
 
-  await Promise.all(artifacts.map((path) => ensureFile(path)));
+	await Promise.all(artifacts.map((path) => ensureFile(path)));
 
-  await Promise.all(
-    artifacts.map((src) => copyFile(src, join(outDir, basename(src))))
-  );
+	await Promise.all(
+		artifacts.map((src) => copyFile(src, join(outDir, basename(src)))),
+	);
 
-  console.error(`WASM artifacts copied to ${outDir}`);
+	console.error(`WASM artifacts copied to ${outDir}`);
 };
 
 await main();
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
index 07d507c..d9c8bde 100755
--- a/scripts/test-wasm-node.js
+++ b/scripts/test-wasm-node.js
@@ -16,7 +16,7 @@ async function loadFactory(factoryPath) {
 async function main() {
   const buildDir = path.resolve(process.argv[2] || 'build-wasm/wasm');
   const outputPath = path.resolve(process.argv[3] || path.join(buildDir, 'test-output.png'));
-  const factoryPath = path.resolve(process.argv[4] || path.join(buildDir, 'libansilove.node.cjs'));
+  const factoryPath = path.resolve(process.argv[4] || path.join(buildDir, 'libansilove.node.mjs'));
   const sampleText = process.argv[5] || 'Hello from libansilove!\r\n';
 
   if (!fs.existsSync(factoryPath)) {
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
index 43cddce..5a52132 100755
--- a/scripts/test-wasm.sh
+++ b/scripts/test-wasm.sh
@@ -15,7 +15,7 @@ cmake --build "$build_dir" --target ansilove_wasm_browser ansilove_wasm_node
 
 browser_js="$artifacts_dir/libansilove.browser.mjs"
 browser_wasm="$artifacts_dir/libansilove.browser.wasm"
-node_js="$artifacts_dir/libansilove.node.cjs"
+node_js="$artifacts_dir/libansilove.node.mjs"
 node_wasm="$artifacts_dir/libansilove.node.wasm"
 
 if [ ! -f "$browser_js" ] || [ ! -f "$browser_wasm" ]; then

From cd6568d2501833b2a34c7e0678ec750d7d02c8c7 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 23:26:45 -0400
Subject: [PATCH 16/26] Refactor Wasm build to use Bun scripts

This commit refactors the WebAssembly build process to use Bun scripts. The `CMakeLists.txt` file has been updated to remove the Emscripten
build logic, and the `npm/packages/libansilove` directory now contains the necessary Bun scripts and configurations for building and
packaging the WebAssembly artifacts.

The following changes were made: - Updated `AGENTS.md` and `README.md` to reflect the new build process. - Removed Emscripten-specific CMake
options and targets. - Created new Bun scripts in `npm/packages/libansilove` for building, preparing the package, and verifying the output.
- Updated `scripts/test-wasm.sh` to use Bun and the new build scripts. - Updated `scripts/test-wasm-node.js` to point to the new output
directory.
---
 AGENTS.md                                     |  20 ++-
 CMakeLists.txt                                |  52 -------
 PR_DESCRIPTION.md                             |   6 +-
 README.md                                     |  44 +++---
 npm/bun.lockb                                 | Bin 0 -> 3454 bytes
 npm/packages/libansilove/README.md            |  71 +++++++++-
 npm/packages/libansilove/generated/README.md  |   1 -
 npm/packages/libansilove/index.ts             |   1 -
 npm/packages/libansilove/package.json         |  68 ++++++++-
 .../libansilove/scripts/build-wasm.bun.ts     | 132 ++++++++++++++----
 .../libansilove/scripts/prepare-package.ts    |  56 ++++++++
 .../libansilove/scripts/verify-dist.ts        |  14 ++
 npm/packages/libansilove/src/bindings.ts      |  58 ++++++++
 npm/packages/libansilove/src/browser.ts       |  13 ++
 npm/packages/libansilove/src/index.ts         |  13 ++
 npm/packages/libansilove/src/node.ts          |  13 ++
 npm/packages/libansilove/src/types.ts         |  41 ++++++
 .../libansilove/src/wasm-modules.d.ts         |  11 ++
 .../src/wasm/libansilove.browser.mjs.d.ts     |   3 +
 .../src/wasm/libansilove.node.mjs.d.ts        |   3 +
 npm/packages/libansilove/tsconfig.build.json  |  17 +++
 npm/packages/libansilove/tsconfig.json        |  25 ++--
 scripts/test-wasm-node.js                     |   2 +-
 scripts/test-wasm.sh                          |  15 +-
 24 files changed, 521 insertions(+), 158 deletions(-)
 create mode 100755 npm/bun.lockb
 delete mode 100644 npm/packages/libansilove/generated/README.md
 delete mode 100644 npm/packages/libansilove/index.ts
 create mode 100644 npm/packages/libansilove/scripts/prepare-package.ts
 create mode 100644 npm/packages/libansilove/scripts/verify-dist.ts
 create mode 100644 npm/packages/libansilove/src/bindings.ts
 create mode 100644 npm/packages/libansilove/src/browser.ts
 create mode 100644 npm/packages/libansilove/src/index.ts
 create mode 100644 npm/packages/libansilove/src/node.ts
 create mode 100644 npm/packages/libansilove/src/types.ts
 create mode 100644 npm/packages/libansilove/src/wasm-modules.d.ts
 create mode 100644 npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
 create mode 100644 npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
 create mode 100644 npm/packages/libansilove/tsconfig.build.json

diff --git a/AGENTS.md b/AGENTS.md
index 24d22c1..bc6f279 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -5,21 +5,19 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 
 ## Build, Test, and Development Commands
 - `cmake -S . -B build -DCMAKE_BUILD_TYPE=Release`: configure the project after installing GD headers and libs.
-- `cmake --build build`: compile shared and static variants of the library.
-- `cmake --build build --target install`: install artifacts into the default prefix.
+- `cmake --build build --parallel`: compile shared and static variants of the library.
+- `cmake --build build --target install --parallel`: install artifacts into the default prefix.
 - `cmake -S fuzz -B fuzz-build`: set up clang-based libFuzzer targets.
-- `cmake --build fuzz-build`: produce fuzz binaries such as `ansi` and `tundra`.
+- `cmake --build fuzz-build --parallel`: produce fuzz binaries such as `ansi` and `tundra`.
 - `nix develop`: enter the flake-backed dev shell with clang, pkg-config, GD, and platform-appropriate debugger preinstalled.
 - `nix build`: build the default flake package (shared/static library) without touching your host toolchain.
 - `nix flake check`: validate the flake packages and dev shell evaluate cleanly across supported systems.
-- `nix develop --command bash scripts/test-wasm.sh`: configure via `emcmake`, build the wasm wrapper, and assert the JS/WASM artefacts exist.
-- `node scripts/test-wasm-node.js build-wasm/wasm`: rerun the wasm smoke test via Node (outputs `test-output.png`).
+- `nix develop --command bash scripts/test-wasm.sh`: run the Bun-driven `emcc` build and assert the JS/WASM artefacts exist.
 - `scripts/test-wasm-browser.sh`: launch a local server and exercise the Safari smoke test end-to-end.
 - `python3 -m http.server 8765 --directory example/wasm`: manual alternative to serve the browser demo (after running `scripts/test-wasm.sh`).
-- `cd npm/libansilove-wasm && npm install && npm run build`: compile the TypeScript wrapper and stage artefacts for publishing.
-- `cd npm/libansilove-wasm && npm test && npm run verify`: run the Node smoke test and distribution checks before publishing.
-- `cd npm/libansilove-wasm && npm run sync-version`: align the npm package version with `ANSILOVE_VERSION` (use `--bump-patch` to increment the patch component).
-- `cd npm/libansilove-wasm && npm run build && npm test`: build the package and run the Node smoke test (see `examples/node-render.mjs`).
+- `cd npm/packages/libansilove && bun install && bun run scripts/build-wasm.bun.ts`: rebuild the npm artefacts.
+- `node scripts/test-wasm-node.js npm/packages/libansilove/generated`: rerun the Node smoke test on an existing build.
+- `npm version patch` within `npm/packages/libansilove` (once publishing is wired) to bump metadata in step with `ANSILOVE_VERSION`.
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
@@ -33,8 +31,8 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - For fuzzing, execute `./fuzz-build/ansi -runs=10000 corpus/` (seed the corpus with representative art files). Investigate sanitizer reports immediately and add reproducer samples.
 - Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
 - If you touch the flake, rerun `nix build` and `nix flake check` and commit the updated `flake.lock` (keep changes reproducible).
-- For the wasm target, keep `scripts/test-wasm.sh` passing under `nix develop`; it wipes `build-wasm/` on each invocation.
-- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper scripts copy `libansilove.{js,wasm}` into `example/wasm/` so you can smoke-test via the provided browser script or a manual `python3 -m http.server` session.
+- For the wasm target, keep `scripts/test-wasm.sh` passing under `nix develop`; it rebuilds the Bun-driven artefacts via `emcc` every run.
+- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper scripts copy `libansilove.browser.{mjs,wasm}` into `example/wasm/` so you can smoke-test via the provided browser script or a manual `python3 -m http.server` session.
 
 ## Commit & Pull Request Guidelines
 - Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 660a369..80a15f3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,8 +14,6 @@ project(ansilove C)
 include(CheckFunctionExists)
 include(GNUInstallDirs)
 
-option(ANSILOVE_BUILD_WASM "Build the WebAssembly wrapper" OFF)
-
 set(IS_EMSCRIPTEN OFF)
 if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
   set(IS_EMSCRIPTEN ON)
@@ -78,53 +76,3 @@ if(NOT IS_EMSCRIPTEN)
   install(FILES man/ansilove_tundra.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
   install(FILES man/ansilove_xbin.3 DESTINATION ${CMAKE_INSTALL_MANDIR}/man3/)
 endif()
-
-if(ANSILOVE_BUILD_WASM)
-  if(NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
-    message(FATAL_ERROR "ANSILOVE_BUILD_WASM requires the Emscripten toolchain (use emcmake).")
-  endif()
-
-  add_library(objlib_wasm OBJECT ${SRC} ${LOADERS})
-  target_include_directories(objlib_wasm PRIVATE include src compat wasm)
-  target_compile_definitions(objlib_wasm PRIVATE ANSILOVE_WASM)
-
-  add_executable(ansilove_wasm_browser
-    wasm/ansilove_wasm.c
-    wasm/minigd.c
-    $<TARGET_OBJECTS:objlib_wasm>)
-  target_include_directories(ansilove_wasm_browser PRIVATE include src compat wasm)
-  target_compile_definitions(ansilove_wasm_browser PRIVATE ANSILOVE_WASM)
-  set_target_properties(ansilove_wasm_browser PROPERTIES
-    OUTPUT_NAME "libansilove.browser"
-    SUFFIX ".mjs"
-    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
-  target_link_options(ansilove_wasm_browser PRIVATE
-    "-sMODULARIZE=1"
-    "-sEXPORT_NAME=LibansiloveBrowser"
-    "-sEXPORT_ES6=1"
-    "-sUSE_ES6_IMPORT_META=1"
-    "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
-    "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
-    "-sENVIRONMENT=web,worker"
-    "-sALLOW_MEMORY_GROWTH=1")
-
-  add_executable(ansilove_wasm_node
-    wasm/ansilove_wasm.c
-    wasm/minigd.c
-    $<TARGET_OBJECTS:objlib_wasm>)
-  target_include_directories(ansilove_wasm_node PRIVATE include src compat wasm)
-  target_compile_definitions(ansilove_wasm_node PRIVATE ANSILOVE_WASM)
-  set_target_properties(ansilove_wasm_node PROPERTIES
-    OUTPUT_NAME "libansilove.node"
-    SUFFIX ".mjs"
-    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/wasm")
-  target_link_options(ansilove_wasm_node PRIVATE
-    "-sMODULARIZE=1"
-    "-sEXPORT_NAME=LibansiloveNode"
-    "-sEXPORT_ES6=1"
-    "-sUSE_ES6_IMPORT_META=1"
-    "-sEXPORTED_FUNCTIONS=['_ansilove_wasm_version','_ansilove_wasm_render_ansi','_ansilove_wasm_get_png_ptr','_ansilove_wasm_get_png_length','_ansilove_wasm_free_png','_malloc','_free']"
-    "-sEXPORTED_RUNTIME_METHODS=['cwrap','ccall','UTF8ToString']"
-    "-sENVIRONMENT=node"
-    "-sALLOW_MEMORY_GROWTH=1")
-endif()
diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md
index 2614cf2..72886bf 100644
--- a/PR_DESCRIPTION.md
+++ b/PR_DESCRIPTION.md
@@ -4,12 +4,12 @@
 - keep the dev shell ergonomic by wiring in Emscripten alongside cmake/clang and documenting the workflow for future agents
 - teach the build to emit `libansilove.{js,wasm}` through a minimal GD-compatible raster backend so the existing loaders work in a browser
 - expose a wasm facade (`ansilove_wasm_render_ansi` etc.), ship a Node smoke test, and serve a demo HTML page that renders ANSI art in Safari
-- scaffold an `@effect-native/libansilove-wasm` package with TypeScript/ESM bindings (Node + browser), reproducible build scripts, and automated version syncing/bumping ready for publication, plus Bun demo integration
+- scaffold an `@effect-native/libansilove` package with TypeScript/ESM bindings (Node + browser), reproducible build scripts, and automated version syncing/bumping ready for publication, plus Bun demo integration
 - ignore transient Nix/wasm artefacts and refresh the README/AGENTS notes with the exact commands for building, testing, and verifying in Safari
 
 ## Testing
 - nix flake check
 - nix develop --command bash scripts/test-wasm.sh
-- node scripts/test-wasm-node.js build-wasm/wasm
+- node scripts/test-wasm-node.js npm/packages/libansilove/generated
 - scripts/test-wasm-browser.sh (Safari with "Allow JavaScript from Apple Events")
-- cd npm/libansilove-wasm && npm run build && npm test && npm run verify
+- cd npm/packages/libansilove && bun run scripts/build-wasm.bun.ts && node ../../scripts/test-wasm-node.js npm/packages/libansilove/generated
diff --git a/README.md b/README.md
index 4b7c79d..38f0bb2 100644
--- a/README.md
+++ b/README.md
@@ -37,9 +37,11 @@ environment to ensure Emscripten is available:
 
 	nix develop --command bash scripts/test-wasm.sh
 
-The script configures the project via `emcmake`, produces
-`build-wasm/wasm/libansilove.browser.{mjs,wasm}` and
-`build-wasm/wasm/libansilove.node.{mjs,wasm}`, and exports
+The helper script drives the Bun-based build harness
+(`npm/packages/libansilove/scripts/build-wasm.bun.ts`), which shells out to
+`emcc` and produces
+`npm/packages/libansilove/generated/libansilove.browser.{mjs,wasm}` and
+`npm/packages/libansilove/generated/libansilove.node.{mjs,wasm}` while exporting
 `ansilove_wasm_version()` for browser consumers. The browser bundle is emitted
 as an ES module factory (`-sMODULARIZE=1 -sEXPORT_ES6=1`), so import the default
 export and await the resulting instance before calling into the runtime:
@@ -51,10 +53,9 @@ const Module = await createLibansilove({ locateFile: (path) => path });
 const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
 ```
 
-The helper also runs a Node-based
-smoke test that renders a sample ANSI string to
-`build-wasm/wasm/test-output.png` and copies the runtime artefacts into
-`example/wasm/`.
+The helper also runs a Node-based smoke test that renders a sample ANSI string
+to `npm/packages/libansilove/generated/test-output.png` and copies the runtime
+artefacts into `example/wasm/`.
 
 Serve the demo page with, for example,
 
@@ -66,35 +67,26 @@ the PNG preview rendered via WebAssembly.
 
 Additional helpers:
 
-- `node scripts/test-wasm-node.js build-wasm/wasm` reruns the Node smoke test on
-  an existing wasm build and refreshes `test-output.png`.
+- `node scripts/test-wasm-node.js npm/packages/libansilove/generated` reruns the
+  Node smoke test on an existing wasm build and refreshes `test-output.png`.
 - `scripts/test-wasm-browser.sh` starts a local server and drives Safari via
   JXA, ensuring the demo page renders successfully (requires the Safari
   automation toggle mentioned above).
 
 # npm package
 
-The `npm/packages/libansilove-wasm` directory contains a TypeScript wrapper and
-packaging scripts for distributing the WebAssembly build on npm:
+The `npm/packages/libansilove` workspace hosts the Bun-based tooling that
+drives the WebAssembly build and will eventually publish the generated
+artefacts to npm. From within that directory you can run:
 
 ```
-nix develop --command bash scripts/test-wasm.sh
-cd npm/libansilove-wasm
-npm install
-npm run build
-npm test
-npm run verify
+bun install
+bun run scripts/build-wasm.bun.ts
 ```
 
-- Node usage: `import { load } from 'libansilove';` (see
-  `npm/packages/libansilove-wasm/examples/node-render.mjs`).
-- Browser usage: `import { loadBrowser } from 'libansilove/browser';` which
-  auto-resolves the wasm asset via `import.meta.url`.
-
-`npm run sync-version` keeps the package version aligned with
-`include/ansilove.h`. Use `npm run version:patch` to bump the patch level when
-preparing a publication. The `prepack` hook rebuilds and verifies artefacts to
-ensure the tarball is reproducible.
+The build script writes outputs to `npm/packages/libansilove/generated/`, which
+you can consume from Node (see `scripts/test-wasm-node.js`) or copy into the
+browser demo under `example/wasm/`.
 
 # Packages
 
diff --git a/npm/bun.lockb b/npm/bun.lockb
new file mode 100755
index 0000000000000000000000000000000000000000..7dcc48d4db563a538a70b2da2786dfb1df75b6ad
GIT binary patch
literal 3454
zcmd5;Yfuwc6yC%XF=(+0wxYE`gj$;2JP;)sD301X;}k21wkm1}o46XXWOsu+S_{5q
zss&$BeEk5eqt>EUX{*IjwTdErXdRrPC><3Qq-ZJlD)!uDFKnkHFxnrSnLFp+&H282
z&b?<hUr?aN$#a@S#;&35sj5V$T?vD<vE~I9#zvDCmP<AXWU5vvCkW!9e?ibW$D`7K
z@gtliIYYKuZm-(5&o$_4L(9RQ)xV9eZs-j`VBQ}0AD<;YpN9k7YafEh@`srcd_4GG
z;0wV6S(cgSh4d7f*bHkF_kqmw9Omx$#Xg3ZVauauo%MR-+ezB&rp$Wl`IY_Zh6eZt
zzmy#mS8iw)di$iW%gfWuSRHaW($I@F{&0Ir{?Q%5S?V{J(TPC!T!u~s*=sOHLVk!3
zJsSX{D~9p2A$ZJl;EP0jfAA=WJ}|msc>g*GM)~&ukMPKM#V|e)KoNj{1wb#rz|TA5
zz;QI-#{#}50K_Kh4C?+J;|~Jf2zazN^iP-fM<j>?4WMw>jpm34t-W9%LmsVBe#o##
z^XJ32`nDqC|I>g^MtFFo)QW4qXZP(<Uv~BRxnk#PzcmY{R|ctambuQvuh?H!qTZf)
zGe2X(Zjy{C9hO?)uz4#^B|N@b(|_EPOLD`)gd?HR5?)j@HpL3BtfS{<6*pUNx$e|V
z9(%y`a$ZhIMPAt)cKD*lnd{!>D|x<l)n7a6#w`gL;5RodvXl+x-rKmOhDq4|mN2@n
zgjd>kilym;;#zi(ad_4KIdE-FY^WtP^2-hDHr_K%E6zN2{H}4!kfG(oaPNDkHzdBl
z_4}C9*S@F=n(t@{`02C85?S<xRT5qWP8Pf(Y-Vn5*@vIYj~~)DsVkHB_VcAS?FwMk
z5rh32Vr!M_w@eNhRdzi*zT*1T!UyN0)K7vA3|<t|@C)_Tp~YK^db}gyMSX%z;r~g}
z#Wjslf1kaaGNT}{*<rZpkWr02HrGv@Y%kxRd*a;j9S`=D{CY{_t6oUoay_p9^Z@N(
zjlq>`hMn4bqhB8hFYY_UtysJypDR#QTJ(mEbJ(?4kNk01Wyo4DqiP49xKbZ?o)nfv
zYARe!6YpP}Lui{em;C<mjp(^QRvkL#-CQ}oHv1z9ue5I!z2@=>%Bt3a!sV~0T&ypB
z*Jsm&;(I5<%XG2MSyg_6lVYYV$j=B2sj3U!xoyhy>TP$1=B!@3cjA`fhga@G6Ey*E
zcQSm(*gs2d-K?Z%DWO|pio}2XlcHA|dCp8Rc3v>qY!sFo)Kre9qf~mWif1xt)}mI8
zP?>Cu)y`T#9AImG;xV*F{oE*W_C_CmFs0EMrjG*XQ%KMqqwg2`)}UTN?;3iKBSiev
zF7TjzF%QB@xmJq!C^2WHai)G`f-?dN8`+kV?%#!BJ%e>gU)k(%pasLq2rC?Kxy>Zd
zyg(3GD`Cwem+2@yrPmW}Y6+_zxh&K}Mihcax(e$f*hgn@|Av(oR!nl)>@Z480UOp_
zSUbsOi$+m8J*6d9iWQz|t5kZcJe{0MbJT=1f#&QcTb#f#c59SM*M0~QZHFN6W_K3f
zJ@VVht<UvCf)qXTtu8P&yz2Ny;CY$@wuB3+>{!dB`@7)qQ5{Po!pmi8FSgznGq@p&
z2j~GfZ{5?5o3Js7COgmA*i;(nOWw>eDMGY+ssRB!PY_c0(Had$TNz&9(kXjN@_e3R
zIjg2UNJFAf(sSsPV9h`)H$?~VwiprZj+bzV^maCh7N;C-G7B9rO2dHE9Zu>Dl#bGc
zp{zQ9igykuaYlv#tTU7(ML?oVN&N^a9C{CSbJ~*_Gt=oYNW*|cx+Fc#<vvh%7kF;I
XgEHE05UAQ0WH@E;BqcU~w{!mhoOq5i

literal 0
HcmV?d00001

diff --git a/npm/packages/libansilove/README.md b/npm/packages/libansilove/README.md
index 23af782..82708b0 100644
--- a/npm/packages/libansilove/README.md
+++ b/npm/packages/libansilove/README.md
@@ -1,15 +1,76 @@
 # libansilove
 
-To install dependencies:
+> Universal WebAssembly bindings for [libansilove](https://www.ansilove.org/).
+
+## Install
 
 ```bash
-bun install
+npm install libansilove
+# or
+pnpm add libansilove
+# or
+bun add libansilove
+```
+
+## Usage
+
+### Node.js / Bun
+
+```ts
+import { loadNode } from "libansilove";
+
+const lib = await loadNode();
+const { png } = lib.renderAnsi("Hello from libansilove!\r\n");
+console.log(`PNG size: ${png.byteLength} bytes`);
+```
+
+### Browser / Worker
+
+```ts
+import { loadBrowser } from "libansilove";
+
+const lib = await loadBrowser();
+const { png } = lib.renderAnsi("Hello from libansilove!\r\n");
+const blob = new Blob([png], { type: "image/png" });
+document.querySelector("img")!.src = URL.createObjectURL(blob);
 ```
 
-To run:
+Both loaders accept an optional `locateFile` override if your bundler moves the
+`.wasm` payloads:
+
+```ts
+const lib = await loadBrowser({
+  locateFile: (path) => new URL(`/static/wasm/${path}`, window.location.href).toString(),
+});
+```
+
+## API
+
+- `loadNode(options?)` – returns an object with the Emscripten module instance,
+  the detected libansilove version, and a `renderAnsi()` helper that yields a
+  `Uint8Array` containing the PNG bytes.
+- `loadBrowser(options?)` – same contract as `loadNode` but tuned for browser,
+  worker, and Deno style environments.
+- `createBindings(module)` – wrap a raw Emscripten module if you are managing
+  instantiation yourself.
+
+See the generated TypeScript definitions in `dist/index.d.ts` for the full type
+surface.
+
+## Building
 
 ```bash
-bun run index.ts
+bun install
+bun run build
+bun run verify
 ```
 
-This project was created using `bun init` in bun v1.2.22. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+The build performs three steps:
+
+1. Compile libansilove to WebAssembly via Emscripten (`build:wasm`).
+2. Emit typed JavaScript entry points (`build:ts`).
+3. Copy runtime artefacts and metadata into `dist/` (`prepare:package`).
+
+`bun run verify` loads the packaged output and renders a short ANSI snippet to
+confirm everything is wired correctly. Use `npm pack` (after running `bun run
+build`) to inspect the final tarball.
diff --git a/npm/packages/libansilove/generated/README.md b/npm/packages/libansilove/generated/README.md
deleted file mode 100644
index 12635f8..0000000
--- a/npm/packages/libansilove/generated/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Emscripten output
diff --git a/npm/packages/libansilove/index.ts b/npm/packages/libansilove/index.ts
deleted file mode 100644
index f67b2c6..0000000
--- a/npm/packages/libansilove/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-console.log("Hello via Bun!");
\ No newline at end of file
diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
index b493373..97363ae 100644
--- a/npm/packages/libansilove/package.json
+++ b/npm/packages/libansilove/package.json
@@ -1,14 +1,70 @@
 {
   "name": "libansilove",
-  "module": "index.ts",
+  "version": "1.4.2",
+  "description": "Universal WebAssembly bindings for libansilove.",
+  "license": "BSD-2-Clause",
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./wasm/browser": {
+      "default": "./dist/wasm/libansilove.browser.mjs"
+    },
+    "./wasm/node": {
+      "default": "./dist/wasm/libansilove.node.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/"
+  ],
   "scripts": {
-    "build": "bun run scripts/build-wasm.bun.ts"
+    "clean": "rm -rf dist",
+    "build:wasm": "bun run scripts/build-wasm.bun.ts",
+    "build:ts": "bunx tsc -p tsconfig.build.json",
+    "prepare:package": "bun run scripts/prepare-package.ts",
+    "build": "bun run clean && bun run build:wasm && bun run build:ts && bun run prepare:package",
+    "check": "bunx tsc --noEmit",
+    "verify": "bun run scripts/verify-dist.ts",
+    "test": "node ../../scripts/test-wasm-node.js npm/packages/libansilove/generated",
+    "prepare": "bun run build"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "ansi",
+    "ansilove",
+    "artscene",
+    "png",
+    "wasm",
+    "emscripten"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ansilove/libansilove.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ansilove/libansilove/issues"
+  },
+  "homepage": "https://www.ansilove.org/",
+  "author": "ANSILOVE Project",
+  "engines": {
+    "node": ">=18"
   },
-  "peerDependencies": {
-    "typescript": "^5"
-  }
+  "sideEffects": false
 }
diff --git a/npm/packages/libansilove/scripts/build-wasm.bun.ts b/npm/packages/libansilove/scripts/build-wasm.bun.ts
index 8a4ec91..0603b31 100644
--- a/npm/packages/libansilove/scripts/build-wasm.bun.ts
+++ b/npm/packages/libansilove/scripts/build-wasm.bun.ts
@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { constants as fsConstants } from "node:fs";
-import { access, copyFile, mkdir, rm } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { access, mkdir, readdir, rename, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const exitWith = (message: string, code = 1) => {
@@ -15,48 +15,122 @@ const requireCommand = (cmd: string, hint: string, code: number) => {
 	}
 };
 
-const ensureFile = async (path: string) => {
-	try {
-		await access(path, fsConstants.F_OK);
-	} catch {
-		exitWith(`error: missing expected artifact ${path}`, 4);
-	}
-};
-
 const main = async () => {
 	const scriptDir = dirname(fileURLToPath(import.meta.url));
 	const pkgDir = resolve(scriptDir, "..");
 	const rootDir = resolve(pkgDir, "../../..");
-	const buildDir = resolve(pkgDir, ".wasm-build");
-	const artifactsDir = resolve(buildDir, "wasm");
 	const outDir = resolve(pkgDir, "generated");
 
-	requireCommand("emcmake", "enter via 'nix develop' or activate emsdk", 2);
-	requireCommand("cmake", "ensure cmake is on PATH", 3);
+	requireCommand("emcc", "enter via 'nix develop' or activate emsdk", 2);
 
-	await rm(buildDir, { recursive: true, force: true });
-	await mkdir(buildDir, { recursive: true });
 	await mkdir(outDir, { recursive: true });
+	const existing = await readdir(outDir).catch(() => []);
+	await Promise.all(
+		existing
+			.filter((entry) => entry !== "README.md")
+			.map((entry) =>
+				rm(join(outDir, entry), { recursive: true, force: true }).catch(
+					() => undefined,
+				),
+			),
+	);
 
-	const { $ } = Bun;
+	const includeFlags = ["include", "src", "compat", "wasm"].map(
+		(dir) => `-I${resolve(rootDir, dir)}`,
+	);
 
-	await $`emcmake cmake -S ${rootDir} -B ${buildDir} -DANSILOVE_BUILD_WASM=ON`;
-	await $`cmake --build ${buildDir} --target ansilove_wasm_browser ansilove_wasm_node`;
+	const commonSources = [
+		"src/clean.c",
+		"src/drawchar.c",
+		"src/fonts.c",
+		"src/error.c",
+		"src/loadfile.c",
+		"src/init.c",
+		"src/output.c",
+		"src/savefile.c",
+		"src/loaders/ansi.c",
+		"src/loaders/artworx.c",
+		"src/loaders/binary.c",
+		"src/loaders/icedraw.c",
+		"src/loaders/pcboard.c",
+		"src/loaders/tundra.c",
+		"src/loaders/xbin.c",
+		"compat/strtonum.c",
+		"compat/reallocarray.c",
+		"wasm/ansilove_wasm.c",
+		"wasm/minigd.c",
+	].map((file) => resolve(rootDir, file));
 
-	const artifacts = [
-		join(artifactsDir, "libansilove.browser.mjs"),
-		join(artifactsDir, "libansilove.browser.wasm"),
-		join(artifactsDir, "libansilove.node.mjs"),
-		join(artifactsDir, "libansilove.node.wasm"),
+	const exportedFunctions = [
+		"_ansilove_wasm_version",
+		"_ansilove_wasm_render_ansi",
+		"_ansilove_wasm_get_png_ptr",
+		"_ansilove_wasm_get_png_length",
+		"_ansilove_wasm_free_png",
+		"_malloc",
+		"_free",
 	];
 
-	await Promise.all(artifacts.map((path) => ensureFile(path)));
+	const exportedRuntimeMethods = ["cwrap", "ccall", "UTF8ToString"];
 
-	await Promise.all(
-		artifacts.map((src) => copyFile(src, join(outDir, basename(src)))),
-	);
+	const makeListFlag = (values: string[]) =>
+		`[${values.map((value) => `'${value}'`).join(",")}]`;
+
+	const buildTarget = async (options: {
+		outputName: string;
+		exportName: string;
+		environment: string;
+	}) => {
+		const { outputName, exportName, environment } = options;
+		const outputPath = join(outDir, outputName);
+		const args = [
+			...includeFlags,
+			"-O3",
+			"-DANSILOVE_WASM",
+			"-sMODULARIZE=1",
+			"-sEXPORT_ES6=1",
+			"-sUSE_ES6_IMPORT_META=1",
+			`-sEXPORT_NAME=${exportName}`,
+			`-sEXPORTED_FUNCTIONS=${makeListFlag(exportedFunctions)}`,
+			`-sEXPORTED_RUNTIME_METHODS=${makeListFlag(exportedRuntimeMethods)}`,
+			"-sALLOW_MEMORY_GROWTH=1",
+			`-sENVIRONMENT=${environment}`,
+			...commonSources,
+			"-o",
+			outputPath,
+		];
+
+		const proc = Bun.spawn(["emcc", ...args], {
+			stdout: "inherit",
+			stderr: "inherit",
+		});
+		const code = await proc.exited;
+		if (code !== 0) {
+			exitWith(
+				`error: emcc exited with code ${code}`,
+				typeof code === "number" ? code : 1,
+			);
+		}
+
+		const wasmPath = outputPath.replace(/\.mjs$/, ".wasm");
+
+		try {
+			await Promise.all([
+				access(outputPath, fsConstants.F_OK),
+				access(wasmPath, fsConstants.F_OK),
+			]);
+		} catch {
+			exitWith(`error: expected artifacts ${outputPath} and ${wasmPath}`, 4);
+		}
+	};
+
+	await buildTarget({
+		outputName: "libansilove.js",
+		exportName: "libansilove",
+		environment: "web,webview,worker,node,shell",
+	});
 
-	console.error(`WASM artifacts copied to ${outDir}`);
+	console.error(`WASM artifacts written to ${outDir}`);
 };
 
 await main();
diff --git a/npm/packages/libansilove/scripts/prepare-package.ts b/npm/packages/libansilove/scripts/prepare-package.ts
new file mode 100644
index 0000000..8074f29
--- /dev/null
+++ b/npm/packages/libansilove/scripts/prepare-package.ts
@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+import { access, copyFile, mkdir, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const pkgDir = resolve(scriptDir, "..");
+const rootDir = resolve(pkgDir, "../../..");
+const distDir = resolve(pkgDir, "dist");
+const wasmDir = resolve(distDir, "wasm");
+const generatedDir = resolve(pkgDir, "generated");
+
+const REQUIRED_ARTIFACTS = [
+	"libansilove.browser.mjs",
+	"libansilove.browser.wasm",
+	"libansilove.node.mjs",
+	"libansilove.node.wasm",
+];
+
+async function ensureArtifacts() {
+	await Promise.all(
+		REQUIRED_ARTIFACTS.map(async (artifact) => {
+			const file = join(generatedDir, artifact);
+			try {
+				await access(file);
+			} catch {
+				throw new Error(`expected wasm artifact at ${file}; run build-wasm first`);
+			}
+		}),
+	);
+}
+
+async function copyAssets() {
+	await rm(wasmDir, { recursive: true, force: true });
+	await mkdir(wasmDir, { recursive: true });
+
+	await Promise.all(
+		REQUIRED_ARTIFACTS.map((artifact) =>
+			copyFile(join(generatedDir, artifact), join(wasmDir, artifact))
+		),
+	);
+
+	await rm(join(distDir, "LICENSE"), { force: true });
+	await rm(join(distDir, "README.md"), { force: true });
+	await copyFile(resolve(rootDir, "LICENSE"), join(distDir, "LICENSE"));
+	await copyFile(join(pkgDir, "README.md"), join(distDir, "README.md"));
+}
+
+async function main() {
+	await ensureArtifacts();
+	await mkdir(distDir, { recursive: true });
+	await copyAssets();
+	console.error(`Packaged artefacts staged in ${distDir}`);
+}
+
+await main();
diff --git a/npm/packages/libansilove/scripts/verify-dist.ts b/npm/packages/libansilove/scripts/verify-dist.ts
new file mode 100644
index 0000000..6075e1b
--- /dev/null
+++ b/npm/packages/libansilove/scripts/verify-dist.ts
@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+const moduleURL = new URL("../dist/index.js", import.meta.url).href;
+
+async function main() {
+	const mod = (await import(moduleURL)) as { loadNode: typeof import("../src/node").loadNode };
+	const bindings = await mod.loadNode();
+	const { png } = bindings.renderAnsi("Hello from libansilove!\r\n");
+	if (!png.byteLength) {
+		throw new Error("renderAnsi returned an empty buffer");
+	}
+	console.error(`Verified libansilove wasm ${bindings.version} (${png.byteLength} bytes)`);
+}
+
+await main();
diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
new file mode 100644
index 0000000..729dcda
--- /dev/null
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -0,0 +1,58 @@
+import type { EmscriptenModule, LibansiloveBindings, RenderInput, RenderOptions, RenderResult } from "./types";
+
+const encoder = new TextEncoder();
+
+const DEFAULT_RENDER_ARGS = {
+	columns: 0,
+	bits: 0,
+	mode: 0,
+	iceColors: 0,
+} as const;
+
+export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
+	const getVersion = Module.cwrap("ansilove_wasm_version", "string", []) as () => string;
+	const renderAnsiFn = Module.cwrap("ansilove_wasm_render_ansi", "number", [
+		"number",
+		"number",
+		"number",
+		"number",
+		"number",
+		"number",
+	]) as (...args: number[]) => number;
+	const getPngPtr = Module.cwrap("ansilove_wasm_get_png_ptr", "number", []) as () => number;
+	const getPngLength = Module.cwrap("ansilove_wasm_get_png_length", "number", []) as () => number;
+	const freePng = Module.cwrap("ansilove_wasm_free_png", null, []) as () => void;
+
+	const renderAnsi = (input: RenderInput, options: RenderOptions = {}): RenderResult => {
+		const data = typeof input === "string" ? encoder.encode(input) : input;
+		const ptr = Module._malloc(data.length || 1);
+		Module.HEAPU8.set(data, ptr);
+
+		const cols = options.columns ?? DEFAULT_RENDER_ARGS.columns;
+		const bits = options.bits ?? DEFAULT_RENDER_ARGS.bits;
+		const mode = options.mode ?? DEFAULT_RENDER_ARGS.mode;
+		const ice = options.iceColors ?? DEFAULT_RENDER_ARGS.iceColors;
+
+		const code = renderAnsiFn(ptr, data.length, cols, bits, mode, ice);
+		Module._free(ptr);
+		if (code !== 0) {
+			throw new Error(`ansilove_wasm_render_ansi failed with exit code ${code}`);
+		}
+
+		const pngPtr = getPngPtr();
+		const pngLength = getPngLength();
+		if (!pngPtr || pngLength <= 0) {
+			throw new Error("libansilove returned an empty PNG buffer");
+		}
+		const png = Module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
+		freePng();
+
+		return { png };
+	};
+
+	return {
+		module: Module,
+		version: getVersion(),
+		renderAnsi,
+	};
+}
diff --git a/npm/packages/libansilove/src/browser.ts b/npm/packages/libansilove/src/browser.ts
new file mode 100644
index 0000000..8efd394
--- /dev/null
+++ b/npm/packages/libansilove/src/browser.ts
@@ -0,0 +1,13 @@
+import { createBindings } from "./bindings";
+import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
+
+const DEFAULT_LOCATE = (path: string) => new URL(`./wasm/${path}`, import.meta.url).href;
+
+export async function loadBrowser(options: LoadOptions = {}): Promise<LibansiloveBindings> {
+	const factoryModule: { default: ModuleFactory } = await import("./wasm/libansilove.browser.mjs");
+	const factory = factoryModule.default;
+	const locateFile = options.locateFile ?? DEFAULT_LOCATE;
+	const overrides = { ...(options.module ?? {}), locateFile };
+	const instance = await factory(overrides);
+	return createBindings(instance);
+}
diff --git a/npm/packages/libansilove/src/index.ts b/npm/packages/libansilove/src/index.ts
new file mode 100644
index 0000000..ed6973b
--- /dev/null
+++ b/npm/packages/libansilove/src/index.ts
@@ -0,0 +1,13 @@
+export { loadBrowser } from "./browser";
+export { loadNode } from "./node";
+export { createBindings } from "./bindings";
+export type {
+	LibansiloveBindings,
+	LoadOptions,
+	RenderInput,
+	RenderOptions,
+	RenderResult,
+	EmscriptenModule,
+	ModuleFactory,
+	ModuleOverrides,
+} from "./types";
diff --git a/npm/packages/libansilove/src/node.ts b/npm/packages/libansilove/src/node.ts
new file mode 100644
index 0000000..496275f
--- /dev/null
+++ b/npm/packages/libansilove/src/node.ts
@@ -0,0 +1,13 @@
+import { createBindings } from "./bindings";
+import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
+
+const DEFAULT_LOCATE = (path: string) => new URL(`./wasm/${path}`, import.meta.url).href;
+
+export async function loadNode(options: LoadOptions = {}): Promise<LibansiloveBindings> {
+	const factoryModule: { default: ModuleFactory } = await import("./wasm/libansilove.node.mjs");
+	const factory = factoryModule.default;
+	const locateFile = options.locateFile ?? DEFAULT_LOCATE;
+	const overrides = { ...(options.module ?? {}), locateFile };
+	const instance = await factory(overrides);
+	return createBindings(instance);
+}
diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
new file mode 100644
index 0000000..49f0cc1
--- /dev/null
+++ b/npm/packages/libansilove/src/types.ts
@@ -0,0 +1,41 @@
+export interface RenderOptions {
+	/** Number of columns to assume when rendering (0 lets libansilove decide). */
+	readonly columns?: number;
+	/** Bits per pixel mode (0 = default). */
+	readonly bits?: number;
+	/** Rendering mode flag (0 = default). */
+	readonly mode?: number;
+	/** Whether to enable ICE colors (0 = disabled). */
+	readonly iceColors?: number;
+}
+
+export type RenderInput = string | Uint8Array;
+
+export interface RenderResult {
+	/** PNG payload produced by the conversion. */
+	readonly png: Uint8Array;
+}
+
+export interface LibansiloveBindings {
+	readonly module: EmscriptenModule;
+	readonly version: string;
+	renderAnsi(input: RenderInput, options?: RenderOptions): RenderResult;
+}
+
+export interface LoadOptions {
+	readonly locateFile?: (path: string) => string;
+	readonly module?: ModuleOverrides;
+}
+
+export type ModuleOverrides = Record<string, unknown>;
+
+export interface EmscriptenModule {
+	cwrap(name: string, returnType: string | null, argTypes: string[]): (...args: unknown[]) => any;
+	HEAPU8: Uint8Array;
+	_malloc(size: number): number;
+	_free(ptr: number): void;
+}
+
+export type ModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (overrides?: ModuleOverrides & {
+	locateFile?: (path: string) => string;
+}) => Promise<T>;
diff --git a/npm/packages/libansilove/src/wasm-modules.d.ts b/npm/packages/libansilove/src/wasm-modules.d.ts
new file mode 100644
index 0000000..1c5662e
--- /dev/null
+++ b/npm/packages/libansilove/src/wasm-modules.d.ts
@@ -0,0 +1,11 @@
+declare module "./wasm/libansilove.browser.mjs" {
+	import type { ModuleFactory } from "./types";
+	const factory: ModuleFactory;
+	export default factory;
+}
+
+declare module "./wasm/libansilove.node.mjs" {
+	import type { ModuleFactory } from "./types";
+	const factory: ModuleFactory;
+	export default factory;
+}
diff --git a/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts b/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
new file mode 100644
index 0000000..870bf46
--- /dev/null
+++ b/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
@@ -0,0 +1,3 @@
+import type { ModuleFactory } from "../types";
+declare const factory: ModuleFactory;
+export default factory;
diff --git a/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts b/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
new file mode 100644
index 0000000..870bf46
--- /dev/null
+++ b/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
@@ -0,0 +1,3 @@
+import type { ModuleFactory } from "../types";
+declare const factory: ModuleFactory;
+export default factory;
diff --git a/npm/packages/libansilove/tsconfig.build.json b/npm/packages/libansilove/tsconfig.build.json
new file mode 100644
index 0000000..c61dfa5
--- /dev/null
+++ b/npm/packages/libansilove/tsconfig.build.json
@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "emitDeclarationOnly": false,
+    "stripInternal": true,
+    "allowImportingTsExtensions": false,
+    "allowArbitraryExtensions": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.d.ts"],
+  "exclude": ["dist", "generated"]
+}
diff --git a/npm/packages/libansilove/tsconfig.json b/npm/packages/libansilove/tsconfig.json
index bfa0fea..3451c21 100644
--- a/npm/packages/libansilove/tsconfig.json
+++ b/npm/packages/libansilove/tsconfig.json
@@ -1,29 +1,26 @@
 {
   "compilerOptions": {
-    // Environment setup & latest features
     "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
+    "target": "ES2022",
+    "module": "ESNext",
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
     "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "allowArbitraryExtensions": true,
     "noEmit": true,
-
-    // Best practices
     "strict": true,
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedIndexedAccess": true,
     "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
     "noPropertyAccessFromIndexSignature": false
-  }
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.d.ts",
+    "scripts/**/*.ts"
+  ]
 }
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
index d9c8bde..a8f1087 100755
--- a/scripts/test-wasm-node.js
+++ b/scripts/test-wasm-node.js
@@ -14,7 +14,7 @@ async function loadFactory(factoryPath) {
 }
 
 async function main() {
-  const buildDir = path.resolve(process.argv[2] || 'build-wasm/wasm');
+  const buildDir = path.resolve(process.argv[2] || 'npm/packages/libansilove/generated');
   const outputPath = path.resolve(process.argv[3] || path.join(buildDir, 'test-output.png'));
   const factoryPath = path.resolve(process.argv[4] || path.join(buildDir, 'libansilove.node.mjs'));
   const sampleText = process.argv[5] || 'Hello from libansilove!\r\n';
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
index 5a52132..37e443e 100755
--- a/scripts/test-wasm.sh
+++ b/scripts/test-wasm.sh
@@ -1,23 +1,19 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-if ! command -v emcmake >/dev/null; then
-  echo "error: emcmake is required (enter via 'nix develop')." >&2
+if ! command -v bun >/dev/null; then
+  echo "error: bun is required (enter via 'nix develop')." >&2
   exit 2
 fi
 
-build_dir="${1:-build-wasm}"
-artifacts_dir="$build_dir/wasm"
-rm -rf "$build_dir"
-
-emcmake cmake -S . -B "$build_dir" -DANSILOVE_BUILD_WASM=ON
-cmake --build "$build_dir" --target ansilove_wasm_browser ansilove_wasm_node
-
+artifacts_dir="npm/packages/libansilove/generated"
 browser_js="$artifacts_dir/libansilove.browser.mjs"
 browser_wasm="$artifacts_dir/libansilove.browser.wasm"
 node_js="$artifacts_dir/libansilove.node.mjs"
 node_wasm="$artifacts_dir/libansilove.node.wasm"
 
+bun npm/packages/libansilove/scripts/build-wasm.bun.ts
+
 if [ ! -f "$browser_js" ] || [ ! -f "$browser_wasm" ]; then
   echo "error: expected browser artefacts ($browser_js, $browser_wasm)" >&2
   exit 3
@@ -30,6 +26,7 @@ fi
 
 node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png" "$node_js"
 
+mkdir -p example/wasm
 cp "$browser_js" example/wasm/libansilove.browser.mjs
 cp "$browser_wasm" example/wasm/libansilove.browser.wasm
 

From b45fa10221874a50fb9730007c70bb3f2b4968c6 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Thu, 18 Sep 2025 23:52:26 -0400
Subject: [PATCH 17/26] Refactor: Consolidate WASM build and distribution

This commit consolidates the WebAssembly build process and distribution strategy.

The legacy `example/wasm` artifacts and corresponding build/test scripts have been removed. The `npm/packages/libansilove` workspace now
serves as the single source of truth for building, testing, and distributing the WebAssembly runtime.

Key changes: - The `.gitignore` now excludes WASM artefacts. - Documentation in `README.md` and `AGENTS.md` has been updated to reflect the
new commands and workflow. - The `libansilove` npm package exports a unified `load` function that works across environments (browser,
Node.js, Deno, Bun). - The build process (`build-wasm.bun.ts`) now generates `libansilove.js` and `libansilove.wasm` directly into `dist/`.
- The `prepare-package.ts` script copies these artifacts to `dist/`. - The old separate browser/node WASM modules (`.mjs` files) have been
removed in favor of a single `.js` file. - Tests have been updated to use the unified `load` function.
---
 .gitignore                                    |    9 -
 AGENTS.md                                     |   14 +-
 PR_DESCRIPTION.md                             |   17 +-
 README.md                                     |   61 +-
 example/wasm/index.html                       |   65 -
 example/wasm/libansilove.js                   | 1820 -----------------
 example/wasm/libansilove.wasm                 |  Bin 172316 -> 0 bytes
 flake.lock                                    |   19 +-
 flake.nix                                     |    5 +-
 .../scripts}/safari-wasm-smoke.js             |    2 +
 npm/packages/libansilove/README.md            |   30 +-
 npm/packages/libansilove/package.json         |   23 +-
 .../libansilove/scripts/build-wasm.bun.ts     |    3 +-
 .../libansilove/scripts/prepare-package.ts    |   12 +-
 .../libansilove/scripts/verify-dist.ts        |    4 +-
 npm/packages/libansilove/src/bindings.ts      |   17 +-
 npm/packages/libansilove/src/browser.ts       |   13 -
 npm/packages/libansilove/src/index.ts         |   19 +-
 npm/packages/libansilove/src/libansilove.d.ts |    5 +
 npm/packages/libansilove/src/libansilove.js   |    1 +
 npm/packages/libansilove/src/node.ts          |   13 -
 npm/packages/libansilove/src/types.ts         |   13 +-
 .../libansilove/src/wasm-modules.d.ts         |   11 -
 .../src/wasm/libansilove.browser.mjs.d.ts     |    3 -
 .../src/wasm/libansilove.node.mjs.d.ts        |    3 -
 npm/packages/libansilove/tests/render.test.ts |   12 +
 npm/packages/libansilove/tsconfig.build.json  |    1 -
 npm/packages/libansilove/tsconfig.json        |    4 +-
 scripts/test-wasm-browser.sh                  |   40 -
 scripts/test-wasm-node.js                     |   64 -
 scripts/test-wasm.sh                          |   33 -
 31 files changed, 135 insertions(+), 2201 deletions(-)
 delete mode 100644 example/wasm/index.html
 delete mode 100644 example/wasm/libansilove.js
 delete mode 100755 example/wasm/libansilove.wasm
 rename {scripts => npm/packages/libansilove-demo-bun/scripts}/safari-wasm-smoke.js (94%)
 delete mode 100644 npm/packages/libansilove/src/browser.ts
 create mode 100644 npm/packages/libansilove/src/libansilove.d.ts
 create mode 100644 npm/packages/libansilove/src/libansilove.js
 delete mode 100644 npm/packages/libansilove/src/node.ts
 delete mode 100644 npm/packages/libansilove/src/wasm-modules.d.ts
 delete mode 100644 npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
 delete mode 100644 npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
 create mode 100644 npm/packages/libansilove/tests/render.test.ts
 delete mode 100755 scripts/test-wasm-browser.sh
 delete mode 100755 scripts/test-wasm-node.js
 delete mode 100755 scripts/test-wasm.sh

diff --git a/.gitignore b/.gitignore
index e7fe2cd..7a00c5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,15 +21,6 @@ CMakeCache.txt
 Makefile
 cmake_install.cmake
 
-# WASM artefacts
-example/wasm/libansilove.browser.mjs
-example/wasm/libansilove.browser.wasm
-build-wasm/wasm/test-output.png
-build-wasm/wasm/libansilove.browser.mjs
-build-wasm/wasm/libansilove.browser.wasm
-build-wasm/wasm/libansilove.node.mjs
-build-wasm/wasm/libansilove.node.wasm
-
 # npm package build
 node_modules/
 npm/packages/*/dist/
diff --git a/AGENTS.md b/AGENTS.md
index bc6f279..8a55c5d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,12 +12,10 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - `nix develop`: enter the flake-backed dev shell with clang, pkg-config, GD, and platform-appropriate debugger preinstalled.
 - `nix build`: build the default flake package (shared/static library) without touching your host toolchain.
 - `nix flake check`: validate the flake packages and dev shell evaluate cleanly across supported systems.
-- `nix develop --command bash scripts/test-wasm.sh`: run the Bun-driven `emcc` build and assert the JS/WASM artefacts exist.
-- `scripts/test-wasm-browser.sh`: launch a local server and exercise the Safari smoke test end-to-end.
-- `python3 -m http.server 8765 --directory example/wasm`: manual alternative to serve the browser demo (after running `scripts/test-wasm.sh`).
-- `cd npm/packages/libansilove && bun install && bun run scripts/build-wasm.bun.ts`: rebuild the npm artefacts.
-- `node scripts/test-wasm-node.js npm/packages/libansilove/generated`: rerun the Node smoke test on an existing build.
-- `npm version patch` within `npm/packages/libansilove` (once publishing is wired) to bump metadata in step with `ANSILOVE_VERSION`.
+- `nix develop --command bash -lc 'cd npm/packages/libansilove && bun run build'`: rebuild the WebAssembly artefacts and stage the publishable dist folder.
+- `cd npm/packages/libansilove && bun test`: run the smoke test suite (includes wasm build).
+- `cd npm/packages/libansilove && bun run verify`: load the packaged output and ensure PNG rendering still works.
+- `cd npm/packages/libansilove && npm pack`: inspect the npm tarball after a successful build.
 
 ## Coding Style & Naming Conventions
 - Target C99 with the default warning set (`-Wall -Wextra -pedantic`).
@@ -31,8 +29,8 @@ libansilove is a C library that converts ANSI and related art files to PNG. Core
 - For fuzzing, execute `./fuzz-build/ansi -runs=10000 corpus/` (seed the corpus with representative art files). Investigate sanitizer reports immediately and add reproducer samples.
 - Ensure new formats or options ship with updated example inputs or fuzz seeds that exercise the paths.
 - If you touch the flake, rerun `nix build` and `nix flake check` and commit the updated `flake.lock` (keep changes reproducible).
-- For the wasm target, keep `scripts/test-wasm.sh` passing under `nix develop`; it rebuilds the Bun-driven artefacts via `emcc` every run.
-- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The helper scripts copy `libansilove.browser.{mjs,wasm}` into `example/wasm/` so you can smoke-test via the provided browser script or a manual `python3 -m http.server` session.
+- For the wasm target, keep `bun run build` passing inside `npm/packages/libansilove` under `nix develop`; it rebuilds the WebAssembly artefacts every run.
+- Safari automation relies on “Allow JavaScript from Apple Events” in Preferences ▸ Advanced. The JXA harness (now in `npm/packages/libansilove-demo-bun/scripts`) should be updated to target the Bun dev server when the demo is rebuilt.
 
 ## Commit & Pull Request Guidelines
 - Commit messages follow sentence case with concise statements ending in a period (for example, `Update ChangeLog.`).
diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md
index 72886bf..92b95f7 100644
--- a/PR_DESCRIPTION.md
+++ b/PR_DESCRIPTION.md
@@ -1,15 +1,14 @@
 
 # Add reproducible flake env and WebAssembly target.
 ## Summary
-- keep the dev shell ergonomic by wiring in Emscripten alongside cmake/clang and documenting the workflow for future agents
-- teach the build to emit `libansilove.{js,wasm}` through a minimal GD-compatible raster backend so the existing loaders work in a browser
-- expose a wasm facade (`ansilove_wasm_render_ansi` etc.), ship a Node smoke test, and serve a demo HTML page that renders ANSI art in Safari
-- scaffold an `@effect-native/libansilove` package with TypeScript/ESM bindings (Node + browser), reproducible build scripts, and automated version syncing/bumping ready for publication, plus Bun demo integration
-- ignore transient Nix/wasm artefacts and refresh the README/AGENTS notes with the exact commands for building, testing, and verifying in Safari
+- keep the dev shell ergonomic by wiring in Emscripten alongside clang/cmake and documenting the workflow for future agents
+- compile libansilove to a single universal `libansilove.{js,wasm}` bundle and surface a small TypeScript API around `renderAnsi`
+- stand up the `libansilove` npm workspace with Bun-based build scripts, packaging helpers, smoke tests, and publishable dist output
+- prune the legacy shell helpers/demo assets in favour of the new universal loader and move the Safari JXA harness into the Bun demo package
+- refresh README/AGENTS with the simplified commands for building, testing, and verifying the wasm pipeline
 
 ## Testing
 - nix flake check
-- nix develop --command bash scripts/test-wasm.sh
-- node scripts/test-wasm-node.js npm/packages/libansilove/generated
-- scripts/test-wasm-browser.sh (Safari with "Allow JavaScript from Apple Events")
-- cd npm/packages/libansilove && bun run scripts/build-wasm.bun.ts && node ../../scripts/test-wasm-node.js npm/packages/libansilove/generated
+- nix develop --command bash -lc 'cd npm/packages/libansilove && bun run build'
+- cd npm/packages/libansilove && bun test
+- cd npm/packages/libansilove && bun run verify
diff --git a/README.md b/README.md
index 38f0bb2..1a22f5f 100644
--- a/README.md
+++ b/README.md
@@ -32,61 +32,46 @@ header files.
 
 # WebAssembly
 
-An experimental WebAssembly wrapper ships in `wasm/`. Use the Nix
-environment to ensure Emscripten is available:
+A unified WebAssembly wrapper now lives in `npm/packages/libansilove`. Use the flake-backed
+development shell so Emscripten and Bun are on `PATH`:
 
-	nix develop --command bash scripts/test-wasm.sh
+	nix develop --command bash -lc 'cd npm/packages/libansilove && bun run build'
 
-The helper script drives the Bun-based build harness
-(`npm/packages/libansilove/scripts/build-wasm.bun.ts`), which shells out to
-`emcc` and produces
-`npm/packages/libansilove/generated/libansilove.browser.{mjs,wasm}` and
-`npm/packages/libansilove/generated/libansilove.node.{mjs,wasm}` while exporting
-`ansilove_wasm_version()` for browser consumers. The browser bundle is emitted
-as an ES module factory (`-sMODULARIZE=1 -sEXPORT_ES6=1`), so import the default
-export and await the resulting instance before calling into the runtime:
+The build performs a fresh `emcc` compile, emits TypeScript shims, and stages the publishable
+artefacts under `npm/packages/libansilove/dist/`. Consumers load the module with:
 
 ```
-import createLibansilove from './libansilove.browser.mjs';
+import { load } from 'libansilove';
 
-const Module = await createLibansilove({ locateFile: (path) => path });
-const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
+const lib = await load();
+const { png } = lib.renderAnsi('Hello from libansilove!\r\n');
 ```
 
-The helper also runs a Node-based smoke test that renders a sample ANSI string
-to `npm/packages/libansilove/generated/test-output.png` and copies the runtime
-artefacts into `example/wasm/`.
+Overwrite the default `locateFile` if your bundler serves the `.wasm` payload from a custom URL:
 
-Serve the demo page with, for example,
-
-	python3 -m http.server 8765 --directory example/wasm
-
-Then open `http://localhost:8765/` in a browser (Safari requires the developer
-setting “Allow JavaScript from Apple Events” for scripted verification) to see
-the PNG preview rendered via WebAssembly.
-
-Additional helpers:
+```
+await load({ locateFile: (path) => new URL(`/static/${path}`, window.location.href).toString() });
+```
 
-- `node scripts/test-wasm-node.js npm/packages/libansilove/generated` reruns the
-  Node smoke test on an existing wasm build and refreshes `test-output.png`.
-- `scripts/test-wasm-browser.sh` starts a local server and drives Safari via
-  JXA, ensuring the demo page renders successfully (requires the Safari
-  automation toggle mentioned above).
+`bun run verify` executes a smoke test against the packaged output and ensures the PNG pipeline
+still works. Use `npm pack` after a build to inspect the final publishing tarball.
 
 # npm package
 
-The `npm/packages/libansilove` workspace hosts the Bun-based tooling that
-drives the WebAssembly build and will eventually publish the generated
-artefacts to npm. From within that directory you can run:
+The `npm/packages/libansilove` workspace contains everything required for publishing. The
+important commands:
 
 ```
 bun install
-bun run scripts/build-wasm.bun.ts
+bun run build
+bun test
+bun run verify
 ```
 
-The build script writes outputs to `npm/packages/libansilove/generated/`, which
-you can consume from Node (see `scripts/test-wasm-node.js`) or copy into the
-browser demo under `example/wasm/`.
+The build step regenerates the WebAssembly artefacts (stored in
+`npm/packages/libansilove/generated/`) and copies them into `dist/` alongside the compiled
+JavaScript and declaration files.
+
 
 # Packages
 
diff --git a/example/wasm/index.html b/example/wasm/index.html
deleted file mode 100644
index 6db5133..0000000
--- a/example/wasm/index.html
+++ /dev/null
@@ -1,65 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>libansilove wasm smoke test</title>
-  <script type="module">
-    import createLibansilove from './libansilove.browser.mjs';
-
-    const status = document.getElementById('status');
-    const preview = document.getElementById('preview');
-
-    async function render() {
-      try {
-        const Module = await createLibansilove({ locateFile: (path) => path });
-
-        const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
-        const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-        const getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
-        const getLength = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
-        const freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
-
-        status.textContent = 'libansilove wasm version: ' + getVersion();
-
-        const encoder = new TextEncoder();
-        const input = encoder.encode('Hello from libansilove!\r\n');
-        const ptr = Module._malloc(input.length);
-        Module.HEAPU8.set(input, ptr);
-
-        const rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
-        Module._free(ptr);
-        if (rc !== 0) {
-          status.textContent = 'Render failed with error code ' + rc;
-          return;
-        }
-
-        const pngPtr = getPtr();
-        const pngLen = getLength();
-        const pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLen);
-        freePng();
-
-        const blob = new Blob([pngData], { type: 'image/png' });
-        const url = URL.createObjectURL(blob);
-        preview.src = url;
-        preview.alt = 'Rendered ANSI sample';
-      } catch (error) {
-        status.textContent = 'Libansilove failed: ' + error;
-      }
-    }
-
-    render();
-  </script>
-  <style>
-    body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; margin: 2rem; }
-    main { max-width: 40rem; }
-    #status { font-weight: bold; }
-  </style>
-</head>
-<body>
-  <main>
-    <h1>libansilove wasm smoke test</h1>
-    <p id="status">waiting for module…</p>
-    <img id="preview" alt="" style="display:block; margin-top: 1rem; max-width: 100%;" />
-  </main>
-</body>
-</html>
diff --git a/example/wasm/libansilove.js b/example/wasm/libansilove.js
deleted file mode 100644
index 6599c63..0000000
--- a/example/wasm/libansilove.js
+++ /dev/null
@@ -1,1820 +0,0 @@
-
-var Libansilove = (() => {
-  var _scriptDir = import.meta.url;
-  
-  return (
-async function(moduleArg = {}) {
-
-// include: shell.js
-// The Module object: Our interface to the outside world. We import
-// and export values on it. There are various ways Module can be used:
-// 1. Not defined. We create it here
-// 2. A function parameter, function(Module) { ..generated code.. }
-// 3. pre-run appended it, var Module = {}; ..generated code..
-// 4. External script tag defines var Module.
-// We need to check if Module already exists (e.g. case 3 above).
-// Substitution will be replaced with actual code on later stage of the build,
-// this way Closure Compiler will not mangle it (e.g. case 4. above).
-// Note that if you want to run closure, and also to use Module
-// after the generated code, you will need to define   var Module = {};
-// before the code. Then that object will be used in the code, and you
-// can continue to use Module afterwards as well.
-var Module = moduleArg;
-
-// Set up the promise that indicates the Module is initialized
-var readyPromiseResolve, readyPromiseReject;
-Module['ready'] = new Promise((resolve, reject) => {
-  readyPromiseResolve = resolve;
-  readyPromiseReject = reject;
-});
-["_ansilove_wasm_version","_ansilove_wasm_render_ansi","_ansilove_wasm_get_png_ptr","_ansilove_wasm_get_png_length","_ansilove_wasm_free_png","_malloc","_free","_memory","___indirect_function_table","_fflush","onRuntimeInitialized"].forEach((prop) => {
-  if (!Object.getOwnPropertyDescriptor(Module['ready'], prop)) {
-    Object.defineProperty(Module['ready'], prop, {
-      get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
-      set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),
-    });
-  }
-});
-
-// --pre-jses are emitted after the Module integration code, so that they can
-// refer to Module (if they choose; they can also define Module)
-
-
-// Sometimes an existing Module object exists with properties
-// meant to overwrite the default module functionality. Here
-// we collect those properties and reapply _after_ we configure
-// the current environment's defaults to avoid having to be so
-// defensive during initialization.
-var moduleOverrides = Object.assign({}, Module);
-
-var arguments_ = [];
-var thisProgram = './this.program';
-var quit_ = (status, toThrow) => {
-  throw toThrow;
-};
-
-// Determine the runtime environment we are in. You can customize this by
-// setting the ENVIRONMENT setting at compile time (see settings.js).
-
-// Attempt to auto-detect the environment
-var ENVIRONMENT_IS_WEB = typeof window == 'object';
-var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
-// N.b. Electron.js environment is simultaneously a NODE-environment, but
-// also a web environment.
-var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
-var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
-
-if (Module['ENVIRONMENT']) {
-  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
-}
-
-// `/` should be present at the end if `scriptDirectory` is not empty
-var scriptDirectory = '';
-function locateFile(path) {
-  if (Module['locateFile']) {
-    return Module['locateFile'](path, scriptDirectory);
-  }
-  return scriptDirectory + path;
-}
-
-// Hooks that are implemented differently in different runtime environments.
-var read_,
-    readAsync,
-    readBinary;
-
-if (ENVIRONMENT_IS_NODE) {
-  if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
-
-  var nodeVersion = process.versions.node;
-  var numericVersion = nodeVersion.split('.').slice(0, 3);
-  numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1);
-  var minVersion = 160000;
-  if (numericVersion < 160000) {
-    throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')');
-  }
-
-  // `require()` is no-op in an ESM module, use `createRequire()` to construct
-  // the require()` function.  This is only necessary for multi-environment
-  // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
-  // TODO: Swap all `require()`'s with `import()`'s?
-  const { createRequire } = await import('module');
-  /** @suppress{duplicate} */
-  var require = createRequire(import.meta.url);
-  // These modules will usually be used on Node.js. Load them eagerly to avoid
-  // the complexity of lazy-loading.
-  var fs = require('fs');
-  var nodePath = require('path');
-
-  if (ENVIRONMENT_IS_WORKER) {
-    scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
-  } else {
-    // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url,
-    // since there's no way getting the current absolute path of the module when
-    // support for that is not available.
-    scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url)); // includes trailing slash
-  }
-
-// include: node_shell_read.js
-read_ = (filename, binary) => {
-  // We need to re-wrap `file://` strings to URLs. Normalizing isn't
-  // necessary in that case, the path should already be absolute.
-  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-  return fs.readFileSync(filename, binary ? undefined : 'utf8');
-};
-
-readBinary = (filename) => {
-  var ret = read_(filename, true);
-  if (!ret.buffer) {
-    ret = new Uint8Array(ret);
-  }
-  assert(ret.buffer);
-  return ret;
-};
-
-readAsync = (filename, onload, onerror, binary = true) => {
-  // See the comment in the `read_` function.
-  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-  fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
-    if (err) onerror(err);
-    else onload(binary ? data.buffer : data);
-  });
-};
-// end include: node_shell_read.js
-  if (!Module['thisProgram'] && process.argv.length > 1) {
-    thisProgram = process.argv[1].replace(/\\/g, '/');
-  }
-
-  arguments_ = process.argv.slice(2);
-
-  // MODULARIZE will export the module in the proper place outside, we don't need to export here
-
-  quit_ = (status, toThrow) => {
-    process.exitCode = status;
-    throw toThrow;
-  };
-
-  Module['inspect'] = () => '[Emscripten Module object]';
-
-} else
-if (ENVIRONMENT_IS_SHELL) {
-
-  if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
-
-  if (typeof read != 'undefined') {
-    read_ = read;
-  }
-
-  readBinary = (f) => {
-    if (typeof readbuffer == 'function') {
-      return new Uint8Array(readbuffer(f));
-    }
-    let data = read(f, 'binary');
-    assert(typeof data == 'object');
-    return data;
-  };
-
-  readAsync = (f, onload, onerror) => {
-    setTimeout(() => onload(readBinary(f)));
-  };
-
-  if (typeof clearTimeout == 'undefined') {
-    globalThis.clearTimeout = (id) => {};
-  }
-
-  if (typeof setTimeout == 'undefined') {
-    // spidermonkey lacks setTimeout but we use it above in readAsync.
-    globalThis.setTimeout = (f) => (typeof f == 'function') ? f() : abort();
-  }
-
-  if (typeof scriptArgs != 'undefined') {
-    arguments_ = scriptArgs;
-  } else if (typeof arguments != 'undefined') {
-    arguments_ = arguments;
-  }
-
-  if (typeof quit == 'function') {
-    quit_ = (status, toThrow) => {
-      // Unlike node which has process.exitCode, d8 has no such mechanism. So we
-      // have no way to set the exit code and then let the program exit with
-      // that code when it naturally stops running (say, when all setTimeouts
-      // have completed). For that reason, we must call `quit` - the only way to
-      // set the exit code - but quit also halts immediately.  To increase
-      // consistency with node (and the web) we schedule the actual quit call
-      // using a setTimeout to give the current stack and any exception handlers
-      // a chance to run.  This enables features such as addOnPostRun (which
-      // expected to be able to run code after main returns).
-      setTimeout(() => {
-        if (!(toThrow instanceof ExitStatus)) {
-          let toLog = toThrow;
-          if (toThrow && typeof toThrow == 'object' && toThrow.stack) {
-            toLog = [toThrow, toThrow.stack];
-          }
-          err(`exiting due to exception: ${toLog}`);
-        }
-        quit(status);
-      });
-      throw toThrow;
-    };
-  }
-
-  if (typeof print != 'undefined') {
-    // Prefer to use print/printErr where they exist, as they usually work better.
-    if (typeof console == 'undefined') console = /** @type{!Console} */({});
-    console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
-    console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print);
-  }
-
-} else
-
-// Note that this includes Node.js workers when relevant (pthreads is enabled).
-// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
-// ENVIRONMENT_IS_NODE.
-if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
-    scriptDirectory = self.location.href;
-  } else if (typeof document != 'undefined' && document.currentScript) { // web
-    scriptDirectory = document.currentScript.src;
-  }
-  // When MODULARIZE, this JS may be executed later, after document.currentScript
-  // is gone, so we saved it, and we use it here instead of any other info.
-  if (_scriptDir) {
-    scriptDirectory = _scriptDir;
-  }
-  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
-  // otherwise, slice off the final part of the url to find the script directory.
-  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
-  // and scriptDirectory will correctly be replaced with an empty string.
-  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
-  // they are removed because they could contain a slash.
-  if (scriptDirectory.indexOf('blob:') !== 0) {
-    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1);
-  } else {
-    scriptDirectory = '';
-  }
-
-  if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
-
-  // Differentiate the Web Worker from the Node Worker case, as reading must
-  // be done differently.
-  {
-// include: web_or_worker_shell_read.js
-read_ = (url) => {
-    var xhr = new XMLHttpRequest();
-    xhr.open('GET', url, false);
-    xhr.send(null);
-    return xhr.responseText;
-  }
-
-  if (ENVIRONMENT_IS_WORKER) {
-    readBinary = (url) => {
-      var xhr = new XMLHttpRequest();
-      xhr.open('GET', url, false);
-      xhr.responseType = 'arraybuffer';
-      xhr.send(null);
-      return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
-    };
-  }
-
-  readAsync = (url, onload, onerror) => {
-    var xhr = new XMLHttpRequest();
-    xhr.open('GET', url, true);
-    xhr.responseType = 'arraybuffer';
-    xhr.onload = () => {
-      if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
-        onload(xhr.response);
-        return;
-      }
-      onerror();
-    };
-    xhr.onerror = onerror;
-    xhr.send(null);
-  }
-
-// end include: web_or_worker_shell_read.js
-  }
-} else
-{
-  throw new Error('environment detection error');
-}
-
-var out = Module['print'] || console.log.bind(console);
-var err = Module['printErr'] || console.error.bind(console);
-
-// Merge back in the overrides
-Object.assign(Module, moduleOverrides);
-// Free the object hierarchy contained in the overrides, this lets the GC
-// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
-moduleOverrides = null;
-checkIncomingModuleAPI();
-
-// Emit code to handle expected values on the Module object. This applies Module.x
-// to the proper local x. This has two benefits: first, we only emit it if it is
-// expected to arrive, and second, by using a local everywhere else that can be
-// minified.
-
-if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');
-
-if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');
-
-if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');
-
-// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
-// Assertions on removed incoming Module JS APIs.
-assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
-assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
-assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
-assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
-assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)');
-assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
-assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
-assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');
-assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
-legacyModuleProp('asm', 'wasmExports');
-legacyModuleProp('read', 'read_');
-legacyModuleProp('readAsync', 'readAsync');
-legacyModuleProp('readBinary', 'readBinary');
-legacyModuleProp('setWindowTitle', 'setWindowTitle');
-var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
-var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';
-var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';
-var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';
-var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';
-var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';
-var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';
-
-var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
-
-assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.");
-
-
-// end include: shell.js
-// include: preamble.js
-// === Preamble library stuff ===
-
-// Documentation for the public APIs defined in this file must be updated in:
-//    site/source/docs/api_reference/preamble.js.rst
-// A prebuilt local version of the documentation is available at:
-//    site/build/text/docs/api_reference/preamble.js.txt
-// You can also build docs locally as HTML or other formats in site/
-// An online HTML version (which may be of a different version of Emscripten)
-//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
-
-var wasmBinary; 
-if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');
-
-if (typeof WebAssembly != 'object') {
-  abort('no native wasm support detected');
-}
-
-// Wasm globals
-
-var wasmMemory;
-
-//========================================
-// Runtime essentials
-//========================================
-
-// whether we are quitting the application. no code should run after this.
-// set in exit() and abort()
-var ABORT = false;
-
-// set by exit() and abort().  Passed to 'onExit' handler.
-// NOTE: This is also used as the process return code code in shell environments
-// but only when noExitRuntime is false.
-var EXITSTATUS;
-
-// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
-// don't define it at all in release modes.  This matches the behaviour of
-// MINIMAL_RUNTIME.
-// TODO(sbc): Make this the default even without STRICT enabled.
-/** @type {function(*, string=)} */
-function assert(condition, text) {
-  if (!condition) {
-    abort('Assertion failed' + (text ? ': ' + text : ''));
-  }
-}
-
-// We used to include malloc/free by default in the past. Show a helpful error in
-// builds with assertions.
-
-// Memory management
-
-var HEAP,
-/** @type {!Int8Array} */
-  HEAP8,
-/** @type {!Uint8Array} */
-  HEAPU8,
-/** @type {!Int16Array} */
-  HEAP16,
-/** @type {!Uint16Array} */
-  HEAPU16,
-/** @type {!Int32Array} */
-  HEAP32,
-/** @type {!Uint32Array} */
-  HEAPU32,
-/** @type {!Float32Array} */
-  HEAPF32,
-/** @type {!Float64Array} */
-  HEAPF64;
-
-function updateMemoryViews() {
-  var b = wasmMemory.buffer;
-  Module['HEAP8'] = HEAP8 = new Int8Array(b);
-  Module['HEAP16'] = HEAP16 = new Int16Array(b);
-  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
-  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
-  Module['HEAP32'] = HEAP32 = new Int32Array(b);
-  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
-  Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
-  Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
-}
-
-assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')
-
-assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,
-       'JS engine does not provide full typed array support');
-
-// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
-assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');
-assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');
-
-// include: runtime_stack_check.js
-// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
-function writeStackCookie() {
-  var max = _emscripten_stack_get_end();
-  assert((max & 3) == 0);
-  // If the stack ends at address zero we write our cookies 4 bytes into the
-  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
-  // monitor writes to address zero.
-  if (max == 0) {
-    max += 4;
-  }
-  // The stack grow downwards towards _emscripten_stack_get_end.
-  // We write cookies to the final two words in the stack and detect if they are
-  // ever overwritten.
-  HEAPU32[((max)>>2)] = 0x02135467;
-  HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;
-  // Also test the global address 0 for integrity.
-  HEAPU32[((0)>>2)] = 1668509029;
-}
-
-function checkStackCookie() {
-  if (ABORT) return;
-  var max = _emscripten_stack_get_end();
-  // See writeStackCookie().
-  if (max == 0) {
-    max += 4;
-  }
-  var cookie1 = HEAPU32[((max)>>2)];
-  var cookie2 = HEAPU32[(((max)+(4))>>2)];
-  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {
-    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
-  }
-  // Also test the global address 0 for integrity.
-  if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) {
-    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
-  }
-}
-// end include: runtime_stack_check.js
-// include: runtime_assertions.js
-// Endianness check
-(function() {
-  var h16 = new Int16Array(1);
-  var h8 = new Int8Array(h16.buffer);
-  h16[0] = 0x6373;
-  if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
-})();
-
-// end include: runtime_assertions.js
-var __ATPRERUN__  = []; // functions called before the runtime is initialized
-var __ATINIT__    = []; // functions called during startup
-var __ATEXIT__    = []; // functions called during shutdown
-var __ATPOSTRUN__ = []; // functions called after the main() is called
-
-var runtimeInitialized = false;
-
-function preRun() {
-  if (Module['preRun']) {
-    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
-    while (Module['preRun'].length) {
-      addOnPreRun(Module['preRun'].shift());
-    }
-  }
-  callRuntimeCallbacks(__ATPRERUN__);
-}
-
-function initRuntime() {
-  assert(!runtimeInitialized);
-  runtimeInitialized = true;
-
-  checkStackCookie();
-
-  
-  callRuntimeCallbacks(__ATINIT__);
-}
-
-function postRun() {
-  checkStackCookie();
-
-  if (Module['postRun']) {
-    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
-    while (Module['postRun'].length) {
-      addOnPostRun(Module['postRun'].shift());
-    }
-  }
-
-  callRuntimeCallbacks(__ATPOSTRUN__);
-}
-
-function addOnPreRun(cb) {
-  __ATPRERUN__.unshift(cb);
-}
-
-function addOnInit(cb) {
-  __ATINIT__.unshift(cb);
-}
-
-function addOnExit(cb) {
-}
-
-function addOnPostRun(cb) {
-  __ATPOSTRUN__.unshift(cb);
-}
-
-// include: runtime_math.js
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
-
-assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
-assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
-assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
-assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
-// end include: runtime_math.js
-// A counter of dependencies for calling run(). If we need to
-// do asynchronous work before running, increment this and
-// decrement it. Incrementing must happen in a place like
-// Module.preRun (used by emcc to add file preloading).
-// Note that you can add dependencies in preRun, even though
-// it happens right before run - run will be postponed until
-// the dependencies are met.
-var runDependencies = 0;
-var runDependencyWatcher = null;
-var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
-var runDependencyTracking = {};
-
-function getUniqueRunDependency(id) {
-  var orig = id;
-  while (1) {
-    if (!runDependencyTracking[id]) return id;
-    id = orig + Math.random();
-  }
-}
-
-function addRunDependency(id) {
-  runDependencies++;
-
-  Module['monitorRunDependencies']?.(runDependencies);
-
-  if (id) {
-    assert(!runDependencyTracking[id]);
-    runDependencyTracking[id] = 1;
-    if (runDependencyWatcher === null && typeof setInterval != 'undefined') {
-      // Check for missing dependencies every few seconds
-      runDependencyWatcher = setInterval(() => {
-        if (ABORT) {
-          clearInterval(runDependencyWatcher);
-          runDependencyWatcher = null;
-          return;
-        }
-        var shown = false;
-        for (var dep in runDependencyTracking) {
-          if (!shown) {
-            shown = true;
-            err('still waiting on run dependencies:');
-          }
-          err(`dependency: ${dep}`);
-        }
-        if (shown) {
-          err('(end of list)');
-        }
-      }, 10000);
-    }
-  } else {
-    err('warning: run dependency added without ID');
-  }
-}
-
-function removeRunDependency(id) {
-  runDependencies--;
-
-  Module['monitorRunDependencies']?.(runDependencies);
-
-  if (id) {
-    assert(runDependencyTracking[id]);
-    delete runDependencyTracking[id];
-  } else {
-    err('warning: run dependency removed without ID');
-  }
-  if (runDependencies == 0) {
-    if (runDependencyWatcher !== null) {
-      clearInterval(runDependencyWatcher);
-      runDependencyWatcher = null;
-    }
-    if (dependenciesFulfilled) {
-      var callback = dependenciesFulfilled;
-      dependenciesFulfilled = null;
-      callback(); // can add another dependenciesFulfilled
-    }
-  }
-}
-
-/** @param {string|number=} what */
-function abort(what) {
-  Module['onAbort']?.(what);
-
-  what = 'Aborted(' + what + ')';
-  // TODO(sbc): Should we remove printing and leave it up to whoever
-  // catches the exception?
-  err(what);
-
-  ABORT = true;
-  EXITSTATUS = 1;
-
-  // Use a wasm runtime error, because a JS error might be seen as a foreign
-  // exception, which means we'd run destructors on it. We need the error to
-  // simply make the program stop.
-  // FIXME This approach does not work in Wasm EH because it currently does not assume
-  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
-  // a trap or not based on a hidden field within the object. So at the moment
-  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
-  // allows this in the wasm spec.
-
-  // Suppress closure compiler warning here. Closure compiler's builtin extern
-  // defintion for WebAssembly.RuntimeError claims it takes no arguments even
-  // though it can.
-  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
-  /** @suppress {checkTypes} */
-  var e = new WebAssembly.RuntimeError(what);
-
-  readyPromiseReject(e);
-  // Throw the error whether or not MODULARIZE is set because abort is used
-  // in code paths apart from instantiation where an exception is expected
-  // to be thrown when abort is called.
-  throw e;
-}
-
-// include: memoryprofiler.js
-// end include: memoryprofiler.js
-// show errors on likely calls to FS when it was not included
-var FS = {
-  error() {
-    abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');
-  },
-  init() { FS.error() },
-  createDataFile() { FS.error() },
-  createPreloadedFile() { FS.error() },
-  createLazyFile() { FS.error() },
-  open() { FS.error() },
-  mkdev() { FS.error() },
-  registerDevice() { FS.error() },
-  analyzePath() { FS.error() },
-
-  ErrnoError() { FS.error() },
-};
-Module['FS_createDataFile'] = FS.createDataFile;
-Module['FS_createPreloadedFile'] = FS.createPreloadedFile;
-
-// include: URIUtils.js
-// Prefix of data URIs emitted by SINGLE_FILE and related options.
-var dataURIPrefix = 'data:application/octet-stream;base64,';
-
-/**
- * Indicates whether filename is a base64 data URI.
- * @noinline
- */
-var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
-
-/**
- * Indicates whether filename is delivered via file protocol (as opposed to http/https)
- * @noinline
- */
-var isFileURI = (filename) => filename.startsWith('file://');
-// end include: URIUtils.js
-function createExportWrapper(name) {
-  return function() {
-    assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
-    var f = wasmExports[name];
-    assert(f, `exported native function \`${name}\` not found`);
-    return f.apply(null, arguments);
-  };
-}
-
-// include: runtime_exceptions.js
-// end include: runtime_exceptions.js
-var wasmBinaryFile;
-if (Module['locateFile']) {
-  wasmBinaryFile = 'libansilove.wasm';
-  if (!isDataURI(wasmBinaryFile)) {
-    wasmBinaryFile = locateFile(wasmBinaryFile);
-  }
-} else {
-  // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
-  wasmBinaryFile = new URL('libansilove.wasm', import.meta.url).href;
-}
-
-function getBinarySync(file) {
-  if (file == wasmBinaryFile && wasmBinary) {
-    return new Uint8Array(wasmBinary);
-  }
-  if (readBinary) {
-    return readBinary(file);
-  }
-  throw "both async and sync fetching of the wasm failed";
-}
-
-function getBinaryPromise(binaryFile) {
-  // If we don't have the binary yet, try to load it asynchronously.
-  // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
-  // See https://github.com/github/fetch/pull/92#issuecomment-140665932
-  // Cordova or Electron apps are typically loaded from a file:// url.
-  // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
-  if (!wasmBinary
-      && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
-    if (typeof fetch == 'function'
-    ) {
-      return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
-        if (!response['ok']) {
-          throw "failed to load wasm binary file at '" + binaryFile + "'";
-        }
-        return response['arrayBuffer']();
-      }).catch(() => getBinarySync(binaryFile));
-    }
-  }
-
-  // Otherwise, getBinarySync should be able to get it synchronously
-  return Promise.resolve().then(() => getBinarySync(binaryFile));
-}
-
-function instantiateArrayBuffer(binaryFile, imports, receiver) {
-  return getBinaryPromise(binaryFile).then((binary) => {
-    return WebAssembly.instantiate(binary, imports);
-  }).then((instance) => {
-    return instance;
-  }).then(receiver, (reason) => {
-    err(`failed to asynchronously prepare wasm: ${reason}`);
-
-    // Warn on some common problems.
-    if (isFileURI(wasmBinaryFile)) {
-      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
-    }
-    abort(reason);
-  });
-}
-
-function instantiateAsync(binary, binaryFile, imports, callback) {
-  if (!binary &&
-      typeof WebAssembly.instantiateStreaming == 'function' &&
-      !isDataURI(binaryFile) &&
-      // Avoid instantiateStreaming() on Node.js environment for now, as while
-      // Node.js v18.1.0 implements it, it does not have a full fetch()
-      // implementation yet.
-      //
-      // Reference:
-      //   https://github.com/emscripten-core/emscripten/pull/16917
-      !ENVIRONMENT_IS_NODE &&
-      typeof fetch == 'function') {
-    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
-      // Suppress closure warning here since the upstream definition for
-      // instantiateStreaming only allows Promise<Repsponse> rather than
-      // an actual Response.
-      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
-      /** @suppress {checkTypes} */
-      var result = WebAssembly.instantiateStreaming(response, imports);
-
-      return result.then(
-        callback,
-        function(reason) {
-          // We expect the most common failure cause to be a bad MIME type for the binary,
-          // in which case falling back to ArrayBuffer instantiation should work.
-          err(`wasm streaming compile failed: ${reason}`);
-          err('falling back to ArrayBuffer instantiation');
-          return instantiateArrayBuffer(binaryFile, imports, callback);
-        });
-    });
-  }
-  return instantiateArrayBuffer(binaryFile, imports, callback);
-}
-
-// Create the wasm instance.
-// Receives the wasm imports, returns the exports.
-function createWasm() {
-  // prepare imports
-  var info = {
-    'env': wasmImports,
-    'wasi_snapshot_preview1': wasmImports,
-  };
-  // Load the wasm module and create an instance of using native support in the JS engine.
-  // handle a generated wasm instance, receiving its exports and
-  // performing other necessary setup
-  /** @param {WebAssembly.Module=} module*/
-  function receiveInstance(instance, module) {
-    wasmExports = instance.exports;
-
-    
-
-    wasmMemory = wasmExports['memory'];
-    
-    assert(wasmMemory, "memory not found in wasm exports");
-    // This assertion doesn't hold when emscripten is run in --post-link
-    // mode.
-    // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
-    //assert(wasmMemory.buffer.byteLength === 16777216);
-    updateMemoryViews();
-
-    addOnInit(wasmExports['__wasm_call_ctors']);
-
-    removeRunDependency('wasm-instantiate');
-    return wasmExports;
-  }
-  // wait for the pthread pool (if any)
-  addRunDependency('wasm-instantiate');
-
-  // Prefer streaming instantiation if available.
-  // Async compilation can be confusing when an error on the page overwrites Module
-  // (for example, if the order of elements is wrong, and the one defining Module is
-  // later), so we save Module and check it later.
-  var trueModule = Module;
-  function receiveInstantiationResult(result) {
-    // 'result' is a ResultObject object which has both the module and instance.
-    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
-    assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');
-    trueModule = null;
-    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
-    // When the regression is fixed, can restore the above PTHREADS-enabled path.
-    receiveInstance(result['instance']);
-  }
-
-  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
-  // to manually instantiate the Wasm module themselves. This allows pages to
-  // run the instantiation parallel to any other async startup actions they are
-  // performing.
-  // Also pthreads and wasm workers initialize the wasm instance through this
-  // path.
-  if (Module['instantiateWasm']) {
-
-    try {
-      return Module['instantiateWasm'](info, receiveInstance);
-    } catch(e) {
-      err(`Module.instantiateWasm callback failed with error: ${e}`);
-        // If instantiation fails, reject the module ready promise.
-        readyPromiseReject(e);
-    }
-  }
-
-  // If instantiation fails, reject the module ready promise.
-  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
-  return {}; // no exports yet; we'll fill them in later
-}
-
-// Globals used by JS i64 conversions (see makeSetValue)
-var tempDouble;
-var tempI64;
-
-// include: runtime_debug.js
-function legacyModuleProp(prop, newName, incomming=true) {
-  if (!Object.getOwnPropertyDescriptor(Module, prop)) {
-    Object.defineProperty(Module, prop, {
-      configurable: true,
-      get() {
-        let extra = incomming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : '';
-        abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
-
-      }
-    });
-  }
-}
-
-function ignoredModuleProp(prop) {
-  if (Object.getOwnPropertyDescriptor(Module, prop)) {
-    abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
-  }
-}
-
-// forcing the filesystem exports a few things by default
-function isExportedByForceFilesystem(name) {
-  return name === 'FS_createPath' ||
-         name === 'FS_createDataFile' ||
-         name === 'FS_createPreloadedFile' ||
-         name === 'FS_unlink' ||
-         name === 'addRunDependency' ||
-         // The old FS has some functionality that WasmFS lacks.
-         name === 'FS_createLazyFile' ||
-         name === 'FS_createDevice' ||
-         name === 'removeRunDependency';
-}
-
-function missingGlobal(sym, msg) {
-  if (typeof globalThis !== 'undefined') {
-    Object.defineProperty(globalThis, sym, {
-      configurable: true,
-      get() {
-        warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
-        return undefined;
-      }
-    });
-  }
-}
-
-missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');
-missingGlobal('asm', 'Please use wasmExports instead');
-
-function missingLibrarySymbol(sym) {
-  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
-    Object.defineProperty(globalThis, sym, {
-      configurable: true,
-      get() {
-        // Can't `abort()` here because it would break code that does runtime
-        // checks.  e.g. `if (typeof SDL === 'undefined')`.
-        var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
-        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
-        // library.js, which means $name for a JS name with no prefix, or name
-        // for a JS name like _name.
-        var librarySymbol = sym;
-        if (!librarySymbol.startsWith('_')) {
-          librarySymbol = '$' + sym;
-        }
-        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
-        if (isExportedByForceFilesystem(sym)) {
-          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
-        }
-        warnOnce(msg);
-        return undefined;
-      }
-    });
-  }
-  // Any symbol that is not included from the JS libary is also (by definition)
-  // not exported on the Module object.
-  unexportedRuntimeSymbol(sym);
-}
-
-function unexportedRuntimeSymbol(sym) {
-  if (!Object.getOwnPropertyDescriptor(Module, sym)) {
-    Object.defineProperty(Module, sym, {
-      configurable: true,
-      get() {
-        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
-        if (isExportedByForceFilesystem(sym)) {
-          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
-        }
-        abort(msg);
-      }
-    });
-  }
-}
-
-// Used by XXXXX_DEBUG settings to output debug messages.
-function dbg(text) {
-  // TODO(sbc): Make this configurable somehow.  Its not always convenient for
-  // logging to show up as warnings.
-  console.warn.apply(console, arguments);
-}
-// end include: runtime_debug.js
-// === Body ===
-
-// end include: preamble.js
-
-  /** @constructor */
-  function ExitStatus(status) {
-      this.name = 'ExitStatus';
-      this.message = `Program terminated with exit(${status})`;
-      this.status = status;
-    }
-
-  var callRuntimeCallbacks = (callbacks) => {
-      while (callbacks.length > 0) {
-        // Pass the module as the first argument.
-        callbacks.shift()(Module);
-      }
-    };
-
-  
-    /**
-     * @param {number} ptr
-     * @param {string} type
-     */
-  function getValue(ptr, type = 'i8') {
-    if (type.endsWith('*')) type = '*';
-    switch (type) {
-      case 'i1': return HEAP8[((ptr)>>0)];
-      case 'i8': return HEAP8[((ptr)>>0)];
-      case 'i16': return HEAP16[((ptr)>>1)];
-      case 'i32': return HEAP32[((ptr)>>2)];
-      case 'i64': abort('to do getValue(i64) use WASM_BIGINT');
-      case 'float': return HEAPF32[((ptr)>>2)];
-      case 'double': return HEAPF64[((ptr)>>3)];
-      case '*': return HEAPU32[((ptr)>>2)];
-      default: abort(`invalid type for getValue: ${type}`);
-    }
-  }
-
-  var noExitRuntime = Module['noExitRuntime'] || true;
-
-  var ptrToString = (ptr) => {
-      assert(typeof ptr === 'number');
-      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
-      ptr >>>= 0;
-      return '0x' + ptr.toString(16).padStart(8, '0');
-    };
-
-  
-    /**
-     * @param {number} ptr
-     * @param {number} value
-     * @param {string} type
-     */
-  function setValue(ptr, value, type = 'i8') {
-    if (type.endsWith('*')) type = '*';
-    switch (type) {
-      case 'i1': HEAP8[((ptr)>>0)] = value; break;
-      case 'i8': HEAP8[((ptr)>>0)] = value; break;
-      case 'i16': HEAP16[((ptr)>>1)] = value; break;
-      case 'i32': HEAP32[((ptr)>>2)] = value; break;
-      case 'i64': abort('to do setValue(i64) use WASM_BIGINT');
-      case 'float': HEAPF32[((ptr)>>2)] = value; break;
-      case 'double': HEAPF64[((ptr)>>3)] = value; break;
-      case '*': HEAPU32[((ptr)>>2)] = value; break;
-      default: abort(`invalid type for setValue: ${type}`);
-    }
-  }
-
-  var warnOnce = (text) => {
-      warnOnce.shown ||= {};
-      if (!warnOnce.shown[text]) {
-        warnOnce.shown[text] = 1;
-        if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text;
-        err(text);
-      }
-    };
-
-  var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
-  
-    /**
-     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
-     * array that contains uint8 values, returns a copy of that string as a
-     * Javascript String object.
-     * heapOrArray is either a regular array, or a JavaScript typed array view.
-     * @param {number} idx
-     * @param {number=} maxBytesToRead
-     * @return {string}
-     */
-  var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
-      var endIdx = idx + maxBytesToRead;
-      var endPtr = idx;
-      // TextDecoder needs to know the byte length in advance, it doesn't stop on
-      // null terminator by itself.  Also, use the length info to avoid running tiny
-      // strings through TextDecoder, since .subarray() allocates garbage.
-      // (As a tiny code save trick, compare endPtr against endIdx using a negation,
-      // so that undefined means Infinity)
-      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
-  
-      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-      }
-      var str = '';
-      // If building with TextDecoder, we have already computed the string length
-      // above, so test loop end condition against that
-      while (idx < endPtr) {
-        // For UTF8 byte structure, see:
-        // http://en.wikipedia.org/wiki/UTF-8#Description
-        // https://www.ietf.org/rfc/rfc2279.txt
-        // https://tools.ietf.org/html/rfc3629
-        var u0 = heapOrArray[idx++];
-        if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
-        var u1 = heapOrArray[idx++] & 63;
-        if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
-        var u2 = heapOrArray[idx++] & 63;
-        if ((u0 & 0xF0) == 0xE0) {
-          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
-        } else {
-          if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');
-          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
-        }
-  
-        if (u0 < 0x10000) {
-          str += String.fromCharCode(u0);
-        } else {
-          var ch = u0 - 0x10000;
-          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
-        }
-      }
-      return str;
-    };
-  
-    /**
-     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
-     * emscripten HEAP, returns a copy of that string as a Javascript String object.
-     *
-     * @param {number} ptr
-     * @param {number=} maxBytesToRead - An optional length that specifies the
-     *   maximum number of bytes to read. You can omit this parameter to scan the
-     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
-     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
-     *   string will cut short at that byte index (i.e. maxBytesToRead will not
-     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
-     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
-     *   JS JIT optimizations off, so it is worth to consider consistently using one
-     * @return {string}
-     */
-  var UTF8ToString = (ptr, maxBytesToRead) => {
-      assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`);
-      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
-    };
-  var ___assert_fail = (condition, filename, line, func) => {
-      abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
-    };
-
-  var _emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
-
-  var getHeapMax = () =>
-      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
-      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
-      // for any code that deals with heap sizes, which would require special
-      // casing all heap size related code to treat 0 specially.
-      2147483648;
-  
-  var growMemory = (size) => {
-      var b = wasmMemory.buffer;
-      var pages = (size - b.byteLength + 65535) / 65536;
-      try {
-        // round size grow request up to wasm page size (fixed 64KB per spec)
-        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
-        updateMemoryViews();
-        return 1 /*success*/;
-      } catch(e) {
-        err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);
-      }
-      // implicit 0 return to save code size (caller will cast "undefined" into 0
-      // anyhow)
-    };
-  var _emscripten_resize_heap = (requestedSize) => {
-      var oldSize = HEAPU8.length;
-      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
-      requestedSize >>>= 0;
-      // With multithreaded builds, races can happen (another thread might increase the size
-      // in between), so return a failure, and let the caller retry.
-      assert(requestedSize > oldSize);
-  
-      // Memory resize rules:
-      // 1.  Always increase heap size to at least the requested size, rounded up
-      //     to next page multiple.
-      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
-      //     geometrically: increase the heap size according to
-      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
-      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
-      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
-      //     linearly: increase the heap size by at least
-      //     MEMORY_GROWTH_LINEAR_STEP bytes.
-      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
-      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
-      // 4.  If we were unable to allocate as much memory, it may be due to
-      //     over-eager decision to excessively reserve due to (3) above.
-      //     Hence if an allocation fails, cut down on the amount of excess
-      //     growth, in an attempt to succeed to perform a smaller allocation.
-  
-      // A limit is set for how much we can grow. We should not exceed that
-      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
-      var maxHeapSize = getHeapMax();
-      if (requestedSize > maxHeapSize) {
-        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
-        return false;
-      }
-  
-      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
-  
-      // Loop through potential heap size increases. If we attempt a too eager
-      // reservation that fails, cut down on the attempted size and reserve a
-      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
-      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
-        // but limit overreserving (default to capping at +96MB overgrowth at most)
-        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );
-  
-        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
-  
-        var replacement = growMemory(newSize);
-        if (replacement) {
-  
-          return true;
-        }
-      }
-      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
-      return false;
-    };
-
-  var getCFunc = (ident) => {
-      var func = Module['_' + ident]; // closure exported function
-      assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
-      return func;
-    };
-  
-  
-  var writeArrayToMemory = (array, buffer) => {
-      assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)')
-      HEAP8.set(array, buffer);
-    };
-  
-  var lengthBytesUTF8 = (str) => {
-      var len = 0;
-      for (var i = 0; i < str.length; ++i) {
-        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
-        // unit, not a Unicode code point of the character! So decode
-        // UTF16->UTF32->UTF8.
-        // See http://unicode.org/faq/utf_bom.html#utf16-3
-        var c = str.charCodeAt(i); // possibly a lead surrogate
-        if (c <= 0x7F) {
-          len++;
-        } else if (c <= 0x7FF) {
-          len += 2;
-        } else if (c >= 0xD800 && c <= 0xDFFF) {
-          len += 4; ++i;
-        } else {
-          len += 3;
-        }
-      }
-      return len;
-    };
-  
-  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
-      assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`);
-      // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
-      // undefined and false each don't write out any bytes.
-      if (!(maxBytesToWrite > 0))
-        return 0;
-  
-      var startIdx = outIdx;
-      var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
-      for (var i = 0; i < str.length; ++i) {
-        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
-        // unit, not a Unicode code point of the character! So decode
-        // UTF16->UTF32->UTF8.
-        // See http://unicode.org/faq/utf_bom.html#utf16-3
-        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
-        // and https://www.ietf.org/rfc/rfc2279.txt
-        // and https://tools.ietf.org/html/rfc3629
-        var u = str.charCodeAt(i); // possibly a lead surrogate
-        if (u >= 0xD800 && u <= 0xDFFF) {
-          var u1 = str.charCodeAt(++i);
-          u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
-        }
-        if (u <= 0x7F) {
-          if (outIdx >= endIdx) break;
-          heap[outIdx++] = u;
-        } else if (u <= 0x7FF) {
-          if (outIdx + 1 >= endIdx) break;
-          heap[outIdx++] = 0xC0 | (u >> 6);
-          heap[outIdx++] = 0x80 | (u & 63);
-        } else if (u <= 0xFFFF) {
-          if (outIdx + 2 >= endIdx) break;
-          heap[outIdx++] = 0xE0 | (u >> 12);
-          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
-          heap[outIdx++] = 0x80 | (u & 63);
-        } else {
-          if (outIdx + 3 >= endIdx) break;
-          if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');
-          heap[outIdx++] = 0xF0 | (u >> 18);
-          heap[outIdx++] = 0x80 | ((u >> 12) & 63);
-          heap[outIdx++] = 0x80 | ((u >> 6) & 63);
-          heap[outIdx++] = 0x80 | (u & 63);
-        }
-      }
-      // Null-terminate the pointer to the buffer.
-      heap[outIdx] = 0;
-      return outIdx - startIdx;
-    };
-  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
-      assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
-      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
-    };
-  var stringToUTF8OnStack = (str) => {
-      var size = lengthBytesUTF8(str) + 1;
-      var ret = stackAlloc(size);
-      stringToUTF8(str, ret, size);
-      return ret;
-    };
-  
-  
-    /**
-     * @param {string|null=} returnType
-     * @param {Array=} argTypes
-     * @param {Arguments|Array=} args
-     * @param {Object=} opts
-     */
-  var ccall = (ident, returnType, argTypes, args, opts) => {
-      // For fast lookup of conversion functions
-      var toC = {
-        'string': (str) => {
-          var ret = 0;
-          if (str !== null && str !== undefined && str !== 0) { // null string
-            // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
-            ret = stringToUTF8OnStack(str);
-          }
-          return ret;
-        },
-        'array': (arr) => {
-          var ret = stackAlloc(arr.length);
-          writeArrayToMemory(arr, ret);
-          return ret;
-        }
-      };
-  
-      function convertReturnValue(ret) {
-        if (returnType === 'string') {
-          
-          return UTF8ToString(ret);
-        }
-        if (returnType === 'boolean') return Boolean(ret);
-        return ret;
-      }
-  
-      var func = getCFunc(ident);
-      var cArgs = [];
-      var stack = 0;
-      assert(returnType !== 'array', 'Return type should not be "array".');
-      if (args) {
-        for (var i = 0; i < args.length; i++) {
-          var converter = toC[argTypes[i]];
-          if (converter) {
-            if (stack === 0) stack = stackSave();
-            cArgs[i] = converter(args[i]);
-          } else {
-            cArgs[i] = args[i];
-          }
-        }
-      }
-      var ret = func.apply(null, cArgs);
-      function onDone(ret) {
-        if (stack !== 0) stackRestore(stack);
-        return convertReturnValue(ret);
-      }
-  
-      ret = onDone(ret);
-      return ret;
-    };
-  
-    /**
-     * @param {string=} returnType
-     * @param {Array=} argTypes
-     * @param {Object=} opts
-     */
-  var cwrap = (ident, returnType, argTypes, opts) => {
-      return function() {
-        return ccall(ident, returnType, argTypes, arguments, opts);
-      }
-    };
-
-
-function checkIncomingModuleAPI() {
-  ignoredModuleProp('fetchSettings');
-}
-var wasmImports = {
-  /** @export */
-  __assert_fail: ___assert_fail,
-  /** @export */
-  emscripten_memcpy_js: _emscripten_memcpy_js,
-  /** @export */
-  emscripten_resize_heap: _emscripten_resize_heap
-};
-var wasmExports = createWasm();
-var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors');
-var _ansilove_wasm_version = Module['_ansilove_wasm_version'] = createExportWrapper('ansilove_wasm_version');
-var _ansilove_wasm_render_ansi = Module['_ansilove_wasm_render_ansi'] = createExportWrapper('ansilove_wasm_render_ansi');
-var _free = Module['_free'] = createExportWrapper('free');
-var _ansilove_wasm_get_png_ptr = Module['_ansilove_wasm_get_png_ptr'] = createExportWrapper('ansilove_wasm_get_png_ptr');
-var _ansilove_wasm_get_png_length = Module['_ansilove_wasm_get_png_length'] = createExportWrapper('ansilove_wasm_get_png_length');
-var _ansilove_wasm_free_png = Module['_ansilove_wasm_free_png'] = createExportWrapper('ansilove_wasm_free_png');
-var _malloc = Module['_malloc'] = createExportWrapper('malloc');
-var ___errno_location = createExportWrapper('__errno_location');
-var _fflush = Module['_fflush'] = createExportWrapper('fflush');
-var _emscripten_builtin_memalign = createExportWrapper('emscripten_builtin_memalign');
-var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();
-var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();
-var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();
-var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();
-var stackSave = createExportWrapper('stackSave');
-var stackRestore = createExportWrapper('stackRestore');
-var stackAlloc = createExportWrapper('stackAlloc');
-var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])();
-
-
-// include: postamble.js
-// === Auto-generated postamble setup entry stuff ===
-
-Module['ccall'] = ccall;
-Module['cwrap'] = cwrap;
-Module['UTF8ToString'] = UTF8ToString;
-var missingLibrarySymbols = [
-  'writeI53ToI64',
-  'writeI53ToI64Clamped',
-  'writeI53ToI64Signaling',
-  'writeI53ToU64Clamped',
-  'writeI53ToU64Signaling',
-  'readI53FromI64',
-  'readI53FromU64',
-  'convertI32PairToI53',
-  'convertI32PairToI53Checked',
-  'convertU32PairToI53',
-  'zeroMemory',
-  'exitJS',
-  'isLeapYear',
-  'ydayFromDate',
-  'arraySum',
-  'addDays',
-  'setErrNo',
-  'inetPton4',
-  'inetNtop4',
-  'inetPton6',
-  'inetNtop6',
-  'readSockaddr',
-  'writeSockaddr',
-  'getHostByName',
-  'initRandomFill',
-  'randomFill',
-  'getCallstack',
-  'emscriptenLog',
-  'convertPCtoSourceLocation',
-  'readEmAsmArgs',
-  'jstoi_q',
-  'jstoi_s',
-  'getExecutableName',
-  'listenOnce',
-  'autoResumeAudioContext',
-  'dynCallLegacy',
-  'getDynCaller',
-  'dynCall',
-  'handleException',
-  'keepRuntimeAlive',
-  'runtimeKeepalivePush',
-  'runtimeKeepalivePop',
-  'callUserCallback',
-  'maybeExit',
-  'asmjsMangle',
-  'asyncLoad',
-  'alignMemory',
-  'mmapAlloc',
-  'handleAllocatorInit',
-  'HandleAllocator',
-  'getNativeTypeSize',
-  'STACK_SIZE',
-  'STACK_ALIGN',
-  'POINTER_SIZE',
-  'ASSERTIONS',
-  'uleb128Encode',
-  'sigToWasmTypes',
-  'generateFuncType',
-  'convertJsFunctionToWasm',
-  'getEmptyTableSlot',
-  'updateTableMap',
-  'getFunctionAddress',
-  'addFunction',
-  'removeFunction',
-  'reallyNegative',
-  'unSign',
-  'strLen',
-  'reSign',
-  'formatString',
-  'intArrayFromString',
-  'intArrayToString',
-  'AsciiToString',
-  'stringToAscii',
-  'UTF16ToString',
-  'stringToUTF16',
-  'lengthBytesUTF16',
-  'UTF32ToString',
-  'stringToUTF32',
-  'lengthBytesUTF32',
-  'stringToNewUTF8',
-  'registerKeyEventCallback',
-  'maybeCStringToJsString',
-  'findEventTarget',
-  'findCanvasEventTarget',
-  'getBoundingClientRect',
-  'fillMouseEventData',
-  'registerMouseEventCallback',
-  'registerWheelEventCallback',
-  'registerUiEventCallback',
-  'registerFocusEventCallback',
-  'fillDeviceOrientationEventData',
-  'registerDeviceOrientationEventCallback',
-  'fillDeviceMotionEventData',
-  'registerDeviceMotionEventCallback',
-  'screenOrientation',
-  'fillOrientationChangeEventData',
-  'registerOrientationChangeEventCallback',
-  'fillFullscreenChangeEventData',
-  'registerFullscreenChangeEventCallback',
-  'JSEvents_requestFullscreen',
-  'JSEvents_resizeCanvasForFullscreen',
-  'registerRestoreOldStyle',
-  'hideEverythingExceptGivenElement',
-  'restoreHiddenElements',
-  'setLetterbox',
-  'softFullscreenResizeWebGLRenderTarget',
-  'doRequestFullscreen',
-  'fillPointerlockChangeEventData',
-  'registerPointerlockChangeEventCallback',
-  'registerPointerlockErrorEventCallback',
-  'requestPointerLock',
-  'fillVisibilityChangeEventData',
-  'registerVisibilityChangeEventCallback',
-  'registerTouchEventCallback',
-  'fillGamepadEventData',
-  'registerGamepadEventCallback',
-  'disableGamepadApiIfItThrows',
-  'registerBeforeUnloadEventCallback',
-  'fillBatteryEventData',
-  'battery',
-  'registerBatteryEventCallback',
-  'setCanvasElementSize',
-  'getCanvasElementSize',
-  'demangle',
-  'demangleAll',
-  'jsStackTrace',
-  'stackTrace',
-  'getEnvStrings',
-  'checkWasiClock',
-  'flush_NO_FILESYSTEM',
-  'wasiRightsToMuslOFlags',
-  'wasiOFlagsToMuslOFlags',
-  'createDyncallWrapper',
-  'safeSetTimeout',
-  'setImmediateWrapped',
-  'clearImmediateWrapped',
-  'polyfillSetImmediate',
-  'getPromise',
-  'makePromise',
-  'idsToPromises',
-  'makePromiseCallback',
-  'ExceptionInfo',
-  'findMatchingCatch',
-  'Browser_asyncPrepareDataCounter',
-  'setMainLoop',
-  'getSocketFromFD',
-  'getSocketAddress',
-  'FS_createPreloadedFile',
-  'FS_modeStringToFlags',
-  'FS_getMode',
-  'FS_stdin_getChar',
-  'FS_createDataFile',
-  'FS_unlink',
-  'FS_mkdirTree',
-  '_setNetworkCallback',
-  'heapObjectForWebGLType',
-  'heapAccessShiftForWebGLHeap',
-  'webgl_enable_ANGLE_instanced_arrays',
-  'webgl_enable_OES_vertex_array_object',
-  'webgl_enable_WEBGL_draw_buffers',
-  'webgl_enable_WEBGL_multi_draw',
-  'emscriptenWebGLGet',
-  'computeUnpackAlignedImageSize',
-  'colorChannelsInGlTextureFormat',
-  'emscriptenWebGLGetTexPixelData',
-  '__glGenObject',
-  'emscriptenWebGLGetUniform',
-  'webglGetUniformLocation',
-  'webglPrepareUniformLocationsBeforeFirstUse',
-  'webglGetLeftBracePos',
-  'emscriptenWebGLGetVertexAttrib',
-  '__glGetActiveAttribOrUniform',
-  'writeGLArray',
-  'registerWebGlEventCallback',
-  'runAndAbortIfError',
-  'SDL_unicode',
-  'SDL_ttfContext',
-  'SDL_audio',
-  'ALLOC_NORMAL',
-  'ALLOC_STACK',
-  'allocate',
-  'writeStringToMemory',
-  'writeAsciiToMemory',
-];
-missingLibrarySymbols.forEach(missingLibrarySymbol)
-
-var unexportedSymbols = [
-  'run',
-  'addOnPreRun',
-  'addOnInit',
-  'addOnPreMain',
-  'addOnExit',
-  'addOnPostRun',
-  'addRunDependency',
-  'removeRunDependency',
-  'FS_createFolder',
-  'FS_createPath',
-  'FS_createLazyFile',
-  'FS_createLink',
-  'FS_createDevice',
-  'FS_readFile',
-  'out',
-  'err',
-  'callMain',
-  'abort',
-  'wasmMemory',
-  'wasmExports',
-  'stackAlloc',
-  'stackSave',
-  'stackRestore',
-  'getTempRet0',
-  'setTempRet0',
-  'writeStackCookie',
-  'checkStackCookie',
-  'ptrToString',
-  'getHeapMax',
-  'growMemory',
-  'ENV',
-  'MONTH_DAYS_REGULAR',
-  'MONTH_DAYS_LEAP',
-  'MONTH_DAYS_REGULAR_CUMULATIVE',
-  'MONTH_DAYS_LEAP_CUMULATIVE',
-  'ERRNO_CODES',
-  'ERRNO_MESSAGES',
-  'DNS',
-  'Protocols',
-  'Sockets',
-  'timers',
-  'warnOnce',
-  'UNWIND_CACHE',
-  'readEmAsmArgsArray',
-  'wasmTable',
-  'noExitRuntime',
-  'getCFunc',
-  'freeTableIndexes',
-  'functionsInTableMap',
-  'setValue',
-  'getValue',
-  'PATH',
-  'PATH_FS',
-  'UTF8Decoder',
-  'UTF8ArrayToString',
-  'stringToUTF8Array',
-  'stringToUTF8',
-  'lengthBytesUTF8',
-  'UTF16Decoder',
-  'stringToUTF8OnStack',
-  'writeArrayToMemory',
-  'JSEvents',
-  'specialHTMLTargets',
-  'currentFullscreenStrategy',
-  'restoreOldWindowedStyle',
-  'ExitStatus',
-  'promiseMap',
-  'uncaughtExceptionCount',
-  'exceptionLast',
-  'exceptionCaught',
-  'Browser',
-  'wget',
-  'SYSCALLS',
-  'preloadPlugins',
-  'FS_stdin_getChar_buffer',
-  'FS',
-  'MEMFS',
-  'TTY',
-  'PIPEFS',
-  'SOCKFS',
-  'tempFixedLengthArray',
-  'miniTempWebGLFloatBuffers',
-  'miniTempWebGLIntBuffers',
-  'GL',
-  'emscripten_webgl_power_preferences',
-  'AL',
-  'GLUT',
-  'EGL',
-  'GLEW',
-  'IDBStore',
-  'SDL',
-  'SDL_gfx',
-  'allocateUTF8',
-  'allocateUTF8OnStack',
-];
-unexportedSymbols.forEach(unexportedRuntimeSymbol);
-
-
-
-var calledRun;
-
-dependenciesFulfilled = function runCaller() {
-  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
-  if (!calledRun) run();
-  if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
-};
-
-function stackCheckInit() {
-  // This is normally called automatically during __wasm_call_ctors but need to
-  // get these values before even running any of the ctors so we call it redundantly
-  // here.
-  _emscripten_stack_init();
-  // TODO(sbc): Move writeStackCookie to native to to avoid this.
-  writeStackCookie();
-}
-
-function run() {
-
-  if (runDependencies > 0) {
-    return;
-  }
-
-    stackCheckInit();
-
-  preRun();
-
-  // a preRun added a dependency, run will be called later
-  if (runDependencies > 0) {
-    return;
-  }
-
-  function doRun() {
-    // run may have just been called through dependencies being fulfilled just in this very frame,
-    // or while the async setStatus time below was happening
-    if (calledRun) return;
-    calledRun = true;
-    Module['calledRun'] = true;
-
-    if (ABORT) return;
-
-    initRuntime();
-
-    readyPromiseResolve(Module);
-    if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
-
-    assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
-
-    postRun();
-  }
-
-  if (Module['setStatus']) {
-    Module['setStatus']('Running...');
-    setTimeout(function() {
-      setTimeout(function() {
-        Module['setStatus']('');
-      }, 1);
-      doRun();
-    }, 1);
-  } else
-  {
-    doRun();
-  }
-  checkStackCookie();
-}
-
-function checkUnflushedContent() {
-  // Compiler settings do not allow exiting the runtime, so flushing
-  // the streams is not possible. but in ASSERTIONS mode we check
-  // if there was something to flush, and if so tell the user they
-  // should request that the runtime be exitable.
-  // Normally we would not even include flush() at all, but in ASSERTIONS
-  // builds we do so just for this check, and here we see if there is any
-  // content to flush, that is, we check if there would have been
-  // something a non-ASSERTIONS build would have not seen.
-  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
-  // mode (which has its own special function for this; otherwise, all
-  // the code is inside libc)
-  var oldOut = out;
-  var oldErr = err;
-  var has = false;
-  out = err = (x) => {
-    has = true;
-  }
-  try { // it doesn't matter if it fails
-    _fflush(0);
-  } catch(e) {}
-  out = oldOut;
-  err = oldErr;
-  if (has) {
-    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');
-    warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');
-  }
-}
-
-if (Module['preInit']) {
-  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
-  while (Module['preInit'].length > 0) {
-    Module['preInit'].pop()();
-  }
-}
-
-run();
-
-
-// end include: postamble.js
-
-
-  return moduleArg.ready
-}
-);
-})();
-;
-export default Libansilove;
\ No newline at end of file
diff --git a/example/wasm/libansilove.wasm b/example/wasm/libansilove.wasm
deleted file mode 100755
index 44c4c8cadfd27dce3f54a9ad541b992f21f38385..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 172316
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

diff --git a/flake.lock b/flake.lock
index 2468070..36c990f 100644
--- a/flake.lock
+++ b/flake.lock
@@ -34,10 +34,27 @@
         "type": "github"
       }
     },
+    "nixpkgs-unstable": {
+      "locked": {
+        "lastModified": 1758029226,
+        "narHash": "sha256-TjqVmbpoCqWywY9xIZLTf6ANFvDCXdctCjoYuYPYdMI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "08b8f92ac6354983f5382124fef6006cade4a1c1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-unstable": "nixpkgs-unstable"
       }
     },
     "systems": {
diff --git a/flake.nix b/flake.nix
index 850f55d..d8b385a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -3,17 +3,20 @@
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
+    nixpkgs-unstable.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
     flake-utils.url = "github:numtide/flake-utils";
   };
 
   outputs = {
     self,
     nixpkgs,
+    nixpkgs-unstable,
     flake-utils,
   }:
     flake-utils.lib.eachDefaultSystem (
       system: let
         pkgs = import nixpkgs {inherit system;};
+        unstablePkgs = import nixpkgs-unstable { inherit system; };
         version = "1.4.2";
       in {
         packages.default = pkgs.stdenv.mkDerivation {
@@ -47,7 +50,7 @@
               pkgs.pkg-config
               pkgs.gd
               pkgs.emscripten
-              pkgs.bun
+              unstablePkgs.bun
               pkgs.clang
               pkgs.clang-tools
             ]
diff --git a/scripts/safari-wasm-smoke.js b/npm/packages/libansilove-demo-bun/scripts/safari-wasm-smoke.js
similarity index 94%
rename from scripts/safari-wasm-smoke.js
rename to npm/packages/libansilove-demo-bun/scripts/safari-wasm-smoke.js
index bc3af48..aee3862 100755
--- a/scripts/safari-wasm-smoke.js
+++ b/npm/packages/libansilove-demo-bun/scripts/safari-wasm-smoke.js
@@ -1,3 +1,5 @@
+// TODO: refactor this Safari automation to align with the new demo build.
+// TODO: ensure the script derives URLs from the Bun dev server dynamically.
 #!/usr/bin/osascript -l JavaScript
 ObjC.import('Foundation');
 
diff --git a/npm/packages/libansilove/README.md b/npm/packages/libansilove/README.md
index 82708b0..8825c21 100644
--- a/npm/packages/libansilove/README.md
+++ b/npm/packages/libansilove/README.md
@@ -14,43 +14,29 @@ bun add libansilove
 
 ## Usage
 
-### Node.js / Bun
-
 ```ts
-import { loadNode } from "libansilove";
+import { load } from "libansilove";
 
-const lib = await loadNode();
+const lib = await load();
 const { png } = lib.renderAnsi("Hello from libansilove!\r\n");
 console.log(`PNG size: ${png.byteLength} bytes`);
 ```
 
-### Browser / Worker
-
-```ts
-import { loadBrowser } from "libansilove";
-
-const lib = await loadBrowser();
-const { png } = lib.renderAnsi("Hello from libansilove!\r\n");
-const blob = new Blob([png], { type: "image/png" });
-document.querySelector("img")!.src = URL.createObjectURL(blob);
-```
-
-Both loaders accept an optional `locateFile` override if your bundler moves the
-`.wasm` payloads:
+The loader automatically works in browsers, workers, Node.js (>=18), Deno, and
+Bun. If your bundler relocates the `.wasm` payload, provide a `locateFile`
+override:
 
 ```ts
-const lib = await loadBrowser({
+const lib = await load({
   locateFile: (path) => new URL(`/static/wasm/${path}`, window.location.href).toString(),
 });
 ```
 
 ## API
 
-- `loadNode(options?)` – returns an object with the Emscripten module instance,
-  the detected libansilove version, and a `renderAnsi()` helper that yields a
+- `load(options?)` – returns an object with the Emscripten module instance, the
+  detected libansilove version, and a `renderAnsi()` helper that yields a
   `Uint8Array` containing the PNG bytes.
-- `loadBrowser(options?)` – same contract as `loadNode` but tuned for browser,
-  worker, and Deno style environments.
 - `createBindings(module)` – wrap a raw Emscripten module if you are managing
   instantiation yourself.
 
diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
index 97363ae..5ebab0e 100644
--- a/npm/packages/libansilove/package.json
+++ b/npm/packages/libansilove/package.json
@@ -9,23 +9,11 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./browser": {
-      "types": "./dist/browser.d.ts",
-      "import": "./dist/browser.js"
-    },
-    "./node": {
-      "types": "./dist/node.d.ts",
-      "import": "./dist/node.js"
-    },
-    "./wasm/browser": {
-      "default": "./dist/wasm/libansilove.browser.mjs"
-    },
-    "./wasm/node": {
-      "default": "./dist/wasm/libansilove.node.mjs"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
+    "./libansilove.js": "./dist/libansilove.js",
+    "./libansilove.wasm": "./dist/libansilove.wasm",
     "./package.json": "./package.json"
   },
   "files": [
@@ -39,11 +27,12 @@
     "build": "bun run clean && bun run build:wasm && bun run build:ts && bun run prepare:package",
     "check": "bunx tsc --noEmit",
     "verify": "bun run scripts/verify-dist.ts",
-    "test": "node ../../scripts/test-wasm-node.js npm/packages/libansilove/generated",
+    "test": "bun run build:wasm && bun test",
     "prepare": "bun run build"
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/node": "^20",
     "typescript": "^5.3.3"
   },
   "keywords": [
diff --git a/npm/packages/libansilove/scripts/build-wasm.bun.ts b/npm/packages/libansilove/scripts/build-wasm.bun.ts
index 0603b31..145a633 100644
--- a/npm/packages/libansilove/scripts/build-wasm.bun.ts
+++ b/npm/packages/libansilove/scripts/build-wasm.bun.ts
@@ -83,6 +83,7 @@ const main = async () => {
 	}) => {
 		const { outputName, exportName, environment } = options;
 		const outputPath = join(outDir, outputName);
+		const wasmPath = outputPath.replace(/\.js$/, ".wasm");
 		const args = [
 			...includeFlags,
 			"-O3",
@@ -112,8 +113,6 @@ const main = async () => {
 			);
 		}
 
-		const wasmPath = outputPath.replace(/\.mjs$/, ".wasm");
-
 		try {
 			await Promise.all([
 				access(outputPath, fsConstants.F_OK),
diff --git a/npm/packages/libansilove/scripts/prepare-package.ts b/npm/packages/libansilove/scripts/prepare-package.ts
index 8074f29..85c63b4 100644
--- a/npm/packages/libansilove/scripts/prepare-package.ts
+++ b/npm/packages/libansilove/scripts/prepare-package.ts
@@ -7,14 +7,11 @@ const scriptDir = dirname(fileURLToPath(import.meta.url));
 const pkgDir = resolve(scriptDir, "..");
 const rootDir = resolve(pkgDir, "../../..");
 const distDir = resolve(pkgDir, "dist");
-const wasmDir = resolve(distDir, "wasm");
 const generatedDir = resolve(pkgDir, "generated");
 
 const REQUIRED_ARTIFACTS = [
-	"libansilove.browser.mjs",
-	"libansilove.browser.wasm",
-	"libansilove.node.mjs",
-	"libansilove.node.wasm",
+	"libansilove.js",
+	"libansilove.wasm",
 ];
 
 async function ensureArtifacts() {
@@ -31,12 +28,9 @@ async function ensureArtifacts() {
 }
 
 async function copyAssets() {
-	await rm(wasmDir, { recursive: true, force: true });
-	await mkdir(wasmDir, { recursive: true });
-
 	await Promise.all(
 		REQUIRED_ARTIFACTS.map((artifact) =>
-			copyFile(join(generatedDir, artifact), join(wasmDir, artifact))
+			copyFile(join(generatedDir, artifact), join(distDir, artifact))
 		),
 	);
 
diff --git a/npm/packages/libansilove/scripts/verify-dist.ts b/npm/packages/libansilove/scripts/verify-dist.ts
index 6075e1b..03d6c4f 100644
--- a/npm/packages/libansilove/scripts/verify-dist.ts
+++ b/npm/packages/libansilove/scripts/verify-dist.ts
@@ -2,8 +2,8 @@
 const moduleURL = new URL("../dist/index.js", import.meta.url).href;
 
 async function main() {
-	const mod = (await import(moduleURL)) as { loadNode: typeof import("../src/node").loadNode };
-	const bindings = await mod.loadNode();
+	const mod = await import(moduleURL) as { load: typeof import("../src/index").load };
+	const bindings = await mod.load();
 	const { png } = bindings.renderAnsi("Hello from libansilove!\r\n");
 	if (!png.byteLength) {
 		throw new Error("renderAnsi returned an empty buffer");
diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
index 729dcda..6eb6cf1 100644
--- a/npm/packages/libansilove/src/bindings.ts
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -1,13 +1,19 @@
-import type { EmscriptenModule, LibansiloveBindings, RenderInput, RenderOptions, RenderResult } from "./types";
+import type {
+	EmscriptenModule,
+	LibansiloveBindings,
+	RenderInput,
+	RenderOptions,
+	RenderResult,
+} from "./types";
 
 const encoder = new TextEncoder();
 
-const DEFAULT_RENDER_ARGS = {
+const DEFAULT_RENDER_ARGS: Required<RenderOptions> = {
 	columns: 0,
 	bits: 0,
 	mode: 0,
 	iceColors: 0,
-} as const;
+};
 
 export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 	const getVersion = Module.cwrap("ansilove_wasm_version", "string", []) as () => string;
@@ -26,7 +32,9 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 	const renderAnsi = (input: RenderInput, options: RenderOptions = {}): RenderResult => {
 		const data = typeof input === "string" ? encoder.encode(input) : input;
 		const ptr = Module._malloc(data.length || 1);
-		Module.HEAPU8.set(data, ptr);
+		if (data.length > 0) {
+			Module.HEAPU8.set(data, ptr);
+		}
 
 		const cols = options.columns ?? DEFAULT_RENDER_ARGS.columns;
 		const bits = options.bits ?? DEFAULT_RENDER_ARGS.bits;
@@ -44,6 +52,7 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 		if (!pngPtr || pngLength <= 0) {
 			throw new Error("libansilove returned an empty PNG buffer");
 		}
+
 		const png = Module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
 		freePng();
 
diff --git a/npm/packages/libansilove/src/browser.ts b/npm/packages/libansilove/src/browser.ts
deleted file mode 100644
index 8efd394..0000000
--- a/npm/packages/libansilove/src/browser.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { createBindings } from "./bindings";
-import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
-
-const DEFAULT_LOCATE = (path: string) => new URL(`./wasm/${path}`, import.meta.url).href;
-
-export async function loadBrowser(options: LoadOptions = {}): Promise<LibansiloveBindings> {
-	const factoryModule: { default: ModuleFactory } = await import("./wasm/libansilove.browser.mjs");
-	const factory = factoryModule.default;
-	const locateFile = options.locateFile ?? DEFAULT_LOCATE;
-	const overrides = { ...(options.module ?? {}), locateFile };
-	const instance = await factory(overrides);
-	return createBindings(instance);
-}
diff --git a/npm/packages/libansilove/src/index.ts b/npm/packages/libansilove/src/index.ts
index ed6973b..ad9dc95 100644
--- a/npm/packages/libansilove/src/index.ts
+++ b/npm/packages/libansilove/src/index.ts
@@ -1,6 +1,17 @@
-export { loadBrowser } from "./browser";
-export { loadNode } from "./node";
-export { createBindings } from "./bindings";
+import factory from "./libansilove.js";
+import { createBindings } from "./bindings";
+import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
+
+const DEFAULT_LOCATE_FILE = (path: string) => new URL(`./${path}`, import.meta.url).href;
+
+export async function load(options: LoadOptions = {}): Promise<LibansiloveBindings> {
+	const locateFile = options.locateFile ?? DEFAULT_LOCATE_FILE;
+	const overrides = { ...(options.module ?? {}), locateFile };
+	const module = await (factory as ModuleFactory)(overrides);
+	return createBindings(module);
+}
+
+export { createBindings };
 export type {
 	LibansiloveBindings,
 	LoadOptions,
@@ -11,3 +22,5 @@ export type {
 	ModuleFactory,
 	ModuleOverrides,
 } from "./types";
+
+export default load;
diff --git a/npm/packages/libansilove/src/libansilove.d.ts b/npm/packages/libansilove/src/libansilove.d.ts
new file mode 100644
index 0000000..f5a6091
--- /dev/null
+++ b/npm/packages/libansilove/src/libansilove.d.ts
@@ -0,0 +1,5 @@
+declare module "./libansilove.js" {
+	import type { ModuleFactory } from "./types";
+	const factory: ModuleFactory;
+	export default factory;
+}
diff --git a/npm/packages/libansilove/src/libansilove.js b/npm/packages/libansilove/src/libansilove.js
new file mode 100644
index 0000000..678c561
--- /dev/null
+++ b/npm/packages/libansilove/src/libansilove.js
@@ -0,0 +1 @@
+export { default } from "../generated/libansilove.js";
diff --git a/npm/packages/libansilove/src/node.ts b/npm/packages/libansilove/src/node.ts
deleted file mode 100644
index 496275f..0000000
--- a/npm/packages/libansilove/src/node.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { createBindings } from "./bindings";
-import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
-
-const DEFAULT_LOCATE = (path: string) => new URL(`./wasm/${path}`, import.meta.url).href;
-
-export async function loadNode(options: LoadOptions = {}): Promise<LibansiloveBindings> {
-	const factoryModule: { default: ModuleFactory } = await import("./wasm/libansilove.node.mjs");
-	const factory = factoryModule.default;
-	const locateFile = options.locateFile ?? DEFAULT_LOCATE;
-	const overrides = { ...(options.module ?? {}), locateFile };
-	const instance = await factory(overrides);
-	return createBindings(instance);
-}
diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
index 49f0cc1..05b5ac4 100644
--- a/npm/packages/libansilove/src/types.ts
+++ b/npm/packages/libansilove/src/types.ts
@@ -1,18 +1,13 @@
 export interface RenderOptions {
-	/** Number of columns to assume when rendering (0 lets libansilove decide). */
 	readonly columns?: number;
-	/** Bits per pixel mode (0 = default). */
 	readonly bits?: number;
-	/** Rendering mode flag (0 = default). */
 	readonly mode?: number;
-	/** Whether to enable ICE colors (0 = disabled). */
 	readonly iceColors?: number;
 }
 
 export type RenderInput = string | Uint8Array;
 
 export interface RenderResult {
-	/** PNG payload produced by the conversion. */
 	readonly png: Uint8Array;
 }
 
@@ -36,6 +31,8 @@ export interface EmscriptenModule {
 	_free(ptr: number): void;
 }
 
-export type ModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (overrides?: ModuleOverrides & {
-	locateFile?: (path: string) => string;
-}) => Promise<T>;
+export type ModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (
+	overrides?: ModuleOverrides & {
+		locateFile?: (path: string) => string;
+	},
+) => Promise<T>;
diff --git a/npm/packages/libansilove/src/wasm-modules.d.ts b/npm/packages/libansilove/src/wasm-modules.d.ts
deleted file mode 100644
index 1c5662e..0000000
--- a/npm/packages/libansilove/src/wasm-modules.d.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-declare module "./wasm/libansilove.browser.mjs" {
-	import type { ModuleFactory } from "./types";
-	const factory: ModuleFactory;
-	export default factory;
-}
-
-declare module "./wasm/libansilove.node.mjs" {
-	import type { ModuleFactory } from "./types";
-	const factory: ModuleFactory;
-	export default factory;
-}
diff --git a/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts b/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
deleted file mode 100644
index 870bf46..0000000
--- a/npm/packages/libansilove/src/wasm/libansilove.browser.mjs.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import type { ModuleFactory } from "../types";
-declare const factory: ModuleFactory;
-export default factory;
diff --git a/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts b/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
deleted file mode 100644
index 870bf46..0000000
--- a/npm/packages/libansilove/src/wasm/libansilove.node.mjs.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import type { ModuleFactory } from "../types";
-declare const factory: ModuleFactory;
-export default factory;
diff --git a/npm/packages/libansilove/tests/render.test.ts b/npm/packages/libansilove/tests/render.test.ts
new file mode 100644
index 0000000..b689998
--- /dev/null
+++ b/npm/packages/libansilove/tests/render.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test";
+import { load } from "../src/index";
+
+const SAMPLE = "\u001b[1;36mHello from libansilove!\u001b[0m\r\n";
+
+describe("libansilove wasm bindings", () => {
+	it("renders ANSI art to PNG", async () => {
+		const bindings = await load();
+		const { png } = bindings.renderAnsi(SAMPLE);
+		expect(png.byteLength).toBeGreaterThan(8);
+	});
+});
diff --git a/npm/packages/libansilove/tsconfig.build.json b/npm/packages/libansilove/tsconfig.build.json
index c61dfa5..44d0de5 100644
--- a/npm/packages/libansilove/tsconfig.build.json
+++ b/npm/packages/libansilove/tsconfig.build.json
@@ -9,7 +9,6 @@
     "sourceMap": true,
     "emitDeclarationOnly": false,
     "stripInternal": true,
-    "allowImportingTsExtensions": false,
     "allowArbitraryExtensions": true
   },
   "include": ["src/**/*.ts", "src/**/*.d.ts"],
diff --git a/npm/packages/libansilove/tsconfig.json b/npm/packages/libansilove/tsconfig.json
index 3451c21..721b41b 100644
--- a/npm/packages/libansilove/tsconfig.json
+++ b/npm/packages/libansilove/tsconfig.json
@@ -6,7 +6,6 @@
     "moduleResolution": "bundler",
     "moduleDetection": "force",
     "verbatimModuleSyntax": true,
-    "allowImportingTsExtensions": true,
     "allowArbitraryExtensions": true,
     "noEmit": true,
     "strict": true,
@@ -21,6 +20,7 @@
   "include": [
     "src/**/*.ts",
     "src/**/*.d.ts",
-    "scripts/**/*.ts"
+    "scripts/**/*.ts",
+    "tests/**/*.ts"
   ]
 }
diff --git a/scripts/test-wasm-browser.sh b/scripts/test-wasm-browser.sh
deleted file mode 100755
index bc5043b..0000000
--- a/scripts/test-wasm-browser.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-PORT="${PORT:-8765}"
-DOC_ROOT="example/wasm"
-URL="http://localhost:${PORT}/index.html"
-
-if ! command -v osascript >/dev/null; then
-  echo "error: osascript is required on macOS to drive Safari." >&2
-  exit 2
-fi
-
-if ! command -v python3 >/dev/null; then
-  echo "error: python3 is required to start the local web server." >&2
-  exit 2
-fi
-
-if [ ! -f "${DOC_ROOT}/libansilove.browser.mjs" ]; then
-  echo "error: ${DOC_ROOT}/libansilove.browser.mjs not found; run scripts/test-wasm.sh first." >&2
-  exit 3
-fi
-
-LOG_FILE=$(mktemp -t libansilove-wasm-http.XXXXXX.log)
-cleanup() {
-  if [ -n "${SERVER_PID:-}" ]; then
-    kill "${SERVER_PID}" 2>/dev/null || true
-  fi
-  rm -f "$LOG_FILE"
-}
-trap cleanup EXIT
-
-python3 -m http.server "${PORT}" --directory "${DOC_ROOT}" >"$LOG_FILE" 2>&1 &
-SERVER_PID=$!
-
-# Give the server a moment to come up
-sleep 1
-
-"$(dirname "$0")/safari-wasm-smoke.js" "$URL"
-
-echo "Safari smoke test passed for $URL"
diff --git a/scripts/test-wasm-node.js b/scripts/test-wasm-node.js
deleted file mode 100755
index a8f1087..0000000
--- a/scripts/test-wasm-node.js
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const { TextEncoder } = require('util');
-const { pathToFileURL } = require('url');
-
-async function loadFactory(factoryPath) {
-  const module = await import(pathToFileURL(factoryPath).href);
-  const factory = module.default ?? module;
-  if (typeof factory !== 'function') {
-    throw new Error('libansilove module did not export an initialization function');
-  }
-  return factory;
-}
-
-async function main() {
-  const buildDir = path.resolve(process.argv[2] || 'npm/packages/libansilove/generated');
-  const outputPath = path.resolve(process.argv[3] || path.join(buildDir, 'test-output.png'));
-  const factoryPath = path.resolve(process.argv[4] || path.join(buildDir, 'libansilove.node.mjs'));
-  const sampleText = process.argv[5] || 'Hello from libansilove!\r\n';
-
-  if (!fs.existsSync(factoryPath)) {
-    throw new Error(`expected wasm factory at ${factoryPath} (run scripts/test-wasm.sh first)`);
-  }
-
-  const factory = await loadFactory(factoryPath);
-  const Module = await factory();
-  const getVersion = Module.cwrap('ansilove_wasm_version', 'string', []);
-  const renderAnsi = Module.cwrap('ansilove_wasm_render_ansi', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
-  const getPtr = Module.cwrap('ansilove_wasm_get_png_ptr', 'number', []);
-  const getLen = Module.cwrap('ansilove_wasm_get_png_length', 'number', []);
-  const freePng = Module.cwrap('ansilove_wasm_free_png', null, []);
-
-  const encoder = new TextEncoder();
-  const input = encoder.encode(sampleText);
-  const ptr = Module._malloc(input.length);
-  Module.HEAPU8.set(input, ptr);
-
-  const rc = renderAnsi(ptr, input.length, 0, 0, 0, 0);
-  Module._free(ptr);
-  if (rc !== 0) {
-    throw new Error(`ansilove_wasm_render_ansi returned ${rc}`);
-  }
-
-  const pngPtr = getPtr();
-  const pngLength = getLen();
-  if (!pngPtr || pngLength <= 8) {
-    throw new Error(`unexpected PNG length ${pngLength}`);
-  }
-
-  const pngData = Module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
-  freePng();
-
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, Buffer.from(pngData));
-
-  const version = getVersion();
-  console.log(`Generated ${path.relative(process.cwd(), outputPath)} (${pngData.length} bytes) using libansilove wasm ${version}.`);
-}
-
-main().catch((error) => {
-  console.error(error && error.stack ? error.stack : error);
-  process.exit(1);
-});
diff --git a/scripts/test-wasm.sh b/scripts/test-wasm.sh
deleted file mode 100755
index 37e443e..0000000
--- a/scripts/test-wasm.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if ! command -v bun >/dev/null; then
-  echo "error: bun is required (enter via 'nix develop')." >&2
-  exit 2
-fi
-
-artifacts_dir="npm/packages/libansilove/generated"
-browser_js="$artifacts_dir/libansilove.browser.mjs"
-browser_wasm="$artifacts_dir/libansilove.browser.wasm"
-node_js="$artifacts_dir/libansilove.node.mjs"
-node_wasm="$artifacts_dir/libansilove.node.wasm"
-
-bun npm/packages/libansilove/scripts/build-wasm.bun.ts
-
-if [ ! -f "$browser_js" ] || [ ! -f "$browser_wasm" ]; then
-  echo "error: expected browser artefacts ($browser_js, $browser_wasm)" >&2
-  exit 3
-fi
-
-if [ ! -f "$node_js" ] || [ ! -f "$node_wasm" ]; then
-  echo "error: expected node artefacts ($node_js, $node_wasm)" >&2
-  exit 4
-fi
-
-node scripts/test-wasm-node.js "$artifacts_dir" "$artifacts_dir/test-output.png" "$node_js"
-
-mkdir -p example/wasm
-cp "$browser_js" example/wasm/libansilove.browser.mjs
-cp "$browser_wasm" example/wasm/libansilove.browser.wasm
-
-echo "WASM artefacts found in $artifacts_dir" >&2

From 6439f3c7b206e58c96c71180eb2efa4c32a7dbc8 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 00:18:04 -0400
Subject: [PATCH 18/26] Refactor: Move generated WASM and JS to /generated

The `libansilove.js` and `libansilove.wasm` artifacts are now placed within a `generated` subdirectory of `dist`. This change improves
organization and clarity by grouping generated files.

The `package.json` has been updated to reflect the new import paths for these files. The `prepare-package.ts` script now ensures that the
`dist/generated` directory exists and copies the artifacts there.

Additionally, memory management in `src/bindings.ts` has been improved by using `using` for `_malloc` and `freePng`, ensuring resources are
properly cleaned up.
---
 npm/packages/libansilove/package.json         |  4 +--
 .../libansilove/scripts/prepare-package.ts    |  5 ++-
 npm/packages/libansilove/src/bindings.ts      | 29 +++++++++++----
 ...ibansilove.d.ts => generated-factory.d.ts} |  2 +-
 npm/packages/libansilove/src/index.ts         | 36 +++++++++++++++----
 npm/packages/libansilove/src/libansilove.js   |  1 -
 6 files changed, 59 insertions(+), 18 deletions(-)
 rename npm/packages/libansilove/src/{libansilove.d.ts => generated-factory.d.ts} (69%)
 delete mode 100644 npm/packages/libansilove/src/libansilove.js

diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
index 5ebab0e..d33e6cc 100644
--- a/npm/packages/libansilove/package.json
+++ b/npm/packages/libansilove/package.json
@@ -12,8 +12,8 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./libansilove.js": "./dist/libansilove.js",
-    "./libansilove.wasm": "./dist/libansilove.wasm",
+    "./libansilove.js": "./dist/generated/libansilove.js",
+    "./libansilove.wasm": "./dist/generated/libansilove.wasm",
     "./package.json": "./package.json"
   },
   "files": [
diff --git a/npm/packages/libansilove/scripts/prepare-package.ts b/npm/packages/libansilove/scripts/prepare-package.ts
index 85c63b4..98115ac 100644
--- a/npm/packages/libansilove/scripts/prepare-package.ts
+++ b/npm/packages/libansilove/scripts/prepare-package.ts
@@ -8,6 +8,7 @@ const pkgDir = resolve(scriptDir, "..");
 const rootDir = resolve(pkgDir, "../../..");
 const distDir = resolve(pkgDir, "dist");
 const generatedDir = resolve(pkgDir, "generated");
+const distGeneratedDir = resolve(distDir, "generated");
 
 const REQUIRED_ARTIFACTS = [
 	"libansilove.js",
@@ -28,9 +29,11 @@ async function ensureArtifacts() {
 }
 
 async function copyAssets() {
+	await rm(distGeneratedDir, { recursive: true, force: true });
+	await mkdir(distGeneratedDir, { recursive: true });
 	await Promise.all(
 		REQUIRED_ARTIFACTS.map((artifact) =>
-			copyFile(join(generatedDir, artifact), join(distDir, artifact))
+			copyFile(join(generatedDir, artifact), join(distGeneratedDir, artifact))
 		),
 	);
 
diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
index 6eb6cf1..02c71d5 100644
--- a/npm/packages/libansilove/src/bindings.ts
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -15,6 +15,25 @@ const DEFAULT_RENDER_ARGS: Required<RenderOptions> = {
 	iceColors: 0,
 };
 
+const toDisposable = (fn: () => void) => ({
+	[Symbol.dispose]() {
+		fn();
+	},
+});
+
+const allocateBuffer = (Module: EmscriptenModule, data: Uint8Array) => {
+	const ptr = Module._malloc(data.length || 1);
+	if (data.length > 0) {
+		Module.HEAPU8.set(data, ptr);
+	}
+	return {
+		ptr,
+	[Symbol.dispose]() {
+		Module._free(ptr);
+	},
+	};
+};
+
 export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 	const getVersion = Module.cwrap("ansilove_wasm_version", "string", []) as () => string;
 	const renderAnsiFn = Module.cwrap("ansilove_wasm_render_ansi", "number", [
@@ -31,18 +50,14 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 
 	const renderAnsi = (input: RenderInput, options: RenderOptions = {}): RenderResult => {
 		const data = typeof input === "string" ? encoder.encode(input) : input;
-		const ptr = Module._malloc(data.length || 1);
-		if (data.length > 0) {
-			Module.HEAPU8.set(data, ptr);
-		}
+		using buffer = allocateBuffer(Module, data);
 
 		const cols = options.columns ?? DEFAULT_RENDER_ARGS.columns;
 		const bits = options.bits ?? DEFAULT_RENDER_ARGS.bits;
 		const mode = options.mode ?? DEFAULT_RENDER_ARGS.mode;
 		const ice = options.iceColors ?? DEFAULT_RENDER_ARGS.iceColors;
 
-		const code = renderAnsiFn(ptr, data.length, cols, bits, mode, ice);
-		Module._free(ptr);
+		const code = renderAnsiFn(buffer.ptr, data.length, cols, bits, mode, ice);
 		if (code !== 0) {
 			throw new Error(`ansilove_wasm_render_ansi failed with exit code ${code}`);
 		}
@@ -53,8 +68,8 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 			throw new Error("libansilove returned an empty PNG buffer");
 		}
 
+		using pngHandle = toDisposable(freePng);
 		const png = Module.HEAPU8.slice(pngPtr, pngPtr + pngLength);
-		freePng();
 
 		return { png };
 	};
diff --git a/npm/packages/libansilove/src/libansilove.d.ts b/npm/packages/libansilove/src/generated-factory.d.ts
similarity index 69%
rename from npm/packages/libansilove/src/libansilove.d.ts
rename to npm/packages/libansilove/src/generated-factory.d.ts
index f5a6091..1eb16c6 100644
--- a/npm/packages/libansilove/src/libansilove.d.ts
+++ b/npm/packages/libansilove/src/generated-factory.d.ts
@@ -1,4 +1,4 @@
-declare module "./libansilove.js" {
+declare module "../generated/libansilove.js" {
 	import type { ModuleFactory } from "./types";
 	const factory: ModuleFactory;
 	export default factory;
diff --git a/npm/packages/libansilove/src/index.ts b/npm/packages/libansilove/src/index.ts
index ad9dc95..3d284a6 100644
--- a/npm/packages/libansilove/src/index.ts
+++ b/npm/packages/libansilove/src/index.ts
@@ -1,13 +1,37 @@
-import factory from "./libansilove.js";
 import { createBindings } from "./bindings";
-import type { LibansiloveBindings, LoadOptions, ModuleFactory } from "./types";
+import type {
+	LibansiloveBindings,
+	LoadOptions,
+	ModuleFactory,
+	ModuleOverrides,
+	RenderInput,
+	RenderOptions,
+	RenderResult,
+	EmscriptenModule,
+} from "./types";
+
+const FACTORY_URL = new URL("../generated/libansilove.js", import.meta.url);
+
+let cachedFactory: ModuleFactory | null = null;
+
+async function resolveFactory(): Promise<ModuleFactory> {
+	if (!cachedFactory) {
+		const module = await import(FACTORY_URL.href);
+		cachedFactory = (module as { default: ModuleFactory }).default;
+	}
+	return cachedFactory;
+}
 
-const DEFAULT_LOCATE_FILE = (path: string) => new URL(`./${path}`, import.meta.url).href;
+const buildLocateFile = (base: URL) => {
+	const baseDir = new URL("./", base);
+	return (path: string) => new URL(path, baseDir).href;
+};
 
 export async function load(options: LoadOptions = {}): Promise<LibansiloveBindings> {
-	const locateFile = options.locateFile ?? DEFAULT_LOCATE_FILE;
-	const overrides = { ...(options.module ?? {}), locateFile };
-	const module = await (factory as ModuleFactory)(overrides);
+	const factory = await resolveFactory();
+	const locateFile = options.locateFile ?? buildLocateFile(FACTORY_URL);
+	const overrides: ModuleOverrides = { ...(options.module ?? {}), locateFile };
+	const module = await factory(overrides);
 	return createBindings(module);
 }
 
diff --git a/npm/packages/libansilove/src/libansilove.js b/npm/packages/libansilove/src/libansilove.js
deleted file mode 100644
index 678c561..0000000
--- a/npm/packages/libansilove/src/libansilove.js
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "../generated/libansilove.js";

From a5c97be5b40c16b7f7f9aae784a8b793230cce44 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 00:56:05 -0400
Subject: [PATCH 19/26] feat: Add ArrayBuffer support for render input

The `RenderInput` type now accepts `ArrayBuffer` in addition to `string` and `Uint8Array`. This allows for more flexible handling of input
data.

Additionally, a new test case for `CL!-AL07.ANS` has been added to ensure compatibility with existing rendering outputs.
---
 npm/packages/libansilove/src/types.ts           |   8 ++++++--
 npm/packages/libansilove/tests/CL!-AL07.ANS     |  15 +++++++++++++++
 npm/packages/libansilove/tests/CL!-AL07.ANS.png | Bin 0 -> 2581 bytes
 npm/packages/libansilove/tests/render.test.ts   |  16 ++++++++++++++--
 4 files changed, 35 insertions(+), 4 deletions(-)
 create mode 100644 npm/packages/libansilove/tests/CL!-AL07.ANS
 create mode 100644 npm/packages/libansilove/tests/CL!-AL07.ANS.png

diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
index 05b5ac4..db7c49f 100644
--- a/npm/packages/libansilove/src/types.ts
+++ b/npm/packages/libansilove/src/types.ts
@@ -5,7 +5,7 @@ export interface RenderOptions {
 	readonly iceColors?: number;
 }
 
-export type RenderInput = string | Uint8Array;
+export type RenderInput = string | Uint8Array | ArrayBuffer;
 
 export interface RenderResult {
 	readonly png: Uint8Array;
@@ -25,7 +25,11 @@ export interface LoadOptions {
 export type ModuleOverrides = Record<string, unknown>;
 
 export interface EmscriptenModule {
-	cwrap(name: string, returnType: string | null, argTypes: string[]): (...args: unknown[]) => any;
+	cwrap(
+		name: string,
+		returnType: string | null,
+		argTypes: string[],
+	): (...args: unknown[]) => any;
 	HEAPU8: Uint8Array;
 	_malloc(size: number): number;
 	_free(ptr: number): void;
diff --git a/npm/packages/libansilove/tests/CL!-AL07.ANS b/npm/packages/libansilove/tests/CL!-AL07.ANS
new file mode 100644
index 0000000..3f2de40
--- /dev/null
+++ b/npm/packages/libansilove/tests/CL!-AL07.ANS
@@ -0,0 +1,15 @@
+
+    � � � � ��� �    � � � � ��� �� ����� � �    � � �   � � ���� � ���� �    � � �� ����� ��  � � �� � ��� ��  �� ��� �� � �    � � �   �� ������ ������
+    � � � ����� � �  � � � ����� � �  � � ����� � �    � � �    �� ��� �� ��� ��    � � �  �  � � �  � � �  �  � � �  � � �  � �       � ���� � ���� �
+� � �  � � �� � �  � � �������� � �   � ������ ������ � ��  � ������ � � �  � � �  �  � � �  �� ����� � �� �  �� ��    �� ��� �� ��� ���  �� �������� �� �  � � �  �  � � �    � ����� � � �  � � �    �� ��� �� ��� ���  � � ������ � � �  � � �  �  � � �� � �  � � �   � ������ ������ ��  � � �  Cl! � � �  � � �  �  � � �  � � �  �  � � �  � � �    � ���� � ���� �
+�  � � ���� � � � ���� � �     � � �  � � � � ��� � �  � � �    �� ��� �� ��� ���  �� ����� � �� ����� � �  �  �� ��  � � �� ����� ��  � � �   �� ������ ������
+ �   � ���� � � � ���� � �     � � �  � � � � ��� �    � � �     � ���  � ���  �    � � �
+���  �����     � � �          � ��� � � � �  � � �  �  � � �  � � � � ��� �   �
+�� �� ��� ��   �� ��  �  �  �� ����� �� � �  �� ��  �  � � �  �� �� � ���� ��  ���� � ���� �   � � �  � �   � � ����� � � �  � � �  �  � � �  � � � � ��� � �  ����� ������    � � �    ��  � � �     � � �  � � �  �  � � �  � � �  �  � � �  ��� �� ��� ��   � � �  � �   � � �  �  � � �  � � �  �  � � �  � � ������� � �  ��� �� ��� ��   � � �  �  �  � � �  �  � � �  � � �     � � �  � �� ��� ��� ��  ����� ������    � � �  �  �  � � �  �  � � �  � � �  �  � � �  � � � ����� �  ��
+��� � ���� �   � � �  �     � � �  �  � � �  � � �  �  � � �  � � �
+�� �� ��� ��   � � �  � ��  � � �     � � �  � � �� � �  � � �   �  � � �
+��� ������ �   � � �����    � � � ����� � �  � � ����� � � �  � � ��� �� � � �
+�� �  ��� �    �� �� �� ��  � � �� ����� ��  �� ����� �� � �  �� ������ �� � �
+��� ������ �     � ��� � �  � � � � ��� �� ��� � � � �    � ���� � � � �
+�ANSi�
+
\ No newline at end of file
diff --git a/npm/packages/libansilove/tests/CL!-AL07.ANS.png b/npm/packages/libansilove/tests/CL!-AL07.ANS.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8d9f8d78371f74bcc1a0060a610e45af30a8c0d
GIT binary patch
literal 2581
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

literal 0
HcmV?d00001

diff --git a/npm/packages/libansilove/tests/render.test.ts b/npm/packages/libansilove/tests/render.test.ts
index b689998..0e2f01c 100644
--- a/npm/packages/libansilove/tests/render.test.ts
+++ b/npm/packages/libansilove/tests/render.test.ts
@@ -1,12 +1,24 @@
 import { describe, expect, it } from "bun:test";
-import { load } from "../src/index";
+import * as libansilove from "../src/index";
 
 const SAMPLE = "\u001b[1;36mHello from libansilove!\u001b[0m\r\n";
 
+const example = {
+	ans: Bun.file(`${__dirname}/CL!-AL07.ANS`),
+	png: Bun.file(`${__dirname}/CL!-AL07.ANS.png`),
+};
+
 describe("libansilove wasm bindings", () => {
 	it("renders ANSI art to PNG", async () => {
-		const bindings = await load();
+		const bindings = await libansilove.load();
 		const { png } = bindings.renderAnsi(SAMPLE);
 		expect(png.byteLength).toBeGreaterThan(8);
 	});
+
+	it("renders the same as ansilove", async () => {
+		const bindings = await libansilove.load();
+		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer());
+		const control = await example.png.arrayBuffer();
+		expect(png).toEqual(new Uint8Array(control));
+	});
 });

From 7fed872dd000f41e76623e60b3302c2a2dcd5282 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:05:51 -0400
Subject: [PATCH 20/26] Update dependencies and add PNGjs

Adds `pngjs` to dependencies and updates the `bun.lock` file. Also includes a new `tmp.png` entry to `.gitignore`. Refactors input handling
for the `renderAnsi` function to better support various input types. Introduces a helper function `toUint8Array` for cleaner input
conversion. Enhances test coverage by comparing PNG dimensions and decoded pixel data.
---
 .gitignore                                    |  1 +
 npm/bun.lock                                  |  9 ++++--
 npm/packages/libansilove/package.json         |  2 ++
 npm/packages/libansilove/src/bindings.ts      | 29 ++++++++++++++++---
 npm/packages/libansilove/src/types.ts         |  2 +-
 npm/packages/libansilove/tests/render.test.ts | 19 ++++++++++--
 6 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/.gitignore b/.gitignore
index 7a00c5c..d3ab876 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,4 @@ cmake_install.cmake
 # npm package build
 node_modules/
 npm/packages/*/dist/
+tmp.png
diff --git a/npm/bun.lock b/npm/bun.lock
index b5977bf..ae2eaf5 100644
--- a/npm/bun.lock
+++ b/npm/bun.lock
@@ -12,11 +12,12 @@
     },
     "packages/libansilove": {
       "name": "libansilove",
+      "version": "1.4.2",
       "devDependencies": {
         "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
+        "@types/node": "^20",
+        "pngjs": "^7.0.0",
+        "typescript": "^5.3.3",
       },
     },
     "packages/libansilove-demo-bun": {
@@ -51,6 +52,8 @@
 
     "libansilove": ["libansilove@workspace:packages/libansilove"],
 
+    "pngjs": ["pngjs@7.0.0", "", {}, "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow=="],
+
     "react": ["react@19.1.1", "", {}, "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ=="],
 
     "react-dom": ["react-dom@19.1.1", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.1" } }, "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw=="],
diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
index d33e6cc..92552c9 100644
--- a/npm/packages/libansilove/package.json
+++ b/npm/packages/libansilove/package.json
@@ -33,6 +33,8 @@
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^20",
+    "@types/pngjs": "^7.2.0",
+    "pngjs": "^7.0.0",
     "typescript": "^5.3.3"
   },
   "keywords": [
diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
index 02c71d5..b9c72fb 100644
--- a/npm/packages/libansilove/src/bindings.ts
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -15,6 +15,26 @@ const DEFAULT_RENDER_ARGS: Required<RenderOptions> = {
 	iceColors: 0,
 };
 
+const toUint8Array = (input: RenderInput): Uint8Array => {
+	if (typeof input === "string") {
+		return encoder.encode(input);
+	}
+
+	if (ArrayBuffer.isView(input)) {
+		const view = input as ArrayBufferView;
+		if (view instanceof Uint8Array) {
+			return view;
+		}
+		return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+	}
+
+	if (input instanceof ArrayBuffer) {
+		return new Uint8Array(input);
+	}
+
+	throw new TypeError("Unsupported render input type");
+};
+
 const toDisposable = (fn: () => void) => ({
 	[Symbol.dispose]() {
 		fn();
@@ -22,8 +42,9 @@ const toDisposable = (fn: () => void) => ({
 });
 
 const allocateBuffer = (Module: EmscriptenModule, data: Uint8Array) => {
-	const ptr = Module._malloc(data.length || 1);
-	if (data.length > 0) {
+	const length = data.byteLength;
+	const ptr = Module._malloc(length || 1);
+	if (length > 0) {
 		Module.HEAPU8.set(data, ptr);
 	}
 	return {
@@ -49,7 +70,7 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 	const freePng = Module.cwrap("ansilove_wasm_free_png", null, []) as () => void;
 
 	const renderAnsi = (input: RenderInput, options: RenderOptions = {}): RenderResult => {
-		const data = typeof input === "string" ? encoder.encode(input) : input;
+		const data = toUint8Array(input);
 		using buffer = allocateBuffer(Module, data);
 
 		const cols = options.columns ?? DEFAULT_RENDER_ARGS.columns;
@@ -57,7 +78,7 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 		const mode = options.mode ?? DEFAULT_RENDER_ARGS.mode;
 		const ice = options.iceColors ?? DEFAULT_RENDER_ARGS.iceColors;
 
-		const code = renderAnsiFn(buffer.ptr, data.length, cols, bits, mode, ice);
+		const code = renderAnsiFn(buffer.ptr, data.byteLength, cols, bits, mode, ice);
 		if (code !== 0) {
 			throw new Error(`ansilove_wasm_render_ansi failed with exit code ${code}`);
 		}
diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
index db7c49f..bfd2a54 100644
--- a/npm/packages/libansilove/src/types.ts
+++ b/npm/packages/libansilove/src/types.ts
@@ -5,7 +5,7 @@ export interface RenderOptions {
 	readonly iceColors?: number;
 }
 
-export type RenderInput = string | Uint8Array | ArrayBuffer;
+export type RenderInput = string | ArrayBuffer | ArrayBufferView;
 
 export interface RenderResult {
 	readonly png: Uint8Array;
diff --git a/npm/packages/libansilove/tests/render.test.ts b/npm/packages/libansilove/tests/render.test.ts
index 0e2f01c..3a91d1f 100644
--- a/npm/packages/libansilove/tests/render.test.ts
+++ b/npm/packages/libansilove/tests/render.test.ts
@@ -1,4 +1,6 @@
 import { describe, expect, it } from "bun:test";
+import { Buffer } from "node:buffer";
+import { PNG } from "pngjs";
 import * as libansilove from "../src/index";
 
 const SAMPLE = "\u001b[1;36mHello from libansilove!\u001b[0m\r\n";
@@ -8,6 +10,15 @@ const example = {
 	png: Bun.file(`${__dirname}/CL!-AL07.ANS.png`),
 };
 
+const decodePng = (input: Uint8Array) => {
+	const { data, width, height } = PNG.sync.read(Buffer.from(input));
+	return {
+		width,
+		height,
+		data: new Uint8Array(data),
+	};
+};
+
 describe("libansilove wasm bindings", () => {
 	it("renders ANSI art to PNG", async () => {
 		const bindings = await libansilove.load();
@@ -18,7 +29,11 @@ describe("libansilove wasm bindings", () => {
 	it("renders the same as ansilove", async () => {
 		const bindings = await libansilove.load();
 		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer());
-		const control = await example.png.arrayBuffer();
-		expect(png).toEqual(new Uint8Array(control));
+		const control = new Uint8Array(await example.png.arrayBuffer());
+		const rendered = decodePng(png);
+		const baseline = decodePng(control);
+		expect(rendered.width).toBe(baseline.width);
+		expect(rendered.height).toBe(baseline.height);
+		expect(rendered.data).toEqual(baseline.data);
 	});
 });

From 900421f546a573e7bc1067c8f1236081ecf9f030 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:06:11 -0400
Subject: [PATCH 21/26] Update pngjs types to match bun.lock

Downgrade @types/pngjs to version 6.0.5 to align with the version specified in bun.lock. This change ensures consistency between the
lockfile and the package.json in the libansilove package.
---
 npm/bun.lock                          | 3 +++
 npm/packages/libansilove/package.json | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/npm/bun.lock b/npm/bun.lock
index ae2eaf5..4d22a18 100644
--- a/npm/bun.lock
+++ b/npm/bun.lock
@@ -16,6 +16,7 @@
       "devDependencies": {
         "@types/bun": "latest",
         "@types/node": "^20",
+        "@types/pngjs": "^6.0.5",
         "pngjs": "^7.0.0",
         "typescript": "^5.3.3",
       },
@@ -40,6 +41,8 @@
 
     "@types/node": ["@types/node@20.19.17", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ=="],
 
+    "@types/pngjs": ["@types/pngjs@6.0.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-0k5eKfrA83JOZPppLtS2C7OUtyNAl2wKNxfyYl9Q5g9lPkgBl/9hNyAu6HuEH2J4XmIv2znEpkDd0SaZVxW6iQ=="],
+
     "@types/react": ["@types/react@19.1.13", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-hHkbU/eoO3EG5/MZkuFSKmYqPbSVk5byPFa3e7y/8TybHiLMACgI8seVYlicwk7H5K/rI2px9xrQp/C+AUDTiQ=="],
 
     "@types/react-dom": ["@types/react-dom@19.1.9", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-qXRuZaOsAdXKFyOhRBg6Lqqc0yay13vN7KrIg4L7N4aaHN68ma9OK3NE1BoDFgFOTfM7zg+3/8+2n8rLUH3OKQ=="],
diff --git a/npm/packages/libansilove/package.json b/npm/packages/libansilove/package.json
index 92552c9..77b387e 100644
--- a/npm/packages/libansilove/package.json
+++ b/npm/packages/libansilove/package.json
@@ -33,7 +33,7 @@
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^20",
-    "@types/pngjs": "^7.2.0",
+    "@types/pngjs": "^6.0.5",
     "pngjs": "^7.0.0",
     "typescript": "^5.3.3"
   },

From 8eba17de35a51dcf8dd1ac0e0cfcc5d0bc66b1e9 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:07:36 -0400
Subject: [PATCH 22/26] Reorder type exports for clarity

Move types to their logical groups to improve readability of the exported types.
---
 npm/packages/libansilove/src/index.ts | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/npm/packages/libansilove/src/index.ts b/npm/packages/libansilove/src/index.ts
index 3d284a6..ef67438 100644
--- a/npm/packages/libansilove/src/index.ts
+++ b/npm/packages/libansilove/src/index.ts
@@ -4,10 +4,6 @@ import type {
 	LoadOptions,
 	ModuleFactory,
 	ModuleOverrides,
-	RenderInput,
-	RenderOptions,
-	RenderResult,
-	EmscriptenModule,
 } from "./types";
 
 const FACTORY_URL = new URL("../generated/libansilove.js", import.meta.url);
@@ -27,7 +23,9 @@ const buildLocateFile = (base: URL) => {
 	return (path: string) => new URL(path, baseDir).href;
 };
 
-export async function load(options: LoadOptions = {}): Promise<LibansiloveBindings> {
+export async function load(
+	options: LoadOptions = {},
+): Promise<LibansiloveBindings> {
 	const factory = await resolveFactory();
 	const locateFile = options.locateFile ?? buildLocateFile(FACTORY_URL);
 	const overrides: ModuleOverrides = { ...(options.module ?? {}), locateFile };
@@ -35,16 +33,16 @@ export async function load(options: LoadOptions = {}): Promise<LibansiloveBindin
 	return createBindings(module);
 }
 
-export { createBindings };
 export type {
+	EmscriptenModule,
 	LibansiloveBindings,
 	LoadOptions,
+	ModuleFactory,
+	ModuleOverrides,
 	RenderInput,
 	RenderOptions,
 	RenderResult,
-	EmscriptenModule,
-	ModuleFactory,
-	ModuleOverrides,
 } from "./types";
+export { createBindings };
 
 export default load;

From a3671a19946bf5f771fd68f8a4e2fb08de76500f Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:31:42 -0400
Subject: [PATCH 23/26] Refactor: Move libansilove exports to a dedicated file

Move the `load` function and related types and exports to a new `libansilove.ts` file. This improves organization by separating the main
loading logic from the core bindings implementation. The `index.ts` file now serves as a simple re-exporting module.

Also includes minor adjustments to TypeScript types and default values in `bindings.ts` for better clarity and correctness.
---
 .../libansilove/scripts/verify-dist.ts        |  4 +-
 npm/packages/libansilove/src/bindings.ts      | 96 ++++++++++++++-----
 npm/packages/libansilove/src/index.ts         | 49 +---------
 npm/packages/libansilove/src/libansilove.ts   | 50 ++++++++++
 npm/packages/libansilove/src/types.ts         | 61 +++++++++++-
 npm/packages/libansilove/tests/render.test.ts |  4 +-
 6 files changed, 187 insertions(+), 77 deletions(-)
 create mode 100644 npm/packages/libansilove/src/libansilove.ts

diff --git a/npm/packages/libansilove/scripts/verify-dist.ts b/npm/packages/libansilove/scripts/verify-dist.ts
index 03d6c4f..30282c3 100644
--- a/npm/packages/libansilove/scripts/verify-dist.ts
+++ b/npm/packages/libansilove/scripts/verify-dist.ts
@@ -2,7 +2,9 @@
 const moduleURL = new URL("../dist/index.js", import.meta.url).href;
 
 async function main() {
-	const mod = await import(moduleURL) as { load: typeof import("../src/index").load };
+	const mod = await import(moduleURL) as {
+		load: typeof import("../src/libansilove").load;
+	};
 	const bindings = await mod.load();
 	const { png } = bindings.renderAnsi("Hello from libansilove!\r\n");
 	if (!png.byteLength) {
diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
index b9c72fb..0f35096 100644
--- a/npm/packages/libansilove/src/bindings.ts
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -2,17 +2,23 @@ import type {
 	EmscriptenModule,
 	LibansiloveBindings,
 	RenderInput,
+	RenderMode,
 	RenderOptions,
 	RenderResult,
 } from "./types";
 
 const encoder = new TextEncoder();
 
-const DEFAULT_RENDER_ARGS: Required<RenderOptions> = {
+const DEFAULT_RENDER_ARGS: {
+	readonly columns: number;
+	readonly bits?: RenderOptions["bits"];
+	readonly mode?: RenderMode;
+	readonly iceColors: boolean;
+} = {
 	columns: 0,
-	bits: 0,
-	mode: 0,
-	iceColors: 0,
+	bits: undefined,
+	mode: undefined,
+	iceColors: false,
 };
 
 const toUint8Array = (input: RenderInput): Uint8Array => {
@@ -35,11 +41,29 @@ const toUint8Array = (input: RenderInput): Uint8Array => {
 	throw new TypeError("Unsupported render input type");
 };
 
-const toDisposable = (fn: () => void) => ({
-	[Symbol.dispose]() {
-		fn();
-	},
-});
+const normaliseColumns = (value: RenderOptions["columns"]): number => {
+	if (value === undefined || value === "auto") {
+		return DEFAULT_RENDER_ARGS.columns;
+	}
+	return value;
+};
+
+const normaliseMode = (mode: RenderMode | undefined): number => {
+	switch (mode) {
+		case "ced":
+			return 1;
+		case "transparent":
+			return 2;
+		case "workbench":
+			return 3;
+		case undefined:
+			return 0;
+		default:
+			return 0;
+	}
+};
+
+const toDisposable = (dispose: () => void) => ({ [Symbol.dispose]: dispose });
 
 const allocateBuffer = (Module: EmscriptenModule, data: Uint8Array) => {
 	const length = data.byteLength;
@@ -49,14 +73,18 @@ const allocateBuffer = (Module: EmscriptenModule, data: Uint8Array) => {
 	}
 	return {
 		ptr,
-	[Symbol.dispose]() {
-		Module._free(ptr);
-	},
+		[Symbol.dispose]() {
+			Module._free(ptr);
+		},
 	};
 };
 
 export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
-	const getVersion = Module.cwrap("ansilove_wasm_version", "string", []) as () => string;
+	const getVersion = Module.cwrap(
+		"ansilove_wasm_version",
+		"string",
+		[],
+	) as () => string;
 	const renderAnsiFn = Module.cwrap("ansilove_wasm_render_ansi", "number", [
 		"number",
 		"number",
@@ -65,22 +93,46 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 		"number",
 		"number",
 	]) as (...args: number[]) => number;
-	const getPngPtr = Module.cwrap("ansilove_wasm_get_png_ptr", "number", []) as () => number;
-	const getPngLength = Module.cwrap("ansilove_wasm_get_png_length", "number", []) as () => number;
-	const freePng = Module.cwrap("ansilove_wasm_free_png", null, []) as () => void;
-
-	const renderAnsi = (input: RenderInput, options: RenderOptions = {}): RenderResult => {
+	const getPngPtr = Module.cwrap(
+		"ansilove_wasm_get_png_ptr",
+		"number",
+		[],
+	) as () => number;
+	const getPngLength = Module.cwrap(
+		"ansilove_wasm_get_png_length",
+		"number",
+		[],
+	) as () => number;
+	const freePng = Module.cwrap(
+		"ansilove_wasm_free_png",
+		null,
+		[],
+	) as () => void;
+
+	const renderAnsi = (
+		input: RenderInput,
+		options: RenderOptions = {},
+	): RenderResult => {
 		const data = toUint8Array(input);
 		using buffer = allocateBuffer(Module, data);
 
-		const cols = options.columns ?? DEFAULT_RENDER_ARGS.columns;
+		const cols = normaliseColumns(options.columns);
 		const bits = options.bits ?? DEFAULT_RENDER_ARGS.bits;
-		const mode = options.mode ?? DEFAULT_RENDER_ARGS.mode;
+		const mode = normaliseMode(options.mode ?? DEFAULT_RENDER_ARGS.mode);
 		const ice = options.iceColors ?? DEFAULT_RENDER_ARGS.iceColors;
 
-		const code = renderAnsiFn(buffer.ptr, data.byteLength, cols, bits, mode, ice);
+		const code = renderAnsiFn(
+			buffer.ptr,
+			data.byteLength,
+			cols,
+			bits ?? 0,
+			mode,
+			ice ? 1 : 0,
+		);
 		if (code !== 0) {
-			throw new Error(`ansilove_wasm_render_ansi failed with exit code ${code}`);
+			throw new Error(
+				`ansilove_wasm_render_ansi failed with exit code ${code}`,
+			);
 		}
 
 		const pngPtr = getPngPtr();
diff --git a/npm/packages/libansilove/src/index.ts b/npm/packages/libansilove/src/index.ts
index ef67438..cddeff2 100644
--- a/npm/packages/libansilove/src/index.ts
+++ b/npm/packages/libansilove/src/index.ts
@@ -1,48 +1 @@
-import { createBindings } from "./bindings";
-import type {
-	LibansiloveBindings,
-	LoadOptions,
-	ModuleFactory,
-	ModuleOverrides,
-} from "./types";
-
-const FACTORY_URL = new URL("../generated/libansilove.js", import.meta.url);
-
-let cachedFactory: ModuleFactory | null = null;
-
-async function resolveFactory(): Promise<ModuleFactory> {
-	if (!cachedFactory) {
-		const module = await import(FACTORY_URL.href);
-		cachedFactory = (module as { default: ModuleFactory }).default;
-	}
-	return cachedFactory;
-}
-
-const buildLocateFile = (base: URL) => {
-	const baseDir = new URL("./", base);
-	return (path: string) => new URL(path, baseDir).href;
-};
-
-export async function load(
-	options: LoadOptions = {},
-): Promise<LibansiloveBindings> {
-	const factory = await resolveFactory();
-	const locateFile = options.locateFile ?? buildLocateFile(FACTORY_URL);
-	const overrides: ModuleOverrides = { ...(options.module ?? {}), locateFile };
-	const module = await factory(overrides);
-	return createBindings(module);
-}
-
-export type {
-	EmscriptenModule,
-	LibansiloveBindings,
-	LoadOptions,
-	ModuleFactory,
-	ModuleOverrides,
-	RenderInput,
-	RenderOptions,
-	RenderResult,
-} from "./types";
-export { createBindings };
-
-export default load;
+export * as libansilove from "./libansilove.js";
diff --git a/npm/packages/libansilove/src/libansilove.ts b/npm/packages/libansilove/src/libansilove.ts
new file mode 100644
index 0000000..3f14de6
--- /dev/null
+++ b/npm/packages/libansilove/src/libansilove.ts
@@ -0,0 +1,50 @@
+import { createBindings } from "./bindings";
+import type {
+	LibansiloveBindings,
+	LoadOptions,
+	ModuleFactory,
+	ModuleOverrides,
+} from "./types";
+
+const FACTORY_URL = new URL("../generated/libansilove.js", import.meta.url);
+
+let cachedFactory: ModuleFactory | null = null;
+
+async function resolveFactory(): Promise<ModuleFactory> {
+	if (!cachedFactory) {
+		const module = await import(FACTORY_URL.href);
+		cachedFactory = (module as { default: ModuleFactory }).default;
+	}
+	return cachedFactory;
+}
+
+const buildLocateFile = (base: URL) => {
+	const baseDir = new URL("./", base);
+	return (path: string) => new URL(path, baseDir).href;
+};
+
+export async function load(
+	options: LoadOptions = {},
+): Promise<LibansiloveBindings> {
+	const factory = await resolveFactory();
+	const locateFile = options.locateFile ?? buildLocateFile(FACTORY_URL);
+	const overrides: ModuleOverrides = { ...(options.module ?? {}), locateFile };
+	const module = await factory(overrides);
+	return createBindings(module);
+}
+
+export type {
+	EmscriptenModule,
+	LibansiloveBindings,
+	LoadOptions,
+	ModuleFactory,
+	ModuleOverrides,
+	RenderBits,
+	RenderInput,
+	RenderMode,
+	RenderOptions,
+	RenderResult,
+} from "./types";
+export { createBindings };
+
+export default load;
diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
index bfd2a54..b192cf5 100644
--- a/npm/packages/libansilove/src/types.ts
+++ b/npm/packages/libansilove/src/types.ts
@@ -1,8 +1,53 @@
+/**
+ * Permitted bit depths for ANSI font rendering. libansilove accepts 8-bit
+ * characters by default and optionally supports 9-bit VGA fonts.
+ */
+export type RenderBits = 8 | 9;
+
+/**
+ * Optional rendering presets that mirror libansilove's C-side mode constants.
+ *
+ * - `"ced"` clamps width to 78 columns and draws with the classic CED
+ *   gray-on-black palette.
+ * - `"transparent"` designates palette index 0 as fully transparent in the
+ *   output PNG so external backgrounds show through.
+ * - `"workbench"` replaces the standard ANSI palette with the 16-color Amiga
+ *   Workbench palette.
+ *
+ * These options are mutually exclusive; omit the field (or pass
+ * `undefined`) to keep the default ANSI rendering path.
+ */
+export type RenderMode = "ced" | "transparent" | "workbench";
+
+/**
+ * Accepted column width overrides. `"auto"` defers to libansilove's
+ * auto-detection (default), otherwise provide a positive integer.
+ */
+export type RenderColumns = number | "auto";
+
 export interface RenderOptions {
-	readonly columns?: number;
-	readonly bits?: number;
-	readonly mode?: number;
-	readonly iceColors?: number;
+	/**
+	 * Explicit character column count for ANSI parsing. When omitted libansilove
+	 * auto-detects the width (default 80). Set to `"auto"` to express that
+	 * behaviour explicitly, or provide a positive integer to force wrapping.
+	 */
+	readonly columns?: RenderColumns;
+	/**
+	 * Character cell bit depth accepted by libansilove. ANSI art is almost
+	 * always 8-bit; pass 9 for VGA extended fonts that rely on the high bit.
+	 */
+	readonly bits?: RenderBits;
+	/**
+	 * Rendering preset that selects specialised palettes or post-processing.
+	 * See {@link RenderMode} for the available values. Leave undefined to retain
+	 * standard ANSI colours.
+	 */
+	readonly mode?: RenderMode;
+	/**
+	 * Treat blinking colours as bright backgrounds (`true`) or keep the original
+	 * blink behaviour (`false`). Mirrors the `-i/--icecolors` CLI flag.
+	 */
+	readonly iceColors?: boolean;
 }
 
 export type RenderInput = string | ArrayBuffer | ArrayBufferView;
@@ -14,6 +59,14 @@ export interface RenderResult {
 export interface LibansiloveBindings {
 	readonly module: EmscriptenModule;
 	readonly version: string;
+	/**
+	 * Convert ANSI or related art into a PNG image using the compiled
+	 * libansilove WebAssembly runtime.
+	 *
+	 * @param input Raw ANSI data as a string, ArrayBuffer, or typed array view.
+	 * @param options Rendering customisations mirroring libansilove CLI flags.
+	 * @returns The rendered PNG bytes and metadata.
+	 */
 	renderAnsi(input: RenderInput, options?: RenderOptions): RenderResult;
 }
 
diff --git a/npm/packages/libansilove/tests/render.test.ts b/npm/packages/libansilove/tests/render.test.ts
index 3a91d1f..b811fb6 100644
--- a/npm/packages/libansilove/tests/render.test.ts
+++ b/npm/packages/libansilove/tests/render.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { Buffer } from "node:buffer";
 import { PNG } from "pngjs";
-import * as libansilove from "../src/index";
+import { libansilove } from "../src/index";
 
 const SAMPLE = "\u001b[1;36mHello from libansilove!\u001b[0m\r\n";
 
@@ -28,7 +28,7 @@ describe("libansilove wasm bindings", () => {
 
 	it("renders the same as ansilove", async () => {
 		const bindings = await libansilove.load();
-		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer());
+		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer(),{bits:8,columns:'auto',iceColors:true,mode:0});
 		const control = new Uint8Array(await example.png.arrayBuffer());
 		const rendered = decodePng(png);
 		const baseline = decodePng(control);

From 4c18a634c2021593810719ce49855acc450647d5 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:46:02 -0400
Subject: [PATCH 24/26] Add `scaleFactor` option and specific error types

The `renderAnsi` function has been updated to accept a `scaleFactor` option, allowing users to upscale the rendered output. Additionally,
specific error classes have been introduced to provide more granular information about potential issues encountered during rendering. This
includes mapping libansilove's internal error codes to distinct JavaScript error types.
---
 npm/packages/libansilove/src/bindings.ts      | 32 ++++---
 npm/packages/libansilove/src/errors.ts        | 90 +++++++++++++++++++
 npm/packages/libansilove/src/libansilove.ts   | 12 +++
 npm/packages/libansilove/src/types.ts         | 19 +++-
 npm/packages/libansilove/tests/render.test.ts | 37 +++++++-
 wasm/ansilove_wasm.c                          |  6 +-
 6 files changed, 180 insertions(+), 16 deletions(-)
 create mode 100644 npm/packages/libansilove/src/errors.ts

diff --git a/npm/packages/libansilove/src/bindings.ts b/npm/packages/libansilove/src/bindings.ts
index 0f35096..6a4651c 100644
--- a/npm/packages/libansilove/src/bindings.ts
+++ b/npm/packages/libansilove/src/bindings.ts
@@ -5,7 +5,9 @@ import type {
 	RenderMode,
 	RenderOptions,
 	RenderResult,
+	RenderScaleFactor,
 } from "./types";
+import { createErrorFromCode } from "./errors";
 
 const encoder = new TextEncoder();
 
@@ -14,11 +16,13 @@ const DEFAULT_RENDER_ARGS: {
 	readonly bits?: RenderOptions["bits"];
 	readonly mode?: RenderMode;
 	readonly iceColors: boolean;
+	readonly scaleFactor?: RenderScaleFactor;
 } = {
 	columns: 0,
 	bits: undefined,
 	mode: undefined,
 	iceColors: false,
+	scaleFactor: undefined,
 };
 
 const toUint8Array = (input: RenderInput): Uint8Array => {
@@ -56,6 +60,8 @@ const normaliseMode = (mode: RenderMode | undefined): number => {
 			return 2;
 		case "workbench":
 			return 3;
+		case "standard":
+			return 0;
 		case undefined:
 			return 0;
 		default:
@@ -85,14 +91,16 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 		"string",
 		[],
 	) as () => string;
-	const renderAnsiFn = Module.cwrap("ansilove_wasm_render_ansi", "number", [
-		"number",
-		"number",
-		"number",
-		"number",
-		"number",
-		"number",
-	]) as (...args: number[]) => number;
+const renderAnsiFn = Module.cwrap("ansilove_wasm_render_ansi", "number", [
+	"number",
+	"number",
+	"number",
+	"number",
+	"number",
+	"number",
+	"number",
+	"number",
+]) as (...args: number[]) => number;
 	const getPngPtr = Module.cwrap(
 		"ansilove_wasm_get_png_ptr",
 		"number",
@@ -120,6 +128,8 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 		const bits = options.bits ?? DEFAULT_RENDER_ARGS.bits;
 		const mode = normaliseMode(options.mode ?? DEFAULT_RENDER_ARGS.mode);
 		const ice = options.iceColors ?? DEFAULT_RENDER_ARGS.iceColors;
+		const scaleFactor = options.scaleFactor ?? DEFAULT_RENDER_ARGS.scaleFactor;
+		const dos = 0;
 
 		const code = renderAnsiFn(
 			buffer.ptr,
@@ -128,11 +138,11 @@ export function createBindings(Module: EmscriptenModule): LibansiloveBindings {
 			bits ?? 0,
 			mode,
 			ice ? 1 : 0,
+			dos,
+			scaleFactor ?? 0,
 		);
 		if (code !== 0) {
-			throw new Error(
-				`ansilove_wasm_render_ansi failed with exit code ${code}`,
-			);
+			throw createErrorFromCode(code);
 		}
 
 		const pngPtr = getPngPtr();
diff --git a/npm/packages/libansilove/src/errors.ts b/npm/packages/libansilove/src/errors.ts
new file mode 100644
index 0000000..af22d89
--- /dev/null
+++ b/npm/packages/libansilove/src/errors.ts
@@ -0,0 +1,90 @@
+export const AnsiloveErrorCodes = {
+	InvalidParam: 1,
+	Format: 2,
+	Memory: 3,
+	Range: 4,
+	FileRead: 5,
+	FileWrite: 6,
+	Gd: 7,
+} as const;
+
+export type AnsiloveErrorCode =
+	(typeof AnsiloveErrorCodes)[keyof typeof AnsiloveErrorCodes];
+
+export class AnsiloveWasmError extends Error {
+	readonly code: number;
+
+	constructor(message: string, code: number) {
+		super(message);
+		this.code = code;
+		this.name = new.target.name;
+	}
+}
+
+export class AnsiloveInvalidParamError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove reported invalid parameters", AnsiloveErrorCodes.InvalidParam);
+	}
+}
+
+export class AnsiloveFormatError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove could not parse the provided ANSI data", AnsiloveErrorCodes.Format);
+	}
+}
+
+export class AnsiloveMemoryError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove ran out of memory while rendering", AnsiloveErrorCodes.Memory);
+	}
+}
+
+export class AnsiloveRangeError extends AnsiloveWasmError {
+	constructor() {
+		super("Rendering options were outside the supported range", AnsiloveErrorCodes.Range);
+	}
+}
+
+export class AnsiloveFileReadError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove encountered a file read error", AnsiloveErrorCodes.FileRead);
+	}
+}
+
+export class AnsiloveFileWriteError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove encountered a file write error", AnsiloveErrorCodes.FileWrite);
+	}
+}
+
+export class AnsiloveGdError extends AnsiloveWasmError {
+	constructor() {
+		super("libansilove failed while processing image data", AnsiloveErrorCodes.Gd);
+	}
+}
+
+export const createErrorFromCode = (code: number): AnsiloveWasmError => {
+	const positive = Math.abs(code);
+	switch (positive) {
+		case AnsiloveErrorCodes.InvalidParam:
+			return new AnsiloveInvalidParamError();
+		case AnsiloveErrorCodes.Format:
+			return new AnsiloveFormatError();
+		case AnsiloveErrorCodes.Memory:
+			return new AnsiloveMemoryError();
+		case AnsiloveErrorCodes.Range:
+			return new AnsiloveRangeError();
+		case AnsiloveErrorCodes.FileRead:
+			return new AnsiloveFileReadError();
+		case AnsiloveErrorCodes.FileWrite:
+			return new AnsiloveFileWriteError();
+		case AnsiloveErrorCodes.Gd:
+			return new AnsiloveGdError();
+		default:
+			return new AnsiloveWasmError(
+				`libansilove returned unknown error code ${code}`,
+				positive,
+			);
+	}
+};
+
diff --git a/npm/packages/libansilove/src/libansilove.ts b/npm/packages/libansilove/src/libansilove.ts
index 3f14de6..6703537 100644
--- a/npm/packages/libansilove/src/libansilove.ts
+++ b/npm/packages/libansilove/src/libansilove.ts
@@ -43,8 +43,20 @@ export type {
 	RenderInput,
 	RenderMode,
 	RenderOptions,
+	RenderScaleFactor,
 	RenderResult,
 } from "./types";
 export { createBindings };
+export {
+	AnsiloveErrorCodes,
+	AnsiloveFileReadError,
+	AnsiloveFileWriteError,
+	AnsiloveFormatError,
+	AnsiloveGdError,
+	AnsiloveInvalidParamError,
+	AnsiloveMemoryError,
+	AnsiloveRangeError,
+	AnsiloveWasmError,
+} from "./errors";
 
 export default load;
diff --git a/npm/packages/libansilove/src/types.ts b/npm/packages/libansilove/src/types.ts
index b192cf5..7b6289f 100644
--- a/npm/packages/libansilove/src/types.ts
+++ b/npm/packages/libansilove/src/types.ts
@@ -4,6 +4,12 @@
  */
 export type RenderBits = 8 | 9;
 
+/**
+ * Supported retina scale factors. Matches libansilove's `--scale` flag where
+ * values 2–8 upscale the raster output while preserving the pixel grid.
+ */
+export type RenderScaleFactor = 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
 /**
  * Optional rendering presets that mirror libansilove's C-side mode constants.
  *
@@ -17,7 +23,12 @@ export type RenderBits = 8 | 9;
  * These options are mutually exclusive; omit the field (or pass
  * `undefined`) to keep the default ANSI rendering path.
  */
-export type RenderMode = "ced" | "transparent" | "workbench";
+export type RenderMode =
+	| undefined
+	| "standard"
+	| "ced"
+	| "transparent"
+	| "workbench";
 
 /**
  * Accepted column width overrides. `"auto"` defers to libansilove's
@@ -48,6 +59,12 @@ export interface RenderOptions {
 	 * blink behaviour (`false`). Mirrors the `-i/--icecolors` CLI flag.
 	 */
 	readonly iceColors?: boolean;
+	/**
+	 * Retina upscale factor applied after rendering. Accepts integers 2 through
+	 * 8, mirroring the native `--scale` flag. Leave undefined to disable
+	 * post-scaling.
+	 */
+	readonly scaleFactor?: RenderScaleFactor;
 }
 
 export type RenderInput = string | ArrayBuffer | ArrayBufferView;
diff --git a/npm/packages/libansilove/tests/render.test.ts b/npm/packages/libansilove/tests/render.test.ts
index b811fb6..4fb1e4c 100644
--- a/npm/packages/libansilove/tests/render.test.ts
+++ b/npm/packages/libansilove/tests/render.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { Buffer } from "node:buffer";
 import { PNG } from "pngjs";
+import load, { AnsiloveRangeError } from "../src/libansilove";
 import { libansilove } from "../src/index";
 
 const SAMPLE = "\u001b[1;36mHello from libansilove!\u001b[0m\r\n";
@@ -26,9 +27,9 @@ describe("libansilove wasm bindings", () => {
 		expect(png.byteLength).toBeGreaterThan(8);
 	});
 
-	it("renders the same as ansilove", async () => {
-		const bindings = await libansilove.load();
-		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer(),{bits:8,columns:'auto',iceColors:true,mode:0});
+	it("renders the same as the native library", async () => {
+		const bindings = await load();
+		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer());
 		const control = new Uint8Array(await example.png.arrayBuffer());
 		const rendered = decodePng(png);
 		const baseline = decodePng(control);
@@ -36,4 +37,34 @@ describe("libansilove wasm bindings", () => {
 		expect(rendered.height).toBe(baseline.height);
 		expect(rendered.data).toEqual(baseline.data);
 	});
+
+	it("supports explicit auto column selection", async () => {
+		const bindings = await load();
+		const { png } = bindings.renderAnsi(SAMPLE, { columns: "auto" });
+		expect(png.byteLength).toBeGreaterThan(8);
+	});
+
+	it("accepts named render modes", async () => {
+		const bindings = await load();
+		const { png } = bindings.renderAnsi(SAMPLE, { mode: "ced" });
+		expect(png.byteLength).toBeGreaterThan(8);
+	});
+
+	it("applies retina scale factors", async () => {
+		const bindings = await load();
+		const base = decodePng(new Uint8Array(await example.png.arrayBuffer()));
+		const { png } = bindings.renderAnsi(await example.ans.arrayBuffer(), {
+			scaleFactor: 2,
+		});
+		const scaled = decodePng(png);
+		expect(scaled.width).toBe(base.width * 2);
+		expect(scaled.height).toBe(base.height * 2);
+	});
+
+	it("maps libansilove error codes to rich errors", async () => {
+		const bindings = await load();
+		expect(() =>
+			bindings.renderAnsi(SAMPLE, { columns: 5000 }),
+		).toThrow(AnsiloveRangeError);
+	});
 });
diff --git a/wasm/ansilove_wasm.c b/wasm/ansilove_wasm.c
index 7f3d229..7824a4a 100644
--- a/wasm/ansilove_wasm.c
+++ b/wasm/ansilove_wasm.c
@@ -42,7 +42,7 @@ ansilove_wasm_version(void)
 EMSCRIPTEN_KEEPALIVE
 int
 ansilove_wasm_render_ansi(uintptr_t data_ptr, size_t length, int columns,
-	int icecolors, int dos, int scale_factor)
+	int bits, int mode, int icecolors, int dos, int scale_factor)
 {
 	struct ansilove_ctx ctx;
 	struct ansilove_options options;
@@ -59,6 +59,10 @@ ansilove_wasm_render_ansi(uintptr_t data_ptr, size_t length, int columns,
 
 	if (columns > 0)
 		options.columns = columns;
+	if (bits == 8 || bits == 9)
+		options.bits = (uint8_t)bits;
+	if (mode >= ANSILOVE_MODE_CED && mode <= ANSILOVE_MODE_WORKBENCH)
+		options.mode = (uint8_t)mode;
 	options.icecolors = icecolors ? true : false;
 	options.dos = dos ? true : false;
 	if (scale_factor >= 0 && scale_factor <= 8)

From 54051b0d8049ac9ea477f8f93bc4208ab4b30b88 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:56:06 -0400
Subject: [PATCH 25/26] Update .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index d3ab876..59c71e9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,4 @@ cmake_install.cmake
 node_modules/
 npm/packages/*/dist/
 tmp.png
+wasm/*.o

From 0531c3cb95ac43d1fffad44375999e3af2755464 Mon Sep 17 00:00:00 2001
From: Tom Aylott <oblivious@subtlegradient.com>
Date: Fri, 19 Sep 2025 01:59:31 -0400
Subject: [PATCH 26/26] Add Emscripten build support

Introduce a conditional compilation for Emscripten to allow building the wasm shim with a host clang toolchain. This ensures that the
`EMSCRIPTEN_KEEPALIVE` macro is defined even when not using Emscripten, preventing build errors.
---
 wasm/ansilove_wasm.c   | 8 ++++++++
 wasm/compile_flags.txt | 8 ++++++++
 2 files changed, 16 insertions(+)
 create mode 100644 wasm/compile_flags.txt

diff --git a/wasm/ansilove_wasm.c b/wasm/ansilove_wasm.c
index 7824a4a..e2f4fca 100644
--- a/wasm/ansilove_wasm.c
+++ b/wasm/ansilove_wasm.c
@@ -1,5 +1,13 @@
 #include "ansilove.h"
+
+#if defined(__EMSCRIPTEN__)
 #include <emscripten/emscripten.h>
+#else
+/* Allow building the wasm shim with a host clang toolchain. */
+#ifndef EMSCRIPTEN_KEEPALIVE
+#define EMSCRIPTEN_KEEPALIVE
+#endif
+#endif
 
 #include <stdbool.h>
 #include <stddef.h>
diff --git a/wasm/compile_flags.txt b/wasm/compile_flags.txt
new file mode 100644
index 0000000..651c2c5
--- /dev/null
+++ b/wasm/compile_flags.txt
@@ -0,0 +1,8 @@
+-std=c99
+-Wall
+-Wextra
+-pedantic
+-I..
+-I../include
+-I.
+-DANSILOVE_WASM