@ugo-studio/jspp 0.3.1 → 0.3.2

package/dist/cli/args.js

@@ -7,6 +7,7 @@ export function parseArgs(rawArgs) {
     let keepCpp = false;
     let outputExePath = null;
     let scriptArgs = [];
+    let target = "native";
     for (let i = 0; i < rawArgs.length; i++) {
         const arg = rawArgs[i];
         if (!arg)
@@ -21,6 +22,26 @@ export function parseArgs(rawArgs) {
         else if (arg === "--keep-cpp") {
             keepCpp = true;
         }
+        else if (arg === "-t" || arg === "--target") {
+            if (i + 1 < rawArgs.length) {
+                const targetValue = rawArgs[i + 1]?.toLowerCase();
+                if (targetValue === "wasm") {
+                    target = "wasm";
+                }
+                else if (targetValue === "native") {
+                    target = "native";
+                }
+                else {
+                    console.error(`${COLORS.red}Error: Invalid target '${targetValue}'. Supported targets: native, wasm.${COLORS.reset}`);
+                    process.exit(1);
+                }
+                i++;
+            }
+            else {
+                console.error(`${COLORS.red}Error: --target requires a value (native or wasm).${COLORS.reset}`);
+                process.exit(1);
+            }
+        }
         else if (arg === "-o" || arg === "--output") {
             if (i + 1 < rawArgs.length) {
                 outputExePath = rawArgs[i + 1] ?? null;
@@ -55,5 +76,6 @@ export function parseArgs(rawArgs) {
             ? path.resolve(process.cwd(), outputExePath)
             : null,
         scriptArgs,
+        target,
     };
 }

package/dist/cli/compiler.js

@@ -0,0 +1,53 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { msToHumanReadable } from "./utils.js";
+export async function compileCpp(cppFilePath, exeFilePath, pchDir, preludePath, isWasm, flags, emsdkEnv, spinner) {
+    spinner.text = `Compiling binary...`;
+    spinner.start();
+    // Ensure output directory exists
+    await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
+    const runtimeLibPath = path.join(pchDir, "libjspp.a");
+    const compiler = isWasm ? "em++" : "g++";
+    const compileArgs = [
+        "-std=c++23",
+        ...flags,
+        "-include",
+        "jspp.hpp",
+        cppFilePath,
+        runtimeLibPath,
+        "-o",
+        exeFilePath,
+        "-I",
+        pchDir,
+        "-I",
+        preludePath,
+    ];
+    if (!isWasm) {
+        compileArgs.splice(1, 0, "-Winvalid-pch");
+    }
+    const compileStartTime = performance.now();
+    const compile = spawn(compiler, compileArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: emsdkEnv,
+        shell: process.platform === "win32",
+    });
+    const compileStderrChunks = [];
+    if (compile.stderr) {
+        compile.stderr.on("data", (chunk) => compileStderrChunks.push(chunk));
+    }
+    const compileExitCode = await new Promise((resolve) => {
+        compile.on("close", (code) => resolve(code ?? 1));
+    });
+    if (compileExitCode !== 0) {
+        const stderr = Buffer.concat(compileStderrChunks).toString();
+        spinner.fail(`Compilation failed`);
+        console.error(stderr);
+        process.exit(1);
+    }
+    const compileEndTime = performance.now();
+    const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
+    spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} ${COLORS.dim}[${compileTime}]${COLORS.reset}`);
+}

package/dist/cli/index.js

@@ -1,138 +1,75 @@
 #!/usr/bin/env node
-import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 import pkg from "../../package.json" with { type: "json" };
-import { CompilerError } from "../core/error.js";
-import { Interpreter } from "../index.js";
+import { CompilerError } from "../interpreter/core/error.js";
 import { parseArgs } from "./args.js";
 import { COLORS } from "./colors.js";
+import { compileCpp } from "./compiler.js";
+import { checkAndRebuildPCH } from "./pch.js";
+import { runOutput } from "./runner.js";
 import { Spinner } from "./spinner.js";
-import { getLatestMtime, msToHumanReadable } from "./utils.js";
+import { transpile } from "./transpiler.js";
+import { postProcessWasm, setupEmsdk } from "./wasm.js";
 const pkgDir = path.dirname(path.dirname(import.meta.dirname));
+const emsdkEnv = {
+    ...process.env,
+    PATH: `${path.join(pkgDir, ".emsdk")}${path.delimiter}${path.join(pkgDir, ".emsdk", "upstream", "emscripten")}${path.delimiter}${process.env.PATH}`,
+};
 async function main() {
-    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs } = parseArgs(process.argv.slice(2));
+    const { jsFilePath, isRelease, keepCpp, outputExePath, scriptArgs, target, } = parseArgs(process.argv.slice(2));
+    const isWasm = target === "wasm";
     const ext = path.extname(jsFilePath);
     const jsFileName = path.basename(jsFilePath, ext);
     const sourceDir = path.dirname(jsFilePath);
-    // Intermediate C++ file goes alongside the source JS file
-    const cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
+    // Intermediate C++ file goes alongside the source JS file if `--output` is not set
+    let cppFilePath = path.join(sourceDir, `${jsFileName}.cpp`);
     // Determine output executable path
     let exeFilePath;
     if (outputExePath) {
         exeFilePath = outputExePath;
+        cppFilePath = path.join(path.dirname(outputExePath), `${jsFileName}.cpp`);
     }
     else {
-        const ext = process.platform === "win32" ? ".exe" : "";
-        exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+        if (isWasm) {
+            exeFilePath = path.join(sourceDir, `${jsFileName}.js`);
+        }
+        else {
+            const ext = process.platform === "win32" ? ".exe" : "";
+            exeFilePath = path.join(sourceDir, `${jsFileName}${ext}`);
+        }
     }
     // Mode Configuration
-    const mode = isRelease ? "release" : "debug";
+    const mode = isWasm ? "wasm" : (isRelease ? "release" : "debug");
+    const modeNote = isRelease
+        ? `${COLORS.dim}(optimized)${COLORS.reset}`
+        : `${COLORS.dim}(debug)${COLORS.reset}\n${COLORS.dim}NOTE: Use "--release" for an optimized build for production${COLORS.reset}`;
     console.log(`${COLORS.bold}JSPP Compiler${COLORS.reset} ${COLORS.dim}v${pkg.version}${COLORS.reset}`);
-    console.log(`Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset}\n`);
-    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-Og", "-ftime-report"];
-    if (process.platform === "win32") {
+    console.log(`Target: ${isWasm ? COLORS.cyan : COLORS.green}${target.toUpperCase()}${COLORS.reset} | Mode: ${isRelease ? COLORS.green : COLORS.yellow}${mode.toUpperCase()}${COLORS.reset} ${modeNote}\n`);
+    const flags = isRelease ? ["-O3", "-DNDEBUG"] : ["-Og"];
+    if (isWasm) {
+        flags.push("-sASYNCIFY", "-sALLOW_MEMORY_GROWTH=1", "-sWASM=1", "-sEXPORT_ES6=1", "-sMODULARIZE=1", "-sEXPORT_NAME=jsppModule");
+    }
+    else if (process.platform === "win32") {
         flags.push("-Wa,-mbig-obj");
     }
     const pchDir = path.resolve(pkgDir, "prelude-build", mode);
     const spinner = new Spinner("Initializing...");
     try {
+        if (isWasm) {
+            await setupEmsdk(pkgDir, spinner);
+        }
         spinner.start();
-        // 1. Interpreter Phase
-        spinner.update(`Reading ${path.basename(jsFilePath)}...`);
-        const jsCode = await fs.readFile(jsFilePath, "utf-8");
-        spinner.update("Transpiling to C++...");
-        const interpreter = new Interpreter();
-        const { cppCode, preludePath } = interpreter.interpret(jsCode, jsFilePath);
-        // Ensure directory for cpp file exists (should exist as it's source dir, but for safety if we change logic)
-        await fs.mkdir(path.dirname(cppFilePath), { recursive: true });
-        await fs.writeFile(cppFilePath, cppCode);
-        spinner.succeed(`Generated cpp`);
+        // 1. Transpilation Phase
+        const { preludePath, wasmExports } = await transpile(jsFilePath, cppFilePath, target, spinner);
         // 2. Precompiled Header Check
-        spinner.text = "Checking precompiled headers...";
-        spinner.start();
-        const pchFile = path.join(pchDir, "jspp.hpp.gch");
-        const runtimeLibPath = path.join(pchDir, "libjspp.a");
-        let shouldRebuild = false;
-        try {
-            const pchStats = await fs.stat(pchFile);
-            const sourceMtime = await getLatestMtime(preludePath);
-            if (sourceMtime > pchStats.mtimeMs) {
-                shouldRebuild = true;
-            }
-        }
-        catch (e) {
-            shouldRebuild = true;
-        }
-        if (shouldRebuild) {
-            spinner.update("Rebuilding precompiled headers (this may take a while)...");
-            // Use spawn (async) instead of spawnSync to keep spinner alive
-            const rebuild = spawn("bun", [
-                "run",
-                "scripts/precompile-headers.ts",
-            ], {
-                cwd: pkgDir,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            const stderrChunks = [];
-            if (rebuild.stderr) {
-                rebuild.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-            }
-            const exitCode = await new Promise((resolve) => {
-                rebuild.on("close", (code) => resolve(code ?? 1));
-            });
-            if (exitCode !== 0) {
-                const stderr = Buffer.concat(stderrChunks).toString();
-                spinner.fail("Failed to rebuild precompiled headers");
-                console.error(stderr);
-                process.exit(1);
-            }
-            spinner.succeed("Precompiled headers updated");
-        }
-        else {
-            spinner.succeed("Precompiled headers");
-        }
+        await checkAndRebuildPCH(pkgDir, pchDir, mode, preludePath, emsdkEnv, spinner);
         // 3. Compilation Phase
-        spinner.text = `Compiling binary...`;
-        spinner.start();
-        // Ensure output directory exists
-        await fs.mkdir(path.dirname(exeFilePath), { recursive: true });
-        const compileStartTime = performance.now();
-        const compile = spawn("g++", [
-            "-std=c++23",
-            ...flags,
-            "-Winvalid-pch",
-            "-include",
-            "jspp.hpp",
-            cppFilePath,
-            runtimeLibPath,
-            "-o",
-            exeFilePath,
-            "-I",
-            pchDir,
-            "-I",
-            preludePath,
-        ], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const compileStderrChunks = [];
-        if (compile.stderr) {
-            compile.stderr.on("data", (chunk) => compileStderrChunks.push(chunk));
+        await compileCpp(cppFilePath, exeFilePath, pchDir, preludePath, isWasm, flags, emsdkEnv, spinner);
+        // 3.5 Post-processing for Wasm (Exports)
+        if (isWasm) {
+            await postProcessWasm(exeFilePath, wasmExports);
         }
-        const compileExitCode = await new Promise((resolve) => {
-            compile.on("close", (code) => resolve(code ?? 1));
-        });
-        if (compileExitCode !== 0) {
-            const stderr = Buffer.concat(compileStderrChunks).toString();
-            spinner.fail(`Compilation failed`);
-            console.error(stderr);
-            process.exit(1);
-        }
-        const compileEndTime = performance.now();
-        const compileTime = msToHumanReadable(compileEndTime - compileStartTime);
-        spinner.succeed(`Compiled to ${COLORS.green}${COLORS.bold}${path.basename(exeFilePath)}${COLORS.reset} in ${COLORS.dim}${COLORS.bold}${compileTime}${COLORS.reset}`);
-        // const stderr = Buffer.concat(compileStderrChunks).toString();
-        // console.log(stderr);
         // Clean up C++ file if not requested to keep
         if (!keepCpp) {
             try {
@@ -143,18 +80,7 @@ async function main() {
             }
         }
         // 4. Execution Phase
-        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
-        const run = spawn(exeFilePath, scriptArgs, {
-            stdio: "inherit",
-        });
-        const runExitCode = await new Promise((resolve) => {
-            run.on("close", (code) => resolve(code ?? 1));
-        });
-        console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
-        if (runExitCode !== 0) {
-            console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);
-            process.exit(1);
-        }
+        await runOutput(exeFilePath, scriptArgs, isWasm);
     }
     catch (error) {
         if (error instanceof CompilerError) {

package/dist/cli/pch.js

@@ -0,0 +1,71 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { getLatestMtime, msToHumanReadable } from "./utils.js";
+export async function checkAndRebuildPCH(pkgDir, pchDir, mode, preludePath, emsdkEnv, spinner) {
+    spinner.text = "Checking precompiled headers...";
+    spinner.start();
+    const pchFile = path.join(pchDir, "jspp.hpp.gch");
+    const runtimeLibPath = path.join(pchDir, "libjspp.a");
+    let shouldRebuildPCH = false;
+    try {
+        const pchStats = await fs.stat(pchFile);
+        const libStats = await fs.stat(runtimeLibPath);
+        // 1. Check if any header is newer than the PCH
+        const latestHeaderMtime = await getLatestMtime(preludePath, (name) => name.endsWith(".hpp") || name.endsWith(".h"));
+        // 2. Check if any CPP file is newer than the library
+        const latestCppMtime = await getLatestMtime(preludePath, (name) => name.endsWith(".cpp"));
+        if (latestHeaderMtime > pchStats.mtimeMs ||
+            latestCppMtime > libStats.mtimeMs ||
+            pchStats.mtimeMs > libStats.mtimeMs) {
+            shouldRebuildPCH = true;
+        }
+    }
+    catch (e) {
+        shouldRebuildPCH = true;
+    }
+    if (shouldRebuildPCH) {
+        spinner.update("Rebuilding precompiled headers (this may take a while)...");
+        const pchStartTime = performance.now();
+        const rebuild = spawn("bun", [
+            "run",
+            "scripts/precompile-headers.ts",
+            "--jspp-cli-is-parent",
+            "--mode",
+            mode,
+        ], {
+            cwd: pkgDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: emsdkEnv,
+        });
+        if (rebuild.stdout) {
+            rebuild.stdout.on("data", (chunk) => {
+                spinner.pause();
+                process.stdout.write(chunk);
+            });
+        }
+        const stderrChunks = [];
+        if (rebuild.stderr) {
+            rebuild.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        }
+        const exitCode = await new Promise((resolve) => {
+            rebuild.on("close", (code) => {
+                spinner.resume();
+                resolve(code ?? 1);
+            });
+        });
+        if (exitCode !== 0) {
+            const stderr = Buffer.concat(stderrChunks).toString();
+            spinner.fail("Failed to rebuild precompiled headers");
+            console.error(stderr);
+            process.exit(1);
+        }
+        const pchTime = msToHumanReadable(performance.now() - pchStartTime);
+        spinner.succeed(`Precompiled headers updated ${COLORS.dim}[${pchTime}]${COLORS.reset}`);
+    }
+    else {
+        spinner.stop();
+    }
+}

package/dist/cli/runner.js

@@ -0,0 +1,23 @@
+import { spawn } from "child_process";
+import path from "path";
+import { COLORS } from "./colors.js";
+export async function runOutput(exeFilePath, scriptArgs, isWasm) {
+    if (isWasm) {
+        console.log(`\n${COLORS.cyan}Compilation finished. To run the output, use node or a browser:${COLORS.reset}`);
+        console.log(`${COLORS.bold}    node ${path.basename(exeFilePath)}${COLORS.reset}\n`);
+    }
+    else {
+        console.log(`\n${COLORS.cyan}--- Running Output ---${COLORS.reset}`);
+        const run = spawn(exeFilePath, scriptArgs, {
+            stdio: "inherit",
+        });
+        const runExitCode = await new Promise((resolve) => {
+            run.on("close", (code) => resolve(code ?? 1));
+        });
+        console.log(`${COLORS.cyan}----------------------${COLORS.reset}\n`);
+        if (runExitCode !== 0) {
+            console.error(`${COLORS.red}Execution failed with exit code ${runExitCode}${COLORS.reset}`);
+            process.exit(1);
+        }
+    }
+}

package/dist/cli/spinner.js

@@ -1,32 +1,42 @@
 import { COLORS } from "./colors.js";
 export class Spinner {
     frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    interval = null;
+    interval = null; // Note: You may need NodeJS.Timeout depending on your environment
     frameIndex = 0;
     text;
     constructor(text) {
         this.text = text;
     }
     start() {
+        if (this.interval)
+            return; // Prevent multiple intervals
         process.stdout.write("\x1b[?25l"); // Hide cursor
         this.frameIndex = 0;
         this.render();
-        this.interval = setInterval(() => {
-            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
-            this.render();
-        }, 80);
-    }
-    update(text) {
-        this.text = text;
-        this.render();
+        this.startInterval();
     }
-    stop(symbol = "", color = COLORS.reset) {
+    pause() {
         if (this.interval) {
             clearInterval(this.interval);
             this.interval = null;
         }
+    }
+    resume() {
+        if (this.interval)
+            return; // Already running
+        process.stdout.write("\x1b[?25l"); // Ensure cursor stays hidden
+        this.startInterval();
+    }
+    update(text) {
+        this.text = text;
+        this.render();
+    }
+    stop(symbol, color = COLORS.reset) {
+        this.pause(); // Reuse pause logic to clear the interval
         this.clearLine();
-        process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        if (symbol) {
+            process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        }
         process.stdout.write("\x1b[?25h"); // Show cursor
     }
     succeed(text) {
@@ -44,6 +54,12 @@ export class Spinner {
             this.text = text;
         this.stop("ℹ", COLORS.cyan);
     }
+    startInterval() {
+        this.interval = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+            this.render();
+        }, 80);
+    }
     render() {
         this.clearLine();
         const frame = this.frames[this.frameIndex];

package/dist/cli/transpiler.js

@@ -0,0 +1,20 @@
+import fs from "fs/promises";
+import path from "path";
+import { Interpreter } from "../index.js";
+import { COLORS } from "./colors.js";
+import { Spinner } from "./spinner.js";
+import { msToHumanReadable } from "./utils.js";
+export async function transpile(jsFilePath, cppFilePath, target, spinner) {
+    spinner.update(`Reading ${path.basename(jsFilePath)}...`);
+    const jsCode = await fs.readFile(jsFilePath, "utf-8");
+    spinner.update("Transpiling to C++...");
+    const transpileStartTime = performance.now();
+    const interpreter = new Interpreter();
+    const { cppCode, preludePath, wasmExports } = interpreter.interpret(jsCode, jsFilePath, target);
+    const transpileTime = msToHumanReadable(performance.now() - transpileStartTime);
+    // Ensure directory for cpp file exists
+    await fs.mkdir(path.dirname(cppFilePath), { recursive: true });
+    await fs.writeFile(cppFilePath, cppCode);
+    spinner.succeed(`Generated cpp ${COLORS.dim}[${transpileTime}]${COLORS.reset}`);
+    return { preludePath, wasmExports };
+}

package/dist/cli/utils.js

@@ -1,16 +1,18 @@
 import fs from "fs/promises";
 import path from "path";
-export async function getLatestMtime(dirPath) {
+export async function getLatestMtime(dirPath, filter) {
     let maxMtime = 0;
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dirPath, entry.name);
         if (entry.isDirectory()) {
-            const nestedMtime = await getLatestMtime(fullPath);
+            const nestedMtime = await getLatestMtime(fullPath, filter);
             if (nestedMtime > maxMtime)
                 maxMtime = nestedMtime;
         }
         else {
+            if (filter && !filter(entry.name))
+                continue;
             const stats = await fs.stat(fullPath);
             if (stats.mtimeMs > maxMtime)
                 maxMtime = stats.mtimeMs;
@@ -19,43 +21,39 @@ export async function getLatestMtime(dirPath) {
     return maxMtime;
 }
 /**
- * Converts milliseconds to a human-readable format.
+ * Converts milliseconds to a single-unit, human-readable decimal format.
  * @param ms - The time in milliseconds
- * @returns A formatted string (e.g., "2 hours, 1 minute, 4 seconds")
+ * @returns A formatted string (e.g., "2.52s", "1.5h")
  */
 export function msToHumanReadable(ms) {
     if (ms < 0) {
         throw new Error("Time cannot be negative");
     }
     if (ms === 0) {
-        return "0 seconds";
+        return "0ms";
     }
-    // Define time constants in milliseconds
     const MS_PER_SECOND = 1000;
     const MS_PER_MINUTE = 60 * MS_PER_SECOND;
     const MS_PER_HOUR = 60 * MS_PER_MINUTE;
     const MS_PER_DAY = 24 * MS_PER_HOUR;
-    // Calculate each unit
-    const days = Math.floor(ms / MS_PER_DAY);
-    const hours = Math.floor((ms % MS_PER_DAY) / MS_PER_HOUR);
-    const minutes = Math.floor((ms % MS_PER_HOUR) / MS_PER_MINUTE);
-    const seconds = Math.floor((ms % MS_PER_MINUTE) / MS_PER_SECOND);
-    // Array to hold the formatted parts
-    const parts = [];
-    // Helper function to handle pluralization
-    const addPart = (value, unit) => {
-        if (value > 0) {
-            parts.push(`${value} ${unit}${value > 1 ? "s" : ""}`);
-        }
+    // Helper to safely truncate to 2 decimal places without rounding up
+    const formatValue = (val) => {
+        // toFixed(3) resolves float math errors, slice(0,-1) enforces truncation (e.g. 2.528 -> 2.52)
+        let str = val.toFixed(3).slice(0, -1);
+        // Remove trailing zeroes and lingering decimal points (e.g., "2.00" -> "2")
+        return str.replace(/0+$/, "").replace(/\.$/, "");
     };
-    addPart(days, "day");
-    addPart(hours, "hour");
-    addPart(minutes, "minute");
-    addPart(seconds, "second");
-    // If the time was less than 1 second, it will be empty
-    if (parts.length === 0) {
-        return `${ms} millisecond${ms > 1 ? "s" : ""}`;
+    if (ms >= MS_PER_DAY) {
+        return formatValue(ms / MS_PER_DAY) + "d";
+    }
+    if (ms >= MS_PER_HOUR) {
+        return formatValue(ms / MS_PER_HOUR) + "h";
+    }
+    if (ms >= MS_PER_MINUTE) {
+        return formatValue(ms / MS_PER_MINUTE) + "m";
+    }
+    if (ms >= MS_PER_SECOND) {
+        return formatValue(ms / MS_PER_SECOND) + "s";
     }
-    // Join the parts with a comma and space
-    return parts.join(", ");
+    return formatValue(ms) + "ms";
 }

package/dist/cli/wasm.js

@@ -0,0 +1,70 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { Spinner } from "./spinner.js";
+export async function setupEmsdk(pkgDir, spinner) {
+    spinner.text = "Checking Emscripten SDK...";
+    spinner.start();
+    // Ensure emsdk is set up
+    const setupEmsdk = spawn("bun", ["run", "scripts/setup-emsdk.ts"], {
+        cwd: pkgDir,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const setupExitCode = await new Promise((resolve) => {
+        setupEmsdk.on("close", (code) => resolve(code ?? 1));
+    });
+    if (setupExitCode !== 0) {
+        spinner.fail("Emscripten SDK setup failed");
+        process.exit(1);
+    }
+    spinner.stop();
+}
+export async function postProcessWasm(exeFilePath, wasmExports) {
+    const outputDir = path.dirname(exeFilePath);
+    const outputBaseName = path.basename(exeFilePath, ".js");
+    // Generate .d.ts
+    let dtsContent = "";
+    for (const exp of wasmExports) {
+        const params = exp.params.map((p) => `${p.name}: ${p.type}`)
+            .join(", ");
+        dtsContent +=
+            `export declare function wasm_export_${exp.jsName}(${params}): ${exp.returnType};\n`;
+    }
+    dtsContent += `export declare const Module: Promise<any>;\n`;
+    dtsContent += `export declare const load: () => typeof Module;\n`;
+    dtsContent +=
+        `declare const jsppModule: (options?: any) => Promise<any>;\n`;
+    dtsContent += `export default jsppModule;\n`;
+    const dtsPath = path.join(outputDir, `${outputBaseName}.d.ts`);
+    await fs.writeFile(dtsPath, dtsContent);
+    // Append exports to .js glue code
+    let jsGlue = await fs.readFile(exeFilePath, "utf-8");
+    // Emscripten with -sEXPORT_ES6=1 adds this at the end
+    const defaultExportStr = "export default jsppModule;";
+    if (jsGlue.trim().endsWith(defaultExportStr)) {
+        jsGlue = jsGlue.trim().substring(0, jsGlue.trim().length - defaultExportStr.length);
+    }
+    jsGlue += `\n\n// JSPP Named Exports\n`;
+    jsGlue += `let _notLoaded = true;\n`;
+    jsGlue += `let _resolve = () => {};\n`;
+    jsGlue += `let _reject = () => {};\n`;
+    jsGlue += `let _instance;\n`;
+    jsGlue +=
+        `const _getinstance=()=>{if(!_instance)throw new Error("Module not loaded");return _instance}\n`;
+    jsGlue +=
+        `export const Module = new Promise((res,rej)=>{_resolve=res;_reject=rej});\n`;
+    jsGlue += `export const load = async () => {\n`;
+    jsGlue += ` if (_notLoaded) {\n`;
+    jsGlue += `  _notLoaded = false;\n`;
+    jsGlue +=
+        `  jsppModule().then(m=>{_instance=m;_resolve(m)}).catch(e=>{_notLoaded=true;_reject(e)});\n`;
+    jsGlue += ` }\n`;
+    jsGlue += ` return Module;\n`;
+    jsGlue += `};\n`;
+    for (const exp of wasmExports) {
+        jsGlue +=
+            `export const wasm_export_${exp.jsName} = (...args) => _getinstance()._wasm_export_${exp.jsName}(...args);\n`;
+    }
+    jsGlue += `export default jsppModule;\n`;
+    await fs.writeFile(exeFilePath, jsGlue);
+}