node-plantuml-2 1.0.2 → 1.0.4

package/README.md

@@ -1,12 +1,12 @@
 # node-plantuml-2
 
-> **Pure Node.js PlantUML Renderer - No Java Required!**
+> **Node.js PlantUML Renderer with Java Backend**
 
 [![npm version](https://img.shields.io/npm/v/node-plantuml-2)](https://www.npmjs.com/package/node-plantuml-2)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D12-green.svg)](https://nodejs.org/)
 
-A powerful Node.js module and CLI for running [PlantUML](http://plantuml.sourceforge.net/) with **pure Node.js support**. This project is a fork and enhancement of [node-plantuml](https://github.com/markushedvall/node-plantuml), featuring WebAssembly-based execution that eliminates the need for Java runtime.
+A powerful Node.js module and CLI for running [PlantUML](http://plantuml.sourceforge.net/). This project is a fork and enhancement of [node-plantuml](https://github.com/markushedvall/node-plantuml), providing improved performance with Nailgun optimization for faster Java startup.
 
 <div align="center">
 
@@ -20,12 +20,12 @@ A powerful Node.js module and CLI for running [PlantUML](http://plantuml.sourcef
 
 ## ✨ Key Features
 
-- 🚀 **Pure Node.js Environment** - No Java installation required! Uses pre-compiled WebAssembly module
-- 📦 **Zero Configuration** - Just `npm install` and start using
+- 🎯 **Zero Java Installation Required** - **Java is automatically bundled!** Just `npm install` and it works - no manual Java setup needed
+- 📦 **Auto-Integrated JRE** - Automatically installs a lightweight JRE (40-60MB) for your platform during `npm install`
+- 🚀 **Optimized Java Execution** - Uses Nailgun for faster Java startup, keeping JVM resident in memory
 - 🎨 **Multiple Output Formats** - Support for PNG, SVG, EPS, ASCII, and Unicode text
 - 🌏 **Multi-language Support** - Perfect rendering for Chinese, Japanese, Korean, and other CJK characters with automatic font detection
-- ⚡ **Fast Startup** - WebAssembly execution is faster than JVM
-- 🔄 **Automatic Fallback** - Falls back to Java executor if Wasm is unavailable
+- ⚡ **Fast Performance** - Nailgun optimization reduces Java startup overhead
 - 📝 **CLI & API** - Both command-line interface and programmatic API
 - 🎯 **Based on PlantUML** - Full compatibility with PlantUML syntax
 
@@ -33,11 +33,24 @@ A powerful Node.js module and CLI for running [PlantUML](http://plantuml.sourcef
 
 ## 📦 Installation
 
+### Quick Install (Recommended)
+
 ```bash
 npm install node-plantuml-2
 ```
 
-**That's it!** No Java, no configuration, no build steps required.
+**That's it! 🎉 No Java installation needed!**
+
+The package **automatically detects your platform** and installs a lightweight, bundled JRE (40-60MB) during `npm install`. You don't need to install Java separately - it's handled automatically!
+
+**How it works:**
+- During `npm install`, the package detects your operating system and architecture
+- Automatically downloads and installs the matching JRE runtime package for your platform:
+  - **Windows x64** → `@node-plantuml-2/jre-win32-x64`
+  - **macOS ARM64** → `@node-plantuml-2/jre-darwin-arm64`
+  - **Linux x64** → `@node-plantuml-2/jre-linux-x64`
+- Only the JRE for your platform is installed (others are skipped automatically)
+- Works out of the box - no configuration needed!
 
 For global CLI installation:
 
@@ -45,6 +58,47 @@ For global CLI installation:
 npm install node-plantuml-2 -g
 ```
 
+**⚠️ Important:** You do NOT need to install Java on your system. The bundled JRE is automatically integrated when you install this npm package.
+
+### Java Requirements
+
+**🎯 Zero Java Installation Required!**
+
+This package **automatically bundles a minimal JRE** during installation. You do **NOT** need to install Java on your system!
+
+**Automatic JRE Integration:**
+
+When you run `npm install node-plantuml-2`, the package:
+1. **Detects your platform** (Windows/macOS/Linux and architecture)
+2. **Automatically downloads** the matching lightweight JRE (40-60MB)
+3. **Integrates it seamlessly** - no manual setup needed
+4. **Works immediately** after installation completes
+
+**Java Resolution Priority:**
+
+The package uses the following priority to find Java:
+
+1. **Bundled JRE** (Primary) ⭐ - Automatically installed during `npm install`
+   - Platform-specific: only your platform's JRE is downloaded
+   - Lightweight: ~40-60MB, built with `jlink` for optimal size
+   - Zero configuration: works out of the box
+
+2. **System Java** (Fallback) - If bundled JRE is unavailable, uses system Java if present
+   - Checks `JAVA_HOME` environment variable
+   - Checks system PATH for `java` command
+
+3. **Custom Java** (Optional) - Override with custom Java path:
+   ```javascript
+   plantuml.generate(code, { javaPath: '/custom/path/to/java' })
+   ```
+
+**Supported Platforms (with automatic JRE):**
+- ✅ Windows x64 - JRE automatically bundled
+- ✅ macOS ARM64 (Apple Silicon) - JRE automatically bundled
+- ✅ Linux x64 - JRE automatically bundled
+
+**Summary: Install the npm package, Java is included automatically! No separate Java installation needed.**
+
 ---
 
 ## 🚀 Quick Start
@@ -427,29 +481,27 @@ app.get('/svg/:uml', (req, res) => {
 app.listen(8080)
 ```
 
-### Force Java Executor (Optional)
-
-If you prefer to use Java executor (requires Java installed):
-
-```bash
-PLANTUML_USE_JAVA=true node your-script.js
-```
-
 ---
 
 ## 🏗️ Architecture
 
-This project uses a **hybrid execution model**:
+This project uses **Java execution** with automatic JRE bundling and optimization:
+
+1. **Bundled JRE** (Automatic)
+   - Lightweight minimal JRE (~40-60MB) installed automatically via `optionalDependencies`
+   - Built with `jlink` for optimal size
+   - Platform-specific packages ensure only relevant JRE is installed
+   - **No manual Java installation required!**
 
-1. **Primary: WebAssembly Executor** (Pure Node.js)
-   - Pre-compiled Wasm module included in npm package
-   - Fast startup, low memory footprint
-   - No Java required
+2. **Java Executor** (Primary)
+   - Uses bundled JRE or system Java to execute `java -jar plantuml.jar`
+   - Full compatibility with PlantUML features
+   - Automatic Java path resolution with fallback strategy
 
-2. **Fallback: Java Executor** (Optional)
-   - Automatic fallback if Wasm unavailable
-   - Requires Java runtime
-   - Full compatibility with original node-plantuml
+3. **Nailgun Optimization** (Optional, for performance)
+   - Keeps JVM resident in memory for faster startup
+   - Use `plantumlExecutor.useNailgun()` to enable
+   - Reduces startup overhead significantly
 
 ### Execution Flow
 
@@ -458,9 +510,19 @@ User Code
     ↓
 plantuml.generate()
     ↓
-Check Wasm Availability
-    ├─ Available → Use Wasm Executor ✅ (Pure Node)
-    └─ Unavailable → Use Java Executor (Fallback)
+plantumlExecutor.exec()
+    ↓
+Java Path Resolution (Priority Order)
+    ├─ options.javaPath (User specified)
+    ├─ Bundled JRE (Auto-installed)
+    ├─ JAVA_HOME (System env var)
+    └─ System PATH java
+    ↓
+Check if Nailgun is running
+    ├─ Running → Use Nailgun (faster)
+    └─ Not running → Use spawn('java', ...)
+    ↓
+Execute PlantUML JAR
     ↓
 Generate Diagram
     ↓
@@ -471,10 +533,19 @@ Return Stream
 
 ## 📋 System Requirements
 
-- **Node.js 12+** (recommended 20+ for stable WASI support)
-- **No Java required** ✅ (Wasm executor works out of the box)
+- **Node.js 12+** - That's it!
+- ~~**Java Runtime Environment (JRE)**~~ - **NOT REQUIRED!** Automatically bundled during `npm install`
 - **Graphviz** (optional, for advanced diagram types)
 
+**✅ Supported Platforms (with automatic JRE integration):**
+- Windows x64 - JRE automatically installed during `npm install`
+- macOS ARM64 (Apple Silicon) - JRE automatically installed during `npm install`
+- Linux x64 - JRE automatically installed during `npm install`
+
+**🎯 Key Point:** You only need Node.js installed. The Java runtime is automatically downloaded and integrated when you install this package. **No manual Java installation or configuration needed!**
+
+The bundled JRE is lightweight (~40-60MB) and specifically built for your platform.
+
 ---
 
 ## 🧪 Testing
@@ -495,13 +566,13 @@ npm run test:batch:png
 
 ## 📝 Changelog
 
-### v0.9.0
+### v1.0.2
 
-- ✨ **Pure Node.js Support** - WebAssembly-based execution, no Java required
 - 🌏 **Multi-language Support** - Perfect rendering for Chinese, Japanese, Korean with automatic font detection
 - 📦 **Auto-update** - Automatic PlantUML JAR updates from GitHub Releases
 - 🎨 **Multiple Formats** - PNG, SVG, EPS, ASCII, Unicode support
-- 🔄 **Smart Fallback** - Automatic fallback to Java if Wasm unavailable
+- ⚡ **Performance Optimization** - Nailgun support for faster Java startup
+- 🧹 **Code Cleanup** - Removed non-functional Wasm implementation (see docs/WASM_BUILD_LIMITATIONS.md)
 
 ---
 
@@ -523,7 +594,6 @@ This project is based on:
 
 - **[PlantUML](http://plantuml.sourceforge.net/)** - The powerful diagramming tool
 - **[node-plantuml](https://github.com/markushedvall/node-plantuml)** - Original Node.js wrapper by Markus Hedvall
-- **[Bytecoder](https://github.com/mirkosertic/Bytecoder)** - Java to WebAssembly compiler
 
 Special thanks to the PlantUML community and all contributors!
 
@@ -545,34 +615,47 @@ Special thanks to the PlantUML community and all contributors!
 
 # node-plantuml-2
 
-> **纯 Node.js PlantUML 渲染器 - 无需 Java！**
+> **Node.js PlantUML 渲染器 - 基于 Java 后端**
 
 [![npm version](https://img.shields.io/npm/v/node-plantuml-2)](https://www.npmjs.com/package/node-plantuml-2)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D12-green.svg)](https://nodejs.org/)
 
-一个强大的 Node.js 模块和 CLI，用于运行 [PlantUML](http://plantuml.sourceforge.net/)，支持**纯 Node.js 环境**。本项目基于 [node-plantuml](https://github.com/markushedvall/node-plantuml) Fork 并增强，采用 WebAssembly 执行，无需 Java 运行时。
+一个强大的 Node.js 模块和 CLI，用于运行 [PlantUML](http://plantuml.sourceforge.net/)。本项目基于 [node-plantuml](https://github.com/markushedvall/node-plantuml) Fork 并增强，通过 Nailgun 优化提供更快的 Java 启动性能。
 
 ## ✨ 核心特性
 
-- 🚀 **纯 Node.js 环境** - 无需安装 Java！使用预编译的 WebAssembly 模块
-- 📦 **零配置** - 只需 `npm install` 即可使用
+- 🎯 **零 Java 安装要求** - **Java 自动集成！** 只需 `npm install` 即可使用 - 无需手动安装 Java
+- 📦 **自动集成 JRE** - 安装 npm 包时自动为您的平台下载并安装轻量级 JRE（40-60MB）
+- 🚀 **优化的 Java 执行** - 使用 Nailgun 加速 Java 启动，保持 JVM 常驻内存
 - 🎨 **多种输出格式** - 支持 PNG、SVG、EPS、ASCII 和 Unicode 文本
 - 🌏 **多语言支持** - 完美支持中文、日文、韩文等多种 CJK 字符渲染，自动字体检测和配置
-- ⚡ **快速启动** - WebAssembly 执行比 JVM 更快
-- 🔄 **自动降级** - Wasm 不可用时自动降级到 Java 执行器
+- ⚡ **高性能** - Nailgun 优化减少 Java 启动开销
 - 📝 **CLI 和 API** - 同时提供命令行界面和编程 API
-- 🎯 **基于 PlantUML** - 完全兼容 PlantUML 语法
+- 🏗️ **基于 PlantUML** - 完全兼容 PlantUML 语法
 
 ---
 
 ## 📦 安装
 
+### 快速安装（推荐）
+
 ```bash
 npm install node-plantuml-2
 ```
 
-**就这么简单！** 无需 Java，无需配置，无需构建步骤。
+**就这么简单！🎉 无需安装 Java！**
+
+该包会在安装时**自动检测您的平台**并安装轻量级 JRE（40-60MB）。您无需单独安装 Java - 一切自动处理！
+
+**工作原理：**
+- 运行 `npm install` 时，包会自动检测您的操作系统和架构
+- 自动下载并安装匹配平台的 JRE runtime 包：
+  - **Windows x64** → `@node-plantuml-2/jre-win32-x64`
+  - **macOS ARM64** → `@node-plantuml-2/jre-darwin-arm64`
+  - **Linux x64** → `@node-plantuml-2/jre-linux-x64`
+- 只安装您平台的 JRE（其他平台自动跳过）
+- 开箱即用 - 无需配置！
 
 全局安装 CLI：
 
@@ -580,6 +663,47 @@ npm install node-plantuml-2
 npm install node-plantuml-2 -g
 ```
 
+**⚠️ 重要提示：** 您**无需**在系统上安装 Java。JRE 会在安装此 npm 包时自动集成。
+
+### Java 要求
+
+**🎯 零 Java 安装要求！**
+
+此包在安装时**自动集成最小 JRE**。您**无需**在系统上安装 Java！
+
+**自动 JRE 集成：**
+
+当您运行 `npm install node-plantuml-2` 时，包会：
+1. **检测您的平台**（Windows/macOS/Linux 和架构）
+2. **自动下载**匹配的轻量级 JRE（40-60MB）
+3. **无缝集成** - 无需手动设置
+4. **立即可用** - 安装完成后即可使用
+
+**Java 解析优先级：**
+
+包使用以下优先级查找 Java：
+
+1. **捆绑的 JRE**（主要方式）⭐ - 在 `npm install` 时自动安装
+   - 平台特定：只下载您平台的 JRE
+   - 轻量级：约 40-60MB，使用 `jlink` 构建以获得最佳体积
+   - 零配置：开箱即用
+
+2. **系统 Java**（后备方案）- 如果捆绑的 JRE 不可用，会使用系统 Java（如果存在）
+   - 检查 `JAVA_HOME` 环境变量
+   - 检查系统 PATH 中的 `java` 命令
+
+3. **自定义 Java**（可选）- 使用自定义 Java 路径覆盖：
+   ```javascript
+   plantuml.generate(code, { javaPath: '/custom/path/to/java' })
+   ```
+
+**支持的平台（带自动 JRE）：**
+- ✅ Windows x64 - 自动集成 JRE
+- ✅ macOS ARM64 (Apple Silicon) - 自动集成 JRE
+- ✅ Linux x64 - 自动集成 JRE
+
+**总结：安装 npm 包，Java 自动包含在内！无需单独安装 Java。**
+
 ---
 
 ## 🚀 快速开始
@@ -960,17 +1084,23 @@ PLANTUML_USE_JAVA=true node your-script.js
 
 ## 🏗️ 架构
 
-本项目采用**混合执行模型**：
+本项目使用**Java 执行**，并自动捆绑 JRE 和进行优化：
+
+1. **捆绑的 JRE**（自动）
+   - 轻量级最小 JRE（约 40-60MB）通过 `optionalDependencies` 自动安装
+   - 使用 `jlink` 构建以获得最佳体积
+   - 特定平台的包确保只安装相关的 JRE
+   - **无需手动安装 Java！**
 
-1. **主要：WebAssembly 执行器**（纯 Node.js）
-   - npm 包中包含预编译的 Wasm 模块
-   - 快速启动，低内存占用
-   - 无需 Java
+2. **Java 执行器**（主要）
+   - 使用捆绑的 JRE 或系统 Java 执行 `java -jar plantuml.jar`
+   - 完全支持 PlantUML 的所有功能
+   - 自动 Java 路径解析，带后备策略
 
-2. **降级：Java 执行器**（可选）
-   - Wasm 不可用时自动降级
-   - 需要 Java 运行时
-   - 与原始 node-plantuml 完全兼容
+3. **Nailgun 优化**（可选，用于性能提升）
+   - 保持 JVM 常驻内存以加速启动
+   - 使用 `plantumlExecutor.useNailgun()` 启用
+   - 显著减少启动开销
 
 ### 执行流程
 
@@ -979,9 +1109,19 @@ PLANTUML_USE_JAVA=true node your-script.js
     ↓
 plantuml.generate()
     ↓
-检查 Wasm 可用性
-    ├─ 可用 → 使用 Wasm 执行器 ✅ (纯 Node)
-    └─ 不可用 → 使用 Java 执行器 (降级)
+plantumlExecutor.exec()
+    ↓
+Java 路径解析（优先级顺序）
+    ├─ options.javaPath（用户指定）
+    ├─ 捆绑的 JRE（自动安装）
+    ├─ JAVA_HOME（系统环境变量）
+    └─ 系统 PATH 中的 java
+    ↓
+检查 Nailgun 是否运行
+    ├─ 运行中 → 使用 Nailgun（更快）
+    └─ 未运行 → 使用 spawn('java', ...)
+    ↓
+执行 PlantUML JAR
     ↓
 生成图表
     ↓
@@ -992,10 +1132,19 @@ plantuml.generate()
 
 ## 📋 系统要求
 
-- **Node.js 12+**（推荐 20+ 以获得稳定的 WASI 支持）
-- **无需 Java** ✅（Wasm 执行器开箱即用）
+- **Node.js 12+** - 仅此而已！
+- ~~**Java Runtime Environment (JRE)**~~ - **不需要！** 在 `npm install` 时自动集成
 - **Graphviz**（可选，用于高级图表类型）
 
+**✅ 支持的平台（带自动 JRE 集成）：**
+- Windows x64 - 在 `npm install` 时自动安装 JRE
+- macOS ARM64 (Apple Silicon) - 在 `npm install` 时自动安装 JRE
+- Linux x64 - 在 `npm install` 时自动安装 JRE
+
+**🎯 关键点：** 您只需要安装 Node.js。Java 运行时会在您安装此包时自动下载并集成。**无需手动安装或配置 Java！**
+
+捆绑的 JRE 轻量级（约 40-60MB），专门为您的平台构建。
+
 ---
 
 ## 🧪 测试
@@ -1016,13 +1165,13 @@ npm run test:batch:png
 
 ## 📝 更新日志
 
-### v0.9.0
+### v1.0.2
 
-- ✨ **纯 Node.js 支持** - 基于 WebAssembly 的执行，无需 Java
 - 🌏 **多语言支持** - 完美支持中文、日文、韩文等多种语言，自动字体检测
 - 📦 **自动更新** - 从 GitHub Releases 自动更新 PlantUML JAR
 - 🎨 **多种格式** - PNG、SVG、EPS、ASCII、Unicode 支持
-- 🔄 **智能降级** - Wasm 不可用时自动降级到 Java
+- ⚡ **性能优化** - Nailgun 支持以加速 Java 启动
+- 🧹 **代码清理** - 移除了不可用的 Wasm 实现（参见 docs/WASM_BUILD_LIMITATIONS.md）
 
 ---
 
@@ -1044,7 +1193,6 @@ MIT License
 
 - **[PlantUML](http://plantuml.sourceforge.net/)** - 强大的图表工具
 - **[node-plantuml](https://github.com/markushedvall/node-plantuml)** - Markus Hedvall 的原始 Node.js 包装器
-- **[Bytecoder](https://github.com/mirkosertic/Bytecoder)** - Java 到 WebAssembly 编译器
 
 特别感谢 PlantUML 社区和所有贡献者！
 

package/lib/java-resolver.js

@@ -0,0 +1,232 @@
+'use strict'
+
+var fs = require('fs')
+var path = require('path')
+var os = require('os')
+var childProcess = require('child_process')
+
+/**
+ * Resolve Java executable path with fallback strategy
+ * 
+ * Priority order:
+ * 1. options.javaPath (user-specified)
+ * 2. Bundled JRE (from optional dependencies)
+ * 3. JAVA_HOME environment variable
+ * 4. System 'java' in PATH (which java)
+ * 
+ * @param {Object} options - Options object
+ * @param {string} options.javaPath - User-specified Java path (highest priority)
+ * @returns {string|null} - Path to Java executable, or null if not found
+ */
+function resolveJavaExecutable (options) {
+  options = options || {}
+  
+  // Priority 1: User-specified Java path
+  if (options.javaPath) {
+    var javaPath = path.resolve(options.javaPath)
+    if (fs.existsSync(javaPath)) {
+      try {
+        // Make executable on Unix if needed
+        if (process.platform !== 'win32') {
+          fs.chmodSync(javaPath, 0o755)
+        }
+        return javaPath
+      } catch (e) {
+        // If can't make executable, still try to use it
+        return javaPath
+      }
+    }
+  }
+
+  // Priority 2: Bundled JRE from optional dependencies
+  var bundledJava = resolveBundledJava()
+  if (bundledJava) {
+    return bundledJava
+  }
+
+  // Priority 3: JAVA_HOME environment variable
+  var javaHome = process.env.JAVA_HOME
+  if (javaHome) {
+    var javaHomeJava = getJavaFromHome(javaHome)
+    if (javaHomeJava && fs.existsSync(javaHomeJava)) {
+      return javaHomeJava
+    }
+  }
+
+  // Priority 4: System 'java' in PATH
+  try {
+    var systemJava = findJavaInPath()
+    if (systemJava) {
+      return systemJava
+    }
+  } catch (e) {
+    // Ignore errors when checking PATH
+  }
+
+  return null
+}
+
+/**
+ * Resolve bundled JRE from optional dependencies
+ * Based on platform and architecture
+ * 
+ * @returns {string|null} - Path to bundled Java executable
+ */
+function resolveBundledJava () {
+  var platform = os.platform()
+  var arch = os.arch()
+
+  // Map platform and arch to package name
+  var pkgName = getRuntimePackageName(platform, arch)
+  if (!pkgName) {
+    return null
+  }
+
+  try {
+    // Try to resolve the runtime package
+    var pkgPath
+    try {
+      // Try to require.resolve the package
+      var pkgJsonPath = require.resolve(pkgName + '/package.json')
+      pkgPath = path.dirname(pkgJsonPath)
+    } catch (e) {
+      // Package might not be installed (optional dependency)
+      // Try to find it in node_modules relative to this package
+      var thisPkgPath = path.join(__dirname, '..')
+      var possiblePath = path.join(thisPkgPath, 'node_modules', pkgName)
+      if (fs.existsSync(path.join(possiblePath, 'package.json'))) {
+        pkgPath = possiblePath
+      } else {
+        return null
+      }
+    }
+
+    // Construct Java executable path
+    var javaExe = platform === 'win32' ? 'java.exe' : 'java'
+    var javaPath = path.join(pkgPath, 'jre', 'bin', javaExe)
+
+    if (fs.existsSync(javaPath)) {
+      try {
+        // Make executable on Unix
+        if (platform !== 'win32') {
+          fs.chmodSync(javaPath, 0o755)
+        }
+        return javaPath
+      } catch (e) {
+        // If chmod fails, still return the path (it might already be executable)
+        return javaPath
+      }
+    }
+  } catch (e) {
+    // Silently fail - bundled JRE not available
+    return null
+  }
+
+  return null
+}
+
+/**
+ * Get runtime package name based on platform and architecture
+ * 
+ * @param {string} platform - OS platform (win32, darwin, linux)
+ * @param {string} arch - Architecture (x64, arm64)
+ * @returns {string|null} - Package name or null if unsupported
+ */
+function getRuntimePackageName (platform, arch) {
+  if (platform === 'win32' && arch === 'x64') {
+    return '@node-plantuml-2/jre-win32-x64'
+  } else if (platform === 'darwin' && arch === 'arm64') {
+    return '@node-plantuml-2/jre-darwin-arm64'
+  } else if (platform === 'darwin' && arch === 'x64') {
+    return '@node-plantuml-2/jre-darwin-x64'
+  } else if (platform === 'linux' && arch === 'x64') {
+    return '@node-plantuml-2/jre-linux-x64'
+  }
+  
+  // Unsupported platform/arch combination
+  return null
+}
+
+/**
+ * Get Java executable from JAVA_HOME
+ * 
+ * @param {string} javaHome - JAVA_HOME path
+ * @returns {string|null} - Path to java executable
+ */
+function getJavaFromHome (javaHome) {
+  var javaExe = process.platform === 'win32' ? 'java.exe' : 'java'
+  var javaPath = path.join(javaHome, 'bin', javaExe)
+  return javaPath
+}
+
+/**
+ * Find Java executable in system PATH
+ * 
+ * @returns {string|null} - Path to java executable
+ */
+function findJavaInPath () {
+  try {
+    // Use 'which' on Unix, 'where' on Windows
+    var command = process.platform === 'win32' ? 'where' : 'which'
+    var result = childProcess.execSync(command + ' java', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    })
+    
+    if (result) {
+      var javaPath = result.trim().split('\n')[0]
+      if (javaPath && fs.existsSync(javaPath)) {
+        return javaPath
+      }
+    }
+  } catch (e) {
+    // Java not found in PATH
+  }
+  
+  return null
+}
+
+/**
+ * Verify Java executable works
+ * 
+ * @param {string} javaPath - Path to Java executable
+ * @returns {Promise<boolean>} - True if Java works
+ */
+function verifyJava (javaPath) {
+  return new Promise(function (resolve) {
+    try {
+      var child = childProcess.spawn(javaPath, ['-version'], {
+        stdio: 'pipe'
+      })
+      
+      var hasOutput = false
+      child.on('data', function () {
+        hasOutput = true
+      })
+      
+      child.on('close', function (code) {
+        resolve(code === 0)
+      })
+      
+      child.on('error', function () {
+        resolve(false)
+      })
+      
+      // Timeout after 5 seconds
+      setTimeout(function () {
+        child.kill()
+        resolve(false)
+      }, 5000)
+    } catch (e) {
+      resolve(false)
+    }
+  })
+}
+
+module.exports = {
+  resolveJavaExecutable: resolveJavaExecutable,
+  resolveBundledJava: resolveBundledJava,
+  getRuntimePackageName: getRuntimePackageName,
+  verifyJava: verifyJava
+}
+

package/lib/node-plantuml.js

@@ -265,7 +265,11 @@ module.exports.generate = function (input, options, callback) {
   callback = args.callback
 
   var o = joinOptions([PIPE], options)
-  var child = plantumlExecutor.exec(o, options.include, callback)
+  // Pass options (including javaPath) to executor
+  var executorOptions = {
+    javaPath: options.javaPath
+  }
+  var child = plantumlExecutor.exec(o, options.include, executorOptions, callback)
 
   if (!input) {
     // For stdin, we need to handle font config in a transform stream
@@ -355,7 +359,7 @@ module.exports.encode = function (input, options, callback) {
 }
 
 module.exports.decode = function (encoded, callback) {
-  var child = plantumlExecutor.exec([DECODE, encoded], callback)
+  var child = plantumlExecutor.exec([DECODE, encoded], undefined, {}, callback)
 
   return {
     out: child.stdout
@@ -363,7 +367,7 @@ module.exports.decode = function (encoded, callback) {
 }
 
 module.exports.testdot = function (callback) {
-  var child = plantumlExecutor.exec([TESTDOT])
+  var child = plantumlExecutor.exec([TESTDOT], undefined, {}, callback)
 
   var chunks = []
   child.stdout.on('data', function (chunk) { chunks.push(chunk) })

package/lib/plantuml-executor.js

@@ -4,6 +4,7 @@ var childProcess = require('child_process')
 var path = require('path')
 var nailgun = require('node-nailgun-server')
 var ngClient = require('node-nailgun-client')
+var javaResolver = require('./java-resolver')
 
 var INCLUDED_PLANTUML_JAR = path.join(__dirname, '../vendor/plantuml.jar')
 var PLANTUML_JAR = process.env.PLANTUML_HOME || INCLUDED_PLANTUML_JAR
@@ -47,9 +48,33 @@ function execWithNailgun (argv, cwd, cb) {
   return ngClient.exec(PLANTUML_NAIL_CLASS, argv, clientOptions)
 }
 
+/**
+ * Find Java executable with fallback strategy
+ * @param {Object} options - Options with optional javaPath
+ * @returns {string} - Java executable path
+ */
+function findJavaExecutable (options) {
+  options = options || {}
+  
+  // Try to resolve Java executable
+  var javaPath = javaResolver.resolveJavaExecutable(options)
+  
+  if (!javaPath) {
+    // Fallback to 'java' in PATH if resolver fails
+    // This maintains backward compatibility
+    return 'java'
+  }
+  
+  return javaPath
+}
+
 // TODO: proper error handling
-function execWithSpawn (argv, cwd, cb) {
+function execWithSpawn (argv, cwd, options, cb) {
   cwd = cwd || process.cwd()
+  options = options || {}
+  
+  var javaExe = findJavaExecutable(options)
+  
   var opts = [
     '-Dplantuml.include.path=' + cwd,
     '-Djava.awt.headless=true',
@@ -58,95 +83,47 @@ function execWithSpawn (argv, cwd, cb) {
     '-Duser.country=US',
     '-jar', PLANTUML_JAR
   ].concat(argv)
-  return childProcess.spawn('java', opts)
-}
-
-module.exports.useWasm = function (callback) {
-  var wasmExecutor = require('./plantuml-executor-wasm')
-  if (wasmExecutor.isAvailable()) {
-    return wasmExecutor.initWasm(callback)
-  } else {
-    console.warn('Wasm executor not available, falling back to Java executor')
-    if (typeof callback === 'function') {
-      callback(new Error('Wasm executor not available'))
-    }
-  }
+  
+  return childProcess.spawn(javaExe, opts)
 }
 
-module.exports.exec = function (argv, cwd, callback) {
+module.exports.exec = function (argv, cwd, callbackOrOptions, callback) {
+  var options = {}
+  var actualCallback
+  
+  // Handle flexible argument signature
   if (typeof argv === 'function') {
-    callback = argv
+    actualCallback = argv
     argv = undefined
     cwd = undefined
   } else if (typeof cwd === 'function') {
-    callback = cwd
+    actualCallback = cwd
     cwd = undefined
+  } else if (typeof callbackOrOptions === 'function') {
+    actualCallback = callbackOrOptions
+  } else if (callbackOrOptions && typeof callbackOrOptions === 'object') {
+    options = callbackOrOptions
+    actualCallback = callback
+  } else if (typeof callback === 'function') {
+    actualCallback = callback
   }
 
-  // Priority 1: Try Wasm executor first (pure Node, no Java needed)
-  var wasmExecutor = require('./plantuml-executor-wasm')
-  var useJava = process.env.PLANTUML_USE_JAVA === 'true' || process.env.PLANTUML_USE_JAVA === '1'
-
-  var task
-  // Use Wasm by default, unless explicitly requested to use Java
-  if (!useJava && wasmExecutor.isAvailable()) {
-    try {
-      // Try to initialize Wasm synchronously first
-      if (!wasmExecutor.isReady()) {
-        if (!wasmExecutor.initWasmSync()) {
-          // Sync init failed, try async (non-blocking)
-          wasmExecutor.initWasm(function (err) {
-            if (err) {
-              console.warn('Wasm initialization failed, falling back to Java:', err.message)
-            }
-          })
-        }
-      }
-
-      // Try to use Wasm executor
-      if (wasmExecutor.isReady()) {
-        task = wasmExecutor.exec(argv, cwd, callback)
-        // Wasm executor handles its own callback setup
-        if (task && typeof callback === 'function') {
-          // Setup callback for Wasm executor if needed
-          var chunks = []
-          if (task.stdout) {
-            task.stdout.on('data', function (chunk) { chunks.push(chunk) })
-            task.stdout.on('end', function () {
-              var data = Buffer.concat(chunks)
-              callback(null, data)
-            })
-            task.stdout.on('error', function () {
-              callback(new Error('error while reading plantuml output'), null)
-            })
-          }
-        }
-        return task
-      } else {
-        // Wasm not ready yet, fallback to Java
-        task = getJavaTask(argv, cwd, callback)
-      }
-    } catch (e) {
-      console.warn('Wasm executor failed, falling back to Java:', e.message)
-      task = getJavaTask(argv, cwd, callback)
-    }
-  } else {
-    // Use Java executor (fallback or explicitly requested)
-    task = getJavaTask(argv, cwd, callback)
-  }
-
-  return task
+  // Use Java executor (Wasm executor is not available due to Bytecoder limitations)
+  // See docs/WASM_BUILD_LIMITATIONS.md for details
+  return getJavaTask(argv, cwd, options, actualCallback)
 }
 
 /**
  * Get Java executor task
  */
-function getJavaTask (argv, cwd, callback) {
+function getJavaTask (argv, cwd, options, callback) {
+  options = options || {}
   var task
+  
   if (nailgunRunning) {
     task = execWithNailgun(argv, cwd, callback)
   } else {
-    task = execWithSpawn(argv, cwd, callback)
+    task = execWithSpawn(argv, cwd, options, callback)
   }
 
   if (typeof callback === 'function') {

package/lib/plantuml-syntax-fixer.js

@@ -436,7 +436,7 @@ function checkSyntaxError (code, callback) {
   var SVG = '-tsvg'
   var PIPE = '-pipe'
 
-  var child = plantumlExecutor.exec([PIPE, SVG])
+  var child = plantumlExecutor.exec([PIPE, SVG], undefined, {})
   var svgChunks = []
   var errorChunks = []
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "node-plantuml-2",
-  "version": "1.0.2",
-  "plantumlVersion": "1.2026.0",
-  "description": "Pure Node.js PlantUML renderer - No Java required! Multiple output formats (PNG, SVG, EPS, ASCII, Unicode) with full UTF-8 support",
+  "version": "1.0.4",
+  "plantumlVersion": "1.2026.1",
+  "description": "Node.js PlantUML renderer with Java backend. Multiple output formats (PNG, SVG, EPS, ASCII, Unicode) with full UTF-8 support",
   "main": "index.js",
   "author": "Markus Hedvall <mackanhedvall@gmail.com>",
   "repository": "https://github.com/JaredYe04/node-plantuml-2",
@@ -14,10 +14,6 @@
     "plantuml",
     "uml",
     "diagram",
-    "wasm",
-    "webassembly",
-    "pure-node",
-    "no-java",
     "svg",
     "png",
     "markdown",
@@ -29,6 +25,11 @@
     "node-nailgun-server": "^0.1.4",
     "plantuml-encoder": "^1.2.5"
   },
+  "optionalDependencies": {
+    "@node-plantuml-2/jre-win32-x64": "^1.0.4",
+    "@node-plantuml-2/jre-darwin-arm64": "^1.0.4",
+    "@node-plantuml-2/jre-linux-x64": "^1.0.4"
+  },
   "devDependencies": {
     "chai": "^4.x",
     "mocha": "^5.x",
@@ -39,27 +40,21 @@
     "index.js",
     "lib/",
     "vendor/plantuml.jar",
-    "vendor/wasm/plantuml.wasm",
     "resources/",
     "nail/plantumlnail.jar",
     "scripts/download.js",
-    "scripts/get-vizjs.js"
+    "scripts/get-vizjs.js",
+    "README.md"
   ],
   "scripts": {
     "prepublish": "node scripts/get-plantuml-jar.js --latest || echo 'JAR download failed, continuing...'",
-    "build:wasm:publish": "node scripts/get-plantuml-jar.js --latest && node scripts/build-plantuml-wasm.js",
     "postinstall": "node scripts/get-vizjs.js",
     "test": "standard && node test/fixtures/prepare.js && mocha",
     "test:batch": "node test/batch-convert-test.js",
     "test:batch:svg": "node test/batch-convert-test.js --svg",
     "test:batch:png": "node test/batch-convert-test.js --png",
     "build": "node nail/build.js",
-    "build:wasm": "node scripts/build-plantuml-wasm.js --method cheerpj",
-    "build:wasm:cheerpj": "node scripts/build-plantuml-wasm.js --method cheerpj",
-    "build:wasm:bytecoder": "node scripts/build-plantuml-wasm.js --method bytecoder",
-    "build:all": "node scripts/build-all.js",
-    "build:all:jar-only": "node scripts/build-all.js --skip-wasm",
-    "build:all:wasm-only": "node scripts/build-all.js --skip-jar"
+    "build:all": "node scripts/build-all.js"
   },
   "bin": {
     "puml": "index.js"

package/scripts/get-vizjs.js

@@ -30,44 +30,15 @@ plantuml.testdot(function (isOk) {
     if (fs.existsSync(VIZJS_JAR)) {
       console.info('vizjs.jar already exists. Skipping download.')
     } else {
-      console.info('graphviz was not found on the system. Downloading vizjs instead. See http://plantuml.com/vizjs. This may take a few minutes.')
-
-      // download additional libraries for working without dot installed.
-      download(VIZJS_URL, VIZJS_JAR, false, function (err) {
-        if (err) {
-          console.warn('Warning: Failed to download vizjs.jar:', err)
-          console.warn('The package can still be used if graphviz is installed on the system, or if vizjs.jar is provided manually.')
-          console.warn('You can retry the download later or install graphviz to avoid this dependency.')
-          // Don't exit with error code - this is a non-critical dependency
-        } else {
-          // also install the V8 engine just in case the currently installed Java does not have Nashorn
-          switch (process.platform) {
-            case 'win32':
-              download(J2V8_WIN_URL, J2V8_WIN_JAR, false, function (err) {
-                if (err) {
-                  console.warn('Warning: Failed to download j2v8 Windows jar:', err)
-                }
-              })
-              break
-            case 'linux':
-              download(J2V8_LINUX_URL, J2V8_LINUX_JAR, false, function (err) {
-                if (err) {
-                  console.warn('Warning: Failed to download j2v8 Linux jar:', err)
-                }
-              })
-              break
-            case 'darwin':
-              download(J2V8_MAC_URL, J2V8_MAC_JAR, false, function (err) {
-                if (err) {
-                  console.warn('Warning: Failed to download j2v8 macOS jar:', err)
-                }
-              })
-              break
-            default:
-              console.error('Unsupported operating system for V8 jars.')
-          }
-        }
-      })
+      console.info('graphviz was not found on the system.')
+      console.info('Note: vizjs and j2v8 downloads are disabled to avoid rate limiting.')
+      console.info('The package can still be used if:')
+      console.info('  1. Graphviz is installed on the system (recommended)')
+      console.info('  2. vizjs.jar is provided manually in vendor/ directory')
+      console.info('  3. Only non-Graphviz diagram types are used')
+      console.info('See http://plantuml.com/vizjs for more information.')
+      // Don't download to avoid rate limiting (429 errors)
+      // Users should install graphviz or provide vizjs.jar manually if needed
     }
   }
 })

package/lib/plantuml-executor-wasm.js

@@ -1,328 +0,0 @@
-'use strict'
-
-/**
- * PlantUML Wasm Executor
- *
- * This module provides Wasm-based execution of PlantUML using TeaVM/Bytecoder.
- *
- * Implementation Strategy:
- * 1. Use TeaVM or Bytecoder to convert PlantUML JAR to WebAssembly
- * 2. Run Wasm module in Node.js using WASI or WebAssembly API
- * 3. Provide file system access through WASI or Node.js FS API
- */
-
-var fs = require('fs')
-var path = require('path')
-var stream = require('stream')
-
-// WASI is available in Node.js 12+ as experimental, stable in 20+
-var WASI
-try {
-  // Try Node.js 20+ stable API
-  WASI = require('wasi').WASI
-} catch (e) {
-  try {
-    // Try experimental API (Node.js 12-19)
-    WASI = require('wasi').WASI
-  } catch (e2) {
-    // WASI not available
-    WASI = null
-  }
-}
-
-var WASM_DIR = path.join(__dirname, '../vendor/wasm')
-var PLANTUML_WASM = path.join(WASM_DIR, 'plantuml.wasm')
-// CheerpJ files (official PlantUML WASM solution)
-var PLANTUML_CORE_JS = path.join(WASM_DIR, 'plantuml-core.js')
-var PLANTUML_CORE_WASM = path.join(WASM_DIR, 'plantuml-core.wasm')
-var wasmInstance = null
-var wasmMemory = null
-var wasi = null
-var wasmReady = false
-
-/**
- * Initialize Wasm module
- * @param {Function} callback - Callback when ready
- */
-function initWasm (callback) {
-  if (wasmReady && wasmInstance) {
-    if (typeof callback === 'function') {
-      callback(null)
-    }
-    return
-  }
-
-  if (!fs.existsSync(PLANTUML_WASM)) {
-    var err = new Error('Wasm module not found: ' + PLANTUML_WASM + '\nPlease run: node scripts/build-plantuml-wasm.js')
-    if (typeof callback === 'function') {
-      callback(err)
-    } else {
-      throw err
-    }
-    return
-  }
-
-  try {
-    // Check Node.js version for WASI support (Node.js 12+)
-    var nodeVersion = process.version
-    var majorVersion = parseInt(nodeVersion.split('.')[0].substring(1))
-    if (majorVersion < 12) {
-      throw new Error('WASI requires Node.js 12+. Current version: ' + nodeVersion)
-    }
-
-    // Initialize WASI
-    var cwd = process.cwd()
-    wasi = new WASI({
-      version: 'preview1',
-      env: process.env,
-      preopens: {
-        '/': cwd,
-        '/tmp': require('os').tmpdir()
-      },
-      args: []
-    })
-
-    // Load Wasm module
-    var wasmBuffer = fs.readFileSync(PLANTUML_WASM)
-
-    // Create import object for WASI
-    var importObject = {
-      wasi_snapshot_preview1: wasi.wasiImport
-    }
-
-    // Instantiate Wasm module
-    /* global WebAssembly */
-    WebAssembly.instantiate(wasmBuffer, importObject)
-      .then(function (result) {
-        wasmInstance = result.instance
-        wasmMemory = wasmInstance.exports.memory
-
-        // Initialize WASI
-        wasi.initialize(wasmInstance)
-
-        wasmReady = true
-        console.log('✓ Wasm module loaded successfully')
-
-        if (typeof callback === 'function') {
-          callback(null)
-        }
-      })
-      .catch(function (err) {
-        console.error('Failed to load Wasm module:', err)
-        if (typeof callback === 'function') {
-          callback(err)
-        } else {
-          throw err
-        }
-      })
-  } catch (err) {
-    if (typeof callback === 'function') {
-      callback(err)
-    } else {
-      throw err
-    }
-  }
-}
-
-/**
- * Create a process-like object for Wasm execution
- * @param {Array} argv - Command line arguments
- * @param {string} cwd - Working directory
- * @param {Function} callback - Callback function
- * @returns {Object} Child process-like object with stdin/stdout/stderr
- */
-function execWithWasm (argv, cwd, callback) {
-  if (!wasmReady || !wasmInstance) {
-    throw new Error('Wasm module not initialized. Call initWasm() first.')
-  }
-
-  // Create streams for stdin/stdout/stderr
-  var stdinStream = new stream.PassThrough()
-  var stdoutStream = new stream.PassThrough()
-  var stderrStream = new stream.PassThrough()
-
-  // Collect stdin data
-  var stdinData = []
-  stdinStream.on('data', function (chunk) {
-    stdinData.push(chunk)
-  })
-
-  stdinStream.on('end', function () {
-    // Process input when stdin ends
-    var inputBuffer = Buffer.concat(stdinData)
-    processWasmExecution(argv, inputBuffer, stdoutStream, stderrStream, cwd, callback)
-  })
-
-  // If no stdin data expected, process immediately
-  setTimeout(function () {
-    if (stdinData.length === 0 && stdinStream.readableEnded) {
-      processWasmExecution(argv, null, stdoutStream, stderrStream, cwd, callback)
-    }
-  }, 100)
-
-  // Return process-like object
-  return {
-    stdin: stdinStream,
-    stdout: stdoutStream,
-    stderr: stderrStream
-  }
-}
-
-/**
- * Process Wasm execution
- * @private
- */
-function processWasmExecution (argv, stdinData, stdoutStream, stderrStream, cwd, callback) {
-  try {
-    // Convert argv to string array for Wasm
-    var args = argv || []
-    var argsString = args.join(' ')
-
-    // Prepare input data
-    var inputText = stdinData ? stdinData.toString('utf-8') : ''
-
-    // Call Wasm main function
-    // Note: This is a simplified version. Actual PlantUML Wasm module
-    // may have different function signatures
-    if (wasmInstance.exports.main) {
-      // If main function exists, call it with arguments
-      var result = wasmInstance.exports.main(args.length, argsString, inputText)
-
-      // Read output from memory
-      if (wasmMemory && result !== undefined) {
-        // Parse result and write to stdout
-        // This is simplified - actual implementation depends on Wasm module API
-        stdoutStream.end(Buffer.from(result))
-      } else {
-        stdoutStream.end()
-      }
-    } else if (wasmInstance.exports._start) {
-      // WASI entry point
-      wasi.start(wasmInstance)
-      stdoutStream.end()
-    } else {
-      // Fallback: try to find PlantUML-specific export
-      console.warn('Wasm module does not export expected functions. PlantUML Wasm module may need custom integration.')
-      stdoutStream.end()
-    }
-
-    if (typeof callback === 'function') {
-      var chunks = []
-      stdoutStream.on('data', function (chunk) {
-        chunks.push(chunk)
-      })
-      stdoutStream.on('end', function () {
-        var data = Buffer.concat(chunks)
-        callback(null, data)
-      })
-    }
-  } catch (err) {
-    stderrStream.write('Error executing Wasm module: ' + err.message + '\n')
-    stderrStream.end()
-    if (typeof callback === 'function') {
-      callback(err)
-    }
-  }
-}
-
-/**
- * Initialize CheerpJ runtime (official PlantUML WASM solution)
- */
-function initCheerpJ (callback) {
-  try {
-    // CheerpJ uses a different loading mechanism
-    // The JS file contains the runtime and can be loaded as a module
-    console.log('Loading CheerpJ PlantUML-core...')
-    
-    // For now, we'll use a simple approach - load the JS file
-    // In a real implementation, you'd need to handle CheerpJ's runtime API
-    var cheerpjCode = fs.readFileSync(PLANTUML_CORE_JS, 'utf8')
-    
-    // Note: CheerpJ requires a browser-like environment or special runtime
-    // This is a placeholder - actual implementation would need CheerpJ runtime
-    console.log('✓ CheerpJ PlantUML-core loaded (runtime initialization needed)')
-    
-    wasmReady = true
-    if (typeof callback === 'function') {
-      callback(null)
-    }
-  } catch (err) {
-    if (typeof callback === 'function') {
-      callback(err)
-    } else {
-      throw err
-    }
-  }
-}
-
-/**
- * Check if Wasm executor is available
- * @returns {boolean}
- */
-function isWasmAvailable () {
-  return fs.existsSync(PLANTUML_WASM) || fs.existsSync(PLANTUML_CORE_JS)
-}
-
-/**
- * Check if Wasm executor is ready (initialized)
- * @returns {boolean}
- */
-function isReady () {
-  return wasmReady && wasmInstance !== null
-}
-
-/**
- * Initialize Wasm synchronously (for immediate use)
- */
-function initWasmSync () {
-  if (wasmReady && wasmInstance) {
-    return true
-  }
-
-  if (!fs.existsSync(PLANTUML_WASM)) {
-    return false
-  }
-
-  try {
-    var nodeVersion = process.version
-    var majorVersion = parseInt(nodeVersion.split('.')[0].substring(1))
-    if (majorVersion < 12) {
-      return false
-    }
-
-    var cwd = process.cwd()
-    wasi = new WASI({
-      version: 'preview1',
-      env: process.env,
-      preopens: {
-        '/': cwd,
-        '/tmp': require('os').tmpdir()
-      },
-      args: []
-    })
-
-    var wasmBuffer = fs.readFileSync(PLANTUML_WASM)
-    var importObject = {
-      wasi_snapshot_preview1: wasi.wasiImport
-    }
-
-    /* global WebAssembly */
-    var result = WebAssembly.instantiateSync(wasmBuffer, importObject)
-    wasmInstance = result.instance
-    wasmMemory = wasmInstance.exports.memory
-    wasi.initialize(wasmInstance)
-    wasmReady = true
-    return true
-  } catch (e) {
-    console.warn('Failed to initialize Wasm synchronously:', e.message)
-    return false
-  }
-}
-
-module.exports = {
-  initWasm: initWasm,
-  exec: execWithWasm,
-  isAvailable: isWasmAvailable,
-  isReady: isReady,
-  initWasmSync: initWasmSync
-}