cluaupp 0.2.3 → 1.0.0

package/examples/game/src/client/init.client.clpp

@@ -0,0 +1,6 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void init() {
+	post("Cluaupp client ok");
+}

package/examples/game/src/server/combat.server.clpp

@@ -0,0 +1,85 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
+
+struct CombatServer {
+	Janitor* janitor;
+	signal<Player*, int> OnHit;
+	void PlayerEntered(Player* player);
+	void BindPart(BasePart* part);
+	void WatchWorkspace();
+};
+
+void CombatServer::BindPart(BasePart* part) {
+	guard (part != null) else {
+		return;
+	}
+
+	part.Touched~>Once(func [](BasePart* other) {
+		Instance* character = other.Parent;
+		guard (character != null) else {
+			return;
+		}
+
+		match (character::FindFirstChild("Humanoid")) {
+			Humanoid* humanoid => {
+				guard (humanoid.Health > 0) else {
+					return;
+				}
+				Players* players = GetService<Players>();
+				Player* player = players::GetPlayerFromCharacter(character);
+				guard (player != null) else {
+					return;
+				}
+				OnHit::Fire(player, 10);
+				part::Destroy();
+			},
+			_ => warn("touch without humanoid")
+		};
+	});
+}
+
+void CombatServer::PlayerEntered(Player* player) {
+	guard (player != null) else {
+		return;
+	}
+
+	observable int combo = 0;
+	OnHit~>Connect(func [](Player* victim, int amount) {
+		guard (victim == player) else {
+			return;
+		}
+		combo = combo + 1;
+		post(player.Name .: " combo " .: combo .: " dmg " .: amount);
+	});
+}
+
+[[server]]
+void CombatServer::WatchWorkspace() {
+	workspace.ChildAdded~>Connect(func [](Instance* child) {
+		match (child) {
+			BasePart* p => BindPart(p),
+			Model* m => post("model spawned " .: m.Name),
+			_ => warn("ignored instance")
+		};
+	});
+}
+
+void init() {
+	CombatServer combat;
+	combat.janitor = new Janitor();
+
+	spawn {
+		task::wait(1);
+		post("combat ready");
+	};
+
+	Players* players = GetService<Players>();
+	for (Player* player : players::GetPlayers()) {
+		combat::PlayerEntered(player);
+	}
+	players::PlayerAdded~>Connect(func [](Player* p) {
+		combat::PlayerEntered(p);
+	});
+	combat::WatchWorkspace();
+}

package/examples/game/src/server/leaderstats.server.clpp

@@ -0,0 +1,28 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void CreateLeaderstats(Player* player) {
+	if (player::FindFirstChild("leaderstats") != null) {
+		return;
+	}
+
+	Folder* leaderstats = new Folder(player);
+	leaderstats.Name = "leaderstats";
+
+	IntValue* coins = new IntValue(leaderstats);
+	coins.Name = "Coins";
+	coins.Value = 0;
+
+	IntValue* level = new IntValue(leaderstats);
+	level.Name = "Level";
+	level.Value = 0;
+}
+
+void init() {
+	Players* players = GetService<Players>();
+	for (Player* player : players::GetPlayers()) {
+		CreateLeaderstats(player);
+	}
+
+	players::PlayerAdded::Connect(CreateLeaderstats);
+}

package/examples/game/src/shared/PlayerData.clh

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <clpp/datatypes.clh>
+
+struct PlayerDataCurrencies {
+	int Coins = 0;
+	int Rebirths = 0;
+};
+
+struct PlayerDataInventory {
+	array<int> HotBar;
+	array<int> Storage;
+
+	int MaxStorage = 90;
+};
+
+struct PlayerData {
+	PlayerDataCurrencies Currencies;
+	PlayerDataInventory Inventory;
+};

package/examples/game/src/shared/config.clp

@@ -0,0 +1,6 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+const int STARTING_COINS = 0;
+const string REMOTE_COINS = "Coins";
+const string LEADERSTATS_FOLDER = "leaderstats";

package/examples/game/src/shared/features.clp

@@ -0,0 +1,88 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+void ShowcaseFeatures(int coins, Player* playerRef) {
+	int n = 100;
+	float speed = 16.5;
+	string name = "Kartz";
+	bool isActive = true;
+	func callback = []() {};
+	(void)speed;
+	(void)isActive;
+	(void)callback;
+
+	array<string> names = {"Kartz", "Player1"};
+	dictionary<string, int> stats = {
+		{"Coins", 100},
+		{"Gems", 50}
+	};
+	(void)names;
+	(void)stats;
+
+	if (coins > 50) {
+		post("Enough balance!");
+	} else if (coins == 0) {
+		warn("No coins!");
+	} else {
+		report("Balance sync error.");
+	}
+
+	for (int i = 0; i < 10; i++) {
+		post("Count: " .: i);
+	}
+
+	n += 1;
+
+	observable int wallet = 100;
+	wallet.OnChange(func [](int newValue) {
+		post("Coins changed to: " .: newValue);
+	});
+
+	signal<Player*, int> OnCoinsUpdated;
+	OnCoinsUpdated~>Connect(func [](Player* player, int newAmount) {
+		post("New coins for " .: player.Name .: ": " .: newAmount);
+	});
+	OnCoinsUpdated~>Once(func [](Player* player, int newAmount) {
+		(void)newAmount;
+		post("First coins for " .: player.Name);
+	});
+	OnCoinsUpdated::Fire(playerRef, wallet);
+
+	guard (playerRef != null) else {
+		warn("Invalid player");
+		return;
+	}
+
+	playerRef::GetPropertyChangedSignal("Name")~>Connect(func []() {
+		post("Name changed");
+	});
+
+	auto [success, result] = pcall(func []() {
+		return 1;
+	});
+	(void)result;
+
+	const int moeda = 4;
+	match (moeda) {
+		int a => post(a),
+		_ => post("Not found")
+	};
+
+	if (success) {
+		post("Data loaded successfully!");
+	}
+
+	spawn {
+		task::wait(2);
+		post("Delay finished!");
+	};
+
+	parallel {
+		post("desync");
+	};
+
+	match (name) {
+		string s => post(s),
+		_ => warn("Instance not supported")
+	};
+}

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);
@@ -73,8 +76,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 +92,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 +100,32 @@ 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 {
+        (0, runner_js_1.resolveClppBinary)();
+        const version = (0, runner_js_1.clppVersion)();
+        if (version) {
+            console.log("clpp", version);
         }
+        console.log(JSON.stringify((0, runner_js_1.clppManifest)(), null, "\t"));
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);
@@ -129,14 +146,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 +170,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 +183,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,5 @@
+"use strict";
+/** Stable CL++ ↔ Cluaupp contract. Cluaupp invokes the `clpp` binary. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLPP_INSTALL_HINT = void 0;
+exports.CLPP_INSTALL_HINT = "Install CL++ and put `clpp` on PATH: https://github.com/KartzRbx/CLPP (`cargo install --path .` then `clpp install`). Override with CLPP_PATH.";

package/generated/clpp/index.js

@@ -0,0 +1,27 @@
+"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.compileViaClpp = 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; } });
+var runner_js_1 = require("./runner.js");
+Object.defineProperty(exports, "compileViaClpp", { enumerable: true, get: function () { return runner_js_1.compileViaClpp; } });
+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,121 @@
+"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.hpp") ||
+        normalized.endsWith("/roblox.h") ||
+        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;
+}