cluaupp 0.2.2 → 1.0.0

package/generated/lex.js

@@ -33,6 +33,9 @@ const KEYWORDS = new Set([
     "case",
     "default",
     "break",
+    "static",
+    "constexpr",
+    "inline",
 ]);
 function tokenize(source) {
     const tokens = [];

package/generated/libs.js

@@ -259,7 +259,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/generated/lsp.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.start = start;
-const node_path_1 = __importDefault(require("node:path"));
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const intellisense_js_1 = require("./intellisense.js");
@@ -28,10 +24,7 @@ function start(options = {}) {
     }));
     const publish = (document) => {
         const file = uriPath(document.uri);
-        const items = (0, intellisense_js_1.diagnosticsFor)(document.getText(), file, {
-            filePath: file,
-            includeDirs: [node_path_1.default.dirname(file), node_path_1.default.join(projectRoot, "src"), node_path_1.default.join(projectRoot, "include")],
-        });
+        const items = (0, intellisense_js_1.diagnosticsFor)(document.getText(), file);
         connection.sendDiagnostics({
             uri: document.uri,
             diagnostics: items.map((item) => ({

package/generated/parse.js

@@ -46,21 +46,124 @@ function parse(source, fileName) {
         eat("op", ">");
         return name;
     };
+    const CAST_NAMES = new Set(["static_cast", "const_cast", "reinterpret_cast", "dynamic_cast"]);
+    function skipSpecifiers() {
+        let isConst = false;
+        while (at("kw", "static") || at("kw", "inline") || at("kw", "constexpr") || at("kw", "const")) {
+            if (at("kw", "constexpr") || at("kw", "const")) {
+                isConst = true;
+            }
+            i += 1;
+        }
+        return isConst;
+    }
+    function looksLikePrimaryStart() {
+        if (at("ident") || at("number") || at("string")) {
+            return true;
+        }
+        if (at("kw", "true") || at("kw", "false") || at("kw", "nullptr") || at("kw", "new")) {
+            return true;
+        }
+        return at("op", "(") || at("op", "{") || at("op", "[") || at("op", "-") || at("op", "!");
+    }
+    function parseLambda() {
+        eat("op", "[");
+        while (!at("eof") && !at("op", "]")) {
+            i += 1;
+        }
+        eat("op", "]");
+        const params = [];
+        if (at("op", "(")) {
+            i += 1;
+            if (!at("op", ")")) {
+                params.push(parseParam());
+                while (at("op", ",")) {
+                    i += 1;
+                    params.push(parseParam());
+                }
+            }
+            eat("op", ")");
+        }
+        const body = parseBlock();
+        return { type: "lambda", params, body };
+    }
+    function parseNamedCast() {
+        i += 1;
+        eat("op", "<");
+        const valueType = parseType() || "any";
+        eat("op", ">");
+        const args = parseArgs();
+        return { type: "cast", valueType, argument: args[0] || { type: "null" } };
+    }
+    function parseParenPrimary() {
+        eat("op", "(");
+        const saved = i;
+        skipSpecifiers();
+        const valueType = parseType();
+        if (valueType && at("op", ")")) {
+            i += 1;
+            if (looksLikePrimaryStart()) {
+                return { type: "cast", valueType, argument: parseUnary() };
+            }
+        }
+        i = saved;
+        const expr = parseExpr();
+        eat("op", ")");
+        return expr;
+    }
+    function eatGeneric() {
+        let text = "";
+        let depth = 0;
+        while (!at("eof")) {
+            const token = peek();
+            if (at("op", "<")) {
+                depth += 1;
+                text += "<";
+                i += 1;
+                continue;
+            }
+            if (at("op", ">")) {
+                depth -= 1;
+                text += ">";
+                i += 1;
+                if (depth === 0) {
+                    return text;
+                }
+                continue;
+            }
+            if (token.type === "string") {
+                text += `"${token.value}"`;
+            }
+            else {
+                text += token.value;
+            }
+            i += 1;
+        }
+        return text;
+    }
     function parseType() {
         if (at("kw", "const")) {
             i += 1;
         }
+        let name = null;
         if (at("kw", "auto") || at("kw", "void") || at("kw", "int") || at("kw", "bool") || at("kw", "float") || at("kw", "double")) {
-            const name = eat("kw").value;
-            while (at("op", "*")) {
+            name = eat("kw").value;
+        }
+        else if (at("ident")) {
+            name = eat("ident").value;
+            while (at("op", "::")) {
                 i += 1;
+                if (at("ident")) {
+                    name += `::${eat("ident").value}`;
+                }
             }
-            return name;
         }
-        if (!at("ident")) {
+        else {
             return null;
         }
-        const name = eat("ident").value;
+        if (at("op", "<")) {
+            name += eatGeneric();
+        }
         while (at("op", "*")) {
             i += 1;
         }
@@ -129,14 +232,17 @@ function parse(source, fileName) {
             eat("op", ")");
             return { type: "getService", service };
         }
+        if (at("ident") && CAST_NAMES.has(peek().value) && peek(1).value === "<") {
+            return parseNamedCast();
+        }
         if (at("ident")) {
             return { type: "ident", name: eat("ident").value };
         }
+        if (at("op", "[")) {
+            return parseLambda();
+        }
         if (at("op", "(")) {
-            i += 1;
-            const expr = parseExpr();
-            eat("op", ")");
-            return expr;
+            return parseParenPrimary();
         }
         if (at("op", "{")) {
             return parseInitList();
@@ -309,11 +415,8 @@ function parse(source, fileName) {
         throw error("only range-for is supported: for (auto* x : list)");
     }
     function parseDeclOrExpr() {
-        const isConst = at("kw", "const");
-        if (isConst) {
-            i += 1;
-        }
         const saved = i;
+        const isConst = skipSpecifiers();
         const maybeType = parseType();
         if (maybeType && at("ident") && (peek(1).value === "=" || peek(1).value === ";")) {
             const name = eat("ident").value;
@@ -325,9 +428,6 @@ function parse(source, fileName) {
             return { type: "decl", name, valueType: maybeType, value, isConst: isConst || maybeType === "const" };
         }
         i = saved;
-        if (isConst) {
-            i = saved - 1;
-        }
         return { type: "expr", expr: parseExpr() };
     }
     function parseStmt() {
@@ -380,6 +480,7 @@ function parse(source, fileName) {
         };
     }
     function parseFunction() {
+        skipSpecifiers();
         const returnType = parseType();
         if (!returnType || !at("ident")) {
             throw error("invalid function declaration");
@@ -449,10 +550,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const valueType = parseType();
             if (valueType && at("ident")) {
                 if (peek(1).value === "(") {
@@ -573,10 +671,7 @@ function parse(source, fileName) {
                 continue;
             }
             const saved = i;
-            const isConst = at("kw", "const");
-            if (isConst) {
-                i += 1;
-            }
+            const isConst = skipSpecifiers();
             const maybeType = parseType();
             if (maybeType && at("ident")) {
                 const next = peek(1);

package/generated/preprocess.js

@@ -1,181 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOURCE_EXTS = void 0;
-exports.isSourceFile = isSourceFile;
-exports.isHeaderFile = isHeaderFile;
-exports.toLuauPath = toLuauPath;
-exports.isEngineStub = isEngineStub;
-exports.siblingImplementation = siblingImplementation;
-exports.siblingHeader = siblingHeader;
-exports.implOutName = implOutName;
-exports.resolveInclude = resolveInclude;
-exports.scanHeaderExports = scanHeaderExports;
-exports.applyPragmas = applyPragmas;
-exports.preprocess = preprocess;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-exports.SOURCE_EXTS = [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hh"];
-function isSourceFile(fileName) {
-    return exports.SOURCE_EXTS.includes(node_path_1.default.extname(fileName).toLowerCase());
-}
-function isHeaderFile(fileName) {
-    return [".h", ".hpp", ".hh"].includes(node_path_1.default.extname(fileName).toLowerCase());
-}
-function toLuauPath(filePath) {
-    return filePath.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
-}
-function isEngineStub(filePath) {
-    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) {
-    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)];
-}
-function siblingImplementation(headerPath) {
-    if (!headerPath || !isHeaderFile(headerPath)) {
-        return null;
-    }
-    const base = headerPath.replace(/\.(h|hpp|hh)$/i, "");
-    for (const ext of [".cpp", ".cc", ".cxx", ".c"]) {
-        if (node_fs_1.default.existsSync(base + ext)) {
-            return base + ext;
-        }
-    }
-    return null;
-}
-function siblingHeader(implPath) {
-    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 (node_fs_1.default.existsSync(base + ext)) {
-            return base + ext;
-        }
-    }
-    return null;
-}
-function implOutName(rel) {
-    return String(rel)
-        .replace(/\\/g, "/")
-        .replace(/\.(cpp|cc|cxx|c)$/i, "Impl.luau");
-}
-function resolveInclude(name, fromFile, includeDirs) {
-    const bases = [node_path_1.default.dirname(fromFile), ...(includeDirs || [])];
-    for (const base of bases) {
-        for (const variant of includeVariants(name)) {
-            const candidate = node_path_1.default.resolve(base, variant);
-            if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile()) {
-                return candidate;
-            }
-        }
-    }
-    return null;
-}
-function scanHeaderExports(source) {
-    const consts = [];
-    const structs = [];
-    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, resolved, impl) {
-    options.moduleIncludes = options.moduleIncludes || [];
-    const srcDir = options.srcDir || null;
-    const moduleFile = impl || resolved;
-    const rel = srcDir ? node_path_1.default.relative(srcDir, moduleFile).replace(/\\/g, "/") : node_path_1.default.basename(moduleFile);
-    const headerText = node_fs_1.default.readFileSync(resolved, "utf8");
-    options.moduleIncludes.push({
-        name: node_path_1.default.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),
-    });
-}
-function applyPragmas(source, options) {
-    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;
-    }
-}
-function preprocess(source, filePath, options = {}) {
-    if (!options.pragmaResolved) {
-        options.pragmaResolved = true;
-        applyPragmas(source, options);
-    }
-    const seen = options.seen || new Set();
-    options.seen = seen;
-    const includeDirs = options.includeDirs || [];
-    const resolvedSelf = filePath ? node_path_1.default.resolve(filePath) : null;
-    if (resolvedSelf) {
-        seen.add(resolvedSelf);
-    }
-    const lines = String(source).split(/\r?\n/);
-    const out = [];
-    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 ? node_path_1.default.resolve(filePath) : null;
-            const ownHeader = Boolean(impl && including && node_path_1.default.resolve(impl) === including);
-            if (!ownHeader) {
-                pushModuleInclude(options, resolved, impl);
-                continue;
-            }
-            seen.add(resolved);
-            const inner = node_fs_1.default.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");
-}
+exports.siblingHeader = exports.toLuauPath = exports.isEngineStub = exports.isHeaderFile = exports.isSourceFile = exports.SOURCE_EXTS = void 0;
+var paths_js_1 = require("./clpp/paths.js");
+Object.defineProperty(exports, "SOURCE_EXTS", { enumerable: true, get: function () { return paths_js_1.SOURCE_EXTS; } });
+Object.defineProperty(exports, "isSourceFile", { enumerable: true, get: function () { return paths_js_1.isSourceFile; } });
+Object.defineProperty(exports, "isHeaderFile", { enumerable: true, get: function () { return paths_js_1.isHeaderFile; } });
+Object.defineProperty(exports, "isEngineStub", { enumerable: true, get: function () { return paths_js_1.isEngineStub; } });
+Object.defineProperty(exports, "toLuauPath", { enumerable: true, get: function () { return paths_js_1.toLuauPath; } });
+Object.defineProperty(exports, "siblingHeader", { enumerable: true, get: function () { return paths_js_1.siblingHeader; } });

package/generated/system-understander.js

@@ -11,7 +11,7 @@ exports.scoreIntents = scoreIntents;
 exports.determineArchitecture = determineArchitecture;
 exports.understandSystem = understandSystem;
 const node_path_1 = __importDefault(require("node:path"));
-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;
 const TREE_NAME_TYPES = new Set([

package/generated/transpile.js

@@ -3,64 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectState = collectState;
 exports.transpileSource = transpileSource;
 exports.outputNameFor = outputNameFor;
 const node_path_1 = __importDefault(require("node:path"));
-const collector_js_1 = require("./parser/collector.js");
-const index_js_1 = require("./parser/index.js");
-const luau_codegen_js_1 = require("./emitter/luau-codegen.js");
 const compile_js_1 = require("./compile.js");
-const system_understander_js_1 = require("./system-understander.js");
-function shouldMerge(name, contents) {
-    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("["));
-}
-function collectState(source, mapper, options) {
-    const tree = (0, index_js_1.parseCpp)(source);
-    if (!tree) {
-        const state = luau_codegen_js_1.LuauCodeEmitter.emptyState(options.strict === true);
-        return state;
-    }
-    const collector = new collector_js_1.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 = (0, system_understander_js_1.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;
-}
-function transpileSource(source, fileName, options, mapper) {
-    const state = collectState(source, mapper, options);
-    if (state.strict) {
-        options.strict = true;
-    }
-    const compiled = (0, compile_js_1.compileService)(source, fileName, options);
-    return {
-        ...compiled,
-        files: compiled.files.map((file) => ({
-            ...file,
-            contents: shouldMerge(file.name, file.contents) ? luau_codegen_js_1.LuauCodeEmitter.merge(state, file.contents) : file.contents,
-        })),
-    };
+function transpileSource(source, fileName, options, _mapper) {
+    return (0, compile_js_1.compileService)(source, fileName, options);
 }
 function outputNameFor(inputFile, outputPath) {
     if (/\.luau$/i.test(outputPath)) {
         return outputPath;
     }
-    const base = node_path_1.default.basename(inputFile).replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, ".luau");
+    const base = node_path_1.default.basename(inputFile).replace(/\.(clpp|clp|clh)$/i, ".luau");
     return node_path_1.default.join(outputPath, base);
 }

package/generated/utils/project.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSourcesFiles = void 0;
 exports.loadConfig = loadConfig;
 exports.collectCpp = collectCpp;
 exports.build = build;
@@ -11,7 +12,7 @@ exports.watch = watch;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const package_info_js_1 = require("../package-info.js");
-const preprocess_js_1 = require("../preprocess.js");
+const paths_js_1 = require("../clpp/paths.js");
 const intellisense_js_1 = require("../intellisense.js");
 const process_orchestrator_js_1 = require("./process-orchestrator.js");
 const rojo_mapper_js_1 = require("./rojo-mapper.js");
@@ -142,27 +143,16 @@ function copyRuntime(dest) {
     syncDir(runtime, node_path_1.default.join(dest, "libs"));
 }
 function copyHeaders(dest) {
-    const from = node_path_1.default.join(__dirname, "..", "..", "include", "cluaupp");
+    const from = node_path_1.default.join(__dirname, "..", "..", "include", "clpp");
     if (!node_fs_1.default.existsSync(from)) {
         return;
     }
-    syncDir(from, node_path_1.default.join(dest, "include", "cluaupp"));
+    syncDir(from, node_path_1.default.join(dest, "include", "clpp"));
 }
 function collectCpp(dir, files = []) {
-    if (!node_fs_1.default.existsSync(dir)) {
-        return files;
-    }
-    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
-        const full = node_path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            collectCpp(full, files);
-        }
-        else if ((0, preprocess_js_1.isSourceFile)(entry.name)) {
-            files.push(full);
-        }
-    }
-    return files;
+    return (0, paths_js_1.collectSources)(dir, files);
 }
+exports.collectSourcesFiles = paths_js_1.collectSources;
 function collectFiles(dir, files = []) {
     if (!node_fs_1.default.existsSync(dir)) {
         return files;
@@ -186,9 +176,9 @@ function posixRel(from, file) {
     return node_path_1.default.relative(from, file).replace(/\\/g, "/");
 }
 function sourcePrefixes(rel) {
-    const noExt = rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+    const noExt = rel.replace(/\.(clpp|clp|clh)$/i, "");
     const noTag = noExt.replace(/\.(server|client)$/i, "");
-    return [...new Set([noExt, noTag, (0, preprocess_js_1.toLuauPath)(rel).replace(/\\/g, "/")])];
+    return [...new Set([noExt, noTag, (0, paths_js_1.toLuauPath)(rel).replace(/\\/g, "/")])];
 }
 function matchesPrefix(relOut, prefixes) {
     const n = relOut.replace(/\\/g, "/").toLowerCase();
@@ -253,7 +243,7 @@ function createMapper(root, config, rojoPath) {
 }
 function compileProject(root, config, mapper) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
-    const files = collectCpp(srcDir);
+    const files = (0, paths_js_1.collectSources)(srcDir);
     const jobs = [];
     const errors = [];
     for (const file of files) {
@@ -264,7 +254,7 @@ function compileProject(root, config, mapper) {
                 ...config,
                 filePath: file,
                 relativeName: rel,
-                outName: (0, preprocess_js_1.toLuauPath)(rel),
+                outName: (0, paths_js_1.toLuauPath)(rel),
                 architecture: config.architecture === true,
                 includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
                 srcDir,
@@ -341,8 +331,8 @@ function build(root, options = {}) {
         ensureVendor(root);
     }
     const srcDir = node_path_1.default.join(root, config.rootDir);
-    if (!node_fs_1.default.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
-        console.error("no .cpp/.h/.hpp files in", config.rootDir);
+    if (!node_fs_1.default.existsSync(srcDir) || (0, paths_js_1.collectSources)(srcDir).length === 0) {
+        console.error("no .clpp/.clp/.clh files in", config.rootDir);
         if (!holdOnError) {
             pruneOut(root, config, new Set(), []);
         }
@@ -400,16 +390,11 @@ async function init(dest) {
     copyDir(include, node_path_1.default.join(target, "include"));
     copyRuntime(target);
     (0, intellisense_js_1.syncEditorSupport)(target);
-    const installed = await (0, intellisense_js_1.installEditorSupport)();
     console.log("Cluaupp ready in", target);
+    console.log("  clpp install          (CL++ highlighting + IntelliSense)");
     console.log("  rokit install");
     console.log("  cluaupp build");
     console.log("  rojo serve");
-    if (installed.local.length ||
-        (installed.clangd && (installed.clangd.status === "installed" || installed.clangd.status === "already")) ||
-        (installed.llvm && (installed.llvm.status === "installed" || installed.llvm.status === "already"))) {
-        console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
-    }
 }
 function pidAlive(pid) {
     try {

package/include/{cluaupp/datatypes.hpp → clpp/datatypes.clh}

@@ -1,5 +1,5 @@
 #pragma once
-#include <cluaupp/generated/enums.hpp>
+#include <clpp/generated/enums.clh>
 using Enum::EasingStyle;
 using Enum::EasingDirection;
 using Enum::Material;
@@ -17,6 +17,10 @@ using Enum::Axis;
 
 using string = const char*;
 
+// Variadic join. Cluaupp emits Luau a .. b .. c.
+template <typename... Args>
+string string_concat(Args... args);
+
 struct Instance;
 struct Player;
 

package/include/{cluaupp/generated/instances.hpp → clpp/generated/instances.clh}

@@ -1,5 +1,5 @@
 #pragma once
-#include <cluaupp/datatypes.hpp>
+#include <clpp/datatypes.clh>
 
 struct Object;
 struct AnimatedImageTrack;

package/include/{cluaupp/libs/chrono.hpp → clpp/libs/chrono.clh}

@@ -1,15 +1,15 @@
 #pragma once
 
 // Parihsz/Chrono — custom character replication, vendored into CluauppLibs.Chrono
-class ChronoHolder {};
-class ChronoEntity {};
-class ChronoStats {};
-class ChronoConfig {};
-class ChronoReplicationRules {};
-class ChronoEvents {};
-class ChronoSnapshots {};
-class ChronoServerClock {};
-class ChronoPlayer {};
+struct ChronoHolder {};
+struct ChronoEntity {};
+struct ChronoStats {};
+struct ChronoConfig {};
+struct ChronoReplicationRules {};
+struct ChronoEvents {};
+struct ChronoSnapshots {};
+struct ChronoServerClock {};
+struct ChronoPlayer {};
 
 namespace Chrono {
 	void Start();