cluaupp 1.5.0 → 1.5.2-cf

package/src/clpp/postprocess.ts

@@ -1,6 +1,16 @@
 import { insertPreamble, libraryNamesFromIncludes, MODULES, requireCluauppLib } from "../libs.js";
 import type { CompileArtifact } from "./contract.js";
+import { formatLuauRoblox } from "./format-luau.js";
+import {
+	applyNativeHintsToLuau,
+	ensureGameServices,
+	rewriteGameRootedRequires,
+} from "./modules.js";
+import { rewriteGetServiceLuau } from "../target/get-service.js";
 import { isTaggedScript } from "./paths.js";
+import { rewriteSweepJanitor } from "./rewrite-janitor.js";
+
+export { formatLuauRoblox } from "./format-luau.js";
 
 export type PostprocessOptions = {
 	relativeName: string;
@@ -10,6 +20,8 @@ export type PostprocessOptions = {
 	strict?: boolean;
 	skipInit?: boolean;
 	source?: string;
+	nativeHints?: string[];
+	layoutHints?: string[];
 };
 
 function insertAfterHeader(luau: string, block: string): string {
@@ -62,14 +74,96 @@ function rewriteClppLibs(luau: string, relativeName?: string): string {
 	return next;
 }
 
-function ensureReplicatedStorage(luau: string): string {
-	if (!luau.includes("CluauppLibs")) {
+function rewriteReplicatedStorageRequires(luau: string): string {
+	let next = rewriteGameRootedRequires(luau);
+	next = ensureGameServices(next);
+	return next;
+}
+
+function rewriteRosterNew(luau: string): string {
+	return String(luau)
+		.replace(/Instance\.new\(\s*["']Roster["']\s*\)/g, "Roster.new()")
+		.replace(/Instance\.new\(\s*["']Roster["']\s*,/g, "Roster.new(")
+		.replace(/\bRoster\.New\s*\(/g, "Roster.new(")
+		.replace(/\bSweep\.New\s*\(/g, "Sweep.new(")
+		.replace(/\bSpark\.New\s*\(/g, "Spark.new(")
+		.replace(/\bCoil\.New\s*\(/g, "Coil.new(")
+		.replace(/\bPin\.new_\s*\(/g, "Pin.new(")
+		.replace(/\bCrest\.new_\s*\(/g, "Crest.new(")
+		.replace(/\bStage\.new_\s*\(/g, "Stage.new(");
+}
+
+function rewriteCamelColon(luau: string): string {
+	// CL++ emits instance calls as `.Method(` without self. Any camelCase receiver +
+	// PascalCase call needs `:`. Static calls stay on PascalCase modules (Roster.New, Trace.Display).
+	let next = String(luau).replace(
+		/\b([a-z][A-Za-z0-9]*)(?<!:)\.([A-Z][A-Za-z0-9]*)\s*\(/g,
+		"$1:$2(",
+	);
+	const lowerMethods = ["setName", "setLabel", "getStatus", "display", "andThen", "catch_", "finally"];
+	for (const name of lowerMethods) {
+		next = next.replace(new RegExp(`\\b([a-z][A-Za-z0-9]*)(?<!:)\\.${name}\\s*\\(`, "g"), `$1:${name}(`);
+	}
+	return next;
+}
+
+function rewriteHiveWorldType(luau: string): string {
+	if (!/\bHiveWorld\b/.test(luau)) {
 		return luau;
 	}
-	if (/GetService\(\s*"ReplicatedStorage"\s*\)/.test(luau)) {
+	let next = String(luau).replace(/(?<![\w.])HiveWorld\b/g, "Hive.HiveWorld");
+	const hasHive = /CluauppLibs\.Hive\b/.test(next) || /\b(?:const|local)\s+Hive\b/.test(next);
+	if (!hasHive) {
+		next = next.replace(/\bHive\.HiveWorld\b/g, "any");
+	}
+	return next;
+}
+
+function rewriteCFrameColon(luau: string): string {
+	const methods = [
+		"ToWorldSpace",
+		"ToObjectSpace",
+		"PointToWorldSpace",
+		"PointToObjectSpace",
+		"VectorToWorldSpace",
+		"VectorToObjectSpace",
+		"IsStudio",
+		"IsClient",
+		"IsServer",
+	];
+	let next = String(luau);
+	for (const name of methods) {
+		next = next.replace(new RegExp(`(?<!:)\\.${name}\\s*\\(`, "g"), `:${name}(`);
+	}
+	return next;
+}
+
+function rewritePlayerTemplateCtor(luau: string): string {
+	if (!/const TemplateData = require\(/.test(luau)) {
 		return luau;
 	}
-	return insertAfterHeader(luau, 'const ReplicatedStorage = game:GetService("ReplicatedStorage")');
+	return String(luau).replace(/\bPlayerTemplate\s*\(/g, "TemplateData(");
+}
+
+export function rewriteClppEmit(luau: string): string {
+	let next = rewriteRosterNew(luau);
+	next = rewriteHiveWorldType(next);
+	next = rewriteCFrameColon(next);
+	next = rewriteCamelColon(next);
+	next = rewritePlayerTemplateCtor(next);
+	next = rewriteSweepJanitor(next);
+	next = rewriteGetServiceLuau(next);
+	next = rewriteReplicatedStorageRequires(next);
+	next = ensureReplicatedStorage(next);
+	const stamp = "-- cluaupp: Roster.new / GetService ReplicatedStorage / self.janitor";
+	if (!next.includes(stamp)) {
+		next = insertAfterHeader(next, stamp);
+	}
+	return formatLuauRoblox(next);
+}
+
+function ensureReplicatedStorage(luau: string): string {
+	return ensureGameServices(luau);
 }
 
 function stripInitCall(luau: string): string {
@@ -142,7 +236,8 @@ export function shouldSkipInit(fileName: string, hasSiblingHeader: boolean): boo
 
 export function clppLuauToGame(artifact: CompileArtifact, options: PostprocessOptions): string {
 	let luau = rewriteClppLibs(artifact.luau || "", options.relativeName);
-	luau = ensureReplicatedStorage(luau);
+	luau = rewriteClppEmit(luau);
+	luau = applyNativeHintsToLuau(luau, options.nativeHints || artifact.nativeHints);
 	if (options.skipInit) {
 		luau = stripInitCall(luau);
 	}

package/src/clpp/rewrite-janitor.ts

@@ -0,0 +1,156 @@
+const HEADER =
+	/^(?:const function |function )([A-Za-z0-9_]+)(?::([A-Za-z0-9_]+))?\(([^)]*)\)[^\n]*\n/gm;
+
+const INSTANCE_TYPES = new Set([
+	"Instance",
+	"Part",
+	"BasePart",
+	"Model",
+	"Player",
+	"ScreenGui",
+	"GuiObject",
+	"TextButton",
+	"TextLabel",
+	"ImageLabel",
+	"Frame",
+	"Tool",
+	"Humanoid",
+	"Folder",
+	"ValueBase",
+	"IntValue",
+	"StringValue",
+	"BoolValue",
+]);
+
+type Param = { name: string; type: string };
+
+function parseParams(sig: string): Param[] {
+	const out: Param[] = [];
+	for (const piece of String(sig).split(",")) {
+		const match = piece.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)/);
+		if (match) {
+			out.push({ name: match[1], type: match[2] });
+		}
+	}
+	return out;
+}
+
+function connectRoots(body: string): string[] {
+	const roots: string[] = [];
+	const seen = new Set<string>();
+	const re = /__janitor:Add\(([A-Za-z_][A-Za-z0-9_]*)/g;
+	let match: RegExpExecArray | null = re.exec(body);
+	while (match) {
+		const name = match[1];
+		if (!seen.has(name)) {
+			seen.add(name);
+			roots.push(name);
+		}
+		match = re.exec(body);
+	}
+	return roots;
+}
+
+function linkTarget(params: Param[], body: string): string | null {
+	const roots = connectRoots(body);
+	for (const root of roots) {
+		const param = params.find((item) => item.name === root && INSTANCE_TYPES.has(item.type));
+		if (param) {
+			return param.name;
+		}
+	}
+	const fallback = params.find((item) => INSTANCE_TYPES.has(item.type));
+	return fallback ? fallback.name : null;
+}
+
+function splitSelfGuard(body: string): { guard: string; rest: string } {
+	const match = body.match(/^(\tif not \(self[\s\S]*?\n\tend\n)/);
+	if (!match) {
+		return { guard: "", rest: body };
+	}
+	return { guard: match[1], rest: body.slice(match[1].length) };
+}
+
+function hoistSelf(): string {
+	return [
+		"\tlocal __janitor = self.janitor",
+		"\tif not __janitor then",
+		"\t\t__janitor = Janitor.new()",
+		"\t\tself.janitor = __janitor",
+		"\tend",
+		"",
+	].join("\n");
+}
+
+function hoistLink(name: string): string {
+	return ["\tlocal __janitor = Janitor.new()", `\t__janitor:LinkToInstance(${name})`, ""].join("\n");
+}
+
+function hoistModule(): string {
+	return [
+		"\tif not __cluauppSweep then",
+		"\t\t__cluauppSweep = Janitor.new()",
+		"\tend",
+		"\tlocal __janitor = __cluauppSweep",
+		"",
+	].join("\n");
+}
+
+function rewriteBody(params: string, body: string, isMethod: boolean): { body: string; moduleSweep: boolean } {
+	if (!/^[ \t]*local __janitor = Janitor\.new\(\)\s*\n/m.test(body)) {
+		return { body, moduleSweep: false };
+	}
+	if (/__janitor:LinkToInstance\(/.test(body)) {
+		return { body, moduleSweep: false };
+	}
+	const stripped = body.replace(/^[ \t]*local __janitor = Janitor\.new\(\)\s*\n/m, "");
+	const parsed = parseParams(params);
+	const link = linkTarget(parsed, stripped);
+	if (link) {
+		const pieces = splitSelfGuard(stripped);
+		return { body: `${pieces.guard}${hoistLink(link)}${pieces.rest}`, moduleSweep: false };
+	}
+	if (isMethod) {
+		const pieces = splitSelfGuard(stripped);
+		return { body: `${pieces.guard}${hoistSelf()}${pieces.rest}`, moduleSweep: false };
+	}
+	const pieces = splitSelfGuard(stripped);
+	return { body: `${pieces.guard}${hoistModule()}${pieces.rest}`, moduleSweep: true };
+}
+
+export function rewriteSweepJanitor(luau: string): string {
+	const source = String(luau);
+	HEADER.lastIndex = 0;
+	const matches = [...source.matchAll(HEADER)];
+	if (matches.length === 0) {
+		return source;
+	}
+
+	let out = source.slice(0, matches[0].index);
+	let needsModule = false;
+	for (let i = 0; i < matches.length; i += 1) {
+		const match = matches[i];
+		const header = match[0];
+		const method = match[2];
+		const params = match[3] || "";
+		const isMethod = Boolean(method);
+		const bodyStart = (match.index || 0) + header.length;
+		const bodyEnd = i + 1 < matches.length ? (matches[i + 1].index as number) : source.length;
+		const rawBody = source.slice(bodyStart, bodyEnd);
+		const rewritten = rewriteBody(params, rawBody, isMethod);
+		if (rewritten.moduleSweep) {
+			needsModule = true;
+		}
+		out += header + rewritten.body;
+	}
+
+	if (needsModule && !/\blocal __cluauppSweep\b/.test(out)) {
+		const inject = "local __cluauppSweep = nil\n";
+		if (/const Janitor = require[^\n]*\n/.test(out)) {
+			out = out.replace(/const Janitor = require[^\n]*\n/, (line) => `${line}${inject}`);
+		} else {
+			out = inject + out;
+		}
+	}
+	return out;
+}

package/src/clpp/runner.ts

@@ -30,11 +30,11 @@ function cmpSemver(a: Semver, b: Semver): number {
 }
 
 function minClpp(): Semver {
-	return parseSemver(MIN_CLPP_VERSION) || { major: 0, minor: 3, patch: 2 };
+	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/download/v0.3.2/clpp-setup.exe or set CLPP / CLPP_PATH.`;
+	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 {
@@ -184,6 +184,12 @@ export function compileViaClpp(request: CompileRequest): CompileArtifact {
 		source: request.source,
 		fileName: request.fileName,
 		strict: request.strict ?? null,
+		optimize: request.optimize ?? true,
+		targetProfilePath: request.targetProfilePath ?? null,
+		targetCacheDir: request.targetCacheDir ?? null,
+		runContext: request.runContext ?? null,
+		capabilityProfilePath: request.capabilityProfilePath ?? null,
+		datamodelProfilePath: request.datamodelProfilePath ?? null,
 	});
 	const result = spawnSync(bin, ["api", "compile"], {
 		input: payload,
@@ -237,6 +243,12 @@ export function compileViaClppAsync(request: CompileRequest): Promise<CompileArt
 				source: request.source,
 				fileName: request.fileName,
 				strict: request.strict ?? null,
+				optimize: request.optimize ?? true,
+				targetProfilePath: request.targetProfilePath ?? null,
+				targetCacheDir: request.targetCacheDir ?? null,
+				runContext: request.runContext ?? null,
+				capabilityProfilePath: request.capabilityProfilePath ?? null,
+				datamodelProfilePath: request.datamodelProfilePath ?? null,
 			}),
 		);
 	});

package/src/compile.ts

@@ -1,9 +1,65 @@
 import path from "node:path";
+import fs from "node:fs";
 import type { CompileOptions, CompileServiceResult } from "./types.js";
 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 { runContextFromFileName } from "./target/roblox.js";
+import { capabilityProfilePath, writeCapabilityProfile, loadCapabilityProfile } from "./target/capability-profile.js";
+import { assertContextSafe, listContextWarnings, formatContextViolations } from "./target/context-check.js";
+import { buildDatamodelProfile } from "./target/datamodel.js";
+import { assertDatamodelSafe } from "./target/datamodel-check.js";
+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";
+
+function defaultTargetProfilePath(): string | undefined {
+	const cached = path.join(projectRoot, "api", "normalized", "roblox-target.profile.json");
+	if (fs.existsSync(cached)) {
+		return cached.replace(/\\/g, "/");
+	}
+	return undefined;
+}
+
+function ensureCapabilityProfile(): string {
+	const file = capabilityProfilePath();
+	if (!fs.existsSync(file)) {
+		writeCapabilityProfile();
+	}
+	return file.replace(/\\/g, "/");
+}
+
+function resolveGameRoot(options: CompileOptions): string {
+	const start = options.rootDir
+		? path.resolve(options.rootDir)
+		: options.filePath
+			? path.dirname(path.resolve(options.filePath))
+			: process.cwd();
+	let dir = start;
+	for (let i = 0; i < 8; i++) {
+		if (fs.existsSync(path.join(dir, "default.project.json")) || fs.existsSync(path.join(dir, "default.project.jsonc"))) {
+			return dir;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) {
+			break;
+		}
+		dir = parent;
+	}
+	return options.rootDir ? path.resolve(options.rootDir) : process.cwd();
+}
+
+function ensureDatamodel(options: CompileOptions): { profilePath?: string; profile: ReturnType<typeof buildDatamodelProfile> } {
+	const root = resolveGameRoot(options);
+	const written = writeDatamodelArtifacts(root);
+	if (written) {
+		return { profilePath: written.profilePath.replace(/\\/g, "/"), profile: written.profile };
+	}
+	return { profile: buildDatamodelProfile(root) };
+}
 
 function compileArgs(source: string, fileName: string | undefined, options: CompileOptions) {
 	const relative = (options.relativeName || fileName || "input.clpp").replace(/\\/g, "/");
@@ -11,20 +67,47 @@ function compileArgs(source: string, fileName: string | undefined, options: Comp
 	const header = options.filePath ? siblingHeader(options.filePath) : null;
 	const skipInit = options.skipInit === true || shouldSkipInit(relative, Boolean(header));
 	const diskPath = options.filePath ? path.resolve(options.filePath) : null;
+	const runContext = runContextFromFileName(relative);
+	const dm = ensureDatamodel(options);
+	const gameRoot = resolveGameRoot(options);
 	return {
 		request: {
 			source,
 			fileName: diskPath ? diskPath.replace(/\\/g, "/") : relative,
 			strict: options.strict,
+			optimize: options.optimize !== false,
 			cwd: diskPath ? path.dirname(diskPath) : options.srcDir,
+			targetProfilePath: defaultTargetProfilePath(),
+			targetCacheDir: path.join(projectRoot, "api", ".cache").replace(/\\/g, "/"),
+			runContext,
+			capabilityProfilePath: ensureCapabilityProfile(),
+			datamodelProfilePath: dm.profilePath,
 		},
 		relative,
 		outName,
 		skipInit,
 		options,
+		datamodel: dm.profile,
+		gameRoot,
+		policy: loadPlatformPolicy(gameRoot),
 	};
 }
 
+function enforcePlatform(source: string, relative: string, args: ReturnType<typeof compileArgs>): void {
+	const profile = loadCapabilityProfile();
+	assertContextSafe(source, relative, profile);
+	const warnings = listContextWarnings(source, relative, profile);
+	if (warnings.length) {
+		console.warn(formatContextViolations(relative, warnings));
+	}
+	if (args.datamodel) {
+		assertDatamodelSafe(source, args.datamodel);
+	}
+	assertParallelSafe(source, relative);
+	assertAuthoritySafe(source, relative, args.policy);
+	assertGetServiceSafe(source, relative);
+}
+
 function finishArtifact(
 	artifact: CompileArtifact,
 	relative: string,
@@ -41,6 +124,8 @@ function finishArtifact(
 		strict: options.strict,
 		skipInit,
 		source,
+		nativeHints: artifact.nativeHints,
+		layoutHints: artifact.layoutHints,
 	});
 	return {
 		kind: emitKind(relative),
@@ -56,12 +141,14 @@ export function compileSource(source: string, fileName?: string, options: Compil
 
 export function compileService(source: string, fileName?: string, options: CompileOptions = {}): CompileServiceResult {
 	const args = compileArgs(source, fileName, options);
+	enforcePlatform(source, args.relative, args);
 	const artifact = compileViaClpp(args.request);
 	return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit, source);
 }
 
 export async function compileServiceAsync(source: string, fileName?: string, options: CompileOptions = {}): Promise<CompileServiceResult> {
 	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);
 }

package/src/flare/parse.ts

@@ -76,6 +76,7 @@ function parseSide(raw: string, file: string, line: number): FlareSide {
 export function parseFlare(source: string, filePath: string, defaultName: string): FlareSchema {
 	const file = filePath.replace(/\\/g, "/");
 	let name = defaultName;
+	let version: number | undefined;
 	const packets: FlarePacket[] = [];
 	const queries: FlareQuery[] = [];
 	let packetId = 1;
@@ -89,6 +90,12 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
+		const verStmt = line.match(/^version\s+(\d+)\s*;?$/i);
+		if (verStmt) {
+			version = Number(verStmt[1]);
+			continue;
+		}
+
 		const opt = line.match(/^opt\s+name\s*=\s*(.+)$/i);
 		if (opt) {
 			const value = opt[1].trim().replace(/^["']|["']$/g, "");
@@ -99,6 +106,12 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 			continue;
 		}
 
+		const optVer = line.match(/^opt\s+version\s*=\s*(\d+)\s*;?$/i);
+		if (optVer) {
+			version = Number(optVer[1]);
+			continue;
+		}
+
 		const packet = line.match(
 			new RegExp(
 				`^packet\\s+(${FLARE_IDENT})\\s*\\((.*)\\)\\s+from\\s+(Client|Server)(?:\\s+(unreliable|reliable))?\\s*$`,
@@ -143,5 +156,5 @@ export function parseFlare(source: string, filePath: string, defaultName: string
 		fail(file, 1, "schema is empty — add a packet or query");
 	}
 
-	return { name, sourcePath: file, packets, queries };
+	return { name, sourcePath: file, version, packets, queries };
 }

package/src/flare/types.ts

@@ -48,6 +48,8 @@ export type FlareQuery = {
 export type FlareSchema = {
 	name: string;
 	sourcePath: string;
+	/** Optional schema version from `version N;` / `opt version = N`. */
+	version?: number;
 	packets: FlarePacket[];
 	queries: FlareQuery[];
 };

package/src/intellisense.ts

@@ -7,6 +7,7 @@ import type { ProjectConfig } from "./types.js";
 import { CLPP_INSTALL_HINT } from "./clpp/contract.js";
 import { hasClpp } from "./clpp/runner.js";
 import { isSourceFile } from "./clpp/paths.js";
+import { editorBin } from "./editor-install.js";
 
 export type CluauppDiagnostic = {
 	line: number;
@@ -83,10 +84,24 @@ function writeVscode(root: string): void {
 		"*.client.clpp": "clpp",
 		"*.plugin.clpp": "clpp",
 		"*.flare": "flare",
+		"*.hive": "hive",
+		"*.mint": "mint",
+		"*.bloom": "bloom",
+		"*.helm": "helm",
+		"*.shift": "shift",
+		"*.axiom": "axiom",
 	};
 	writeJson(settingsPath, {
 		...current,
 		"files.associations": associations,
+		"[luau]": {
+			...((current["[luau]"] && typeof current["[luau]"] === "object" && !Array.isArray(current["[luau]"]))
+				? (current["[luau]"] as Record<string, unknown>)
+				: {}),
+			"editor.insertSpaces": false,
+			"editor.tabSize": 4,
+			"editor.detectIndentation": false,
+		},
 	});
 
 	const extensionsPath = path.join(root, ".vscode", "extensions.json");
@@ -104,8 +119,32 @@ export function diagnosticsFor(_source?: string, _fileName?: string): CluauppDia
 	return [];
 }
 
+function writeStylua(root: string): void {
+	const dest = path.join(root, "stylua.toml");
+	const body = `# cluaupp roblox luau
+syntax = "Luau"
+column_width = 120
+line_endings = "Unix"
+indent_type = "Tabs"
+indent_width = 4
+quote_style = "AutoPreferDouble"
+call_parentheses = "Always"
+collapse_simple_statement = "Never"
+`;
+	if (fs.existsSync(dest)) {
+		const existing = fs.readFileSync(dest, "utf8");
+		if (!existing.includes("cluaupp roblox luau") && existing.trim() !== "") {
+			return;
+		}
+	}
+	if (!fs.existsSync(dest) || fs.readFileSync(dest, "utf8") !== body) {
+		fs.writeFileSync(dest, body, "utf8");
+	}
+}
+
 export function syncEditorSupport(root: string, _config: Partial<ProjectConfig> = {}): void {
 	writeVscode(root);
+	writeStylua(root);
 }
 
 export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
@@ -121,6 +160,15 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 			continue;
 		}
 		fs.mkdirSync(home, { recursive: true });
+		try {
+			for (const name of fs.readdirSync(home)) {
+				if (name.startsWith("kartzdev.cluaupp-flare-") && name !== id) {
+					fs.rmSync(path.join(home, name), { recursive: true, force: true });
+				}
+			}
+		} catch {
+			// ignore prune errors
+		}
 		const dest = path.join(home, id);
 		copyDir(from, dest);
 		fs.writeFileSync(path.join(dest, "cluaupp.root"), path.resolve(cluauppRoot), "utf8");
@@ -136,13 +184,22 @@ export function installEditorExtension(cluauppRoot = PACKAGE_ROOT): string[] {
 		}
 		installed.push(dest);
 	}
+
+	const bin = editorBin();
+	if (bin && installed[0]) {
+		spawnSync(bin, ["--install-extension", installed[0], "--force"], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 120000,
+		});
+	}
 	return installed;
 }
 
 export async function installEditorSupport() {
 	const local = installEditorExtension();
 	if (local.length > 0) {
-		console.log("cluaupp: Flare IntelliSense installed");
+		console.log("cluaupp: schema IntelliSense installed (.flare .hive .mint .bloom .helm .shift .axiom)");
 		for (const dest of local) {
 			console.log(" ", dest);
 		}