cluaupp 0.2.3 → 1.3.0

package/generated/cli.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.program = exports.init = exports.watch = void 0;
+exports.hasClpp = exports.program = exports.init = exports.watch = void 0;
 exports.build = build;
 exports.dispatch = dispatch;
 const commander_1 = require("commander");
@@ -11,7 +11,10 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const package_info_js_1 = require("./package-info.js");
 const lsp_js_1 = require("./lsp.js");
-const preprocess_js_1 = require("./preprocess.js");
+const paths_js_1 = require("./clpp/paths.js");
+const contract_js_1 = require("./clpp/contract.js");
+const runner_js_1 = require("./clpp/runner.js");
+Object.defineProperty(exports, "hasClpp", { enumerable: true, get: function () { return runner_js_1.hasClpp; } });
 const intellisense_js_1 = require("./intellisense.js");
 const rojo_mapper_js_1 = require("./utils/rojo-mapper.js");
 const process_orchestrator_js_1 = require("./utils/process-orchestrator.js");
@@ -23,7 +26,7 @@ const program = new commander_1.Command();
 exports.program = program;
 program
     .name("cluaupp")
-    .description("Definitive transpiler from C++ subset to structured Luau")
+    .description("Cluaupp toolchain — compile CL++ to Luau, Rojo, and CluauppLibs")
     .version(package_info_js_1.pkg.version, "-v, --version", "print version")
     .showHelpAfterError()
     .action(() => {
@@ -44,14 +47,14 @@ program
 });
 program
     .command("build")
-    .description("Transpila um arquivo, diretório ou projeto C++ para Luau")
+    .description("Compile a CL++ file, directory, or project to Luau")
     .argument("[folder]", "project folder", ".")
-    .option("-i, --input <path>", "Arquivo ou diretório C++ de entrada")
-    .option("-o, --output <path>", "Arquivo ou diretório Luau de saída")
-    .option("-r, --rojo <path>", "Caminho para o default.project.json do Rojo", "./default.project.json")
-    .option("--strict", "Emitir --!strict")
-    .option("--format", "Rodar StyLua no output")
-    .option("--analyze", "Rodar luau-analyze no output")
+    .option("-i, --input <path>", "CL++ file or directory")
+    .option("-o, --output <path>", "Luau file or directory")
+    .option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
+    .option("--strict", "Emit --!strict")
+    .option("--format", "Run StyLua on output")
+    .option("--analyze", "Run luau-analyze on output")
     .action(async (folder, options) => {
     if (options.input) {
         await buildInput(options);
@@ -62,6 +65,7 @@ program
             format: options.format === true,
             analyze: options.analyze === true,
             rojo: options.rojo,
+            strict: options.strict === true,
         });
     }
     catch (err) {
@@ -73,8 +77,8 @@ program
     .command("watch")
     .description("rebuild on save")
     .argument("[folder]", "project folder", ".")
-    .option("-r, --rojo <path>", "Caminho para o default.project.json do Rojo", "./default.project.json")
-    .option("--format", "Rodar StyLua no output")
+    .option("-r, --rojo <path>", "Path to Rojo default.project.json", "./default.project.json")
+    .option("--format", "Run StyLua on output")
     .action((folder, options) => {
     try {
         (0, project_js_1.watch)(node_path_1.default.resolve(process.cwd(), folder), {
@@ -89,7 +93,7 @@ program
 });
 program
     .command("lsp")
-    .description("Cluaupp subset diagnostics over stdio (JSON-RPC). C++ completion is clangd.")
+    .description("Language server stdio (JSON-RPC). Use `clpp install` for CL++ IntelliSense.")
     .argument("[folder]", "project folder", ".")
     .action((folder) => {
     (0, lsp_js_1.start)({ projectRoot: node_path_1.default.resolve(process.cwd(), folder) });
@@ -97,18 +101,37 @@ program
 program
     .command("intellisense")
     .alias("intelisense")
-    .description("install LLVM clangd and write compile_commands.json")
+    .description("Point the editor at CL++ (`clpp install`)")
     .argument("[folder]", "project folder", ".")
     .action(async (folder) => {
     try {
         const root = node_path_1.default.resolve(process.cwd(), folder);
         (0, intellisense_js_1.syncEditorSupport)(root, (0, project_js_1.loadConfig)(root));
-        const installed = await (0, intellisense_js_1.installEditorSupport)();
-        console.log("cluaupp: compile_commands.json, .clangd, and .vscode updated in", root);
-        console.log("cluaupp: C++ completion is clangd (include/cluaupp/roblox.hpp)");
-        if (installed.clangd || installed.llvm) {
-            console.log("cluaupp: reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+        await (0, intellisense_js_1.installEditorSupport)();
+        console.log("cluaupp: editor associations written in", root);
+        console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("language")
+    .description("CL++ manifest (`clpp api manifest`)")
+    .action(() => {
+    try {
+        const bin = (0, runner_js_1.resolveClppBinary)();
+        const version = (0, runner_js_1.clppVersion)();
+        if (version) {
+            console.log(version, `(${bin})`);
+        }
+        for (const install of (0, runner_js_1.clppInstalls)()) {
+            if (!install.selected) {
+                console.log(`skipped ${install.bin} (${install.version || "unknown"})`);
+            }
         }
+        console.log(JSON.stringify((0, runner_js_1.clppManifest)(), null, "\t"));
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);
@@ -129,14 +152,13 @@ async function buildInput(options) {
         console.error(`[Erro] O caminho de entrada especificado não existe: ${inputPath}`);
         process.exit(1);
     }
-    console.log("🏁 Inicializando Pipeline do Compilador Cluaupp V2...");
     const mapper = new rojo_mapper_js_1.RojoMapper(node_path_1.default.resolve(options.rojo), node_path_1.default.dirname(inputPath));
     await mapper.load();
     const inputs = (await promises_1.default.stat(inputPath)).isDirectory()
-        ? (0, project_js_1.collectCpp)(inputPath)
+        ? (0, paths_js_1.collectSources)(inputPath)
         : [inputPath];
     if (inputs.length === 0) {
-        console.error("no .cpp/.h/.hpp files in", inputPath);
+        console.error("no .clpp/.clp/.clh files in", inputPath);
         process.exit(1);
     }
     const outputIsFile = /\.luau$/i.test(outputPath);
@@ -154,7 +176,7 @@ async function buildInput(options) {
             srcDir: node_path_1.default.dirname(file),
             includeDirs: [node_path_1.default.dirname(file)],
         }, mapper);
-        const dest = outputIsFile ? outputPath : node_path_1.default.join(outputPath, node_path_1.default.basename((0, preprocess_js_1.toLuauPath)(rel)));
+        const dest = outputIsFile ? outputPath : node_path_1.default.join(outputPath, node_path_1.default.basename((0, paths_js_1.toLuauPath)(rel)));
         await promises_1.default.mkdir(node_path_1.default.dirname(dest), { recursive: true });
         const luau = compiled.files[0]?.contents ?? "";
         await promises_1.default.writeFile(dest, luau, "utf8");
@@ -167,7 +189,7 @@ async function buildInput(options) {
                 console.log("\nRelatório de Análise Estática do Luau:\n", analysisReport);
             }
         }
-        console.log(`Transpilação concluída! ${file} → ${dest}`);
+        console.log(`Compiled ${file} → ${dest}`);
     }
 }
 function build(root, options = {}) {

package/generated/clpp/contract.js

@@ -0,0 +1,6 @@
+"use strict";
+/** Stable CL++ ↔ Cluaupp contract (CL++ 0.3.2). Cluaupp invokes the `clpp` binary. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLPP_INSTALL_HINT = exports.MIN_CLPP_VERSION = void 0;
+exports.MIN_CLPP_VERSION = "0.3.2";
+exports.CLPP_INSTALL_HINT = "Install CL++ 0.3.2 (clpp-setup.exe or `clpp setup`) and put `clpp` on PATH. Instances are class names (`Player player`, not `Player*`). Override with CLPP or CLPP_PATH.";

package/generated/clpp/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLuauPath = exports.siblingHeader = exports.scriptKind = exports.isTaggedScript = exports.isSourceFile = exports.isImplFile = exports.isHeaderFile = exports.isEngineStub = exports.fileStem = exports.emitKind = exports.collectSources = exports.SOURCE_EXTS = exports.shouldSkipInit = exports.clppLuauToGame = exports.resolveClppBinary = exports.hasClpp = exports.clppVersion = exports.clppManifest = exports.compileViaClppAsync = exports.compileViaClpp = exports.MIN_CLPP_VERSION = exports.CLPP_INSTALL_HINT = void 0;
+var contract_js_1 = require("./contract.js");
+Object.defineProperty(exports, "CLPP_INSTALL_HINT", { enumerable: true, get: function () { return contract_js_1.CLPP_INSTALL_HINT; } });
+Object.defineProperty(exports, "MIN_CLPP_VERSION", { enumerable: true, get: function () { return contract_js_1.MIN_CLPP_VERSION; } });
+var runner_js_1 = require("./runner.js");
+Object.defineProperty(exports, "compileViaClpp", { enumerable: true, get: function () { return runner_js_1.compileViaClpp; } });
+Object.defineProperty(exports, "compileViaClppAsync", { enumerable: true, get: function () { return runner_js_1.compileViaClppAsync; } });
+Object.defineProperty(exports, "clppManifest", { enumerable: true, get: function () { return runner_js_1.clppManifest; } });
+Object.defineProperty(exports, "clppVersion", { enumerable: true, get: function () { return runner_js_1.clppVersion; } });
+Object.defineProperty(exports, "hasClpp", { enumerable: true, get: function () { return runner_js_1.hasClpp; } });
+Object.defineProperty(exports, "resolveClppBinary", { enumerable: true, get: function () { return runner_js_1.resolveClppBinary; } });
+var postprocess_js_1 = require("./postprocess.js");
+Object.defineProperty(exports, "clppLuauToGame", { enumerable: true, get: function () { return postprocess_js_1.clppLuauToGame; } });
+Object.defineProperty(exports, "shouldSkipInit", { enumerable: true, get: function () { return postprocess_js_1.shouldSkipInit; } });
+var paths_js_1 = require("./paths.js");
+Object.defineProperty(exports, "SOURCE_EXTS", { enumerable: true, get: function () { return paths_js_1.SOURCE_EXTS; } });
+Object.defineProperty(exports, "collectSources", { enumerable: true, get: function () { return paths_js_1.collectSources; } });
+Object.defineProperty(exports, "emitKind", { enumerable: true, get: function () { return paths_js_1.emitKind; } });
+Object.defineProperty(exports, "fileStem", { enumerable: true, get: function () { return paths_js_1.fileStem; } });
+Object.defineProperty(exports, "isEngineStub", { enumerable: true, get: function () { return paths_js_1.isEngineStub; } });
+Object.defineProperty(exports, "isHeaderFile", { enumerable: true, get: function () { return paths_js_1.isHeaderFile; } });
+Object.defineProperty(exports, "isImplFile", { enumerable: true, get: function () { return paths_js_1.isImplFile; } });
+Object.defineProperty(exports, "isSourceFile", { enumerable: true, get: function () { return paths_js_1.isSourceFile; } });
+Object.defineProperty(exports, "isTaggedScript", { enumerable: true, get: function () { return paths_js_1.isTaggedScript; } });
+Object.defineProperty(exports, "scriptKind", { enumerable: true, get: function () { return paths_js_1.scriptKind; } });
+Object.defineProperty(exports, "siblingHeader", { enumerable: true, get: function () { return paths_js_1.siblingHeader; } });
+Object.defineProperty(exports, "toLuauPath", { enumerable: true, get: function () { return paths_js_1.toLuauPath; } });

package/generated/clpp/paths.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_EXTS = void 0;
+exports.isSourceFile = isSourceFile;
+exports.isEngineStub = isEngineStub;
+exports.isHeaderFile = isHeaderFile;
+exports.isImplFile = isImplFile;
+exports.toLuauPath = toLuauPath;
+exports.fileStem = fileStem;
+exports.scriptKind = scriptKind;
+exports.emitKind = emitKind;
+exports.isTaggedScript = isTaggedScript;
+exports.siblingHeader = siblingHeader;
+exports.collectSources = collectSources;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.SOURCE_EXTS = [".clpp", ".clp", ".clh"];
+function isSourceFile(fileName) {
+    return exports.SOURCE_EXTS.includes(node_path_1.default.extname(fileName).toLowerCase());
+}
+function isEngineStub(filePath) {
+    const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+    return (normalized.includes("/include/cluaupp/") ||
+        normalized.includes("/include/clpp/") ||
+        normalized.includes("/include/cluau/") ||
+        normalized.includes("/stdlib/") ||
+        normalized.endsWith("/roblox.clh"));
+}
+function isHeaderFile(fileName) {
+    return node_path_1.default.extname(fileName).toLowerCase() === ".clh";
+}
+function isImplFile(fileName) {
+    const ext = node_path_1.default.extname(fileName).toLowerCase();
+    return ext === ".clp" || ext === ".clpp";
+}
+function toLuauPath(filePath) {
+    return String(filePath).replace(/\.(clpp|clp|clh)$/i, ".luau");
+}
+function fileStem(fileName) {
+    let name = node_path_1.default.basename(fileName);
+    const lower = name.toLowerCase();
+    for (const ext of [".clpp", ".clp", ".clh"]) {
+        if (lower.endsWith(ext)) {
+            name = name.slice(0, -ext.length);
+            break;
+        }
+    }
+    const tagged = name.toLowerCase();
+    for (const tag of [".legacy.server", ".legacy.client", ".legacy", ".server", ".client", ".plugin"]) {
+        if (tagged.endsWith(tag)) {
+            name = name.slice(0, -tag.length);
+            break;
+        }
+    }
+    return name;
+}
+function scriptKind(fileName) {
+    const name = node_path_1.default.basename(fileName).toLowerCase();
+    if (name.endsWith(".clh")) {
+        return "header";
+    }
+    if (name.includes(".legacy.")) {
+        return "legacy";
+    }
+    if (name.includes(".server.")) {
+        return "server";
+    }
+    if (name.includes(".client.")) {
+        return "client";
+    }
+    if (name.includes(".plugin.")) {
+        return "plugin";
+    }
+    return "module";
+}
+function emitKind(fileName) {
+    const kind = scriptKind(fileName);
+    if (kind === "legacy") {
+        return "legacy";
+    }
+    if (kind === "module" || kind === "header") {
+        return "module";
+    }
+    return "flat";
+}
+function isTaggedScript(fileName) {
+    const kind = scriptKind(fileName);
+    return kind === "server" || kind === "client" || kind === "plugin" || kind === "legacy";
+}
+function siblingHeader(implPath) {
+    if (!implPath || isHeaderFile(implPath)) {
+        return null;
+    }
+    const dir = node_path_1.default.dirname(implPath);
+    const stem = fileStem(implPath);
+    const candidate = node_path_1.default.join(dir, `${stem}.clh`);
+    if (node_fs_1.default.existsSync(candidate)) {
+        return candidate;
+    }
+    return null;
+}
+function collectSources(dir, files = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return files;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectSources(full, files);
+        }
+        else if (isSourceFile(entry.name)) {
+            files.push(full);
+        }
+    }
+    return files;
+}

package/generated/clpp/postprocess.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipInit = shouldSkipInit;
+exports.clppLuauToGame = clppLuauToGame;
+const libs_js_1 = require("../libs.js");
+const paths_js_1 = require("./paths.js");
+function insertAfterHeader(luau, block) {
+    const match = String(luau).match(/^(?:--[^\n]*\n)+/);
+    if (!match) {
+        return `${block}\n${luau}`;
+    }
+    const insertAt = match[0].length;
+    const rest = luau.slice(insertAt).replace(/^\n*/, "\n");
+    return `${luau.slice(0, insertAt)}\n${block}\n${rest}`;
+}
+function rewriteClppLibs(luau) {
+    return String(luau).replace(/require\(\s*ClppLibs\.([A-Za-z0-9_]+)\s*\)/g, (_all, name) => {
+        return (0, libs_js_1.requireCluauppLib)(name);
+    });
+}
+function ensureReplicatedStorage(luau) {
+    if (!luau.includes("CluauppLibs")) {
+        return luau;
+    }
+    if (/GetService\(\s*"ReplicatedStorage"\s*\)/.test(luau)) {
+        return luau;
+    }
+    return insertAfterHeader(luau, 'const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+}
+function stripInitCall(luau) {
+    return String(luau).replace(/\ninit\(\)\s*\n?$/m, "\n");
+}
+function ensureStrict(luau, strict) {
+    if (!strict || /^\s*--!strict\b/m.test(luau)) {
+        return luau;
+    }
+    if (luau.startsWith("--")) {
+        return `--!strict\n${luau}`;
+    }
+    return `--!strict\n${luau}`;
+}
+function librarySpecs(names) {
+    const specs = [];
+    const seen = new Set();
+    for (const name of names || []) {
+        const spec = libs_js_1.MODULES[name];
+        if (!spec || seen.has(spec.bind)) {
+            continue;
+        }
+        seen.add(spec.bind);
+        specs.push(spec);
+    }
+    return specs;
+}
+function missingLibraries(luau, names) {
+    return librarySpecs(names).filter((spec) => {
+        return !luau.includes(`CluauppLibs.${spec.file}`) && !new RegExp(`\\bconst ${spec.bind}\\b`).test(luau);
+    });
+}
+function shouldSkipInit(fileName, hasSiblingHeader) {
+    if (!hasSiblingHeader) {
+        return false;
+    }
+    return !(0, paths_js_1.isTaggedScript)(fileName);
+}
+function clppLuauToGame(artifact, options) {
+    let luau = rewriteClppLibs(artifact.luau || "");
+    luau = ensureReplicatedStorage(luau);
+    if (options.skipInit) {
+        luau = stripInitCall(luau);
+    }
+    luau = ensureStrict(luau, options.strict);
+    const missing = missingLibraries(luau, artifact.libraries);
+    if (missing.length > 0) {
+        luau = (0, libs_js_1.insertPreamble)(luau, [], missing, options.outName);
+    }
+    return luau;
+}

package/generated/clpp/runner.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasClpp = hasClpp;
+exports.resolveClppBinary = resolveClppBinary;
+exports.formatClppFailure = formatClppFailure;
+exports.compileViaClpp = compileViaClpp;
+exports.compileViaClppAsync = compileViaClppAsync;
+exports.clppManifest = clppManifest;
+exports.clppVersion = clppVersion;
+exports.clppInstalls = clppInstalls;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const contract_js_1 = require("./contract.js");
+const MISSING_CLPP = `cluaupp: clpp not found. ${contract_js_1.CLPP_INSTALL_HINT}`;
+let cachedBin;
+function parseSemver(text) {
+    const match = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match) {
+        return null;
+    }
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+function cmpSemver(a, b) {
+    return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+function minClpp() {
+    return parseSemver(contract_js_1.MIN_CLPP_VERSION) || { major: 0, minor: 3, patch: 2 };
+}
+function tooOldMessage(bin, version) {
+    return `cluaupp: clpp ${version || "unknown"} is too old (${bin}). Need CL++ ${contract_js_1.MIN_CLPP_VERSION}+. Install https://github.com/KartzRbx/CLPP/releases/download/v0.3.2/clpp-setup.exe or set CLPP / CLPP_PATH.`;
+}
+function probeVersion(bin) {
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0) {
+        return null;
+    }
+    return String(result.stdout || result.stderr || "").trim() || null;
+}
+function pushCandidate(out, seen, item) {
+    const value = String(item || "").trim();
+    if (!value) {
+        return;
+    }
+    const key = value.toLowerCase();
+    if (seen.has(key)) {
+        return;
+    }
+    seen.add(key);
+    out.push(value);
+}
+function existsBin(bin) {
+    try {
+        return node_fs_1.default.existsSync(bin);
+    }
+    catch {
+        return false;
+    }
+}
+function listClppCandidates() {
+    const seen = new Set();
+    const override = [];
+    pushCandidate(override, seen, process.env.CLPP);
+    pushCandidate(override, seen, process.env.CLPP_PATH);
+    const overrideExisting = override.filter(existsBin);
+    if (overrideExisting.length > 0) {
+        return overrideExisting;
+    }
+    const out = [];
+    const finder = process.platform === "win32" ? "where" : "which";
+    const found = (0, node_child_process_1.spawnSync)(finder, ["clpp"], { encoding: "utf8", windowsHide: true });
+    if (found.status === 0) {
+        for (const line of String(found.stdout || "").split(/\r?\n/)) {
+            pushCandidate(out, seen, line);
+        }
+    }
+    if (process.platform === "win32") {
+        const local = process.env.LOCALAPPDATA || node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Local");
+        pushCandidate(out, seen, node_path_1.default.join(local, "Programs", "CLPP", "clpp.exe"));
+    }
+    return out.filter(existsBin);
+}
+function pickClppBinary() {
+    const candidates = listClppCandidates();
+    if (candidates.length === 0) {
+        return null;
+    }
+    let best = null;
+    let fallback = null;
+    for (const bin of candidates) {
+        const version = probeVersion(bin);
+        const parsed = parseSemver(version || "");
+        if (!fallback) {
+            fallback = bin;
+        }
+        if (!parsed) {
+            continue;
+        }
+        if (!best || cmpSemver(parsed, best.parsed) > 0) {
+            best = { bin, parsed };
+        }
+    }
+    return best?.bin || fallback;
+}
+function whichClpp() {
+    if (cachedBin !== undefined) {
+        return cachedBin;
+    }
+    cachedBin = pickClppBinary();
+    return cachedBin;
+}
+function hasClpp() {
+    return Boolean(whichClpp());
+}
+function resolveClppBinary() {
+    const bin = whichClpp();
+    if (!bin) {
+        throw new Error(MISSING_CLPP);
+    }
+    const version = probeVersion(bin);
+    const parsed = parseSemver(version || "");
+    if (!parsed || cmpSemver(parsed, minClpp()) < 0) {
+        throw new Error(tooOldMessage(bin, version));
+    }
+    return bin;
+}
+function parseArtifact(stdout, fileName, fallbackError) {
+    const text = String(stdout || "").trim();
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return {
+        ok: false,
+        luau: "",
+        fileName,
+        outputHint: "",
+        scriptKind: null,
+        isScript: false,
+        isHeader: false,
+        rojoClass: "ModuleScript",
+        libraries: [],
+        error: fallbackError || "clpp returned invalid JSON",
+    };
+}
+function formatClppFailure(artifact, fallback) {
+    const diags = Array.isArray(artifact.diagnostics) ? artifact.diagnostics : [];
+    if (diags.length > 0) {
+        return diags
+            .map((d) => {
+            const where = `${artifact.fileName || "clpp"}:${d.line}:${d.column}`;
+            return `${where}: ${d.message}`;
+        })
+            .join("\n");
+    }
+    return artifact.error || fallback;
+}
+function compileViaClpp(request) {
+    const bin = resolveClppBinary();
+    const payload = JSON.stringify({
+        source: request.source,
+        fileName: request.fileName,
+        strict: request.strict ?? null,
+    });
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "compile"], {
+        input: payload,
+        encoding: "utf8",
+        cwd: request.cwd,
+        maxBuffer: 16 * 1024 * 1024,
+        windowsHide: true,
+    });
+    const stderr = String(result.stderr || "").trim();
+    const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
+    if (!artifact.ok) {
+        throw new Error(formatClppFailure(artifact, stderr || result.error?.message || `clpp failed (${result.status})`));
+    }
+    return artifact;
+}
+function compileViaClppAsync(request) {
+    return new Promise((resolve, reject) => {
+        let bin;
+        try {
+            bin = resolveClppBinary();
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        const child = (0, node_child_process_1.spawn)(bin, ["api", "compile"], {
+            cwd: request.cwd,
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const artifact = parseArtifact(stdout, request.fileName, stderr.trim() || `clpp api compile failed (${code})`);
+            if (!artifact.ok) {
+                reject(new Error(formatClppFailure(artifact, stderr.trim() || `clpp failed (${code})`)));
+                return;
+            }
+            resolve(artifact);
+        });
+        child.stdin.end(JSON.stringify({
+            source: request.source,
+            fileName: request.fileName,
+            strict: request.strict ?? null,
+        }));
+    });
+}
+function clppManifest() {
+    const bin = resolveClppBinary();
+    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        throw new Error(String(result.stderr || result.error?.message || "clpp api manifest failed"));
+    }
+    return JSON.parse(result.stdout);
+}
+function clppVersion() {
+    const bin = whichClpp();
+    if (!bin) {
+        return null;
+    }
+    return probeVersion(bin);
+}
+function clppInstalls() {
+    const selected = whichClpp();
+    return listClppCandidates().map((bin) => ({
+        bin,
+        version: probeVersion(bin),
+        selected: bin === selected,
+    }));
+}