cluaupp 1.5.2 → 2.0.0-beta.2

package/src/api/surface/model.ts

@@ -0,0 +1,96 @@
+/**
+ * Roblox surface: the typed Roblox API the CL++ checker validates against.
+ * Built from luau-lsp's Roblox definitions (types, nullability, overloads, operators) merged with
+ * the Roblox API dump profile (security, read-only, creatable, services, int vs float).
+ * Stored as `api/roblox/surface.json` and loaded once per process.
+ */
+
+export type LType =
+	| { k: "name"; name: string; args?: LType[] }
+	| { k: "opt"; t: LType }
+	| { k: "union"; ts: LType[] }
+	| { k: "inter"; ts: LType[] }
+	| { k: "array"; t: LType }
+	| { k: "map"; key: LType; value: LType }
+	| { k: "table"; fields: Record<string, LType> }
+	| { k: "fn"; params: LParam[]; variadic?: LType; returns: LType[]; returnsVariadic?: LType; generics?: string[] }
+	| { k: "lit"; value: string | boolean }
+	| { k: "pack"; name: string };
+
+export interface LParam {
+	name?: string;
+	t: LType;
+}
+
+export type LFn = Extract<LType, { k: "fn" }>;
+
+export interface SurfaceMember {
+	kind: "property" | "method" | "event" | "callback";
+	/** Property type, or the function type of a callback. */
+	type?: LType;
+	/** Method overloads (without `self`). */
+	overloads?: LFn[];
+	/** Event argument types. */
+	args?: LType[];
+	readonly?: boolean;
+	/** `true`, or the replacement to suggest. */
+	deprecated?: string | true;
+	/** Read / call security when not `None`. */
+	security?: string;
+	writeSecurity?: string;
+	yields?: boolean;
+	notScriptable?: boolean;
+	/** Instance-valued property (may be nil even when the definitions say otherwise). */
+	notReplicated?: boolean;
+}
+
+export interface SurfaceClass {
+	name: string;
+	superclass: string | null;
+	members: Record<string, SurfaceMember>;
+	creatable: boolean;
+	service: boolean;
+	abstract?: boolean;
+	deprecated?: string | true;
+	notCreatable?: boolean;
+	tags?: string[];
+}
+
+export interface SurfaceStatic {
+	kind: "function" | "value";
+	overloads?: LFn[];
+	type?: LType;
+	deprecated?: string | true;
+}
+
+export interface SurfaceDatatype {
+	name: string;
+	members: Record<string, SurfaceMember>;
+	/** Metamethods: `__add`, `__sub`, `__mul`, `__div`, `__idiv`, `__mod`, `__unm`, `__eq`, `__lt`, `__le`. */
+	operators: Record<string, LFn[]>;
+	statics: Record<string, SurfaceStatic>;
+}
+
+export interface SurfaceEnum {
+	name: string;
+	items: string[];
+	deprecated?: string[];
+}
+
+export interface SurfaceGlobal {
+	type?: LType;
+	overloads?: LFn[];
+	deprecated?: string | true;
+}
+
+export interface RobloxSurface {
+	schema: 1;
+	generatedAt: string;
+	sources: Record<string, string>;
+	classes: Record<string, SurfaceClass>;
+	datatypes: Record<string, SurfaceDatatype>;
+	enums: Record<string, SurfaceEnum>;
+	globals: Record<string, SurfaceGlobal>;
+	libraries: Record<string, Record<string, SurfaceStatic>>;
+	aliases: Record<string, LType>;
+}

package/src/api-cli.ts

@@ -55,7 +55,7 @@ export function registerApiCommands(program: import("commander").Command): void
 		.command("generate")
 		.description("Build RobloxTargetProfile and regenerate CL++ / Luau projections")
 		.option("--dump <path>", "Mini-API-Dump.json path")
-		.option("--skip-headers", "Skip CL++ header generation")
+		.option("--skip-headers", "Skip legacy .clh API projections")
 		.option("--skip-luau", "Skip .d.luau generation")
 		.option("--docs", "No-op retained for CLI compat (Creator Docs are not mirrored)")
 		.action((opts: { dump?: string; skipHeaders?: boolean; skipLuau?: boolean; docs?: boolean }) => {
@@ -235,7 +235,7 @@ export function registerTargetCommands(program: import("commander").Command): vo
 
 	target
 		.command("datamodel")
-		.description("Build Typed DataModel profile + generated datamodel.clh from Rojo project")
+		.description("Build Typed DataModel profile (legacy projects also get .clh)")
 		.argument("[folder]", "game root with default.project.json", ".")
 		.option("-r, --rojo <path>", "Rojo project json")
 		.action((folder: string, options: { rojo?: string }) => {

package/src/cli.ts

@@ -4,8 +4,7 @@ import path from "node:path";
 import { pkg } from "./package-info.js";
 import { start as startLsp } from "./lsp.js";
 import { collectSources, toLuauPath } from "./clpp/paths.js";
-import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
-import { clppInstalls, clppManifest, clppVersion, hasClpp, resolveClppBinary } from "./clpp/runner.js";
+import { clppManifest, hasClpp } from "./clpp/runner.js";
 import { installEditorSupport, syncEditorSupport } from "./intellisense.js";
 import { RojoMapper } from "./utils/rojo-mapper.js";
 import { ProcessOrchestrator } from "./utils/process-orchestrator.js";
@@ -103,7 +102,8 @@ program
 
 program
 	.command("lsp")
-	.description("Language server stdio — Flare `.flare` IntelliSense. CL++ still uses `clpp setup`.")
+	.description("Schema language server over stdio")
+	.option("--stdio", "Use standard input/output (default)")
 	.argument("[folder]", "project folder", ".")
 	.action((folder: string) => {
 		startLsp({ projectRoot: path.resolve(process.cwd(), folder) });
@@ -112,7 +112,7 @@ program
 program
 	.command("intellisense")
 	.alias("intelisense")
-	.description("Install schema IntelliSense (.flare .hive .mint .bloom .helm .shift .axiom) + sync .vscode; CL++ via clpp install")
+	.description("Install schema editor support and sync .vscode")
 	.argument("[folder]", "project folder", ".")
 	.action(async (folder: string) => {
 		try {
@@ -120,7 +120,6 @@ program
 			syncEditorSupport(root, loadConfig(root));
 			await installEditorSupport();
 			console.log("cluaupp: editor associations written in", root);
-			console.log("cluaupp:", CLPP_INSTALL_HINT);
 		} catch (err) {
 			console.error(err instanceof Error ? err.message : err);
 			process.exit(1);
@@ -129,20 +128,22 @@ program
 
 program
 	.command("language")
-	.description("CL++ manifest (`clpp api manifest`)")
-	.action(() => {
+	.description("Describe the Roblox .clp target; --legacy probes external clpp")
+	.option("--legacy", "Read the manifest of the compatible legacy compiler")
+	.action((options: { legacy?: boolean }) => {
 		try {
-			const bin = resolveClppBinary();
-			const version = clppVersion();
-			if (version) {
-				console.log(version, `(${bin})`);
-			}
-			for (const install of clppInstalls()) {
-				if (!install.selected) {
-					console.log(`skipped ${install.bin} (${install.version || "unknown"})`);
-				}
-			}
-			console.log(JSON.stringify(clppManifest(), null, "\t"));
+			const manifest = options.legacy ? clppManifest() : {
+				name: "Cluaupp Roblox target",
+				version: pkg.version,
+				status: "experimental",
+				sourceExtensions: [".clp"],
+				fileTags: { server: ".server.clp", client: ".client.clp", plugin: ".plugin.clp" },
+				importSyntax: "link",
+				headers: false,
+				builtinLinks: ["@clpp.roblox", "@clpp.libs.<Library>"],
+				legacy: { sourceExtensions: [".clpp", ".clh"], command: "cluaupp language --legacy" },
+			};
+			console.log(JSON.stringify(manifest, null, "\t"));
 		} catch (err) {
 			console.error(err instanceof Error ? err.message : err);
 			process.exit(1);

package/src/clpp/contract.ts

@@ -1,4 +1,4 @@
-/** Stable CL++ ↔ Cluaupp contract (CL++ 0.8.x). Cluaupp invokes the `clpp` binary. */
+/** Legacy adapter policy for CL++ 0.8.x. Requires an upstream compiler implementing the handshake. */
 
 export interface CompileRequest {
 	source: string;
@@ -21,6 +21,10 @@ export interface CompileRequest {
 
 export interface CompileDiagnostic {
 	message: string;
+	code?: string;
+	help?: string;
+	endLine?: number;
+	endColumn?: number;
 	/** 1-based */
 	line: number;
 	/** 1-based */
@@ -36,6 +40,14 @@ export interface ModuleRequireEntry {
 	toFile?: string;
 }
 
+export interface SourceMapLine {
+	luauLine: number;
+	clppLine: number;
+	file: string;
+	luauColumn?: number;
+	clppColumn?: number;
+}
+
 export interface CompileArtifact {
 	ok: boolean;
 	luau: string;
@@ -48,7 +60,7 @@ export interface CompileArtifact {
 	libraries: string[];
 	error?: string;
 	diagnostics?: CompileDiagnostic[];
-	sourceMap?: Array<{ luauLine: number; clppLine: number; file: string }>;
+	sourceMap?: SourceMapLine[];
 	/** Named `import` / quoted include requires from CL++ (RFC 0003). */
 	requires?: ModuleRequireEntry[];
 	/** Selective @native candidates (RFC 0011). Not auto-applied as blanket. */
@@ -62,6 +74,8 @@ export interface CompileArtifact {
 }
 
 export interface LanguageManifest {
+	/** Explicit host protocol handshake; a VM manifest is not compatible. */
+	contractVersion: number;
 	name: "CL++";
 	id: "clpp";
 	version: string;
@@ -77,6 +91,9 @@ export interface LanguageManifest {
 }
 
 export const MIN_CLPP_VERSION = "0.8.0";
+export const MAX_CLPP_VERSION_EXCLUSIVE = "0.9.0";
+export const CLPP_VERSION_RANGE = ">=0.8.0 <0.9.0";
+export const CLPP_CONTRACT_VERSION = 1;
 
 export const CLPP_INSTALL_HINT =
-	"Install CL++ 0.8.0+ (`clpp` from https://github.com/KartzRbx/CLPP/releases). Put it on PATH. Prefer `import { Name } from \"./x.clh\"` for language modules; angle `#include <clpp/…>` stays for host prelude. Override with CLPP or CLPP_PATH.";
+	"Install the legacy Luau compiler >=0.8.0 <0.9.0 with contractVersion 1 (the CL++ VM is incompatible) (`clpp` from https://github.com/KartzRbx/CLPP/releases). Put it on PATH. Prefer `import { Name } from \"./x.clh\"` for language modules; angle `#include <clpp/…>` stays for host prelude. Override with CLPP or CLPP_PATH.";

package/src/clpp/handshake.ts

@@ -0,0 +1,25 @@
+import { CLPP_CONTRACT_VERSION, CLPP_VERSION_RANGE, MIN_CLPP_VERSION, MAX_CLPP_VERSION_EXCLUSIVE, type LanguageManifest } from "./contract.js";
+
+export function parseCompilerVersion(text: string): number[] | null {
+ const m = /^(?:clpp\s+|CL\+\+\s+)?(\d+)\.(\d+)\.(\d+)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/i.exec(text.trim());
+ return m ? m.slice(1, 4).map(Number) : null;
+}
+function compare(a: number[], b: number[]): number {
+ return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+export function acceptsCompilerVersion(text: string): boolean {
+ const v = parseCompilerVersion(text);
+ return !!v && compare(v, parseCompilerVersion(MIN_CLPP_VERSION)!) >= 0 && compare(v, parseCompilerVersion(MAX_CLPP_VERSION_EXCLUSIVE)!) < 0;
+}
+export function validateCompilerHandshake(version: string, value: unknown): LanguageManifest {
+ const fail = (reason: string): never => {throw new Error(`cluaupp: incompatible clpp (${version || "unknown"}): ${reason}. Require Luau compiler ${CLPP_VERSION_RANGE}, contractVersion ${CLPP_CONTRACT_VERSION}. The clpp game VM cannot emit Roblox Luau. Set CLPP or CLPP_PATH to the Luau compiler.`);};
+ if (!acceptsCompilerVersion(version)) fail("unsupported version");
+ if (!value || typeof value !== "object") fail("missing api manifest");
+ const m = value as LanguageManifest;
+ if (m.id !== "clpp" || m.name !== "CL++") fail("wrong compiler identity");
+ if (m.contractVersion !== CLPP_CONTRACT_VERSION) fail("missing or unsupported contractVersion");
+ if (!acceptsCompilerVersion(m.version) || compare(parseCompilerVersion(version)!, parseCompilerVersion(m.version)!) !== 0) fail("binary and manifest versions disagree");
+ if (!Array.isArray(m.extensions) || ![".clpp", ".clp", ".clh"].every(x => m.extensions.includes(x))) fail("missing source extensions");
+ if (!Array.isArray(m.tags) || ![["*.server.clpp", "server", "Script"], ["*.client.clpp", "client", "LocalScript"], ["*.clh", "header", "ModuleScript"]].every(([pattern, kind, cls]) => m.tags.some(t => t.pattern === pattern && t.scriptKind === kind && t.rojoClass === cls))) fail("missing Roblox file tags");
+ return m;
+}

package/src/clpp/modules.ts

@@ -150,7 +150,7 @@ export function resolveLanguageDeps(source: string, fromFile: string, srcDir?: s
 }
 
 /**
- * Fingerprint source + one-hop language deps so import/include edits invalidate incremental cache.
+ * Fingerprint source + transitive language deps so import/include edits invalidate incremental cache.
  */
 export function fingerprintSourceWithDeps(
 	source: string,
@@ -159,15 +159,22 @@ export function fingerprintSourceWithDeps(
 	srcDir: string | undefined,
 	hashText: (text: string) => string,
 ): string {
-	const parts = [configKey, source];
-	for (const dep of resolveLanguageDeps(source, fromFile, srcDir)) {
-		try {
-			parts.push(`\n//dep:${dep.replace(/\\/g, "/")}\n`);
-			parts.push(fs.readFileSync(dep, "utf8"));
-		} catch {
-			parts.push(`\n//dep-missing:${dep.replace(/\\/g, "/")}\n`);
-		}
-	}
+ const parts = [configKey, source];
+ const seen = new Set<string>([path.resolve(fromFile)]);
+ const visit = (text: string, file: string) => {
+  for (const ref of collectModuleRefs(text)) {
+   if (ref.angled) continue;
+   const dep = resolveModuleFile(ref.modulePath, file, srcDir);
+   if (!dep) {parts.push("\n//missing:" + file + ":" + ref.modulePath); continue;}
+   const key = path.resolve(dep);
+   if (seen.has(key)) continue;
+   seen.add(key);
+   const contents = fs.readFileSync(key, "utf8");
+   parts.push("\n//dep:" + key.replace(/\\/g, "/") + "\n", contents);
+   visit(contents, key);
+  }
+ };
+ visit(source, fromFile);
 	return hashText(parts.join(""));
 }
 

package/src/clpp/runner.ts

@@ -4,47 +4,66 @@ import os from "node:os";
 import path from "node:path";
 import {
 	CLPP_INSTALL_HINT,
-	MIN_CLPP_VERSION,
 	type CompileArtifact,
 	type CompileDiagnostic,
 	type CompileRequest,
 	type LanguageManifest,
 } from "./contract.js";
 
+import { acceptsCompilerVersion, validateCompilerHandshake } from "./handshake.js";
+
 const MISSING_CLPP = `cluaupp: clpp not found. ${CLPP_INSTALL_HINT}`;
 
 type Semver = { major: number; minor: number; patch: number };
 
 let cachedBin: string | null | undefined;
+let cachedSelectionKey = "";
+const contractSupport = new Map<string, LanguageManifest>();
+
+function binaryKey(bin: string): string {
+	const stat = fs.statSync(bin);
+	return JSON.stringify([bin, stat.size, stat.mtimeMs]);
+}
 
 function parseSemver(text: string): Semver | null {
-	const match = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+	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]) };
+	return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3] || 0) };
 }
 
 function cmpSemver(a: Semver, b: Semver): number {
 	return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
 }
 
-function minClpp(): Semver {
-	return parseSemver(MIN_CLPP_VERSION) || { major: 0, minor: 8, patch: 0 };
-}
-
-function tooOldMessage(bin: string, version: string | null): string {
-	return `cluaupp: clpp ${version || "unknown"} is too old (${bin}). Need CL++ ${MIN_CLPP_VERSION}+. Install https://github.com/KartzRbx/CLPP/releases or set CLPP / CLPP_PATH.`;
-}
-
 function probeVersion(bin: string): string | null {
-	const result = spawnSync(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+	const result = spawnSync(bin, ["--version"], { encoding: "utf8", windowsHide: true, timeout: 10_000 });
 	if (result.status !== 0) {
 		return null;
 	}
 	return String(result.stdout || result.stderr || "").trim() || null;
 }
 
+function handshake(bin: string): LanguageManifest {
+ const key = binaryKey(bin);
+ const cached = contractSupport.get(key);
+ if (cached) return cached;
+ const version = probeVersion(bin) || "";
+ let manifest: unknown;
+ // Reject the VM before asking it to compile or interpret any input.
+ if (acceptsCompilerVersion(version)) {
+  const result = spawnSync(bin, ["api", "manifest"], { encoding: "utf8", windowsHide: true, timeout: 10_000 });
+  if (result.status === 0) {try {manifest = JSON.parse(String(result.stdout || ""));} catch {}}
+ }
+ const validated = validateCompilerHandshake(version, manifest);
+ contractSupport.set(key, validated);
+ return validated;
+}
+function supportsLuauContract(bin: string): boolean {
+ try {handshake(bin); return true;} catch {return false;}
+}
+
 function pushCandidate(out: string[], seen: Set<string>, item: string | undefined): void {
 	const value = String(item || "").trim();
 	if (!value) {
@@ -71,9 +90,11 @@ function listClppCandidates(): string[] {
 	const override: string[] = [];
 	pushCandidate(override, seen, process.env.CLPP);
 	pushCandidate(override, seen, process.env.CLPP_PATH);
-	const overrideExisting = override.filter(existsBin);
-	if (overrideExisting.length > 0) {
-		return overrideExisting;
+	if (override.length > 0) {
+		for (const bin of override) {
+			if (!existsBin(bin)) throw new Error(`cluaupp: explicit CLPP/CLPP_PATH does not exist: ${bin}`);
+		}
+		return override;
 	}
 
 	const out: string[] = [];
@@ -106,7 +127,7 @@ function pickClppBinary(): string | null {
 		if (!fallback) {
 			fallback = bin;
 		}
-		if (!parsed) {
+		if (!parsed || !supportsLuauContract(bin)) {
 			continue;
 		}
 		if (!best || cmpSemver(parsed, best.parsed) > 0) {
@@ -117,9 +138,11 @@ function pickClppBinary(): string | null {
 }
 
 function whichClpp(): string | null {
-	if (cachedBin !== undefined) {
+	const selectionKey = JSON.stringify([process.env.CLPP, process.env.CLPP_PATH, process.env.PATH]);
+	if (cachedBin !== undefined && selectionKey === cachedSelectionKey) {
 		return cachedBin;
 	}
+	cachedSelectionKey = selectionKey;
 	cachedBin = pickClppBinary();
 	return cachedBin;
 }
@@ -133,11 +156,7 @@ export function resolveClppBinary(): string {
 	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));
-	}
+	handshake(bin);
 	return bin;
 }
 
@@ -145,7 +164,7 @@ function parseArtifact(stdout: string, fileName: string, fallbackError: string):
 	const text = String(stdout || "").trim();
 	try {
 		const parsed = JSON.parse(text) as CompileArtifact;
-		if (parsed && typeof parsed === "object") {
+		if (parsed && typeof parsed === "object" && typeof parsed.ok === "boolean" && typeof parsed.luau === "string" && typeof parsed.fileName === "string") {
 			return parsed;
 		}
 	} catch {
@@ -171,7 +190,7 @@ export function formatClppFailure(artifact: CompileArtifact, fallback: string):
 		return diags
 			.map((d: CompileDiagnostic) => {
 				const where = `${artifact.fileName || "clpp"}:${d.line}:${d.column}`;
-				return `${where}: ${d.message}`;
+				return `${where}: ${d.severity}${d.code ? " [" + d.code + "]" : ""}: ${d.message}${d.help ? "\n  " + d.help : ""}`;
 			})
 			.join("\n");
 	}
@@ -200,7 +219,7 @@ export function compileViaClpp(request: CompileRequest): CompileArtifact {
 	});
 	const stderr = String(result.stderr || "").trim();
 	const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
-	if (!artifact.ok) {
+	if (result.status !== 0 || result.error || !artifact.ok) {
 		throw new Error(formatClppFailure(artifact, stderr || result.error?.message || `clpp failed (${result.status})`));
 	}
 	return artifact;
@@ -232,7 +251,7 @@ export function compileViaClppAsync(request: CompileRequest): Promise<CompileArt
 		child.on("error", reject);
 		child.on("close", (code) => {
 			const artifact = parseArtifact(stdout, request.fileName, stderr.trim() || `clpp api compile failed (${code})`);
-			if (!artifact.ok) {
+			if (code !== 0 || !artifact.ok) {
 				reject(new Error(formatClppFailure(artifact, stderr.trim() || `clpp failed (${code})`)));
 				return;
 			}
@@ -256,14 +275,7 @@ export function compileViaClppAsync(request: CompileRequest): Promise<CompileArt
 
 export function clppManifest(): LanguageManifest {
 	const bin = resolveClppBinary();
-	const result = 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) as LanguageManifest;
+	return handshake(bin);
 }
 
 export function clppVersion(): string | null {
@@ -282,3 +294,9 @@ export function clppInstalls(): Array<{ bin: string; version: string | null; sel
 		selected: bin === selected,
 	}));
 }
+
+/** Include the actual binary and handshake in incremental fingerprints. */
+export function clppCacheIdentity(): string {
+ const bin = resolveClppBinary();
+ return JSON.stringify([binaryKey(bin), handshake(bin)]);
+}

package/src/compile.ts

@@ -5,7 +5,7 @@ import { compileViaClpp, compileViaClppAsync } from "./clpp/runner.js";
 import { clppLuauToGame, shouldSkipInit } from "./clpp/postprocess.js";
 import { emitKind, siblingHeader, toLuauPath } from "./clpp/paths.js";
 import type { CompileArtifact } from "./clpp/contract.js";
-import { projectRoot } from "./package-info.js";
+import { pkg, projectRoot } from "./package-info.js";
 import { runContextFromFileName } from "./target/roblox.js";
 import { capabilityProfilePath, writeCapabilityProfile, loadCapabilityProfile } from "./target/capability-profile.js";
 import { assertContextSafe, listContextWarnings, formatContextViolations } from "./target/context-check.js";
@@ -15,6 +15,8 @@ import { writeDatamodelArtifacts } from "./target/datamodel-generate.js";
 import { assertParallelSafe } from "./target/parallel-check.js";
 import { assertAuthoritySafe, loadPlatformPolicy } from "./target/authority-check.js";
 import { assertGetServiceSafe } from "./target/get-service.js";
+import { compileSource as compileRobloxClp } from "./compiler/project.js";
+import { formatDiagnostic } from "./compiler/diagnostics.js";
 
 function defaultTargetProfilePath(): string | undefined {
 	const cached = path.join(projectRoot, "api", "normalized", "roblox-target.profile.json");
@@ -130,7 +132,7 @@ function finishArtifact(
 	return {
 		kind: emitKind(relative),
 		plan: { kind: emitKind(relative), strict: options.strict === true },
-		files: [{ name: outName, contents: luau }],
+		files: [{ name: outName, contents: luau, sourceMap: artifact.sourceMap, generatedSource: artifact.luau }],
 		stale: [],
 	};
 }
@@ -140,6 +142,9 @@ export function compileSource(source: string, fileName?: string, options: Compil
 }
 
 export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
+	if (/\.clp$/i.test(options.relativeName || fileName || "")) {
+		return compileModernSource(source, fileName, options);
+	}
 	const args = compileArgs(source, fileName, options);
 	enforcePlatform(source, args.relative, args);
 	const artifact = compileViaClpp(args.request);
@@ -147,8 +152,21 @@ export function compileService(source: string, fileName?: string, options: Compi
 }
 
 export async function compileServiceAsync(source: string, fileName?: string, options: CompileOptions = {}): Promise<CompileServiceResult> {
+	if (/\.clp$/i.test(options.relativeName || fileName || "")) {
+		return compileModernSource(source, fileName, options);
+	}
 	const args = compileArgs(source, fileName, options);
 	enforcePlatform(source, args.relative, args);
 	const artifact = await compileViaClppAsync(args.request);
 	return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit, source);
 }
+
+function compileModernSource(source: string, fileName: string | undefined, options: CompileOptions): CompileServiceResult {
+	const relative = (options.relativeName || fileName || "input.clp").replace(/\\/g, "/");
+	const srcDir = options.srcDir || (options.filePath ? path.dirname(path.resolve(options.filePath)) : process.cwd());
+	const result = compileRobloxClp(source, relative, { srcDir, strict: options.strict === true, version: pkg.version });
+	if (result.luau === null) {
+		throw new Error(result.diagnostics.filter((d) => d.severity === "error").map((d) => formatDiagnostic(d, result.source)).join("\n") || `${relative}: Luau emission failed`);
+	}
+	return { kind: emitKind(relative), files: [{ name: options.outName || toLuauPath(relative), contents: result.luau, sourceMap: result.sourceMap, generatedSource: result.luau }], stale: [] };
+}