cluaupp 1.5.2 → 2.0.0-beta.2

package/src/target/datamodel-generate.ts

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import type { DatamodelNode, DatamodelProfile } from "./datamodel.js";
 import { buildDatamodelProfile } from "./datamodel.js";
+import { collectSources } from "../clpp/paths.js";
 
 function safeIdent(name: string): string {
 	const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
@@ -58,7 +59,7 @@ export function profileWithoutIndex(profile: DatamodelProfile): Omit<DatamodelPr
 export function writeDatamodelArtifacts(
 	projectRoot: string,
 	opts?: { projectJson?: string; outDir?: string; headerPath?: string },
-): { profile: DatamodelProfile; profilePath: string; headerPath: string } | null {
+): { profile: DatamodelProfile; profilePath: string; headerPath: string | null } | null {
 	const profile = buildDatamodelProfile(projectRoot, opts?.projectJson);
 	if (!profile) {
 		return null;
@@ -68,6 +69,16 @@ export function writeDatamodelArtifacts(
 	const profilePath = path.join(outDir, "datamodel-profile.json");
 	fs.writeFileSync(profilePath, JSON.stringify(profileWithoutIndex(profile), null, "\t") + "\n", "utf8");
 
+	let sourceRoot = "src";
+	const configPath = path.join(projectRoot, "cluaupp.config.json");
+	if (fs.existsSync(configPath)) {
+		const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+		if (typeof config.rootDir === "string") sourceRoot = config.rootDir;
+	}
+	const sources = collectSources(path.resolve(projectRoot, sourceRoot));
+	const modern = sources.some(file => /\.clp$/i.test(file)) && !sources.some(file => /\.clpp$/i.test(file));
+	if (modern && !opts?.headerPath) return { profile, profilePath, headerPath: null };
+
 	const headerPath =
 		opts?.headerPath ||
 		path.join(projectRoot, "include", "clpp", "generated", "datamodel.clh");

package/src/target/gen-rojo-tree.ts

@@ -101,6 +101,21 @@ export function buildRojoTree(root: string, rootDir: string, outDir: string): Ro
 	const sourceRoot = fs.existsSync(outRoot) ? outRoot : srcRoot;
 	const tree = baseTree();
 	const relRoot = path.relative(root, sourceRoot).replace(/\\/g, "/");
+	const projectSources = walkFiles(srcRoot);
+	const modernOnly = projectSources.some((file) => /\.clp$/i.test(file)) && !projectSources.some((file) => /\.(clpp|clh)$/i.test(file));
+	if (modernOnly) {
+		for (const service of ["ServerScriptService", "ServerStorage", "ReplicatedStorage", "ReplicatedFirst", "Workspace", "StarterGui", "StarterPack", "Lighting", "SoundService", "Teams"]) {
+			if (projectSources.some((file) => path.relative(srcRoot, file).replace(/\\/g, "/").startsWith(`${service}/`))) {
+				withPath(ensureNode(tree, [service]), `${outDir}/${service}`);
+			}
+		}
+		for (const nested of ["StarterPlayerScripts", "StarterCharacterScripts"]) {
+			if (projectSources.some((file) => path.relative(srcRoot, file).replace(/\\/g, "/").startsWith(`StarterPlayer/${nested}/`))) {
+				withPath(ensureNode(tree, ["StarterPlayer", nested]), `${outDir}/StarterPlayer/${nested}`);
+			}
+		}
+		return tree;
+	}
 
 	withPath(ensureNode(tree, ["ServerScriptService"]), `${relRoot}/Server`);
 	withPath(ensureNode(tree, ["ServerScriptService", "Parallel"]), `${relRoot}/Parallel`);

package/src/target/source-map.ts

@@ -1,36 +1,74 @@
-/** Minimal source map: CL++ path ↔ emitted Luau (1:1 file mapping for v1). */
+/** Compiler coordinates are retained only for lines that survive host transformations. */
 import fs from "node:fs";
 import path from "node:path";
+import type { SourceMapLine } from "../clpp/contract.js";
 
 export interface CluauppSourceMap {
-	version: 1;
-	file: string;
-	sourceRoot: string;
-	sources: string[];
-	mappings: string;
-	cluaupp: {
-		source: string;
-		generated: string;
-	};
+ version: 1;
+ file: string;
+ sourceRoot: string;
+ sources: string[];
+ cluaupp: { source: string; generated: string; lines: SourceMapLine[] };
+}
+
+/** LCS alignment: inserted headers and removed lines never become fake source locations. */
+export function remapSourceLines(original: string, generated: string, mappings: SourceMapLine[] = []): SourceMapLine[] {
+ const a = original.split(/\r?\n/);
+ const b = generated.split(/\r?\n/);
+ if (original === generated) return mappings.map(m => ({...m}));
+ // Avoid unbounded memory for generated bundles. An absent map is safer than a wrong one.
+ if (a.length * b.length > 4_000_000) return [];
+ const widths = b.length + 1;
+ const dp = new Uint32Array((a.length + 1) * widths);
+ for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) {
+  dp[i * widths + j] = a[i].trim() === b[j].trim() ? 1 + dp[(i+1)*widths+j+1] : Math.max(dp[(i+1)*widths+j], dp[i*widths+j+1]);
+ }
+ const translated = new Map<number, number>();
+ let i = 0, j = 0;
+ while (i < a.length && j < b.length) {
+  if (a[i].trim() === b[j].trim()) {translated.set(i+1, j+1); i++; j++;}
+  else if (dp[(i+1)*widths+j] >= dp[i*widths+j+1]) i++;
+  else j++;
+ }
+ return mappings.flatMap(m => {
+  const line = translated.get(m.luauLine);
+  if (!line || !Number.isInteger(m.clppLine) || m.clppLine < 1) return [];
+  // Formatting can move columns; do not invent a column in that case.
+  const exact = a[m.luauLine-1] === b[line-1];
+  const {luauColumn, ...rest} = m;
+  return [{...rest, luauLine: line, ...(exact && luauColumn ? {luauColumn} : {})}];
+ });
+}
+
+export function embedSourceMap(luau: string, lines: SourceMapLine[]): { contents: string; lines: SourceMapLine[] } {
+ if (!lines.length) return {contents: luau, lines: []};
+ const shifted = lines.map(m => ({...m, luauLine: m.luauLine+1}));
+ // Preserve Luau directives at the start of the file.
+ const parts = luau.split(/\r?\n/);
+ let index = 0;
+ while (index < parts.length && parts[index].startsWith("--!")) index++;
+ const adjusted = shifted.map((m, i) => ({...m, luauLine: lines[i].luauLine > index ? m.luauLine : lines[i].luauLine}));
+ parts.splice(index, 0, "-- cluaupp-map: " + JSON.stringify(adjusted));
+ return {contents: parts.join("\n"), lines: adjusted};
 }
 
 export function writeSourceMap(opts: {
-	outLuauPath: string;
-	sourceClppRel: string;
-	projectRoot: string;
+ outLuauPath: string;
+ sourceClppRel: string;
+ projectRoot: string;
+ lines?: SourceMapLine[];
 }): string {
-	const map: CluauppSourceMap = {
-		version: 1,
-		file: path.basename(opts.outLuauPath),
-		sourceRoot: opts.projectRoot.replace(/\\/g, "/"),
-		sources: [opts.sourceClppRel.replace(/\\/g, "/")],
-		mappings: "AAAA", // identity stub — refine when clpp emits VLQ maps
-		cluaupp: {
-			source: opts.sourceClppRel.replace(/\\/g, "/"),
-			generated: path.relative(opts.projectRoot, opts.outLuauPath).replace(/\\/g, "/"),
-		},
-	};
-	const mapPath = opts.outLuauPath + ".map.json";
-	fs.writeFileSync(mapPath, JSON.stringify(map, null, "\t") + "\n", "utf8");
-	return mapPath;
+ const lines = opts.lines || [];
+ const source = opts.sourceClppRel.replace(/\\/g, "/");
+ const map: CluauppSourceMap = {
+  version: 1,
+  file: path.basename(opts.outLuauPath),
+  sourceRoot: opts.projectRoot.replace(/\\/g, "/"),
+  sources: [...new Set([source, ...lines.map(m => m.file)])],
+  cluaupp: { source, generated: path.relative(opts.projectRoot, opts.outLuauPath).replace(/\\/g, "/"), lines },
+ };
+ const mapPath = opts.outLuauPath + ".map.json";
+ const contents = JSON.stringify(map, null, "\t") + "\n";
+ if (!fs.existsSync(mapPath) || fs.readFileSync(mapPath, "utf8") !== contents) fs.writeFileSync(mapPath, contents, "utf8");
+ return mapPath;
 }

package/src/target/studio-bridge.ts

@@ -16,6 +16,7 @@ export interface BridgeEvent {
 	type: "open" | "select" | "error" | "ping";
 	path?: string;
 	line?: number;
+	column?: number;
 	message?: string;
 	instancePath?: string;
 }
@@ -86,6 +87,7 @@ export function startStudioBridge(opts: {
 					const data = JSON.parse(body || "{}") as {
 						path?: string;
 						line?: number;
+						column?: number;
 						instancePath?: string;
 						type?: BridgeEvent["type"];
 						message?: string;
@@ -106,6 +108,7 @@ export function startStudioBridge(opts: {
 						type: data.type || "open",
 						path: rel || undefined,
 						line: data.line,
+						column: data.column,
 						instancePath: data.instancePath,
 						message: data.message,
 					});

package/src/types.ts

@@ -78,6 +78,9 @@ export interface BuildResult {
 export interface CompiledArtifact {
 	name: string;
 	contents: string;
+	/** Compiler coordinates before host output transforms. */
+	sourceMap?: import("./clpp/contract.js").SourceMapLine[];
+	generatedSource?: string;
 }
 
 export interface CompileServiceResult {

package/src/utils/project.ts

@@ -1,17 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { BuildOptions, BuildResult, ProjectConfig } from "../types.js";
-import { pkg } from "../package-info.js";
+import { pkg, projectRoot as toolRoot } from "../package-info.js";
+import { clppCacheIdentity } from "../clpp/runner.js";
+import type { CompiledArtifact } from "../types.js";
 import { rewriteClppEmit } from "../clpp/postprocess.js";
 import { collectSources, toLuauPath } from "../clpp/paths.js";
 import { collectFlareFiles, compileFlareFile } from "../flare/index.js";
 import { collectNativeSchemaFiles, compileNativeSchemaFile } from "../native/index.js";
-import { installEditorExtension, syncEditorSupport } from "../intellisense.js";
+import { syncEditorSupport } from "../intellisense.js";
 import { ProcessOrchestrator } from "./process-orchestrator.js";
 import { RojoMapper } from "./rojo-mapper.js";
 import { transpileSource, transpileSourceAsync } from "../transpile.js";
 import { assertInitDest, assertInside, isInside, safeProjectSubdir, safeRelPath } from "./safe-paths.js";
-import { writeSourceMap } from "../target/source-map.js";
+import { writeSourceMap, remapSourceLines, embedSourceMap } from "../target/source-map.js";
 import { stampLuauFromClpp } from "../target/luau-stamp.js";
 import { collectSoaPlansFromProject, writeSoaArtifacts } from "../target/optimizer-soa.js";
 import { verifyLock } from "../api/index.js";
@@ -28,6 +30,8 @@ import {
 	writeCachedJob,
 } from "../target/build-cache.js";
 import { fingerprintSourceWithDeps } from "../clpp/modules.js";
+import { ProjectCompiler } from "../compiler/project.js";
+import { formatDiagnostic } from "../compiler/diagnostics.js";
 
 function readProjectConfig(file: string): Partial<ProjectConfig> {
 	const raw = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -334,8 +338,13 @@ function compileOptions(root: string, config: ProjectConfig, file: string, rel:
 	};
 }
 
+function needsLegacyHeaders(srcDir: string): boolean {
+	const sources = collectSources(srcDir);
+	return sources.some(file => /\.clpp$/i.test(file)) || !sources.some(file => /\.clp$/i.test(file));
+}
+
 function compileSchemaJobs(root: string, config: ProjectConfig, srcDir: string) {
-	const jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }> = [];
+	const jobs: Array<{ rel: string; files: CompiledArtifact[]; stale: string[] }> = [];
 	const errors: Array<{ rel: string; prefixes: string[]; message: string }> = [];
 	const flare = compileFlareJobs(root, config, srcDir);
 	jobs.push(...flare.jobs);
@@ -348,7 +357,7 @@ function compileSchemaJobs(root: string, config: ProjectConfig, srcDir: string)
 			if (!isInside(path.resolve(root, config.rootDir), headerDest) && !isInside(srcDir, headerDest)) {
 				throw new Error(`cluaupp schema: skip unsafe header ${emit.headerRel}`);
 			}
-			writeTextIfChanged(headerDest, emit.header);
+			if (needsLegacyHeaders(srcDir)) writeTextIfChanged(headerDest, emit.header);
 			jobs.push({
 				rel,
 				files: [{ name: emit.luauRel, contents: emit.luau }],
@@ -366,7 +375,7 @@ function compileSchemaJobs(root: string, config: ProjectConfig, srcDir: string)
 }
 
 function compileFlareJobs(root: string, config: ProjectConfig, srcDir: string) {
-	const jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }> = [];
+	const jobs: Array<{ rel: string; files: CompiledArtifact[]; stale: string[] }> = [];
 	const errors: Array<{ rel: string; prefixes: string[]; message: string }> = [];
 	for (const file of collectFlareFiles(srcDir)) {
 		const rel = posixRel(srcDir, file);
@@ -376,7 +385,7 @@ function compileFlareJobs(root: string, config: ProjectConfig, srcDir: string) {
 			if (!isInside(path.resolve(root, config.rootDir), headerDest) && !isInside(srcDir, headerDest)) {
 				throw new Error(`cluaupp flare: skip unsafe header ${emit.headerRel}`);
 			}
-			writeTextIfChanged(headerDest, emit.header);
+			if (needsLegacyHeaders(srcDir)) writeTextIfChanged(headerDest, emit.header);
 			jobs.push({
 				rel,
 				files: [{ name: emit.luauRel, contents: emit.luau }],
@@ -389,27 +398,58 @@ function compileFlareJobs(root: string, config: ProjectConfig, srcDir: string) {
 	return { jobs, errors };
 }
 
-function configFingerprint(config: ProjectConfig): string {
+function configFingerprint(root: string, config: ProjectConfig, rojoPath?: string): string {
+	const inputs = [path.resolve(root, rojoPath || "default.project.json"), path.join(root, "cluaupp.platform.json"), path.join(root, "cluaupp.profile.json"), path.join(toolRoot, "api", "normalized", "roblox-target.profile.json"), path.join(toolRoot, "api", "generated", "capability-profile.json"), path.join(toolRoot, "api", "roblox-api.lock.json")];
 	return JSON.stringify({
 		strict: config.strict === true,
 		architecture: config.architecture === true,
 		rootDir: config.rootDir,
 		outDir: config.outDir,
 		v: pkg.version,
+		rules: config.rules,
+		components: config.components,
+		inputs: inputs.map(file => [file, fs.existsSync(file) ? hashText(fs.readFileSync(file, "utf8")) : null]),
 	});
 }
 
+function compileClpJobs(root: string, config: ProjectConfig, srcDir: string) {
+	const compiler = new ProjectCompiler({ root, srcDir, strict: config.strict === true, version: pkg.version });
+	const jobs: Array<{ rel: string; files: CompiledArtifact[]; stale: string[] }> = [];
+	const errors: Array<{ rel: string; prefixes: string[]; message: string }> = [];
+	for (const result of compiler.compileAll()) {
+		if (result.luau === null) {
+			const diagnostics = result.diagnostics.filter((d) => d.severity === "error");
+			errors.push({
+				rel: result.rel,
+				prefixes: sourcePrefixes(result.rel),
+				message: diagnostics.map((d) => formatDiagnostic(d, result.source)).join("\n") || `${result.rel}: Luau emission failed`,
+			});
+			continue;
+		}
+		jobs.push({ rel: result.rel, files: [{ name: result.outRel, contents: result.luau, sourceMap: result.sourceMap, generatedSource: result.luau }], stale: [] });
+	}
+	return { jobs, errors };
+}
+
 function compileProject(root: string, config: ProjectConfig, mapper: RojoMapper, options: BuildOptions = {}) {
 	const srcDir = path.join(root, config.rootDir);
 	const schema = compileSchemaJobs(root, config, srcDir);
 	const files = collectSources(srcDir);
-	const jobs = [...schema.jobs];
-	const errors = [...schema.errors];
+	const legacyFiles = files.filter((file) => !file.toLowerCase().endsWith(".clp"));
+	const clp = compileClpJobs(root, config, srcDir);
+	const jobs = [...schema.jobs, ...clp.jobs];
+	const errors = [...schema.errors, ...clp.errors];
 	const incremental = options.incremental !== false;
-	const cfgKey = configFingerprint(config);
+	let cfgKey = configFingerprint(root, config, options.rojo);
+	if (legacyFiles.length) {
+		try {cfgKey += clppCacheIdentity();} catch (err) {
+			for (const file of legacyFiles) {const rel = posixRel(srcDir, file); errors.push({rel, prefixes: sourcePrefixes(rel), message: (err as Error).message});}
+			return {files, jobs, errors};
+		}
+	}
 	let cacheHits = 0;
 
-	for (const file of files) {
+	for (const file of legacyFiles) {
 		const source = fs.readFileSync(file, "utf8");
 		const rel = posixRel(srcDir, file);
 		const sourceHash = fingerprintSourceWithDeps(source, file, cfgKey, srcDir, hashText);
@@ -438,7 +478,7 @@ function compileProject(root: string, config: ProjectConfig, mapper: RojoMapper,
 	}
 
 	if (cacheHits > 0) {
-		console.log(`cluaupp: incremental cache hit ${cacheHits}/${files.length}`);
+		console.log(`cluaupp: incremental cache hit ${cacheHits}/${legacyFiles.length}`);
 	}
 	return { files, jobs, errors };
 }
@@ -447,14 +487,22 @@ async function compileProjectAsync(root: string, config: ProjectConfig, mapper:
 	const srcDir = path.join(root, config.rootDir);
 	const schema = compileSchemaJobs(root, config, srcDir);
 	const files = collectSources(srcDir);
-	const jobs = [...schema.jobs];
-	const errors = [...schema.errors];
+	const legacyFiles = files.filter((file) => !file.toLowerCase().endsWith(".clp"));
+	const clp = compileClpJobs(root, config, srcDir);
+	const jobs = [...schema.jobs, ...clp.jobs];
+	const errors = [...schema.errors, ...clp.errors];
 	const incremental = options.incremental !== false;
-	const cfgKey = configFingerprint(config);
+	let cfgKey = configFingerprint(root, config, options.rojo);
+	if (legacyFiles.length) {
+		try {cfgKey += clppCacheIdentity();} catch (err) {
+			for (const file of legacyFiles) {const rel = posixRel(srcDir, file); errors.push({rel, prefixes: sourcePrefixes(rel), message: (err as Error).message});}
+			return {files, jobs, errors};
+		}
+	}
 	const concurrency = options.jobs ?? defaultJobCount();
 	let cacheHits = 0;
 
-	const compiled = await mapPool(files, concurrency, async (file) => {
+	const compiled = await mapPool(legacyFiles, concurrency, async (file) => {
 		const source = fs.readFileSync(file, "utf8");
 		const rel = posixRel(srcDir, file);
 		const sourceHash = fingerprintSourceWithDeps(source, file, cfgKey, srcDir, hashText);
@@ -510,8 +558,8 @@ async function compileProjectAsync(root: string, config: ProjectConfig, mapper:
 	}
 
 	if (cacheHits > 0) {
-		console.log(`cluaupp: incremental cache hit ${cacheHits}/${files.length} (jobs=${concurrency})`);
-	} else if (files.length > 1 && concurrency > 1) {
+		console.log(`cluaupp: incremental cache hit ${cacheHits}/${legacyFiles.length} (jobs=${concurrency})`);
+	} else if (legacyFiles.length > 1 && concurrency > 1) {
 		console.log(`cluaupp: parallel compile jobs=${concurrency}`);
 	}
 	return { files, jobs, errors };
@@ -541,7 +589,7 @@ function outDest(root: string, config: ProjectConfig, rel: string): string | nul
 	return dest;
 }
 
-function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }>, format: boolean): Set<string> {
+function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: string; files: CompiledArtifact[]; stale: string[] }>, format: boolean): Set<string> {
 	const written = new Set<string>();
 	for (const job of jobs) {
 		for (const artifact of job.files) {
@@ -553,7 +601,18 @@ function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: strin
 			if (/\.luau$/i.test(dest)) {
 				const srcFile = path.join(root, config.rootDir, job.rel);
 				const clppSource = fs.existsSync(srcFile) ? fs.readFileSync(srcFile, "utf8") : undefined;
-				contents = stampLuauFromClpp(rewriteClppEmit(contents), job.rel, clppSource);
+				contents = stampLuauFromClpp(/\.clp$/i.test(job.rel) ? contents : rewriteClppEmit(contents), posixRel(root, srcFile), clppSource);
+			}
+			let lines = (artifact.sourceMap || []).map(m => ({...m, file: path.isAbsolute(m.file) ? posixRel(root, m.file) : path.posix.join(config.rootDir.replace(/\\/g, "/"), m.file)}));
+			if (format && /\.luau$/i.test(dest)) {
+				writeTextIfChanged(dest, contents);
+				ProcessOrchestrator.formatWithStyLuaSync(dest);
+				contents = fs.readFileSync(dest, "utf8");
+			}
+			if (/\.luau$/i.test(dest)) {
+				lines = remapSourceLines(artifact.generatedSource || artifact.contents, contents, lines);
+				const embedded = embedSourceMap(contents, lines);
+				contents = embedded.contents; lines = embedded.lines;
 			}
 			const changed = writeTextIfChanged(dest, contents);
 			written.add(resolveKey(dest));
@@ -563,14 +622,12 @@ function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: strin
 			if (/\.luau$/i.test(dest)) {
 				const mapPath = writeSourceMap({
 					outLuauPath: dest,
-					sourceClppRel: job.rel,
+					sourceClppRel: path.posix.join(config.rootDir.replace(/\\/g, "/"), job.rel),
 					projectRoot: root,
+					lines,
 				});
 				written.add(resolveKey(mapPath));
 			}
-			if (format && /\.luau$/i.test(dest)) {
-				ProcessOrchestrator.formatWithStyLuaSync(dest);
-			}
 		}
 		for (const stale of job.stale || []) {
 			const dest = outDest(root, config, stale);
@@ -586,13 +643,16 @@ function writeJobs(root: string, config: ProjectConfig, jobs: Array<{ rel: strin
 
 function ensureVendor(root: string): void {
 	copyRuntime(root);
-	copyHeaders(root);
+	const config = loadConfig(root);
+	if (collectSources(path.join(root, config.rootDir)).some(file => /\.clpp$/i.test(file))) {
+		copyHeaders(root);
+	}
 }
 
 function finishBuild(
 	root: string,
 	config: ProjectConfig,
-	compiled: { jobs: Array<{ rel: string; files: Array<{ name: string; contents: string }>; stale: string[] }>; errors: Array<{ rel: string; prefixes: string[]; message: string }> },
+	compiled: { jobs: Array<{ rel: string; files: CompiledArtifact[]; stale: string[] }>; errors: Array<{ rel: string; prefixes: string[]; message: string }> },
 	options: BuildOptions,
 ): BuildResult {
 	const exitOnError = options.exitOnError !== false;
@@ -726,10 +786,15 @@ export async function buildAsync(root: string, options: BuildOptions = {}): Prom
 
 export async function init(dest: string): Promise<void> {
 	const target = assertInitDest(dest);
-	const template = path.join(__dirname, "..", "..", "templates", "game");
-	const include = path.join(__dirname, "..", "..", "include");
+	if (fs.existsSync(path.join(target, "cluaupp.config.json")) || fs.existsSync(path.join(target, "src"))) {
+		throw new Error("cluaupp init: project already exists; choose a new folder. Existing .clpp/.clh sources require migration, not another init.");
+	}
+	const template = path.join(__dirname, "..", "..", "templates", "game-modern");
 	copyDir(template, target);
-	copyDir(include, path.join(target, "include"));
+	const packageFile = path.join(target, "package.json");
+	const projectPackage = JSON.parse(fs.readFileSync(packageFile, "utf8"));
+	projectPackage.devDependencies = { ...projectPackage.devDependencies, cluaupp: pkg.version };
+	fs.writeFileSync(packageFile, JSON.stringify(projectPackage, null, "\t") + "\n");
 	const skills = path.join(__dirname, "..", "..", "skills");
 	if (fs.existsSync(skills)) {
 		copyDir(skills, path.join(target, ".cursor", "skills"));
@@ -738,16 +803,13 @@ export async function init(dest: string): Promise<void> {
 	const initConfig = loadConfig(target);
 	syncRojoTree(target, initConfig);
 	syncEditorSupport(target);
-	try {
-		installEditorExtension();
-	} catch {
-		// editor homes may be missing in CI
-	}
+	// CL++ 0.10 owns its editor extension; project init only writes associations.
 	console.log("Cluaupp ready in", target);
-	console.log("  clpp install          (CL++ highlighting + IntelliSense)");
+	console.log("  CL++ 0.10 editor extension provides syntax highlighting; Cluaupp compiles Roblox .clp files");
 	console.log("  cluaupp intellisense  (schema .flare .hive .mint .bloom .helm .shift .axiom)");
 	console.log("  rokit install");
-	console.log("  cluaupp build");
+	console.log("  npm install");
+	console.log("  npm run build");
 	console.log("  rojo serve");
 }
 

package/templates/README.md

@@ -0,0 +1,7 @@
+# Project templates
+
+| Template | Use |
+| --- | --- |
+| [`game-modern/`](game-modern/) | **`cluaupp init`** — CL++ 0.10 Roblox target: `src/`, `.clp`, `link`, top-level scripts |
+
+Legacy `.clpp` / `Src/` / `#include` layouts are not scaffolded anymore. For migration, see [migration](https://kartzrbx.github.io/Cluaupp/migration/). Integration tests keep a frozen copy under [`test/fixtures/legacy-clpp-game/`](../test/fixtures/legacy-clpp-game/).

package/templates/{game → game-modern}/cluaupp.config.json

@@ -1,6 +1,6 @@
 {
-	"rootDir": "Src",
+	"rootDir": "src",
 	"outDir": "out",
-	"strict": false,
+	"strict": true,
 	"architecture": false
 }

package/templates/{game → game-modern}/package.json

@@ -3,7 +3,6 @@
 	"private": true,
 	"scripts": {
 		"build": "cluaupp build",
-		"watch": "cluaupp watch",
-		"dev": "cluaupp watch"
+		"watch": "cluaupp watch"
 	}
 }

package/templates/game-modern/rokit.toml

@@ -0,0 +1,2 @@
+[tools]
+rojo = "rojo-rbx/rojo@7.7.0"

package/templates/game-modern/src/ReplicatedStorage/Shared/GameInfo.clp

@@ -0,0 +1 @@
+const GAME_NAME = "My CL++ game";

package/templates/game-modern/src/ServerScriptService/Handlers/Guard.server.clp

@@ -0,0 +1,4 @@
+link @clpp.roblox;
+link @clpp.libs.ward as Ward;
+
+Ward.Start();

package/templates/game-modern/src/ServerScriptService/Main.server.clp

@@ -0,0 +1,8 @@
+link @clpp.roblox;
+link @ReplicatedStorage.Shared.GameInfo as GameInfo;
+
+Players players = GetService<Players>();
+post(GameInfo.GAME_NAME .: " server ready");
+players.PlayerAdded ~> func (Player player) {
+	post(player.Name .: " joined");
+};

package/templates/game-modern/src/StarterPlayer/StarterPlayerScripts/Main.client.clp

@@ -0,0 +1,4 @@
+link @clpp.roblox;
+link @ReplicatedStorage.Shared.GameInfo as GameInfo;
+
+post(GameInfo.GAME_NAME .: " client ready");

package/examples/game/out/ReplicatedStorage/Shared/Constants/Datas/TemplateData.luau

@@ -1,29 +0,0 @@
---!nonstrict
--- cluaupp-source: ReplicatedStorage/Shared/Constants/Datas/TemplateData.clh
--- Compiled by CL++ — C++ × Luau
-
--- cluaupp: Roster.new / GetService ReplicatedStorage / self.janitor
-
-export type PlayerTemplate = {
-	Currencies: Currencies,
-	Rebirths: number,
-	Rank: number,
-	Inventory: PlayerInventory,
-	Trade: PlayerTrade,
-	Settings: PlayerSettings,
-	Codes: PlayerCodes,
-}
-
-const function PlayerTemplate()
-	return {
-		Currencies = { Coins = 0, Gems = 0 },
-		Rebirths = 0,
-		Rank = 0,
-		Inventory = { Slots = 20 },
-		Trade = { DayKey = nil, TradesToday = 0, LastTradeAt = 0, ActiveTradeId = nil },
-		Settings = { GameMusic = 100, Effects = 100 },
-		Codes = { RedeemedCount = 0 },
-	}
-end
-
-return PlayerTemplate

package/examples/game/out/ReplicatedStorage/Shared/Constants/Datas/TemplateData.luau.map.json

@@ -1,13 +0,0 @@
-{
-	"version": 1,
-	"file": "TemplateData.luau",
-	"sourceRoot": "C:/Users/gtofr/OneDrive/Documentos/GitHub/Cluaupp/examples/game",
-	"sources": [
-		"ReplicatedStorage/Shared/Constants/Datas/TemplateData.clh"
-	],
-	"mappings": "AAAA",
-	"cluaupp": {
-		"source": "ReplicatedStorage/Shared/Constants/Datas/TemplateData.clh",
-		"generated": "out/ReplicatedStorage/Shared/Constants/Datas/TemplateData.luau"
-	}
-}