setup

#!/usr/bin/env node

import { execSync, spawn } from 'node:child_process';
import crypto from 'node:crypto';
import fs from 'node:fs';
import path from 'node:path';
import * as url from 'node:url';
const __dirname = url.fileURLToPath(new URL('.', import.meta.url));

async function command(cmd, args, options) {
    if (args == null) args = [];
    if (options == null) options = {};
    if (options.cwd == null) options.cwd = process.cwd();

    if (process.platform == 'win32') {
        options.shell = cmd.endsWith('.exe') ? false : true;
        if (options.shell) {
            args = [].concat(args);
            for (let i = 0; i < args.length; i++) {
                args[i] = '"' + args[i].replace(/"/g, '""') + '"';
            }
        }
    }

    console.log('\n> ' + cmd + ' ' + args.join(' '));

    return new Promise((resolve, reject) => {
        const child = spawn(cmd, args, {
            stdio: 'inherit',
            cwd: options.cwd,
            env: process.env,
            shell: options.shell
        });

        child.on('close', (code) => {
            if (code !== 0) {
                reject(new Error(`Child process exited with code ${code}`));
            } else {
                resolve(code);
            }
        });

        child.on('error', (error) => {
            reject(error);
        });
    });
}

function walkDirectory(dir, callback) {
    // Get the contents of the directory
    const entries = fs.readdirSync(dir);

    // Iterate through each entry
    for (const entry of entries) {
        // Create full path
        const fullPath = path.join(dir, entry);

        // Get file/directory stats
        const stats = fs.statSync(fullPath);

        if (stats.isDirectory()) {
            // Recursively walk through subdirectories
            walkDirectory(fullPath, callback);
        } else {
            // Call the callback with the file path
            callback(fullPath);
        }
    }
}

function extractCsNamespace(content) {
    // Match 'namespace' followed by any valid C# namespace characters
    // Handles optional whitespace and the opening brace
    const namespaceMatch = content.match(/namespace\s+([\w.]+)\s*{/);

    if (namespaceMatch) {
        return namespaceMatch[1];
    }

    return null; // Return null if no namespace found
}

function getDotnetRid() {
    const os = process.platform == 'darwin' ? 'osx'
             : process.platform == 'win32' ? 'win'
             : 'linux';
    const arch = process.arch == 'arm64' ? 'arm64' : 'x64';
    return os + '-' + arch;
}

function isLinuxArm64() {
    try {
        const arch = execSync('uname -m').toString().trim();
        return arch == 'aarch64';
    } catch (error) {
        console.error('Error detecting architecture:', error);
        return null;
    }
}

async function downloadFile(fileUrl, destPath) {
    const https = await import('node:https');
    const http = await import('node:http');

    return new Promise((resolve, reject) => {
        const client = fileUrl.startsWith('https') ? https : http;
        client.get(fileUrl, (response) => {
            // Follow redirects (GitHub releases redirect to CDN)
            if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
                downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
                response.resume();
                return;
            }
            if (response.statusCode !== 200) {
                response.resume();
                reject(new Error('HTTP ' + response.statusCode + ' for ' + fileUrl));
                return;
            }
            const file = fs.createWriteStream(destPath);
            response.pipe(file);
            file.on('finish', () => { file.close(resolve); });
            file.on('error', (err) => { fs.unlinkSync(destPath); reject(err); });
        }).on('error', reject);
    });
}

async function extractArchive(archivePath, destDir) {
    fs.mkdirSync(destDir, { recursive: true });
    if (archivePath.endsWith('.tar.gz') || archivePath.endsWith('.tgz')) {
        await command('tar', ['xzf', archivePath, '-C', destDir]);
    } else if (archivePath.endsWith('.zip')) {
        if (process.platform === 'win32') {
            await command('powershell', [
                '-Command',
                'Expand-Archive -Path "' + archivePath + '" -DestinationPath "' + destDir + '" -Force'
            ]);
        } else {
            await command('unzip', ['-o', '-q', archivePath, '-d', destDir]);
        }
    }
}

/**
 * The language server is tooling (CLI, editors): it must not end up in the
 * runtime exports that projects embed. Fails when a runtime export has it.
 */
function checkNoLanguageServer(exportName, found) {
    if (found) {
        throw new Error('The language server (loreline.lsp) is in the ' + exportName + ' runtime export');
    }
    console.log('No language server in the ' + exportName + ' runtime export');
}

// Example usage with async/await
async function main() {

    process.chdir(__dirname);
    let rawArgs = process.argv.slice(2);

    var haxelib = process.platform == 'win32' ? 'haxelib.cmd' : './haxelib';
    var haxe = process.platform == 'win32' ? 'haxe.cmd' : './haxe';

    let haxeBuildArgs = [];
    let buildCpp = rawArgs.indexOf('--cpp-cli') != -1 || rawArgs.indexOf('--cpp') != -1;
    let buildCppLib = rawArgs.indexOf('--cpp-lib') != -1;
    let buildCppLibTest = rawArgs.indexOf('--cpp-lib-test') != -1;
    let buildCs = rawArgs.indexOf('--cs') != -1;
    let buildCsDll = rawArgs.indexOf('--cs-dll') != -1;
    let buildCsGenerics = rawArgs.indexOf('--cs-generics') != -1;
    let buildJs = rawArgs.indexOf('--js') != -1;
    let buildPython = rawArgs.indexOf('--python') != -1 || rawArgs.indexOf('--py') != -1;
    let buildLua = rawArgs.indexOf('--lua') != -1;
    let buildPhp = rawArgs.indexOf('--php') != -1;
    let buildPhpCli = rawArgs.indexOf('--php-cli') != -1;
    let buildJvm = rawArgs.indexOf('--jvm') != -1;
    let buildIos = rawArgs.indexOf('--ios') != -1;
    let buildAndroid = rawArgs.indexOf('--android') != -1;
    let buildWasm = rawArgs.indexOf('--wasm') != -1;
    let buildGodot = rawArgs.indexOf('--godot') != -1;
    let buildGdscript = rawArgs.indexOf('--gdscript') != -1;
    let testGdscript = rawArgs.indexOf('--gdscript-test') != -1;
    let testSyntax = rawArgs.indexOf('--syntax-test') != -1;
    let testLsp = rawArgs.indexOf('--lsp-test') != -1;
    let testLspJs = testLsp || rawArgs.indexOf('--lsp-test-js') != -1;
    let testLspCpp = testLsp || rawArgs.indexOf('--lsp-test-cpp') != -1;
    let testGodotLifetime = rawArgs.indexOf('--godot-lifetime-test') != -1;
    let buildGodotIos = rawArgs.indexOf('--godot-ios') != -1;
    let buildGodotAndroid = rawArgs.indexOf('--godot-android') != -1;
    let buildGodotWasm = rawArgs.indexOf('--godot-wasm') != -1;
    let buildUnityPackage = rawArgs.indexOf('--unity-package') != -1;
    let runTest = rawArgs.indexOf('--test') != -1;
    let debug = false;

    // --sample [web|unity|cpp|python|lua|sdl3|java]: copy built files into sample projects
    let setupSample = rawArgs.indexOf('--sample') != -1;
    let sampleTarget = null; // null = all, 'web', 'unity', 'cpp', 'python', 'lua', 'sdl3', or 'java'
    if (setupSample) {
        const idx = rawArgs.indexOf('--sample');
        if (idx + 1 < rawArgs.length && !rawArgs[idx + 1].startsWith('-')) {
            sampleTarget = rawArgs[idx + 1];
        }
    }

    // --archs <arch>[,<arch>...]: restrict Android builds to the given
    // architectures. Accepts either Godot arch names (arm64, arm32, x86_64,
    // x86_32) or Android ABI names (arm64-v8a, armeabi-v7a, x86_64, x86).
    // Defaults to all of them.
    let archFilter = null;
    if (rawArgs.indexOf('--archs') != -1) {
        const idx = rawArgs.indexOf('--archs');
        if (idx + 1 < rawArgs.length && !rawArgs[idx + 1].startsWith('-')) {
            archFilter = rawArgs[idx + 1].split(',');
        }
    }
    const archMatches = (c) => archFilter == null
        || archFilter.indexOf(c.abi) != -1
        || archFilter.indexOf(c.arch) != -1;

    let i = 0;
    while (i < rawArgs.length) {
        if (rawArgs[i].startsWith('-D')) {
            haxeBuildArgs.push('-D');
            haxeBuildArgs.push(rawArgs[i].substring(2));
        }
        else if (rawArgs[i] == '--debug') {
            debug = true;
            haxeBuildArgs.push('--debug');
        }
        i++;
    }

    // Install dependencies (only needed for build targets, not --sample or --test)
    if (buildCpp || buildCppLib || buildIos || buildAndroid || buildWasm || buildCs || buildCsGenerics || buildJs || buildPython || buildLua || buildJvm || buildGdscript || testLspJs || testLspCpp) {
        var haxelibRepoPath = path.join(__dirname, '.haxelib');
        if (!fs.existsSync(haxelibRepoPath)) {
            fs.mkdirSync(haxelibRepoPath);
        }
        await command(haxelib, ['dev', 'hxcpp', 'git/hxcpp', '--quiet'], { cwd: __dirname });
        if (buildGdscript) {
            await command(haxelib, ['dev', 'reflaxe', 'git/reflaxe', '--quiet'], { cwd: __dirname });
            await command(haxelib, ['dev', 'gdscript', 'git/reflaxe.GDScript', '--quiet'], { cwd: __dirname });
        }
        await command(haxelib, ['dev', 'hxcs', 'git/hxcs', '--quiet'], { cwd: __dirname });
        if (buildJvm) {
            await command(haxelib, ['dev', 'hxjava', 'git/hxjava', '--quiet'], { cwd: __dirname });
        }
        // The language server test build for node, like the VS Code extension
        if (testLspJs && !fs.existsSync(path.join(haxelibRepoPath, 'hxnodejs'))) {
            await command(haxelib, ['install', 'hxnodejs', '12.2.0', '--quiet', '--always'], { cwd: __dirname });
        }
    }

    if (buildCpp) {

        let haxeBuildCppArgs = [
            'build-cli.hxml',
            '--cpp', 'build/cpp',
            '-D', 'HXCPP_DEBUG_LINK',
            '-D', 'HXCPP_STACK_LINE',
            '-D', 'HXCPP_STACK_TRACE',
            '-D', 'HXCPP_CHECK_POINTER',
            '-D', 'HXCPP_CPP11',
            '-D', 'HXCPP_IMMORTAL_STATICS',
            '-D', 'safeMode'
        ];

        if (process.platform == 'darwin') {
            console.log('Build loreline for mac');

            await command(haxe, haxeBuildCppArgs.concat(haxeBuildArgs).concat([
                '-D', 'mac', '-D', 'mac_arm64', '-D', 'no-compilation'
            ]));
            await command('../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64'].concat(debug ? ['-Ddebug'] : []), { cwd: path.join(__dirname, 'build', 'cpp') });
            if (debug) {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli-debug'), path.join(__dirname, 'build/cpp/loreline-arm64'));
            }
            else {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli'), path.join(__dirname, 'build/cpp/loreline-arm64'));
            }

            await command(haxe, haxeBuildCppArgs.concat(haxeBuildArgs).concat([
                '-D', 'mac', '-D', 'mac_x86_64', '-D', 'no-compilation'
            ]));
            await command('../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: path.join(__dirname, 'build', 'cpp') });
            if (debug) {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli-debug'), path.join(__dirname, 'build/cpp/loreline-x86_64'));
            }
            else {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli'), path.join(__dirname, 'build/cpp/loreline-x86_64'));
            }

            if (fs.existsSync(path.join(__dirname, 'loreline'))) {
                fs.unlinkSync(path.join(__dirname, 'loreline'));
            }

            await command('lipo', [
                '-create', 'loreline-arm64', 'loreline-x86_64',
                '-output', '../../loreline'
            ], { cwd: path.join(__dirname, 'build', 'cpp') });
        }
        else if (process.platform == 'win32') {
            console.log("Build loreline for windows");

            await command(haxe, haxeBuildCppArgs.concat(haxeBuildArgs).concat([
                '-D', 'windows', '-D', 'no-compilation'
            ]));

            let haxelibCmd = fs.readFileSync(path.join(__dirname, 'haxelib.cmd'), 'utf8');
            haxelibCmd = haxelibCmd.split('/git/').join('/../../git/');
            fs.writeFileSync(path.join(__dirname, 'build', 'cpp', 'haxelib.cmd'), haxelibCmd);

            await command(haxelib, ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: path.join(__dirname, 'build', 'cpp') });

            if (fs.existsSync(path.join(__dirname, 'loreline.exe'))) {
                fs.unlinkSync(path.join(__dirname, 'loreline.exe'));
            }

            if (debug) {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli-debug.exe'), path.join(__dirname, 'loreline.exe'));
            }
            else {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli.exe'), path.join(__dirname, 'loreline.exe'));
            }
        }
        else {
            console.log("Build loreline for linux");

            if (isLinuxArm64()) {
                await command(haxe, haxeBuildCppArgs.concat(haxeBuildArgs).concat([
                    '-D', 'linux', '-D', 'no-compilation', '-D', 'linux_arm64'
                ]));
                await command('../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64'].concat(debug ? ['-Ddebug'] : []), { cwd: path.join(__dirname, 'build', 'cpp') });
            }
            else {
                await command(haxe, haxeBuildCppArgs.concat(haxeBuildArgs).concat([
                    '-D', 'linux', '-D', 'no-compilation', '-D', 'linux_x86_64'
                ]));
                await command('../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: path.join(__dirname, 'build', 'cpp') });
            }

            if (fs.existsSync(path.join(__dirname, 'loreline'))) {
                fs.unlinkSync(path.join(__dirname, 'loreline'));
            }

            if (debug) {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli-debug'), path.join(__dirname, 'loreline'));
            }
            else {
                fs.renameSync(path.join(__dirname, 'build/cpp/Cli'), path.join(__dirname, 'loreline'));
            }
        }
    }

    if (buildCppLib) {

        let haxeBuildCppLibArgs = [
            'build-cpp-lib.hxml'
        ];

        if (process.platform == 'darwin') {
            console.log('Build loreline C++ library for mac');

            const buildDir = path.join(__dirname, 'build', 'cpp-lib', 'mac');

            // Build arm64
            await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
                '--cpp', 'build/cpp-lib/mac',
                '-D', 'mac', '-D', 'mac_arm64'
            ]));
            await command('../../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64'].concat(debug ? ['-Ddebug'] : []), { cwd: buildDir });

            // Rename intermediate static lib (hxcpp produces libLibrary.a on macOS)
            const staticLib = debug ? 'libLibrary-debug.a' : 'libLibrary.a';
            const armLib = path.join(buildDir, 'libLoreline-arm64.a');
            fs.renameSync(path.join(buildDir, staticLib), armLib);

            // Build x86_64
            await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
                '--cpp', 'build/cpp-lib/mac',
                '-D', 'mac', '-D', 'mac_x86_64'
            ]));
            await command('../../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: buildDir });

            const x64Lib = path.join(buildDir, 'libLoreline-x86_64.a');
            fs.renameSync(path.join(buildDir, staticLib), x64Lib);

            // Link arm64 dylib
            const armDylib = path.join(buildDir, 'libLoreline-arm64.dylib');
            await command('clang++', [
                '-arch', 'arm64',
                '-shared', '-fvisibility=hidden',
                '-o', armDylib,
                '-Wl,-force_load,' + armLib,
                '-framework', 'Foundation', '-lpthread'
            ]);
            await command('install_name_tool', ['-id', '@rpath/libLoreline.dylib', armDylib]);
            await command('codesign', ['--force', '--sign', '-', armDylib]);

            // Link x86_64 dylib
            const x64Dylib = path.join(buildDir, 'libLoreline-x86_64.dylib');
            await command('clang++', [
                '-arch', 'x86_64',
                '-shared', '-fvisibility=hidden',
                '-o', x64Dylib,
                '-Wl,-force_load,' + x64Lib,
                '-framework', 'Foundation', '-lpthread'
            ]);
            await command('install_name_tool', ['-id', '@rpath/libLoreline.dylib', x64Dylib]);
            await command('codesign', ['--force', '--sign', '-', x64Dylib]);

            // Create universal dylib
            const outputDylib = path.join(buildDir, 'libLoreline.dylib');
            if (fs.existsSync(outputDylib)) fs.unlinkSync(outputDylib);
            await command('lipo', [
                '-create', armDylib, x64Dylib,
                '-output', outputDylib
            ]);
            // Re-sign the universal dylib (lipo combines but doesn't preserve sigs)
            await command('codesign', ['--force', '--sign', '-', outputDylib]);

            console.log('Built: ' + outputDylib);
        }
        else if (process.platform == 'win32') {
            console.log('Build loreline C++ library for windows');

            const buildDir = path.join(__dirname, 'build', 'cpp-lib', 'windows');

            await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
                '--cpp', 'build/cpp-lib/windows',
                '-D', 'windows'
            ]));

            let haxelibCmd = fs.readFileSync(path.join(__dirname, 'haxelib.cmd'), 'utf8');
            haxelibCmd = haxelibCmd.split('/git/').join('/../../../git/');
            fs.writeFileSync(path.join(buildDir, 'haxelib.cmd'), haxelibCmd);

            await command(haxelib, ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: buildDir });

            // On Windows, hxcpp with static_link produces a .lib; link into DLL via cl /LD
            // Using cl instead of link directly ensures proper CRT DLL initialization
            const staticLib = debug ? 'libLibrary-debug.lib' : 'libLibrary.lib';
            const stubFile = path.join(buildDir, '_dll_stub.c');
            fs.writeFileSync(stubFile, '/* stub for DLL creation */\n');
            await command('cl', [
                '/LD', '/MT',
                stubFile,
                '/Fe:' + path.join(buildDir, 'Loreline.dll'),
                '/link',
                '/WHOLEARCHIVE:' + path.join(buildDir, staticLib),
                'ws2_32.lib', 'Crypt32.lib', 'user32.lib'
            ]);

            console.log('Built: ' + path.join(buildDir, 'Loreline.dll'));
        }
        else {
            console.log('Build loreline C++ library for linux');

            const buildDir = path.join(__dirname, 'build', 'cpp-lib', 'linux');

            if (isLinuxArm64()) {
                await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
                    '--cpp', 'build/cpp-lib/linux',
                    '-D', 'linux', '-D', 'linux_arm64'
                ]));
                await command('../../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64'].concat(debug ? ['-Ddebug'] : []), { cwd: buildDir });
            }
            else {
                await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
                    '--cpp', 'build/cpp-lib/linux',
                    '-D', 'linux', '-D', 'linux_x86_64'
                ]));
                await command('../../../haxelib', ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-DHXCPP_X86_64'].concat(debug ? ['-Ddebug'] : []), { cwd: buildDir });
            }

            // On Linux, hxcpp also produces libLibrary.a
            const staticLib = debug ? 'libLibrary-debug.a' : 'libLibrary.a';
            await command('g++', [
                '-shared', '-fvisibility=hidden',
                '-o', path.join(buildDir, 'libLoreline.so'),
                '-Wl,--whole-archive', path.join(buildDir, staticLib), '-Wl,--no-whole-archive',
                '-lpthread', '-ldl'
            ]);

            console.log('Built: ' + path.join(buildDir, 'libLoreline.so'));
        }
    }

    if (buildCppLibTest) {
        console.log('Test loreline C++ library');

        let buildDir;
        if (process.platform == 'darwin') {
            buildDir = path.join(__dirname, 'build', 'cpp-lib', 'mac');
            await command('clang++', [
                '-std=c++17',
                '-o', path.join(buildDir, 'test_runner'),
                'cpp/test/test_runner.cpp',
                '-Icpp/include',
                '-L' + buildDir,
                '-lLoreline',
                '-Wl,-rpath,@executable_path'
            ]);
        }
        else if (process.platform == 'win32') {
            buildDir = path.join(__dirname, 'build', 'cpp-lib', 'windows');
            await command('cl', [
                '/std:c++17', '/EHsc',
                '/I', 'cpp\\include',
                'cpp\\test\\test_runner.cpp',
                '/Fe:' + path.join(buildDir, 'test_runner.exe'),
                '/link', '/LIBPATH:' + buildDir, 'Loreline.lib'
            ]);
        }
        else {
            buildDir = path.join(__dirname, 'build', 'cpp-lib', 'linux');
            await command('g++', [
                '-std=c++17',
                '-o', path.join(buildDir, 'test_runner'),
                'cpp/test/test_runner.cpp',
                '-Icpp/include',
                '-L' + buildDir,
                '-lLoreline',
                "-Wl,-rpath,$ORIGIN"
            ]);
        }

        const testBin = path.join(buildDir, process.platform == 'win32' ? 'test_runner.exe' : 'test_runner');
        await command(testBin, ['./test']);
    }

    if (buildIos) {
        if (process.platform != 'darwin') {
            throw new Error('iOS builds are only supported on macOS');
        }

        console.log('Build loreline .xcframework for iOS');

        const iosBuildDir = path.join(__dirname, 'build', 'cpp-lib', 'ios');
        const haxelibRelPath = '../../../haxelib';

        let haxeBuildCppLibArgs = [
            'build-cpp-lib.hxml',
            '-D', 'HXCPP_STACK_LINE',
            '-D', 'HXCPP_STACK_TRACE'
        ];

        const iosLinkFrameworks = ['-framework', 'Foundation', '-framework', 'QuartzCore', '-lpthread'];
        const iphoneosSDK = execSync('xcrun --sdk iphoneos --show-sdk-path').toString().trim();
        const iphonesimSDK = execSync('xcrun --sdk iphonesimulator --show-sdk-path').toString().trim();

        // hxcpp produces .a files with a suffix based on platform/arch:
        //   iphoneos + ARM64 -> libLibrary.iphoneos-64.a
        //   iphonesim + M64  -> libLibrary.iphonesim-64.a  (both x86_64 and arm64)
        const hxcppStaticLibName = (debug ? 'libLibrary-debug' : 'libLibrary');

        // -- Device arm64 ----------------------------------------------
        await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
            '--cpp', 'build/cpp-lib/ios',
            '-D', 'iphoneos'
        ]));
        await command(haxelibRelPath, ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64', '-Diphoneos'].concat(debug ? ['-Ddebug'] : []), { cwd: iosBuildDir });

        const deviceStaticLib = hxcppStaticLibName + '.iphoneos-64.a';
        const deviceDylib = path.join(iosBuildDir, 'libLoreline-device-arm64.dylib');
        await command('xcrun', [
            '--sdk', 'iphoneos', 'clang++',
            '-arch', 'arm64',
            '-shared', '-fvisibility=hidden',
            '-isysroot', iphoneosSDK,
            '-miphoneos-version-min=12.0',
            '-o', deviceDylib,
            '-Wl,-force_load,' + path.join(iosBuildDir, deviceStaticLib)
        ].concat(iosLinkFrameworks));
        await command('install_name_tool', ['-id', '@rpath/Loreline.framework/Loreline', deviceDylib]);

        // -- Simulator arm64 ------------------------------------------
        await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
            '--cpp', 'build/cpp-lib/ios',
            '-D', 'iphonesim', '-D', 'simulator'
        ]));
        await command(haxelibRelPath, ['run', 'hxcpp', 'Build.xml', '-DHXCPP_ARM64', '-DHXCPP_M64', '-Diphonesim', '-Dsimulator'].concat(debug ? ['-Ddebug'] : []), { cwd: iosBuildDir });

        // Rename the .a so it doesn't get overwritten by the x86_64 build
        const simArm64StaticLib = 'libLoreline-sim-arm64.a';
        fs.renameSync(
            path.join(iosBuildDir, hxcppStaticLibName + '.iphonesim-arm64.a'),
            path.join(iosBuildDir, simArm64StaticLib)
        );

        const simArm64Dylib = path.join(iosBuildDir, 'libLoreline-sim-arm64.dylib');
        await command('xcrun', [
            '--sdk', 'iphonesimulator', 'clang++',
            '-arch', 'arm64',
            '-shared', '-fvisibility=hidden',
            '-isysroot', iphonesimSDK,
            '-mios-simulator-version-min=12.0',
            '-o', simArm64Dylib,
            '-Wl,-force_load,' + path.join(iosBuildDir, simArm64StaticLib)
        ].concat(iosLinkFrameworks));

        // -- Simulator x86_64 -----------------------------------------
        await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
            '--cpp', 'build/cpp-lib/ios',
            '-D', 'iphonesim', '-D', 'simulator'
        ]));
        await command(haxelibRelPath, ['run', 'hxcpp', 'Build.xml', '-DHXCPP_M64', '-Diphonesim', '-Dsimulator'].concat(debug ? ['-Ddebug'] : []), { cwd: iosBuildDir });

        const simX86StaticLib = hxcppStaticLibName + '.iphonesim-64.a';
        const simX86Dylib = path.join(iosBuildDir, 'libLoreline-sim-x86_64.dylib');
        await command('xcrun', [
            '--sdk', 'iphonesimulator', 'clang++',
            '-arch', 'x86_64',
            '-shared', '-fvisibility=hidden',
            '-isysroot', iphonesimSDK,
            '-mios-simulator-version-min=12.0',
            '-o', simX86Dylib,
            '-Wl,-force_load,' + path.join(iosBuildDir, simX86StaticLib)
        ].concat(iosLinkFrameworks));

        // Step 9: Create combined simulator dylib via lipo
        const simCombinedDylib = path.join(iosBuildDir, 'libLoreline-sim.dylib');
        if (fs.existsSync(simCombinedDylib)) fs.unlinkSync(simCombinedDylib);
        await command('lipo', [
            '-create', simArm64Dylib, simX86Dylib,
            '-output', simCombinedDylib
        ]);
        await command('install_name_tool', ['-id', '@rpath/Loreline.framework/Loreline', simCombinedDylib]);

        // Step 10: Assemble .framework bundles
        const deviceFrameworkDir = path.join(iosBuildDir, 'device', 'Loreline.framework');
        const simFrameworkDir = path.join(iosBuildDir, 'simulator', 'Loreline.framework');

        for (const fwDir of [deviceFrameworkDir, simFrameworkDir]) {
            if (fs.existsSync(fwDir)) fs.rmSync(fwDir, { recursive: true, force: true });
            fs.mkdirSync(path.join(fwDir, 'Headers'), { recursive: true });
            fs.mkdirSync(path.join(fwDir, 'Modules'), { recursive: true });

            // Copy header
            fs.copyFileSync(
                path.join(__dirname, 'cpp', 'include', 'Loreline.h'),
                path.join(fwDir, 'Headers', 'Loreline.h')
            );

            // Copy module map and Info.plist from templates
            fs.copyFileSync(
                path.join(__dirname, 'tpl', 'ios', 'module.modulemap'),
                path.join(fwDir, 'Modules', 'module.modulemap')
            );
            fs.copyFileSync(
                path.join(__dirname, 'tpl', 'ios', 'Framework-Info.plist'),
                path.join(fwDir, 'Info.plist')
            );
        }

        // Copy the dylibs as the framework executables
        fs.copyFileSync(deviceDylib, path.join(deviceFrameworkDir, 'Loreline'));
        fs.copyFileSync(simCombinedDylib, path.join(simFrameworkDir, 'Loreline'));

        // Step 11: Create .xcframework
        const xcframeworkPath = path.join(iosBuildDir, 'Loreline.xcframework');
        if (fs.existsSync(xcframeworkPath)) fs.rmSync(xcframeworkPath, { recursive: true, force: true });
        await command('xcodebuild', [
            '-create-xcframework',
            '-framework', deviceFrameworkDir,
            '-framework', simFrameworkDir,
            '-output', xcframeworkPath
        ]);

        console.log('Built: ' + xcframeworkPath);

        // -- Static .xcframework with symbol renaming ---------------------

        const llvmPrefix = execSync('brew --prefix llvm').toString().trim();
        const llvmNm = path.join(llvmPrefix, 'bin', 'llvm-nm');
        const llvmObjcopy = path.join(llvmPrefix, 'bin', 'llvm-objcopy');
        if (!fs.existsSync(llvmNm) || !fs.existsSync(llvmObjcopy)) {
            throw new Error(
                'LLVM is required for static framework symbol renaming.\n' +
                'Install it with: brew install llvm'
            );
        }

        async function renameSymbols(staticLib, outputLib) {
            const symbols = execSync(`${llvmNm} --defined-only -g ${staticLib}`, { maxBuffer: 64 * 1024 * 1024 })
                .toString().split('\n');

            const mappingFile = outputLib + '.symmap';
            const mappings = [];
            for (const line of symbols) {
                const parts = line.trim().split(/\s+/);
                if (parts.length < 3) continue;
                const sym = parts[2];
                // Keep only top-level Loreline_ symbols (public API)
                // Namespaced loreline::* symbols (e.g. __ZN8loreline...) get renamed
                const isPublicApi = /^__Z\d+Loreline_/.test(sym) ||
                    /^__ZN\d+Loreline_/.test(sym) ||
                    /^__ZT[INSV]+\d*Loreline_/.test(sym);
                if (isPublicApi) continue;
                if (sym.startsWith('_')) {
                    mappings.push(`${sym} _lorimpl_${sym.slice(1)}`);
                }
            }
            fs.writeFileSync(mappingFile, mappings.join('\n'));
            console.log(`  Symbol renaming: ${mappings.length} renamed, ${symbols.length - mappings.length} kept`);

            fs.copyFileSync(staticLib, outputLib);
            await command(llvmObjcopy, ['--redefine-syms=' + mappingFile, outputLib]);
            fs.unlinkSync(mappingFile);
        }

        // Rename symbols in each thin slice (llvm-objcopy cannot process fat binaries)
        const deviceStaticRenamed = path.join(iosBuildDir, 'libLoreline-static-device-arm64.a');
        await renameSymbols(path.join(iosBuildDir, deviceStaticLib), deviceStaticRenamed);

        const simArm64StaticRenamed = path.join(iosBuildDir, 'libLoreline-static-sim-arm64.a');
        await renameSymbols(path.join(iosBuildDir, simArm64StaticLib), simArm64StaticRenamed);

        const simX86StaticRenamed = path.join(iosBuildDir, 'libLoreline-static-sim-x86_64.a');
        await renameSymbols(path.join(iosBuildDir, simX86StaticLib), simX86StaticRenamed);

        // Combine simulator slices
        const simStaticCombined = path.join(iosBuildDir, 'libLoreline-static-sim.a');
        if (fs.existsSync(simStaticCombined)) fs.unlinkSync(simStaticCombined);
        await command('lipo', [
            '-create', simArm64StaticRenamed, simX86StaticRenamed,
            '-output', simStaticCombined
        ]);

        // Assemble static .framework bundles
        const deviceStaticFrameworkDir = path.join(iosBuildDir, 'device-static', 'Loreline.framework');
        const simStaticFrameworkDir = path.join(iosBuildDir, 'simulator-static', 'Loreline.framework');

        for (const fwDir of [deviceStaticFrameworkDir, simStaticFrameworkDir]) {
            if (fs.existsSync(fwDir)) fs.rmSync(fwDir, { recursive: true, force: true });
            fs.mkdirSync(path.join(fwDir, 'Headers'), { recursive: true });
            fs.mkdirSync(path.join(fwDir, 'Modules'), { recursive: true });

            fs.copyFileSync(
                path.join(__dirname, 'cpp', 'include', 'Loreline.h'),
                path.join(fwDir, 'Headers', 'Loreline.h')
            );
            fs.copyFileSync(
                path.join(__dirname, 'tpl', 'ios', 'module.modulemap'),
                path.join(fwDir, 'Modules', 'module.modulemap')
            );
            fs.copyFileSync(
                path.join(__dirname, 'tpl', 'ios', 'Framework-Info.plist'),
                path.join(fwDir, 'Info.plist')
            );
        }

        fs.copyFileSync(deviceStaticRenamed, path.join(deviceStaticFrameworkDir, 'Loreline'));
        fs.copyFileSync(simStaticCombined, path.join(simStaticFrameworkDir, 'Loreline'));

        // Create static .xcframework
        const staticXcframeworkPath = path.join(iosBuildDir, 'Loreline-static.xcframework');
        if (fs.existsSync(staticXcframeworkPath)) fs.rmSync(staticXcframeworkPath, { recursive: true, force: true });
        await command('xcodebuild', [
            '-create-xcframework',
            '-framework', deviceStaticFrameworkDir,
            '-framework', simStaticFrameworkDir,
            '-output', staticXcframeworkPath
        ]);

        console.log('Built: ' + staticXcframeworkPath);
    }

    if (buildAndroid) {
        console.log('Build loreline .aar for Android');

        // Resolve Android NDK path
        const ndkRoot = process.env.ANDROID_NDK_ROOT || process.env.ANDROID_NDK_HOME || process.env.ANDROID_NDK;
        if (!ndkRoot) {
            throw new Error('ANDROID_NDK_ROOT environment variable is not set. Set it to the path of your Android NDK installation.');
        }
        if (!fs.existsSync(ndkRoot)) {
            throw new Error('Android NDK not found at: ' + ndkRoot);
        }

        const androidBuildDir = path.join(__dirname, 'build', 'cpp-lib', 'android');
        const haxelibRelPath = '../../../haxelib';

        // Determine host platform for NDK toolchain
        let ndkHost;
        if (process.platform == 'darwin') ndkHost = 'darwin-x86_64';
        else if (process.platform == 'win32') ndkHost = 'windows-x86_64';
        else ndkHost = 'linux-x86_64';

        const ndkClang = path.join(ndkRoot, 'toolchains', 'llvm', 'prebuilt', ndkHost, 'bin', 'clang++');
        const ndkStrip = path.join(ndkRoot, 'toolchains', 'llvm', 'prebuilt', ndkHost, 'bin', 'llvm-strip');

        let haxeBuildCppLibArgs = [
            'build-cpp-lib.hxml',
            '-D', 'HXCPP_STACK_LINE',
            '-D', 'HXCPP_STACK_TRACE'
        ];

        // Step 1: Haxe -> C++ for Android
        await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
            '--cpp', 'build/cpp-lib/android',
            '-D', 'android',
            '-D', 'ANDROID_NDK_ROOT=' + ndkRoot
        ]));

        // Step 2: Compile and link for each ABI
        const abiConfigs = [
            { abi: 'arm64-v8a', arch: 'arm64', hxcppFlags: ['-DHXCPP_ARM64'], suffix: '-64', target: 'aarch64-linux-android21' },
            { abi: 'armeabi-v7a', arch: 'arm32', hxcppFlags: ['-DHXCPP_ARMV7'], suffix: '-v7', target: 'armv7a-linux-androideabi21' },
            { abi: 'x86_64', arch: 'x86_64', hxcppFlags: ['-DHXCPP_M64', '-DHXCPP_X86_64'], suffix: '-x86_64', target: 'x86_64-linux-android21' },
            { abi: 'x86', arch: 'x86_32', hxcppFlags: ['-DHXCPP_M32', '-DHXCPP_X86'], suffix: '-x86', target: 'i686-linux-android21' }
        ].filter(archMatches);

        for (const abi of abiConfigs) {
            console.log('  Compiling for ' + abi.abi + '...');

            // hxcpp compile
            await command(haxelibRelPath, [
                'run', 'hxcpp', 'Build.xml'
            ].concat(abi.hxcppFlags).concat(debug ? ['-Ddebug'] : []), { cwd: androidBuildDir });

            const staticLibName = (debug ? 'libLibrary-debug' : 'libLibrary') + abi.suffix + '.a';
            const staticLibPath = path.join(androidBuildDir, staticLibName);

            if (!fs.existsSync(staticLibPath)) {
                // Try without suffix (hxcpp naming can vary)
                const altName = debug ? 'libLibrary-debug.a' : 'libLibrary.a';
                const altPath = path.join(androidBuildDir, altName);
                if (fs.existsSync(altPath)) {
                    fs.renameSync(altPath, staticLibPath);
                } else {
                    throw new Error('Static library not found: ' + staticLibPath + ' (also tried ' + altPath + ')');
                }
            }

            // Link .a into .so
            const soDir = path.join(androidBuildDir, 'jni', abi.abi);
            fs.mkdirSync(soDir, { recursive: true });
            const soPath = path.join(soDir, 'libloreline.so');

            await command(ndkClang, [
                '--target=' + abi.target,
                '-shared', '-fvisibility=hidden',
                '-o', soPath,
                '-Wl,--whole-archive', staticLibPath, '-Wl,--no-whole-archive',
                '-llog'
            ]);

            // Strip symbols for release
            if (!debug) {
                await command(ndkStrip, ['--strip-unneeded', soPath]);
            }

            console.log('  Built: ' + soPath);
        }

        // Step 3: Assemble the AAR
        const aarDir = path.join(androidBuildDir, 'aar-staging');
        if (fs.existsSync(aarDir)) fs.rmSync(aarDir, { recursive: true, force: true });
        fs.mkdirSync(aarDir, { recursive: true });

        // Copy AndroidManifest.xml
        fs.copyFileSync(
            path.join(__dirname, 'tpl', 'android', 'AndroidManifest.xml'),
            path.join(aarDir, 'AndroidManifest.xml')
        );

        // The AAR format requires classes.jar to be present. Since Loreline is a
        // pure native C++ library (no Java/Kotlin code), we create a valid but empty
        // JAR. A JAR is a ZIP file, so we write the minimal 22-byte valid ZIP archive
        // (just an End of Central Directory record with zero entries). A 0-byte file
        // would not be a valid ZIP and would cause errors in Android build tools.
        const emptyJarPath = path.join(aarDir, 'classes.jar');
        const emptyZip = Buffer.from([
            0x50, 0x4b, 0x05, 0x06, // End of central directory signature
            0x00, 0x00, // Number of this disk
            0x00, 0x00, // Disk where central directory starts
            0x00, 0x00, // Number of central directory records on this disk
            0x00, 0x00, // Total number of central directory records
            0x00, 0x00, 0x00, 0x00, // Size of central directory
            0x00, 0x00, 0x00, 0x00, // Offset of start of central directory
            0x00, 0x00  // Comment length
        ]);
        fs.writeFileSync(emptyJarPath, emptyZip);

        // Copy jni/ directory with .so files
        for (const abi of abiConfigs) {
            const srcSo = path.join(androidBuildDir, 'jni', abi.abi, 'libloreline.so');
            const dstDir = path.join(aarDir, 'jni', abi.abi);
            fs.mkdirSync(dstDir, { recursive: true });
            fs.copyFileSync(srcSo, path.join(dstDir, 'libloreline.so'));
        }

        // Copy prefab structure from template
        const prefabSrcDir = path.join(__dirname, 'tpl', 'android', 'prefab');
        const prefabDstDir = path.join(aarDir, 'prefab');
        fs.cpSync(prefabSrcDir, prefabDstDir, { recursive: true });

        // Copy header into prefab
        const prefabIncludeDir = path.join(prefabDstDir, 'modules', 'loreline', 'include');
        fs.mkdirSync(prefabIncludeDir, { recursive: true });
        fs.copyFileSync(
            path.join(__dirname, 'cpp', 'include', 'Loreline.h'),
            path.join(prefabIncludeDir, 'Loreline.h')
        );

        // Copy .so files into prefab and update abi.json ndk version
        let ndkVersion = 27; // default
        try {
            const sourceProps = fs.readFileSync(path.join(ndkRoot, 'source.properties'), 'utf8');
            const versionMatch = sourceProps.match(/Pkg\.Revision\s*=\s*(\d+)/);
            if (versionMatch) ndkVersion = parseInt(versionMatch[1], 10);
        } catch (e) { /* use default */ }

        for (const abi of abiConfigs) {
            const prefabLibDir = path.join(prefabDstDir, 'modules', 'loreline', 'libs', 'android.' + abi.abi);
            // Copy .so into prefab
            fs.copyFileSync(
                path.join(aarDir, 'jni', abi.abi, 'libloreline.so'),
                path.join(prefabLibDir, 'libloreline.so')
            );
            // Update abi.json with actual NDK version
            const abiJsonPath = path.join(prefabLibDir, 'abi.json');
            const abiJson = JSON.parse(fs.readFileSync(abiJsonPath, 'utf8'));
            abiJson.ndk = ndkVersion;
            fs.writeFileSync(abiJsonPath, JSON.stringify(abiJson, null, '  ') + '\n');
        }

        // Step 4: Zip into .aar
        const aarOutputPath = path.join(androidBuildDir, 'loreline.aar');
        if (fs.existsSync(aarOutputPath)) fs.unlinkSync(aarOutputPath);

        // Get list of entries in the aar staging directory
        const aarEntries = fs.readdirSync(aarDir);

        if (process.platform == 'win32') {
            await command('powershell.exe', [
                '-NoProfile', '-NonInteractive', '-Command',
                `Compress-Archive -Path @(${aarEntries.map(e => "'" + e + "'").join(',')}) -DestinationPath '${aarOutputPath}' -Force`
            ], { cwd: aarDir });
        } else {
            await command('zip', ['-q', '-r', aarOutputPath].concat(aarEntries), { cwd: aarDir });
        }

        console.log('Built: ' + aarOutputPath);
    }

    if (buildWasm) {
        console.log('Build loreline C++ library for WebAssembly (Emscripten)');

        const emsdkRoot = process.env.EMSDK;
        if (!emsdkRoot) {
            throw new Error('EMSDK environment variable is not set. Install Emscripten SDK and set EMSDK.');
        }

        const wasmNothreadsBuildDir = path.join(__dirname, 'build', 'cpp-lib', 'wasm-nothreads');
        const wasmThreadsBuildDir = path.join(__dirname, 'build', 'cpp-lib', 'wasm-threads');
        const wasmOutputDir = path.join(__dirname, 'build', 'cpp-lib', 'wasm');

        let haxeBuildCppLibArgs = [
            'build-cpp-lib.hxml',
            '-D', 'HXCPP_STACK_LINE',
            '-D', 'HXCPP_STACK_TRACE'
        ];

        // Step 1: Haxe -> C++ (once, with emscripten define)
        await command(haxe, haxeBuildCppLibArgs.concat(haxeBuildArgs).concat([
            '--cpp', 'build/cpp-lib/wasm-nothreads',
            '-D', 'emscripten'
        ]));

        // Copy generated C++ to threads build dir
        if (fs.existsSync(wasmThreadsBuildDir)) fs.rmSync(wasmThreadsBuildDir, { recursive: true, force: true });
        fs.cpSync(wasmNothreadsBuildDir, wasmThreadsBuildDir, { recursive: true });

        // Step 2: Build nothreads variant
        console.log('  Building nothreads variant...');
        await command('../../../haxelib', [
            'run', 'hxcpp', 'Build.xml',
            '-Demscripten',
            '-DHXCPP_EMSCRIPTEN_FPIC'
        ].concat(debug ? ['-Ddebug'] : []), { cwd: wasmNothreadsBuildDir });

        // Step 3: Build threads variant
        console.log('  Building threads variant...');
        await command('../../../haxelib', [
            'run', 'hxcpp', 'Build.xml',
            '-Demscripten',
            '-DHXCPP_MULTI_THREADED_APP',
            '-DHXCPP_MULTI_THREADED',
            '-DHXCPP_EMSCRIPTEN_FPIC'
        ].concat(debug ? ['-Ddebug'] : []), { cwd: wasmThreadsBuildDir });

        // Step 4: Copy final .a files to wasm/
        const staticLibName = debug ? 'libLibrary-debug.a' : 'libLibrary.a';
        fs.mkdirSync(wasmOutputDir, { recursive: true });
        fs.copyFileSync(
            path.join(wasmNothreadsBuildDir, staticLibName),
            path.join(wasmOutputDir, 'libLoreline.nothreads.a')
        );
        fs.copyFileSync(
            path.join(wasmThreadsBuildDir, staticLibName),
            path.join(wasmOutputDir, 'libLoreline.threads.a')
        );
        console.log('Built: ' + path.join(wasmOutputDir, 'libLoreline.nothreads.a'));
        console.log('Built: ' + path.join(wasmOutputDir, 'libLoreline.threads.a'));
    }

    if (buildGodot || buildGodotIos || buildGodotAndroid || buildGodotWasm) {
        const godotDir = path.join(__dirname, 'godot');
        const sconsTarget = debug ? 'template_debug' : 'template_release';

        // --godot: build for host platform (macOS/Windows/Linux)
        if (buildGodot) {
            console.log('Build loreline GDExtension for Godot');

            // Determine platform and architecture for scons
            let sconsPlatform;
            let sconsArchList;
            if (process.platform == 'darwin') {
                sconsPlatform = 'macos';
                sconsArchList = ['arm64', 'x86_64'];
            } else if (process.platform == 'win32') {
                sconsPlatform = 'windows';
                sconsArchList = ['x86_64'];
            } else {
                sconsPlatform = 'linux';
                sconsArchList = [isLinuxArm64() ? 'arm64' : 'x86_64'];
            }

            for (const sconsArch of sconsArchList) {
                let sconsArgs = [
                    'platform=' + sconsPlatform,
                    'arch=' + sconsArch,
                    'target=' + sconsTarget
                ];

                await command('scons', sconsArgs, { cwd: godotDir });
                console.log('Built: GDExtension for ' + sconsPlatform + ' (' + sconsArch + ')');

            }

            // On macOS, create universal binary via lipo
            if (sconsPlatform == 'macos' && sconsArchList.length > 1) {
                const arm64Lib = path.join(godotDir, 'bin', 'libloreline_godot.arm64.dylib');
                const x64Lib = path.join(godotDir, 'bin', 'libloreline_godot.x86_64.dylib');
                const universalLib = path.join(godotDir, 'bin', 'libloreline_godot.dylib');
                if (fs.existsSync(arm64Lib) && fs.existsSync(x64Lib)) {
                    if (fs.existsSync(universalLib)) fs.unlinkSync(universalLib);
                    await command('lipo', ['-create', arm64Lib, x64Lib, '-output', universalLib]);
                    fs.unlinkSync(arm64Lib);
                    fs.unlinkSync(x64Lib);
                    console.log('Created universal macOS dylib');
                }
            }

            // On macOS, patch GDExtension to find libLoreline via @loader_path (same directory)
            // instead of @rpath (which Godot doesn't set for addon directories)
            if (sconsPlatform == 'macos') {
                const gdextLib = sconsArchList.length > 1
                    ? path.join(godotDir, 'bin', 'libloreline_godot.dylib')
                    : path.join(godotDir, 'bin', 'libloreline_godot.' + sconsArchList[0] + '.dylib');
                if (fs.existsSync(gdextLib)) {
                    await command('install_name_tool', [
                        '-change', '@rpath/libLoreline.dylib', '@loader_path/libLoreline.dylib',
                        gdextLib
                    ]);
                    console.log('Patched dylib to use @loader_path for libLoreline');

                    // Re-sign with ad-hoc signature: install_name_tool invalidates
                    // the existing signature, and macOS Sequoia+ refuses to load
                    // dylibs with broken signatures (Code Signature Invalid).
                    await command('codesign', ['--force', '--sign', '-', gdextLib]);
                    console.log('Re-signed dylib (ad-hoc) after install_name_tool');
                }
            }
        }

        // --godot-ios: build GDExtension for iOS
        if (buildGodotIos) {
            if (process.platform != 'darwin') {
                throw new Error('iOS GDExtension builds are only supported on macOS');
            }
            const iosXcfw = path.join(__dirname, 'build', 'cpp-lib', 'ios', 'Loreline.xcframework');
            if (!fs.existsSync(iosXcfw)) {
                throw new Error('Loreline.xcframework not found. Run --ios first.');
            }

            console.log('Building GDExtension for iOS...');

            // Device arm64: link against ios-arm64/Loreline.framework
            const deviceFwDir = path.join(iosXcfw, 'ios-arm64');
            await command('scons', [
                'platform=ios', 'arch=arm64', 'target=' + sconsTarget,
                'loreline_framework_dir=' + deviceFwDir
            ], { cwd: godotDir });

            // Simulator arm64
            const simFwDir = path.join(iosXcfw, 'ios-arm64_x86_64-simulator');
            await command('scons', [
                'platform=ios', 'arch=arm64', 'ios_simulator=yes', 'target=' + sconsTarget,
                'loreline_framework_dir=' + simFwDir
            ], { cwd: godotDir });

            // Simulator x86_64
            await command('scons', [
                'platform=ios', 'arch=x86_64', 'ios_simulator=yes', 'target=' + sconsTarget,
                'loreline_framework_dir=' + simFwDir
            ], { cwd: godotDir });

            // Lipo simulator arm64 + x86_64 into universal
            const simArm64 = path.join(godotDir, 'bin', 'libloreline_godot.ios.arm64.simulator.dylib');
            const simX86 = path.join(godotDir, 'bin', 'libloreline_godot.ios.x86_64.simulator.dylib');
            const simUniversal = path.join(godotDir, 'bin', 'libloreline_godot.ios.universal.simulator.dylib');
            if (fs.existsSync(simUniversal)) fs.unlinkSync(simUniversal);
            await command('lipo', ['-create', simArm64, simX86, '-output', simUniversal]);

            // Wrap dylibs in .framework bundles for proper codesigning
            const deviceDylib = path.join(godotDir, 'bin', 'libloreline_godot.ios.arm64.dylib');
            const fwName = 'loreline_godot';
            const fwInfoPlist = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>CFBundleExecutable</key>
    <string>${fwName}</string>
    <key>CFBundleIdentifier</key>
    <string>app.loreline.godot</string>
    <key>CFBundleInfoDictionaryVersion</key>
    <string>6.0</string>
    <key>CFBundlePackageType</key>
    <string>FMWK</string>
    <key>CFBundleVersion</key>
    <string>1.0</string>
</dict>
</plist>`;

            for (const [dylib, label] of [[deviceDylib, 'device'], [simUniversal, 'simulator']]) {
                const fwDir = path.join(godotDir, 'bin', label, fwName + '.framework');
                if (fs.existsSync(fwDir)) fs.rmSync(fwDir, { recursive: true, force: true });
                fs.mkdirSync(fwDir, { recursive: true });
                fs.copyFileSync(dylib, path.join(fwDir, fwName));
                fs.writeFileSync(path.join(fwDir, 'Info.plist'), fwInfoPlist);

                // Set install name so iOS app finds this framework via @rpath
                const fwBinary = path.join(fwDir, fwName);
                await command('install_name_tool', ['-id', '@rpath/' + fwName + '.framework/' + fwName, fwBinary]);
            }

            // Assemble xcframework from .framework bundles
            const deviceFw = path.join(godotDir, 'bin', 'device', fwName + '.framework');
            const simFw = path.join(godotDir, 'bin', 'simulator', fwName + '.framework');
            const xcfwOut = path.join(godotDir, 'bin', 'loreline_godot.xcframework');
            if (fs.existsSync(xcfwOut)) fs.rmSync(xcfwOut, { recursive: true });
            await command('xcodebuild', [
                '-create-xcframework',
                '-framework', deviceFw,
                '-framework', simFw,
                '-output', xcfwOut
            ]);

            console.log('Built: GDExtension iOS xcframework');
        }

        // --godot-android: build GDExtension for Android
        if (buildGodotAndroid) {
            if (!process.env.ANDROID_NDK_ROOT) {
                throw new Error('ANDROID_NDK_ROOT not set. Install Android NDK first.');
            }
            const androidJniDir = path.join(__dirname, 'build', 'cpp-lib', 'android', 'jni');
            const androidArm64So = path.join(androidJniDir, 'arm64-v8a', 'libloreline.so');
            if (!fs.existsSync(androidArm64So)) {
                throw new Error('Android libloreline.so not found. Run --android first.');
            }

            console.log('Building GDExtension for Android...');

            const androidArchs = [
                { arch: 'arm64', abi: 'arm64-v8a' },
                { arch: 'arm32', abi: 'armeabi-v7a' },
                { arch: 'x86_64', abi: 'x86_64' },
                { arch: 'x86_32', abi: 'x86' }
            ].filter(archMatches);

            // Detect installed NDK version from ANDROID_NDK_ROOT path
            const ndkVersion = path.basename(process.env.ANDROID_NDK_ROOT);

            for (const { arch, abi } of androidArchs) {
                const libDir = path.join(androidJniDir, abi);
                await command('scons', [
                    'platform=android', 'arch=' + arch, 'target=' + sconsTarget,
                    'loreline_android_lib_dir=' + libDir,
                    'ndk_version=' + ndkVersion
                ], { cwd: godotDir });
                // Move to per-abi directory so next arch doesn't overwrite
                const outputSo = path.join(godotDir, 'bin', 'libloreline_godot.so');
                const abiDir = path.join(godotDir, 'bin', abi);
                fs.mkdirSync(abiDir, { recursive: true });
                fs.renameSync(outputSo, path.join(abiDir, 'libloreline_godot.so'));
                console.log('Built: GDExtension for Android (' + arch + ')');
            }
        }

        // --godot-wasm: build GDExtension for Web (WASM)
        if (buildGodotWasm) {
            if (!process.env.EMSDK) {
                throw new Error('EMSDK environment variable is not set. Install Emscripten SDK first.');
            }

            // Generate JS bundle header from loreline.min.js
            const jsMinPath = path.join(__dirname, 'js', 'loreline.min.js');
            if (!fs.existsSync(jsMinPath)) {
                throw new Error('loreline.min.js not found. Run --js first.');
            }
            const jsBundleHeaderPath = path.join(godotDir, 'src', 'loreline_js_bundle.h');
            console.log('Generating JS bundle header...');
            const jsSource = fs.readFileSync(jsMinPath, 'utf8');
            // Transform ES module JS into eval()-compatible code with window globals.
            // loreline.min.js has: "use strict";let Xl={},Bn={};(IIFE)(Xl,Bn);export const Loreline=Xl.loreline.Loreline,...;
            // Strict mode eval scopes var declarations to the eval block (no globals created),
            // and let is always block-scoped. We need explicit window assignments.
            let jsSourceForBundle = jsSource;
            // Remove leading "use strict"; so var declarations can create globals
            jsSourceForBundle = jsSourceForBundle.replace(/^"use strict";/, '');
            // Change leading 'let' to 'var' so IIFE parameters survive the eval scope
            jsSourceForBundle = jsSourceForBundle.replace(/^let /, 'var ');
            // Extract export declarations and replace with explicit window assignments
            const exportMatch = jsSourceForBundle.match(/export const (.+);[\s]*$/);
            if (exportMatch) {
                jsSourceForBundle = jsSourceForBundle.replace(/export const .+;[\s]*$/, '');
                const parts = exportMatch[1].split(/,(?=\w+=)/);
                const assignments = parts.map(d => {
                    const eq = d.indexOf('=');
                    return 'window.' + d.substring(0, eq) + '=' + d.substring(eq + 1);
                });
                // Also expose the full lowercase `loreline` namespace so bridge code
                // can do `new loreline.Async(...)`. Derive the prefix (e.g. `Xl.loreline`)
                // from the first export's RHS, which is always `<ns>.loreline.<ClassName>`.
                const firstRhs = parts[0].substring(parts[0].indexOf('=') + 1);
                const nsPath = firstRhs.replace(/\.[A-Za-z_$][\w$]*$/, '');
                jsSourceForBundle += 'window.loreline=' + nsPath + ';' + assignments.join(';') + ';';
            }
            // Escape for C++ raw string literal using a unique delimiter
            const headerContent = [
                '#ifndef LORELINE_JS_BUNDLE_H',
                '#define LORELINE_JS_BUNDLE_H',
                '',
                '// Auto-generated from js/loreline.min.js, do not edit',
                'static const char LORELINE_JS_BUNDLE[] = R"LORELINE_JS(',
                jsSourceForBundle,
                ')LORELINE_JS";',
                '',
                '#endif // LORELINE_JS_BUNDLE_H',
                ''
            ].join('\n');
            fs.writeFileSync(jsBundleHeaderPath, headerContent);
            console.log('Generated: ' + jsBundleHeaderPath);

            console.log('Building GDExtension for Web (WASM)...');

            // Build nothreads variant
            await command('scons', [
                'platform=web', 'target=' + sconsTarget, 'threads=no'
            ], { cwd: godotDir });
            console.log('Built: GDExtension for Web (nothreads)');

            // Build threads variant
            await command('scons', [
                'platform=web', 'target=' + sconsTarget, 'threads=yes'
            ], { cwd: godotDir });
            console.log('Built: GDExtension for Web (threads)');
        }
    }

    if (buildCs) {
        console.log('Export loreline for C#');

        if (fs.existsSync('build/cs/Loreline')) {
            fs.rmSync('build/cs/Loreline', { recursive: true, force: true });
        }

        await command(haxe, ['build-cs.hxml'].concat(haxeBuildArgs));

        // Remove the generated Library entry point (not part of the public API)
        for (const f of [
            'build/cs/src/loreline/lib/_Library/Library_Fields_.cs',
            'build/cs/src/loreline/lib/Library.cs'
        ]) {
            if (fs.existsSync(f)) fs.unlinkSync(f);
        }
        //fs.unlinkSync('build/cs/src/loreline/Loreline.cs');
        if (fs.existsSync('build/cs/hxcs_build.txt')) fs.unlinkSync('build/cs/hxcs_build.txt');

        if (fs.existsSync('cs/Loreline/Internal'))
            fs.rmSync('cs/Loreline/Internal', { recursive: true, force: true });
        if (fs.existsSync('cs/Loreline/Runtime'))
            fs.rmSync('cs/Loreline/Runtime', { recursive: true, force: true });

        walkDirectory('build/cs/src', (filePath) => {
            if (filePath.endsWith('.cs')) {
                const original = fs.readFileSync(filePath, 'utf8');
                let content = original;

                // Replace any haxe.X with Loreline.Hx.X (with X capitalized)
                content = content.replace(
                    /\bhaxe\.(\w+)\b/g,
                    (_, identifier) => `Loreline.Internal.${identifier.charAt(0).toUpperCase() + identifier.slice(1)}`
                );

                content = content.replace(/\bhaxe\b/g, 'Loreline.Internal');
                // The vendored script engine `loreline.lorscript` -> Loreline.Internal.Lorscript.
                // Must run BEFORE the generic `loreline` -> Loreline.Runtime rule below; the
                // capitalized 3rd namespace segment makes these files land in
                // cs/Loreline/Internal/Lorscript/ without colliding with cs/Loreline/Runtime/.
                content = content.replace(/\bloreline\.lorscript\b/g, 'Loreline.Internal.Lorscript');
                content = content.replace(/\bnamespace cs\b/g, 'namespace Loreline.Internal.Cs');
                content = content.replace(/\bcs\.\b/g, 'Loreline.Internal.Cs.');
                content = content.replace(/\bloreline\b/g, 'Loreline.Runtime');
                content = content.replace(/\bLoreline\.Internal\./g, 'global::Loreline.Internal.');
                content = content.replace(/\bnamespace global::Loreline\.Internal\./g, 'namespace Loreline.Internal.');
                content = content.replace(/\bglobal::global::Loreline\.Internal\./g, 'global::Loreline.Internal.');

                // Disable warnings related to AOT (the code is still expected to work in that
                // situation because it should not rely on actual C# reflection. Uses FieldLookup instead)
                content = content.split("#pragma warning disable 109, 114, 219, 429, 168, 162").join("#pragma warning disable 109, 114, 219, 429, 168, 162, IL2026, IL2070, IL2072, IL2060, CS0108");

                // Fix Std.string() to use InvariantCulture for floats (prevents locale-dependent decimal separators)
                content = content.replace(
                    /return s\.ToString\(\);(\s*\}[\s\S]*?public static int @int)/,
                    'if (s is double d) return d.ToString(System.Globalization.CultureInfo.InvariantCulture);\n\t\t\tif (s is float f) return f.ToString(System.Globalization.CultureInfo.InvariantCulture);\n\t\t\treturn s.ToString();$1'
                );

                const namespace = extractCsNamespace(content);
                if (namespace == null) {
                    throw 'Failed to extract namespace for file: ' + filePath;
                }
                const namespaceParts = namespace.split('.');

                let newPath = path.join('cs', namespaceParts[0], namespaceParts[1], path.basename(filePath));

                if (namespaceParts.length > 2 && namespaceParts[2].charAt(0).toUpperCase() == namespaceParts[2].charAt(0) && namespaceParts[2].charAt(0) != '_' && namespaceParts[2] != 'Cs') {
                    newPath = path.join('cs', namespaceParts[0], namespaceParts[1], namespaceParts[2], path.basename(filePath));
                }

                if (!fs.existsSync(path.dirname(newPath))) {
                    fs.mkdirSync(path.dirname(newPath), { recursive: true });
                }
                if (fs.existsSync(newPath)) {
                    throw 'File path collision: ' + newPath;
                }
                fs.writeFileSync(newPath, content);
            }
        });

        fs.rmSync('build/cs/src', { recursive: true, force: true });

        // These identify Loreline
        const solutionGuid = '60F34EF9-0A9A-47B7-883F-8EC1F188C262';
        const projectGuid = 'F3DEFEF5-8B8F-4D6D-8C2C-1DD7F3E309D4';

        if (buildCsDll) {
            const csConfig = debug ? 'Debug' : 'Release';
            const csPlatform = 'netstandard2.1';
            const dllFiles = [
                'Loreline.deps.json',
                'Loreline.dll',
                'Loreline.pdb',
                'Loreline.xml'
            ];
            for (let name of dllFiles) {
                if (fs.existsSync('cs/' + name)) {
                    fs.rmSync('cs/' + name, { recursive: true, force: true });
                }
            }
            await command('dotnet', ['build', '-c', csConfig], { cwd: 'cs' });
            for (let name of dllFiles) {
                fs.copyFileSync(
                    'build/cs/bin/Loreline/' + csConfig + '/' + csPlatform + '/' + name,
                    'cs/' + name
                );
            }
        }

    }

    if (buildCsGenerics) {
        console.log('Export loreline test runner for C# without erase-generics (plain Haxe consumer build)');

        fs.rmSync('build/cs-generics', { recursive: true, force: true });

        await command(haxe, ['build-cs-generics.hxml'].concat(haxeBuildArgs));

        if (fs.existsSync('build/cs-generics/hxcs_build.txt')) fs.unlinkSync('build/cs-generics/hxcs_build.txt');

        // Transient test project: compiles the raw haxe output as-is (no namespace
        // rewriting, no loreline_* defines). InvariantGlobalization keeps float
        // formatting locale-stable (the distribution patches Std.cs instead, which
        // is not needed for a self-contained test executable).
        fs.writeFileSync('build/cs-generics/LorelineGenericsTest.csproj', `<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <LangVersion>9.0</LangVersion>
    <ImplicitUsings>disable</ImplicitUsings>
    <Nullable>disable</Nullable>
    <AssemblyName>LorelineGenericsTest</AssemblyName>
    <InvariantGlobalization>true</InvariantGlobalization>
    <NoWarn>$(NoWarn);CS0108;CS0114;CS0162;CS0168;CS0219;CS0649;IL2026;IL2060;IL2067;IL2070;IL2072;IL2075;IL3053</NoWarn>
    <PublishAot Condition="'$(AotBuild)' == 'true'">true</PublishAot>
  </PropertyGroup>
</Project>
`);
    }

    if (buildJs) {
        console.log('Export loreline for Javascript');

        await command(haxe, ['build-js.hxml'].concat(haxeBuildArgs));

        let ln = process.platform == 'win32' ? '\r\n' : '\n';

        let js = fs.readFileSync('js/loreline.js', 'utf8');
        js = 'let runtime = {}; let globals = {}; ' + js;
        js = js.split('})(typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this, typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this);').join('})(runtime, globals);');
        js += ln + 'export const Loreline = runtime.loreline.Loreline;';
        js += ln + 'export const Interpreter = runtime.loreline.Interpreter;';
        js += ln + 'export const Node = runtime.loreline.Node;';
        js += ln + 'export const Script = runtime.loreline.Script;';
        fs.writeFileSync('js/loreline.js', js);

        // Minify
        const esbuild = await import('esbuild');
        await esbuild.build({
            entryPoints: ['js/loreline.js'],
            outfile: 'js/loreline.min.js',
            minify: true,
            bundle: false,
        });

    }

    if (buildPython) {
        console.log('Export loreline for Python');

        fs.mkdirSync('py/loreline', { recursive: true });

        await command(haxe, ['build-python.hxml'].concat(haxeBuildArgs));

        // Post-process: guard the main() entry-point call
        let py = fs.readFileSync('py/loreline/_core.py', 'utf8');
        // Haxe generates a top-level main() call at the end: guard it
        py = py.replace(/\n(loreline_lib_Library\.main\(\))\s*$/, '\nif __name__ == "__main__":\n    $1\n');
        fs.writeFileSync('py/loreline/_core.py', py);
    }

    if (buildPhp) {
        console.log('Export loreline for PHP');

        fs.mkdirSync('php/lib', { recursive: true });

        await command(haxe, ['build-php.hxml'].concat(haxeBuildArgs));
    }

    if (buildPhpCli) {
        console.log('Export loreline PHP CLI');

        await command(haxe, ['build-cli.hxml', '--php', 'build/php-cli', '-D', 'loreline_utf8_vector'].concat(haxeBuildArgs));
    }

    if (buildGdscript) {
        console.log('Export loreline for GDScript (Godot)');

        // Stale-output deletion is disabled (no _GeneratedFiles.json in the
        // export), so clean the output directories before building
        fs.rmSync(path.join(__dirname, 'godot', 'gdscript', 'internal'), { recursive: true, force: true });
        fs.rmSync(path.join(__dirname, 'godot', 'test', 'gdscript', 'internal'), { recursive: true, force: true });

        // Runtime for the addon
        await command(haxe, ['build-gdscript.hxml'].concat(haxeBuildArgs));

        // Runtime + portable test suite for the headless test project
        // (same build with the test package included, redirected output)
        await command(haxe, [
            'build-gdscript.hxml',
            '--macro', "include('loreline.test')",
            '-D', 'gdscript-output=godot/test/gdscript/internal'
        ].concat(haxeBuildArgs));

        console.log('Generated: godot/gdscript/internal');
    }

    if (testLspJs || testLspCpp) {
        // Language server tests on the targets the server ships on, where the
        // CLI does not run: JS with node (VS Code extension), plain JS (web
        // worker of the web editor) and C++. The test-lsp files are embedded at
        // compile time. On its own targets (Neko, C# with generics, PHP CLI), the
        // CLI runs the protocol tests with `test`, and the files with `test-lsp`.
        // Built on their own (build-lsp-test.hxml), so that the server stays out
        // of the runtime exports.
        const lspDir = path.join(__dirname, 'build', 'lsp-test');
        fs.mkdirSync(lspDir, { recursive: true });

        if (testLspJs) {
            // .cjs: package.json declares ES modules, and the Haxe output is a script
            console.log('Run language server tests (JS with node)');
            await command(haxe, ['build-lsp-test.hxml', '--library', 'hxnodejs', '--js', 'build/lsp-test/lsp-test-node.cjs'].concat(haxeBuildArgs));
            await command('node', ['build/lsp-test/lsp-test-node.cjs']);

            console.log('Run language server tests (JS)');
            await command(haxe, ['build-lsp-test.hxml', '--js', 'build/lsp-test/lsp-test.cjs'].concat(haxeBuildArgs));
            await command('node', ['build/lsp-test/lsp-test.cjs']);
        }

        if (testLspCpp) {
            console.log('Run language server tests (C++)');
            const lspCppDir = path.join(lspDir, 'cpp');
            await command(haxe, ['build-lsp-test.hxml', '--library', 'hxcpp', '--cpp', 'build/lsp-test/cpp', '-D', 'no-compilation'].concat(haxeBuildArgs));
            const lspArchArgs = process.arch == 'arm64' ? ['-DHXCPP_ARM64'] : ['-DHXCPP_M64'];
            await command(process.platform == 'win32' ? path.join(__dirname, 'haxelib.cmd') : path.join(__dirname, 'haxelib'), ['run', 'hxcpp', 'Build.xml'].concat(lspArchArgs), { cwd: lspCppDir });
            await command(path.join(lspCppDir, process.platform == 'win32' ? 'LspTestMain.exe' : 'LspTestMain'), []);
        }
    }

    if (testSyntax) {
        // Syntax coloring of language/loreline.tmLanguage.json, checked with Shiki.
        // Writes a report to build/syntax-test/index.html for a manual check.
        console.log('Run loreline syntax coloring tests');
        await command('node', ['test-syntax/run.mjs']);
    }

    if (testGdscript) {
        console.log('Run loreline GDScript tests (headless Godot)');

        const godotBin = process.env.GODOT_BIN
            || (process.platform == 'darwin' && fs.existsSync('/Applications/Godot.app/Contents/MacOS/Godot')
                ? '/Applications/Godot.app/Contents/MacOS/Godot'
                : 'godot');

        const testProject = path.join(__dirname, 'godot', 'test', 'gdscript');

        // Refresh the addon copy used by the API parity check
        fs.rmSync(path.join(testProject, 'addons', 'loreline'), { recursive: true, force: true });
        fs.cpSync(
            path.join(__dirname, 'godot', 'gdscript'),
            path.join(testProject, 'addons', 'loreline'),
            { recursive: true }
        );
        fs.rmSync(path.join(testProject, 'addons', 'loreline', 'internal'), { recursive: true, force: true });

        // Import pass registers global script classes. Always through godot-import.sh:
        // a headless import with a GDExtension loaded crashes Godot on shutdown.
        await command('bash', [path.join(__dirname, 'sample', 'loreline-godot', 'godot-import.sh'), godotBin, testProject]);

        // Full .lor suite through the compiled runtime
        await command(godotBin, ['--headless', '--path', testProject, '--script', 'res://run_tests.gd', '--', path.join(__dirname, 'test')]);

        // Public API parity check
        await command(godotBin, ['--headless', '--path', testProject, '--script', 'res://api_parity.gd']);
    }

    if (testGodotLifetime) {
        console.log('Run loreline Godot lifetime tests (GDScript + native + web backends)');

        // run.sh assembles addons/loreline for each backend in turn and asserts
        // both reach the same verdict. It skips a backend whose binaries are
        // not built, so run the relevant setup steps first.
        await command('bash', [path.join(__dirname, 'godot', 'test', 'lifetime', 'run.sh'), 'all']);
    }

    if (buildLua) {
        console.log('Export loreline for Lua');

        fs.mkdirSync('lua/loreline', { recursive: true });

        let haxeBuildLuaArgs = [
            'build-lua.hxml',
        ];

        await command(haxe, haxeBuildLuaArgs.concat(haxeBuildArgs));

        // Post-process the generated Lua
        let lua = fs.readFileSync('lua/loreline/core.lua', 'utf8');
        // Remove the main() xpcall at the end, keep static init
        lua = lua.replace(/\nlocal success, err = _G\.xpcall\(function\(\)[\s\S]*$/, '\n');
        // Remove unused external library references (rex_pcre2/EReg, luv)
        // - EReg is only used by lorscript's XML metadata parser, never by loreline itself
        // - luv is only used by Sys.time/Sys.sleep, replaced below with vanilla Lua
        lua = lua.replace(/^__lua_lib_lrexlib_Rex = .*\n/m, '');
        lua = lua.replace(/^__lua_lib_luv_Misc = .*\n/m, '');
        lua = lua.replace(/^__lua_lib_luv_Thread = .*\n/m, '');
        lua = lua.replace(/^local EReg = _hx_e\(\)\n/m, '');
        // Remove entire EReg class definition (EReg.new through EReg.prototype.__class__)
        lua = lua.replace(/EReg\.new = function[\s\S]*?EReg\.prototype\.__class__ = +EReg\n/m, '');
        lua = lua.replace(/_hxClasses\["EReg"\] = EReg\nEReg\.__name__ = "EReg"\n/m, '');
        // Replace the single EReg usage (lorscript XML metadata) with native Lua string.gsub
        lua = lua.replace(
            /EReg\.new\("[^"]*", "[^"]*"\):replace\((\w+), ""\)/g,
            '_G.string.gsub($1, "[\\n\\r\\t]+", "")'
        );
        // Stub _hx_safe_require for any remaining optional requires
        const safeRequire = [
            'local _hx_safe_require = function(m) local ok, mod = pcall(require, m); if ok then return mod end; return nil end',
            '-- Provide bit32 shim for Lua 5.4+ (native bitwise operators replace the bit32 library)',
            'if not pcall(require, "bit32") and not pcall(require, "bit") then',
            '  _G.package.preload["bit32"] = function()',
            '    return {',
            '      band = function(a, b) return a & b end,',
            '      bor = function(a, b) return a | b end,',
            '      bxor = function(a, b) return a ~ b end,',
            '      bnot = function(a) return ~a end,',
            '      lshift = function(a, n) return a << n end,',
            '      rshift = function(a, n) return a >> n end,',
            '      arshift = function(a, n) return a >> n end,',
            '      btest = function(a, b) return (a & b) ~= 0 end,',
            '    }',
            '  end',
            'end',
        ].join('\n') + '\n';
        lua = lua.replace(/-- Generated by Haxe[^\n]*\n/, '$&' + safeRequire);
        lua = lua.replace(/_G\.require\(/g, '_hx_safe_require(');
        // Remove EReg/Rex references in _hx_static_init
        lua = lua.replace(/if \(__lua_lib_lrexlib_Rex == nil\) then\s*_G\.error[^;]*;\s*end;/g, '');
        lua = lua.replace(/EReg\.FLAGS = __lua_lib_lrexlib_Rex\.flags\(\);/g, '');
        // Provide fallbacks for Sys.time/Sys.sleep when luv is unavailable
        lua = lua.replace(
            /Sys\.time = function\(\) *\n(?:.*\n)*?end\n/,
            'Sys.time = function()\n  return os.clock()\nend\n'
        );
        lua = lua.replace(
            /Sys\.sleep = function\(seconds\) *\n(?:.*\n)*?end\n/,
            'Sys.sleep = function(seconds)\n  -- No-op without luv\nend\n'
        );
        // Fix Lua 5.4 float formatting: tostring(13.0) gives "13.0" instead of "13".
        // Patch _hx_tostring to strip trailing .0 for integer-valued floats.
        lua = lua.replace(
            'else return _G.tostring(obj)\n        end',
            'else\n            local s = _G.tostring(obj)\n            if _G.math.type(obj) == "float" and obj == _G.math.floor(obj) then s = _G.string.format("%d", obj) end\n            return s\n        end'
        );
        // Fix lorscript Parser nil comparison: Lua's string.byte returns nil at end-of-input,
        // which gets assigned to self.char; comparing nil < 0 is a Lua runtime error.
        // Replace with a nil-safe check (nil means "no char buffered", same as -1).
        lua = lua.replace(/self\.char < 0/g, '(not self.char or self.char < 0)');
        // Expose _hx_o globally so external code (test runner, wrapper) can create anon objects
        lua = lua.replace('local function _hx_o(obj)', '_G._hx_o = nil\nlocal function _hx_o(obj)');
        lua = lua.replace('_hx_static_init();', '_G._hx_o = _hx_o\n_hx_static_init();');
        fs.writeFileSync('lua/loreline/core.lua', lua);
    }

    if (buildJvm) {
        console.log('Export loreline for JVM');

        const asmVersion = '9.7.1';
        const asmJar = path.join(__dirname, 'jvm', 'lib', `asm-${asmVersion}.jar`);
        const asmCommonsJar = path.join(__dirname, 'jvm', 'lib', `asm-commons-${asmVersion}.jar`);

        // Download ASM jars from Maven Central if not cached
        if (!fs.existsSync(asmJar) || !fs.existsSync(asmCommonsJar)) {
            fs.mkdirSync(path.join(__dirname, 'jvm', 'lib'), { recursive: true });
            const mavenBase = `https://repo1.maven.org/maven2/org/ow2/asm`;
            for (const [artifact, dest] of [
                [`asm/${asmVersion}/asm-${asmVersion}.jar`, asmJar],
                [`asm-commons/${asmVersion}/asm-commons-${asmVersion}.jar`, asmCommonsJar]
            ]) {
                if (!fs.existsSync(dest)) {
                    console.log(`  Downloading ${path.basename(dest)}...`);
                    await command('curl', ['-sL', '-o', dest, `${mavenBase}/${artifact}`]);
                }
            }
        }

        // Step 1: Haxe build -> core jar
        fs.mkdirSync(path.join(__dirname, 'build', 'jvm'), { recursive: true });
        await command(haxe, ['build-jvm.hxml'].concat(haxeBuildArgs));

        // Step 2: Relocate packages + fix Haxe JVM generic checkcast issues
        const cpSep = process.platform == 'win32' ? ';' : ':';
        const asmCp = [asmJar, asmCommonsJar].join(cpSep);
        const relocatorToolsDir = path.join(__dirname, 'build', 'jvm', 'tools');
        fs.mkdirSync(relocatorToolsDir, { recursive: true });
        await command('javac', ['-cp', asmCp, '-d', relocatorToolsDir,
            path.join(__dirname, 'jvm', 'tools', 'Relocator.java')]);
        await command('java', ['-cp', [relocatorToolsDir, asmCp].join(cpSep), 'Relocator',
            path.join(__dirname, 'build', 'jvm', 'loreline-core.jar'),
            path.join(__dirname, 'build', 'jvm', 'loreline-relocated.jar')]);

        // Step 3: Compile Java wrapper classes
        const wrapperClassesDir = path.join(__dirname, 'build', 'jvm', 'classes');
        fs.mkdirSync(wrapperClassesDir, { recursive: true });
        await command('javac', [
            '-cp', path.join(__dirname, 'build', 'jvm', 'loreline-relocated.jar'),
            '-d', wrapperClassesDir,
            ...fs.readdirSync(path.join(__dirname, 'jvm', 'src', 'loreline'))
                .filter(f => f.endsWith('.java'))
                .map(f => path.join(__dirname, 'jvm', 'src', 'loreline', f))
        ]);

        // Step 4: Merge relocated jar + wrapper classes -> final loreline.jar
        const mergeDir = path.join(__dirname, 'build', 'jvm', 'jar-merge');
        if (fs.existsSync(mergeDir)) fs.rmSync(mergeDir, { recursive: true, force: true });
        fs.mkdirSync(mergeDir, { recursive: true });
        // Extract relocated jar
        await command('jar', ['xf', path.join(__dirname, 'build', 'jvm', 'loreline-relocated.jar')],
            { cwd: mergeDir });
        // Copy wrapper classes
        for (const f of fs.readdirSync(path.join(wrapperClassesDir, 'loreline'))) {
            if (f.endsWith('.class')) {
                fs.copyFileSync(
                    path.join(wrapperClassesDir, 'loreline', f),
                    path.join(mergeDir, 'loreline', f)
                );
            }
        }
        // Create final jar
        await command('jar', ['cf', path.join(__dirname, 'jvm', 'loreline.jar'), '-C', mergeDir, '.']);

        console.log('Built: jvm/loreline.jar');
    }

    // -- Set up sample projects ----------------------------------------------
    //
    // Copies built runtime files and story scripts into the sample directories.
    // Usage:
    //   node ./setup --sample          (all samples)
    //   node ./setup --sample web      (loreline-web only)
    //   node ./setup --sample unity    (loreline-unity only)
    //   node ./setup --sample cpp      (loreline-cpp only)
    //   node ./setup --sample python   (loreline-python only)
    //   node ./setup --sample lua      (loreline-lua only)
    //   node ./setup --sample java     (loreline-java only)
    //   node ./setup --sample sdl3     (loreline-sdl3 only)

    if (setupSample) {

        // loreline-web: needs js/loreline.js (from --js) + story files
        if (sampleTarget == null || sampleTarget == 'web') {
            console.log('Set up sample: loreline-web');

            const webDir = path.join(__dirname, 'sample', 'loreline-web');
            const storyDir = path.join(webDir, 'story');

            // Copy loreline.js runtime
            const jsSrc = path.join(__dirname, 'js', 'loreline.js');
            if (!fs.existsSync(jsSrc)) {
                console.warn('  Warning: js/loreline.js not found, run --js first');
            } else {
                fs.copyFileSync(jsSrc, path.join(webDir, 'loreline.js'));
                console.log('  js/loreline.js -> sample/loreline-web/loreline.js');
            }

            // Copy story files into story/ subfolder
            fs.mkdirSync(storyDir, { recursive: true });
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(storyDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-web/story/' + name);
            }
        }

        // loreline-unity: needs cs/Loreline/ (from --cs) + story files as .lor.txt
        if (sampleTarget == null || sampleTarget == 'unity') {
            console.log('Set up sample: loreline-unity');

            const unityPluginDir = path.join(__dirname, 'sample', 'loreline-unity', 'Assets', 'Plugins', 'Loreline');
            const unityResourceDir = path.join(__dirname, 'sample', 'loreline-unity', 'Assets', 'Resources', 'Story');
            const csSrcDir = path.join(__dirname, 'cs', 'Loreline');

            // Copy C# plugin files
            if (!fs.existsSync(path.join(csSrcDir, 'Internal'))) {
                console.warn('  Warning: cs/Loreline/Internal/ not found, run --cs first');
            } else {
                // Clear stale plugin files, then copy fresh (preserve Editor/)
                if (fs.existsSync(unityPluginDir)) {
                    for (const entry of fs.readdirSync(unityPluginDir)) {
                        if (entry === 'Editor') continue;
                        fs.rmSync(path.join(unityPluginDir, entry), { recursive: true, force: true });
                    }
                }
                fs.cpSync(csSrcDir, unityPluginDir, { recursive: true });
                console.log('  cs/Loreline/ -> sample/loreline-unity/Assets/Plugins/Loreline/');
            }

            // Copy story files
            fs.mkdirSync(unityResourceDir, { recursive: true });
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(unityResourceDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-unity/Assets/Resources/' + name);
            }
        }

        // loreline-cpp: needs cpp/include/Loreline.h + libLoreline + story files
        if (sampleTarget == null || sampleTarget == 'cpp') {
            console.log('Set up sample: loreline-cpp');

            const cppDir = path.join(__dirname, 'sample', 'loreline-cpp');
            const storyDir = path.join(cppDir, 'story');
            const lorelineDir = path.join(cppDir, 'loreline');

            // Determine platform-specific library paths
            let buildLibDir, libFiles, platformSubdir;
            if (process.platform == 'darwin') {
                buildLibDir = path.join(__dirname, 'build', 'cpp-lib', 'mac');
                libFiles = ['libLoreline.dylib'];
                platformSubdir = 'mac';
            } else if (process.platform == 'win32') {
                buildLibDir = path.join(__dirname, 'build', 'cpp-lib', 'windows');
                libFiles = ['Loreline.dll', 'Loreline.lib'];
                platformSubdir = 'windows';
            } else {
                buildLibDir = path.join(__dirname, 'build', 'cpp-lib', 'linux');
                libFiles = ['libLoreline.so'];
                platformSubdir = isLinuxArm64() ? 'linux-aarch64' : 'linux-x86_64';
            }

            // Build the C++ library if it doesn't exist yet
            if (!fs.existsSync(path.join(buildLibDir, libFiles[0]))) {
                console.log('  C++ library not found, building with --cpp-lib...');
                await command('node', ['./setup', '--cpp-lib']);
            }

            // Copy header
            const includeDir = path.join(lorelineDir, 'include');
            fs.mkdirSync(includeDir, { recursive: true });
            fs.copyFileSync(
                path.join(__dirname, 'cpp', 'include', 'Loreline.h'),
                path.join(includeDir, 'Loreline.h')
            );
            console.log('  cpp/include/Loreline.h -> sample/loreline-cpp/loreline/include/Loreline.h');

            // Copy platform library
            const platformDir = path.join(lorelineDir, platformSubdir);
            fs.mkdirSync(platformDir, { recursive: true });
            for (const libFile of libFiles) {
                fs.copyFileSync(
                    path.join(buildLibDir, libFile),
                    path.join(platformDir, libFile)
                );
                console.log('  ' + libFile + ' -> sample/loreline-cpp/loreline/' + platformSubdir + '/' + libFile);
            }

            // Copy story files
            fs.mkdirSync(storyDir, { recursive: true });
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(storyDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-cpp/story/' + name);
            }
        }

        // loreline-sdl3: needs SDL3 prebuilt binaries + Loreline header + libs + stb_truetype + story files
        if (sampleTarget == null || sampleTarget == 'sdl3') {
            console.log('Set up sample: loreline-sdl3');

            const sdl3SampleDir = path.join(__dirname, 'sample', 'loreline-sdl3');
            const sdl3LibDir = path.join(sdl3SampleDir, 'sdl3');
            const sdl3LorelineDir = path.join(sdl3SampleDir, 'loreline');
            const sdl3StoryDir = path.join(sdl3SampleDir, 'story');

            const sdl3ReleaseUrl = 'https://github.com/jeremyfa/build-sdl3/releases/download/sdl3-77f4a8e';
            const stbUrl = 'https://raw.githubusercontent.com/nothings/stb/master/stb_truetype.h';

            // 1. Download stb_truetype.h if not present
            const stbPath = path.join(sdl3SampleDir, 'stb_truetype.h');
            if (!fs.existsSync(stbPath)) {
                console.log('  Downloading stb_truetype.h...');
                await downloadFile(stbUrl, stbPath);
                console.log('  -> stb_truetype.h');
            }

            // 2. Download SDL3 prebuilt binaries for all platforms
            const sdl3Archives = [
                { name: 'sdl3-mac-universal.zip',    dir: 'mac' },
                { name: 'sdl3-linux-x64.tar.gz',     dir: 'linux-x64' },
                { name: 'sdl3-linux-arm64.tar.gz',    dir: 'linux-arm64' },
                { name: 'sdl3-windows-x64.zip',       dir: 'windows' },
                { name: 'sdl3-ios-universal.zip',      dir: 'ios' },
                { name: 'sdl3-android-r27.zip',        dir: 'android' },
            ];

            for (const arch of sdl3Archives) {
                const destDir = path.join(sdl3LibDir, arch.dir);
                if (fs.existsSync(destDir)) {
                    console.log('  SDL3 ' + arch.dir + ' already present, skipping');
                    continue;
                }
                console.log('  Downloading ' + arch.name + '...');
                const tmpPath = path.join(sdl3SampleDir, arch.name);
                await downloadFile(sdl3ReleaseUrl + '/' + arch.name, tmpPath);
                await extractArchive(tmpPath, destDir);
                fs.unlinkSync(tmpPath);
                console.log('  -> sdl3/' + arch.dir + '/');
            }

            // 3. Download SDL3 Java sources for Android (SDLActivity etc.)
            const sdl3Commit = '77f4a8e2b8066d3bc376eab1ce443e57bc04d4ee';
            const sdl3JavaDir = path.join(sdl3SampleDir, 'android', 'app', 'src', 'main',
                                          'java', 'org', 'libsdl', 'app');
            const sdl3JavaFiles = [
                'SDL.java', 'SDLActivity.java', 'SDLAudioManager.java',
                'SDLControllerManager.java', 'SDLDummyEdit.java',
                'SDLInputConnection.java', 'SDLSurface.java',
                'HIDDevice.java', 'HIDDeviceBLESteamController.java',
                'HIDDeviceManager.java', 'HIDDeviceUSB.java',
            ];
            fs.mkdirSync(sdl3JavaDir, { recursive: true });
            const sdl3JavaBaseUrl = 'https://raw.githubusercontent.com/libsdl-org/SDL/'
                + sdl3Commit + '/android-project/app/src/main/java/org/libsdl/app/';
            for (const jf of sdl3JavaFiles) {
                const dest = path.join(sdl3JavaDir, jf);
                if (fs.existsSync(dest)) continue;
                console.log('  Downloading SDL3 ' + jf + '...');
                await downloadFile(sdl3JavaBaseUrl + jf, dest);
            }
            console.log('  -> android/.../org/libsdl/app/ (SDL3 Java sources)');

            // 4. Copy Loreline header
            const sdl3IncludeDir = path.join(sdl3LorelineDir, 'include');
            fs.mkdirSync(sdl3IncludeDir, { recursive: true });
            fs.copyFileSync(
                path.join(__dirname, 'cpp', 'include', 'Loreline.h'),
                path.join(sdl3IncludeDir, 'Loreline.h')
            );
            console.log('  cpp/include/Loreline.h -> loreline/include/Loreline.h');

            // 4. Copy Loreline platform libraries (whatever is available)
            const sdl3PlatformMappings = [
                { build: 'mac',     dest: 'mac',           files: ['libLoreline.dylib'] },
                { build: 'windows', dest: 'windows',       files: ['Loreline.dll', 'Loreline.lib'] },
                { build: 'linux',   dest: isLinuxArm64() ? 'linux-aarch64' : 'linux-x86_64',
                                                           files: ['libLoreline.so'] },
            ];

            for (const pm of sdl3PlatformMappings) {
                const srcDir = path.join(__dirname, 'build', 'cpp-lib', pm.build);
                if (!fs.existsSync(srcDir)) continue;
                const destPlatDir = path.join(sdl3LorelineDir, pm.dest);
                fs.mkdirSync(destPlatDir, { recursive: true });
                for (const f of pm.files) {
                    const src = path.join(srcDir, f);
                    if (fs.existsSync(src)) {
                        fs.copyFileSync(src, path.join(destPlatDir, f));
                        console.log('  ' + f + ' -> loreline/' + pm.dest + '/' + f);
                    }
                }
            }

            // Copy iOS xcframework if available
            const sdl3IosXcfw = path.join(__dirname, 'build', 'cpp-lib', 'ios', 'Loreline.xcframework');
            if (fs.existsSync(sdl3IosXcfw)) {
                const destIos = path.join(sdl3LorelineDir, 'ios', 'Loreline.xcframework');
                fs.mkdirSync(path.join(sdl3LorelineDir, 'ios'), { recursive: true });
                fs.cpSync(sdl3IosXcfw, destIos, { recursive: true });
                console.log('  Loreline.xcframework -> loreline/ios/Loreline.xcframework');
            }

            // Copy Android JNI .so files if available
            const sdl3AndroidJni = path.join(__dirname, 'build', 'cpp-lib', 'android', 'jni');
            if (fs.existsSync(sdl3AndroidJni)) {
                const destAndroidJni = path.join(sdl3LorelineDir, 'android', 'jni');
                fs.mkdirSync(path.join(sdl3LorelineDir, 'android'), { recursive: true });
                fs.cpSync(sdl3AndroidJni, destAndroidJni, { recursive: true });
                console.log('  android JNI libs -> loreline/android/jni/');
            }

            // 5. Copy story files
            fs.mkdirSync(sdl3StoryDir, { recursive: true });
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(sdl3StoryDir, name)
                );
                console.log('  sample/' + name + ' -> story/' + name);
            }

            // 6. Android assets are copied by build-android.sh before Gradle
            // runs (symlinks aren't followed by AAPT when packaging the APK).
            // Nothing to do here: the build script handles it.
        }

        // loreline-python: needs py/loreline/ (from --py) + story files
        if (sampleTarget == null || sampleTarget == 'python') {
            console.log('Set up sample: loreline-python');

            const pyDir = path.join(__dirname, 'sample', 'loreline-python');
            const pyPkgDir = path.join(pyDir, 'loreline');
            const pyStoryDir = path.join(pyDir, 'story');

            fs.mkdirSync(pyPkgDir, { recursive: true });
            fs.mkdirSync(pyStoryDir, { recursive: true });

            // Copy loreline package files
            const pySrcDir = path.join(__dirname, 'py', 'loreline');
            for (const file of ['__init__.py', '_core.py', 'py.typed']) {
                const src = path.join(pySrcDir, file);
                if (fs.existsSync(src)) {
                    fs.copyFileSync(src, path.join(pyPkgDir, file));
                    console.log('  py/loreline/' + file + ' -> sample/loreline-python/loreline/' + file);
                }
            }

            // Copy story files
            const storyFiles = ['CoffeeShop.lor', 'characters.lor'];
            for (const name of storyFiles) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(pyStoryDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-python/story/' + name);
            }
        }

        // loreline-lua: needs lua/loreline/ (from --lua) + story files
        if (sampleTarget == null || sampleTarget == 'lua') {
            console.log('Set up sample: loreline-lua');

            const luaDir = path.join(__dirname, 'sample', 'loreline-lua');
            const luaPkgDir = path.join(luaDir, 'loreline');
            const luaStoryDir = path.join(luaDir, 'story');

            fs.mkdirSync(luaPkgDir, { recursive: true });
            fs.mkdirSync(luaStoryDir, { recursive: true });

            // Copy loreline package files
            const luaSrcDir = path.join(__dirname, 'lua', 'loreline');
            for (const file of ['init.lua', 'core.lua']) {
                const src = path.join(luaSrcDir, file);
                if (fs.existsSync(src)) {
                    fs.copyFileSync(src, path.join(luaPkgDir, file));
                    console.log('  lua/loreline/' + file + ' -> sample/loreline-lua/loreline/' + file);
                }
            }

            // Copy story files
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(luaStoryDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-lua/story/' + name);
            }
        }

        // loreline-java: needs jvm/loreline.jar (from --jvm) + story files
        if (sampleTarget == null || sampleTarget == 'java') {
            console.log('Set up sample: loreline-java');

            const javaDir = path.join(__dirname, 'sample', 'loreline-java');
            const javaStoryDir = path.join(javaDir, 'story');

            // Copy loreline.jar
            const jarSrc = path.join(__dirname, 'jvm', 'loreline.jar');
            if (!fs.existsSync(jarSrc)) {
                console.warn('  Warning: jvm/loreline.jar not found, run --jvm first');
            } else {
                fs.copyFileSync(jarSrc, path.join(javaDir, 'loreline.jar'));
                console.log('  jvm/loreline.jar -> sample/loreline-java/loreline.jar');
            }

            // Copy story files
            fs.mkdirSync(javaStoryDir, { recursive: true });
            for (const name of ['CoffeeShop.lor', 'characters.lor']) {
                fs.copyFileSync(
                    path.join(__dirname, 'sample', name),
                    path.join(javaStoryDir, name)
                );
                console.log('  sample/' + name + ' -> sample/loreline-java/story/' + name);
            }
        }

    }

    // -- Build Unity package -------------------------------------------------
    //
    // Creates a .unitypackage containing the Loreline C# library and
    // a ScriptedImporter for .lor files.

    if (buildUnityPackage) {
        console.log('Build Unity package');

        const csSrcDir = path.join(__dirname, 'cs', 'Loreline');
        if (!fs.existsSync(path.join(csSrcDir, 'Internal'))) {
            console.error('  Error: cs/Loreline/Internal/ not found, run --cs first');
            process.exit(1);
        }

        const importerSrc = path.join(__dirname, 'sample', 'loreline-unity', 'Assets', 'Plugins', 'Loreline', 'Editor', 'LorelineImporter.cs');
        if (!fs.existsSync(importerSrc)) {
            console.error('  Error: LorelineImporter.cs not found');
            process.exit(1);
        }

        const tempDir = path.join(__dirname, '.unity-package-temp-' + Date.now());
        const stagingDir = path.join(tempDir, 'staging');
        const packageDir = path.join(tempDir, 'package');
        const outputPath = path.join(__dirname, 'loreline.unitypackage');

        try {
            // Stage files: Assets/Plugins/Loreline/...
            const pluginDst = path.join(stagingDir, 'Assets', 'Plugins', 'Loreline');
            fs.cpSync(csSrcDir, pluginDst, { recursive: true });

            // Copy the importer into Editor/
            const editorDst = path.join(pluginDst, 'Editor');
            fs.mkdirSync(editorDst, { recursive: true });
            fs.copyFileSync(importerSrc, path.join(editorDst, 'LorelineImporter.cs'));

            // Build .unitypackage structure
            fs.mkdirSync(packageDir, { recursive: true });

            function generateGuid(assetPath) {
                return crypto.createHash('md5').update(assetPath + ' ~ GUID', 'utf8').digest('hex');
            }

            function generateFileMeta(guid, isCs) {
                if (isCs) {
                    return `fileFormatVersion: 2\nguid: ${guid}\nMonoImporter:\n  serializedVersion: 2\n  defaultReferences: []\n  executionOrder: 0\n  icon: {instanceID: 0}\n  userData: \n  assetBundleName: \n  assetBundleVariant: \n`;
                }
                return `fileFormatVersion: 2\nguid: ${guid}\nDefaultImporter:\n  userData: \n`;
            }

            function generateDirMeta(guid) {
                return `fileFormatVersion: 2\nguid: ${guid}\nfolderAsset: yes\nDefaultImporter:\n  userData: \n`;
            }

            function addAssetToPackage(assetPath, filePath) {
                // assetPath: e.g. "Assets/Plugins/Loreline/Internal/Foo.cs"
                // filePath: absolute path to the file on disk (null for directories)
                const guid = generateGuid(assetPath);
                const guidDir = path.join(packageDir, guid);
                fs.mkdirSync(guidDir, { recursive: true });
                fs.writeFileSync(path.join(guidDir, 'pathname'), assetPath);

                if (filePath === null) {
                    // Directory
                    fs.writeFileSync(path.join(guidDir, 'asset.meta'), generateDirMeta(guid));
                } else {
                    // File
                    fs.copyFileSync(filePath, path.join(guidDir, 'asset'));
                    const isCs = assetPath.endsWith('.cs');
                    fs.writeFileSync(path.join(guidDir, 'asset.meta'), generateFileMeta(guid, isCs));
                }
            }

            // Recursively add all staged files and directories
            function addDirectory(dirPath, assetsPrefix) {
                // Add the directory itself
                addAssetToPackage(assetsPrefix, null);

                const entries = fs.readdirSync(dirPath, { withFileTypes: true });

                // Process files first
                for (const entry of entries) {
                    if (entry.isFile()) {
                        const fullPath = path.join(dirPath, entry.name);
                        const assetPath = assetsPrefix + '/' + entry.name;
                        addAssetToPackage(assetPath, fullPath);
                    }
                }

                // Process subdirectories
                for (const entry of entries) {
                    if (entry.isDirectory()) {
                        const fullPath = path.join(dirPath, entry.name);
                        const assetPath = assetsPrefix + '/' + entry.name;
                        addDirectory(fullPath, assetPath);
                    }
                }
            }

            // Add parent directories: Assets, Assets/Plugins
            addAssetToPackage('Assets', null);
            addAssetToPackage('Assets/Plugins', null);

            // Add the Loreline plugin tree
            addDirectory(pluginDst, 'Assets/Plugins/Loreline');

            // Create tar.gz
            await command('tar', ['-czf', outputPath, '.'], { cwd: packageDir });

            console.log('  Created: loreline.unitypackage');

        } finally {
            // Clean up temp directory
            if (fs.existsSync(tempDir)) {
                fs.rmSync(tempDir, { recursive: true, force: true });
            }
        }
    }

    // -- Run all test suites -------------------------------------------------
    //
    // Replicates test-all.sh in cross-platform Node.js:
    //   1. Neko tests (via node run)
    //   2. C# build + dotnet tests
    //   3. C# AOT publish + tests (auto-detects platform RID)
    //   4. JS build + tests
    //   5. C++ lib build + tests

    if (runTest) {

        // 1. Neko tests
        console.log('\n=== Neko tests ===');
        await command('node', ['run', 'test', './test']);

        // Syntax coloring tests (grammar only, no build needed)
        console.log('\n=== Syntax coloring tests ===');
        await command('node', ['test-syntax/run.mjs']);

        // Language server tests: the test-lsp files on Neko, then JS and C++
        console.log('\n=== Language server tests ===');
        await command('node', ['run', 'test-lsp', './test-lsp']);
        await command('node', ['./setup', '--lsp-test']);

        // 2. C# build + tests
        console.log('\n=== C# build + tests ===');
        await command('node', ['./setup', '--cs', '--cs-dll']);
        await command('dotnet', ['run', '--project', 'cs/TestRunner', '--', './test']);

        // 3. C# AOT build + tests
        console.log('\n=== C# AOT build + tests ===');
        const rid = getDotnetRid();
        const aotPublishDir = path.join('build', 'cs', 'bin', 'TestRunner', 'Release', 'net8.0', rid, 'publish');
        await command('dotnet', [
            'publish', 'cs/TestRunner', '-c', 'Release',
            '-r', rid, '-p:AotBuild=true'
        ]);
        const aotBin = path.join(aotPublishDir, process.platform == 'win32' ? 'TestRunner.exe' : 'TestRunner');
        await command(aotBin, ['./test']);

        // 4. C# (with generics) build + tests (plain Haxe consumer mode)
        console.log('\n=== C# (with generics) build + tests ===');
        await command('node', ['./setup', '--cs-generics']);
        await command('dotnet', ['run', '--project', 'build/cs-generics', '--', 'test', './test']);

        // 5. C# (with generics) AOT build + tests
        console.log('\n=== C# (with generics) AOT build + tests ===');
        const noeraseAotPublishDir = path.join('build', 'cs-generics', 'bin', 'Release', 'net8.0', rid, 'publish');
        await command('dotnet', [
            'publish', 'build/cs-generics', '-c', 'Release',
            '-r', rid, '-p:AotBuild=true'
        ]);
        const noeraseAotBin = path.join(noeraseAotPublishDir, process.platform == 'win32' ? 'LorelineGenericsTest.exe' : 'LorelineGenericsTest');
        await command(noeraseAotBin, ['test', './test']);

        // 6. JS build + tests
        console.log('\n=== JS build + tests ===');
        await command('node', ['./setup', '--js']);
        await command('npx', ['tsx', 'js/test-runner.ts', './test']);
        // Classes of the loreline.lsp package are named loreline_lsp_* in JS
        checkNoLanguageServer('JS', fs.readFileSync(path.join(__dirname, 'js', 'loreline.js'), 'utf8').includes('loreline_lsp_'));

        // 7. C++ lib build + tests
        console.log('\n=== C++ lib build + test ===');
        await command('node', ['./setup', '--cpp-lib']);
        await command('node', ['./setup', '--cpp-lib-test']);
        // Headers generated for the loreline.lsp package would be in include/loreline/lsp
        const cppLibPlatform = process.platform == 'darwin' ? 'mac' : process.platform == 'win32' ? 'windows' : 'linux';
        checkNoLanguageServer('C++', fs.existsSync(path.join(__dirname, 'build', 'cpp-lib', cppLibPlatform, 'include', 'loreline', 'lsp')));

        // 8. Python build + tests
        console.log('\n=== Python build + tests ===');
        await command('node', ['./setup', '--py']);
        await command('python3', ['py/test-runner.py', './test']);

        // 9. Lua build + tests
        console.log('\n=== Lua build + tests ===');
        await command('node', ['./setup', '--lua']);
        await command('lua', ['lua/test-runner.lua', './test']);

        // 10. PHP build + tests
        console.log('\n=== PHP build + tests ===');
        await command('node', ['./setup', '--php']);
        await command('php', ['php/test-runner.php', './test']);

        // 11. PHP CLI build + tests
        console.log('\n=== PHP CLI build + tests ===');
        await command('node', ['./setup', '--php-cli']);
        await command('php', ['build/php-cli/index.php', 'test', './test']);

        // 12. JVM build + tests
        console.log('\n=== JVM build + tests ===');
        await command('node', ['./setup', '--jvm']);
        const jvmCpSep = process.platform == 'win32' ? ';' : ':';
        const jvmTestClassesDir = path.join(__dirname, 'build', 'jvm', 'test');
        fs.mkdirSync(jvmTestClassesDir, { recursive: true });
        await command('javac', [
            '-cp', path.join(__dirname, 'jvm', 'loreline.jar'),
            '-d', jvmTestClassesDir,
            path.join(__dirname, 'jvm', 'test', 'TestRunner.java')
        ]);
        await command('java', [
            '-cp', [path.join(__dirname, 'jvm', 'loreline.jar'), jvmTestClassesDir].join(jvmCpSep),
            'TestRunner', './test'
        ]);

    }

}

(async () => {
    try {
        await main();
    } catch (error) {
        console.error(error);
        process.exit(1);
    }
})();