cluaupp 0.2.2 → 1.0.0

package/src/intellisense.ts

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { parse } from "./parse.js";
-import { preprocess } from "./preprocess.js";
-import { findClangPlusPlus, installMarketplaceExtension, ensureLlvm, CLANGD_ID, reportInstall } from "./editor-install.js";
+import { spawnSync } from "node:child_process";
 import { pkg, projectRoot as PACKAGE_ROOT } from "./package-info.js";
 import type { ProjectConfig } from "./types.js";
-import type { PreprocessOptions } from "./ast.js";
+import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
+import { compileViaClpp, hasClpp } from "./clpp/runner.js";
+import { isSourceFile } from "./clpp/paths.js";
 
 export type CluauppDiagnostic = {
 	line: number;
@@ -15,83 +15,6 @@ export type CluauppDiagnostic = {
 	severity: "error";
 };
 
-function posix(file: string): string {
-	return String(file).replace(/\\/g, "/");
-}
-
-function collectFiles(dir: string, files: string[] = []): string[] {
-	if (!fs.existsSync(dir)) {
-		return files;
-	}
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const full = path.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			collectFiles(full, files);
-		} else {
-			files.push(full);
-		}
-	}
-	return files;
-}
-
-function isCppFile(file: string): boolean {
-	return /\.(cpp|cc|cxx|c|h|hpp|hh)$/i.test(file);
-}
-
-function clangCompileArgs(root: string): string[] {
-	const absRoot = posix(path.resolve(root));
-	const absInclude = posix(path.join(absRoot, "include"));
-	const absSrc = posix(path.join(absRoot, "src"));
-	const roblox = posix(path.join(absInclude, "cluaupp", "roblox.hpp"));
-	return [
-		"-xc++",
-		"-std=c++20",
-		"-ferror-limit=0",
-		"-I" + absInclude,
-		"-I" + absSrc,
-		"-Iinclude",
-		"-Isrc",
-		"-include",
-		roblox,
-	];
-}
-
-function compileCommandEntry(root: string, file: string) {
-	const absRoot = posix(path.resolve(root));
-	const absFile = posix(path.resolve(file));
-	return {
-		directory: absRoot,
-		file: absFile,
-		arguments: [clangPath(), ...clangCompileArgs(root), "-c", absFile],
-	};
-}
-
-function mergeJson(file: string, patch: Record<string, unknown>): boolean {
-	let current: Record<string, unknown> = {};
-	if (fs.existsSync(file)) {
-		try {
-			current = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
-		} catch {
-			current = {};
-		}
-	}
-	const next: Record<string, unknown> = { ...current, ...patch };
-	for (const key of Object.keys(patch)) {
-		const value = patch[key];
-		const existing = current[key];
-		if (value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing)) {
-			next[key] = { ...(existing as Record<string, unknown>), ...(value as Record<string, unknown>) };
-		}
-	}
-	const json = `${JSON.stringify(next, null, "\t")}\n`;
-	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === json) {
-		return false;
-	}
-	fs.mkdirSync(path.dirname(file), { recursive: true });
-	fs.writeFileSync(file, json, "utf8");
-	return true;
-}
-
 function copyDir(from: string, to: string): void {
 	fs.mkdirSync(to, { recursive: true });
 	for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
@@ -105,153 +28,94 @@ function copyDir(from: string, to: string): void {
 	}
 }
 
-function clangdEditorArgs(): string[] {
-	return [
-		"--compile-commands-dir=${workspaceFolder}",
-		"--header-insertion=never",
-		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
-	];
-}
-
-export function intelliSenseMode(): string {
-	const arch = process.arch === "arm64" ? "arm64" : "x64";
-	if (process.platform === "win32") {
-		return `windows-clang-${arch}`;
-	}
-	if (process.platform === "darwin") {
-		return `macos-clang-${arch}`;
+function uniqueStrings(...lists: unknown[]): string[] {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const list of lists) {
+		if (!Array.isArray(list)) {
+			continue;
+		}
+		for (const item of list) {
+			if (typeof item === "string" && item && !seen.has(item)) {
+				seen.add(item);
+				out.push(item);
+			}
+		}
 	}
-	return `linux-clang-${arch}`;
+	return out;
 }
 
-export function clangPath(): string {
-	return findClangPlusPlus() || "clang++";
-}
-
-export function writeCompileCommands(root: string, srcDir: string): boolean {
-	const files = collectFiles(srcDir).filter((file) => isCppFile(file)).sort();
-	const json = `${JSON.stringify(files.map((file) => compileCommandEntry(root, file)), null, "\t")}\n`;
-	const dest = path.join(root, "compile_commands.json");
-	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === json) {
-		return false;
+function readJsonObject(file: string): Record<string, unknown> {
+	if (!fs.existsSync(file)) {
+		return {};
+	}
+	try {
+		const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+	} catch {
+		// ignore
 	}
-	fs.writeFileSync(dest, json, "utf8");
-	return true;
+	return {};
 }
 
-export function writeClangd(root: string): boolean {
-	const flags = clangCompileArgs(root)
-		.map((flag) => `    - ${flag}`)
-		.join("\n");
-	const contents = `CompileFlags:
-  CompilationDatabase: .
-  Add:
-${flags}
-
-Diagnostics:
-  Suppress: '*'
-
----
-If:
-  PathMatch: .*\\.(cpp|cc|cxx|c|h|hpp|hh)$
-CompileFlags:
-  Add:
-    - -xc++
-
----
-If:
-  PathMatch: (out|libs)/.*
-Index:
-  Background: Skip
-`;
-	const dest = path.join(root, ".clangd");
-	if (fs.existsSync(dest) && fs.readFileSync(dest, "utf8") === contents) {
-		return false;
+function writeJson(file: string, value: Record<string, unknown>): void {
+	const json = `${JSON.stringify(value, null, "\t")}\n`;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === json) {
+		return;
 	}
-	fs.writeFileSync(dest, contents, "utf8");
-	return true;
+	fs.writeFileSync(file, json, "utf8");
 }
 
 function writeVscode(root: string): void {
-	const settings = path.join(root, ".vscode", "settings.json");
-	mergeJson(settings, {
-		"C_Cpp.intelliSenseEngine": "Disabled",
-		"C_Cpp.default.cppStandard": "c++20",
-		"C_Cpp.default.cStandard": "c17",
-		"C_Cpp.default.compilerPath": clangPath(),
-		"C_Cpp.default.intelliSenseMode": intelliSenseMode(),
-		"C_Cpp.default.includePath": ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-		"clangd.enable": true,
-		"clangd.arguments": clangdEditorArgs(),
-		"files.associations": {
-			"*.hpp": "cpp",
-			"*.h": "cpp",
-			"*.server.cpp": "cpp",
-			"*.client.cpp": "cpp",
-			"*.plugin.cpp": "cpp",
-			"*.legacy.cpp": "cpp",
-			"*.legacy.server.cpp": "cpp",
-			"*.legacy.client.cpp": "cpp",
-		},
+	const settingsPath = path.join(root, ".vscode", "settings.json");
+	const current = readJsonObject(settingsPath);
+	const associations = {
+		...((current["files.associations"] && typeof current["files.associations"] === "object" && !Array.isArray(current["files.associations"]))
+			? (current["files.associations"] as Record<string, unknown>)
+			: {}),
+		"*.clpp": "clpp",
+		"*.clp": "clpp",
+		"*.clh": "clpp",
+		"*.server.clpp": "clpp",
+		"*.client.clpp": "clpp",
+		"*.plugin.clpp": "clpp",
+	};
+	writeJson(settingsPath, {
+		...current,
+		"files.associations": associations,
 	});
-	mergeJson(path.join(root, ".vscode", "extensions.json"), {
-		recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+
+	const extensionsPath = path.join(root, ".vscode", "extensions.json");
+	const extensions = readJsonObject(extensionsPath);
+	writeJson(extensionsPath, {
+		...extensions,
+		recommendations: uniqueStrings(extensions.recommendations),
+		unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
 	});
-	const props = path.join(root, ".vscode", "c_cpp_properties.json");
-	const nextProps = {
-		configurations: [
-			{
-				name: "Cluaupp",
-				compilerPath: clangPath(),
-				cStandard: "c17",
-				cppStandard: "c++20",
-				intelliSenseMode: intelliSenseMode(),
-				includePath: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-				forcedInclude: ["${workspaceFolder}/include/cluaupp/roblox.hpp"],
-				compileCommands: "${workspaceFolder}/compile_commands.json",
-				browse: {
-					path: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-					limitSymbolsToIncludedHeaders: true,
-				},
-			},
-		],
-		version: 4,
-	};
-	const json = `${JSON.stringify(nextProps, null, "\t")}\n`;
-	fs.mkdirSync(path.dirname(props), { recursive: true });
-	if (!fs.existsSync(props) || fs.readFileSync(props, "utf8") !== json) {
-		fs.writeFileSync(props, json, "utf8");
-	}
 }
 
-export function diagnosticsFor(source: string, fileName?: string, options: PreprocessOptions = {}): CluauppDiagnostic[] {
+export function diagnosticsFor(source: string, fileName?: string): CluauppDiagnostic[] {
+	if (!hasClpp()) {
+		return [];
+	}
 	try {
-		const prepared = options.filePath ? preprocess(source, options.filePath, options) : source;
-		parse(prepared, fileName || "input.cpp");
+		compileViaClpp({ source, fileName: fileName || "input.clpp" });
 		return [];
 	} catch (err) {
-		const error = err as { message?: string; line?: number; col?: number };
-		const message = error.message ? String(error.message) : "parse error";
+		const message = err instanceof Error ? err.message : String(err);
 		const match = message.match(/:(\d+):(\d+):\s*(.*)$/);
 		if (match) {
 			return [{ line: Number(match[1]), col: Number(match[2]), message: match[3], severity: "error" }];
 		}
-		return [{ line: error.line || 1, col: error.col || 1, message, severity: "error" }];
+		return [{ line: 1, col: 1, message, severity: "error" }];
 	}
 }
 
-export function syncEditorSupport(root: string, config: Partial<ProjectConfig> = {}): void {
-	const srcDir = path.join(root, config.rootDir || "src");
-	if (fs.existsSync(srcDir)) {
-		writeCompileCommands(root, srcDir);
-	}
-	writeClangd(root);
+export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {
 	writeVscode(root);
-	const flags = ["-xc++", "-std=c++20", "-ferror-limit=0", "-Iinclude", "-Isrc", "-include", "include/cluaupp/roblox.hpp"].join("\n") + "\n";
-	const flagsFile = path.join(root, "compile_flags.txt");
-	if (!fs.existsSync(flagsFile) || fs.readFileSync(flagsFile, "utf8") !== flags) {
-		fs.writeFileSync(flagsFile, flags, "utf8");
-	}
 }
 
 export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
@@ -275,12 +139,19 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 	return installed;
 }
 
-export async function installEditorSupport(cluauppRoot = PACKAGE_ROOT) {
-	const local = installEditorExtension(cluauppRoot);
-	const llvm = ensureLlvm();
-	reportInstall(llvm, "LLVM clang++");
-	const clangd = await installMarketplaceExtension(CLANGD_ID, "clangd (LLVM)");
-	reportInstall(clangd, "clangd");
-	console.log("cluaupp: C++ completion is clangd — reload the editor (Ctrl+Shift+P → Developer: Reload Window)");
-	return { local, llvm, clangd };
+export async function installEditorSupport() {
+	const local = installEditorExtension();
+	if (hasClpp()) {
+		const result = spawnSync("clpp", ["install"], { encoding: "utf8", windowsHide: true });
+		if (result.status === 0) {
+			console.log(String(result.stderr || result.stdout || "clpp install ok").trim());
+		} else {
+			console.log("cluaupp:", CLPP_INSTALL_HINT);
+		}
+	} else {
+		console.log("cluaupp:", CLPP_INSTALL_HINT);
+	}
+	return { local };
 }
+
+export const isClppSource = isSourceFile;

package/src/libs.ts

@@ -248,7 +248,7 @@ function walk(node, visit) {
 function modulesFromIncludes(source) {
 	const found = new Set();
 	for (const line of String(source).split(/\r?\n/)) {
-		const match = line.match(/^\s*#\s*include\s+<cluaupp\/(?:libs\/)?([A-Za-z0-9]+)\.hpp>/);
+		const match = line.match(/^\s*#\s*include\s+<(?:clpp|cluaupp)\/(?:libs\/)?([A-Za-z0-9]+)\.(?:clh|hpp)>/);
 		if (!match) {
 			continue;
 		}

package/src/lsp.ts

@@ -1,4 +1,3 @@
-import path from "node:path";
 import {
 	createConnection,
 	ProposedFeatures,
@@ -31,10 +30,7 @@ export function start(options: { projectRoot?: string } = {}): void {
 
 	const publish = (document: TextDocument) => {
 		const file = uriPath(document.uri);
-		const items = diagnosticsFor(document.getText(), file, {
-			filePath: file,
-			includeDirs: [path.dirname(file), path.join(projectRoot, "src"), path.join(projectRoot, "include")],
-		});
+		const items = diagnosticsFor(document.getText(), file);
 		connection.sendDiagnostics({
 			uri: document.uri,
 			diagnostics: items.map((item) => ({

package/src/preprocess.ts

@@ -1,180 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { ModuleInclude, PreprocessOptions } from "./ast.js";
-
-export const SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
-
-export function isSourceFile(fileName: string): boolean {
-	return SOURCE_EXTS.includes(path.extname(fileName).toLowerCase());
-}
-
-export function isHeaderFile(fileName: string): boolean {
-	return [".h", ".hpp", ".hh"].includes(path.extname(fileName).toLowerCase());
-}
-
-export function toLuauPath(filePath: string): string {
-	return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
-}
-
-export function isEngineStub(filePath: string): boolean {
-	const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-	return (
-		normalized.includes("/include/cluaupp/") ||
-		normalized.includes("/include/cluau/") ||
-		normalized.endsWith("/roblox.hpp") ||
-		normalized.endsWith("/roblox.h")
-	);
-}
-
-function includeVariants(name: string): string[] {
-	const variants = [name];
-	if (/\.h$/i.test(name)) {
-		variants.push(name.replace(/\.h$/i, ".hpp"), name.replace(/\.h$/i, ".hh"));
-	} else if (/\.hpp$/i.test(name)) {
-		variants.push(name.replace(/\.hpp$/i, ".h"), name.replace(/\.hpp$/i, ".hh"));
-	} else if (/\.hh$/i.test(name)) {
-		variants.push(name.replace(/\.hh$/i, ".h"), name.replace(/\.hh$/i, ".hpp"));
-	}
-	return [...new Set(variants)];
-}
-
-export function siblingImplementation(headerPath: string | null | undefined): string | null {
-	if (!headerPath || !isHeaderFile(headerPath)) {
-		return null;
-	}
-	const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
-	for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
-		if (fs.existsSync(base + ext)) {
-			return base + ext;
-		}
-	}
-	return null;
-}
-
-export function siblingHeader(implPath: string | null | undefined): string | null {
-	if (!implPath || isHeaderFile(implPath)) {
-		return null;
-	}
-	const base = String(implPath).replace(/\.(cpp|cc|cxx|c)$/i, "");
-	if (base === String(implPath)) {
-		return null;
-	}
-	for (const ext of [".h", ".hpp", ".hh"]) {
-		if (fs.existsSync(base + ext)) {
-			return base + ext;
-		}
-	}
-	return null;
-}
-
-export function implOutName(rel: string): string {
-	return String(rel)
-		.replace(/\\/g, "/")
-		.replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
-}
-
-export function resolveInclude(name: string, fromFile: string, includeDirs?: string[]): string | null {
-	const bases = [path.dirname(fromFile), ...(includeDirs || [])];
-	for (const base of bases) {
-		for (const variant of includeVariants(name)) {
-			const candidate = path.resolve(base, variant);
-			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-				return candidate;
-			}
-		}
-	}
-	return null;
-}
-
-export function scanHeaderExports(source: string): { consts: string[]; structs: string[]; hasProtos: boolean } {
-	const consts: string[] = [];
-	const structs: string[] = [];
-	for (const match of String(source).matchAll(/\bconst\s+(?:int|bool|float|double|auto|string)\s+(\w+)/g)) {
-		if (!consts.includes(match[1])) {
-			consts.push(match[1]);
-		}
-	}
-	for (const match of String(source).matchAll(/\bstruct\s+(\w+)/g)) {
-		if (!structs.includes(match[1])) {
-			structs.push(match[1]);
-		}
-	}
-	const hasProtos = /\b(?:void|int|bool|float|double|auto|string|[\w:]+)\s+\w+\s*\([^;]*\)\s*;/.test(String(source));
-	return { consts, structs, hasProtos };
-}
-
-function pushModuleInclude(options: PreprocessOptions, resolved: string, impl: string | null): void {
-	options.moduleIncludes = options.moduleIncludes || [];
-	const srcDir = options.srcDir || null;
-	const moduleFile = impl || resolved;
-	const rel = srcDir ? path.relative(srcDir, moduleFile).replace(/\\/g, "/") : path.basename(moduleFile);
-	const headerText = fs.readFileSync(resolved, "utf8");
-	options.moduleIncludes.push({
-		name: path.basename(resolved).replace(/\.(h|hpp|hh)$/i, ""),
-		outRel: rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau"),
-		header: resolved,
-		impl: impl || null,
-		exports: scanHeaderExports(headerText),
-	});
-}
-
-export function applyPragmas(source: string, options: PreprocessOptions): void {
-	let nstrict = false;
-	let strict = false;
-	for (const line of String(source).split(/\r?\n/)) {
-		if (/^\s*#\s*pragma\s+nstrict\b/i.test(line)) {
-			nstrict = true;
-		} else if (/^\s*#\s*pragma\s+strict\b/i.test(line)) {
-			strict = true;
-		}
-	}
-	if (nstrict) {
-		options.strict = false;
-	} else if (strict) {
-		options.strict = true;
-	}
-}
-
-export function preprocess(source: string, filePath: string | null, options: PreprocessOptions = {}): string {
-	if (!options.pragmaResolved) {
-		options.pragmaResolved = true;
-		applyPragmas(source, options);
-	}
-	const seen = options.seen || new Set<string>();
-	options.seen = seen;
-	const includeDirs = options.includeDirs || [];
-	const resolvedSelf = filePath ? path.resolve(filePath) : null;
-	if (resolvedSelf) {
-		seen.add(resolvedSelf);
-	}
-
-	const lines = String(source).split(/\r?\n/);
-	const out: string[] = [];
-
-	for (const line of lines) {
-		const quoted = line.match(/^\s*#\s*include\s+"([^"]+)"/);
-		if (quoted) {
-			const resolved = resolveInclude(quoted[1], filePath || process.cwd(), includeDirs);
-			if (!resolved || isEngineStub(resolved) || seen.has(resolved)) {
-				continue;
-			}
-			const impl = siblingImplementation(resolved);
-			const including = filePath ? path.resolve(filePath) : null;
-			const ownHeader = Boolean(impl && including && path.resolve(impl) === including);
-			if (!ownHeader) {
-				pushModuleInclude(options, resolved, impl);
-				continue;
-			}
-			seen.add(resolved);
-			const inner = fs.readFileSync(resolved, "utf8");
-			out.push(preprocess(inner, resolved, { ...options, seen }));
-			continue;
-		}
-		if (/^\s*#\s*include\s+</.test(line)) {
-			continue;
-		}
-		out.push(line);
-	}
-
-	return out.join("\n");
-}
+export {
+	SOURCE_EXTS,
+	isSourceFile,
+	isHeaderFile,
+	isEngineStub,
+	toLuauPath,
+	siblingHeader,
+} from "./clpp/paths.js";

package/src/system-understander.ts

@@ -40,7 +40,7 @@ export interface ArchitectureReport {
 	reasoning: string[];
 }
 
-const EXT = "(cpp|cc|cxx|c|h|hpp|hh)";
+const EXT = "(clpp|clp|clh)";
 const EXT_REGEX = new RegExp(`\\.${EXT}$`, "i");
 const SCORE_THRESHOLD = 2;
 

package/src/transpile.ts

@@ -1,64 +1,21 @@
 import path from "node:path";
-import type { CompileOptions, CompileServiceResult, TranspilerState } from "./types.js";
-import { ASTCollector } from "./parser/collector.js";
-import { parseCpp } from "./parser/index.js";
-import { LuauCodeEmitter } from "./emitter/luau-codegen.js";
+import type { CompileOptions, CompileServiceResult } from "./types.js";
 import { compileService } from "./compile.js";
-import { determineArchitecture } from "./system-understander.js";
 import type { RojoMapper } from "./utils/rojo-mapper.js";
 
-function shouldMerge(name: string, contents: string): boolean {
-	const file = String(name || "").replace(/\\/g, "/");
-	if (/\.json$/i.test(file) || /\.meta\.json$/i.test(file)) {
-		return false;
-	}
-	const trimmed = String(contents || "").trim();
-	return !(trimmed.startsWith("{") || trimmed.startsWith("["));
-}
-
-export function collectState(source: string, mapper: RojoMapper, options: CompileOptions): TranspilerState {
-	const tree = parseCpp(source);
-	if (!tree) {
-		const state = LuauCodeEmitter.emptyState(options.strict === true);
-		return state;
-	}
-	const collector = new ASTCollector(mapper, {
-		fileName: options.relativeName || options.filePath || "input.cpp",
-		sourcePath: options.filePath,
-		srcDir: options.srcDir,
-		outDir: options.outDir,
-		strict: options.strict,
-	});
-	const state = collector.collect(tree.rootNode);
-	const report = determineArchitecture(options.relativeName || options.filePath || "input.cpp", null, tree.rootNode);
-	for (const service of report.injectedServices) {
-		state.robloxServices.add(service);
-	}
-	for (const line of report.reasoning) {
-		state.headerLines.push(`-- ${line}`);
-	}
-	return state;
-}
-
-export function transpileSource(source: string, fileName: string, options: CompileOptions, mapper: RojoMapper): CompileServiceResult {
-	const state = collectState(source, mapper, options);
-	if (state.strict) {
-		options.strict = true;
-	}
-	const compiled = compileService(source, fileName, options);
-	return {
-		...compiled,
-		files: compiled.files.map((file) => ({
-			...file,
-			contents: shouldMerge(file.name, file.contents) ? LuauCodeEmitter.merge(state, file.contents) : file.contents,
-		})),
-	};
+export function transpileSource(
+	source: string,
+	fileName: string,
+	options: CompileOptions,
+	_mapper?: RojoMapper,
+): CompileServiceResult {
+	return compileService(source, fileName, options);
 }
 
 export function outputNameFor(inputFile: string, outputPath: string): string {
 	if (/\.luau$/i.test(outputPath)) {
 		return outputPath;
 	}
-	const base = path.basename(inputFile).replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+	const base = path.basename(inputFile).replace(/\.(clpp|clp|clh)$/i, ".luau");
 	return path.join(outputPath, base);
 }