cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/compiler/stdlib.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * CL++ standard library modules (`@clpp.axiom`, `@clpp.text`, `@clpp.math`, `@clpp.http`) on the
+ * Roblox target. Each function has a CL++ signature and a lowering: an inline Luau template using
+ * fast built-ins, or a call into the CluauppLibs runtime (`Axiom`) / a file-local helper.
+ *
+ * Templates use `$1…$n` for arguments; `@n` marks arguments that are evaluated more than once,
+ * so the emitter only inlines when those arguments are side-effect free.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STD_PATHS = exports.DESKTOP_ONLY = void 0;
+exports.stdModule = stdModule;
+exports.stdFunctionType = stdFunctionType;
+const types_js_1 = require("./types.js");
+const typeOf = {
+    float: types_js_1.T.float,
+    int: types_js_1.T.int,
+    bool: types_js_1.T.bool,
+    string: types_js_1.T.string,
+    Vector2: types_js_1.T.datatype("Vector2"),
+    Vector3: types_js_1.T.datatype("Vector3"),
+    Color3: types_js_1.T.datatype("Color3"),
+    CFrame: types_js_1.T.datatype("CFrame"),
+    UDim2: types_js_1.T.datatype("UDim2"),
+    floats: types_js_1.T.list(types_js_1.T.float),
+    strings: types_js_1.T.list(types_js_1.T.string),
+    list: types_js_1.T.list(types_js_1.T.any, false),
+    any: types_js_1.T.any,
+    strings2: types_js_1.T.list(types_js_1.T.string),
+};
+function sig(spec, inline, extra = {}) {
+    const m = /^(\w+)\(([^)]*)\)\s*->\s*(\w+)$/.exec(spec);
+    if (!m) {
+        throw new Error(`bad std signature ${spec}`);
+    }
+    const params = m[2]
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean)
+        .map((p, i) => {
+        const optional = p.endsWith("?");
+        const [tname, pname] = p.replace("?", "").split(/\s+/);
+        return { name: pname || `p${i}`, type: typeOf[tname] ?? types_js_1.T.any, optional };
+    });
+    return { name: m[1], params, ret: typeOf[m[3]] ?? types_js_1.T.void, inline, ...extra };
+}
+const AXIOM = [
+    sig("Clamp(float value, float min, float max) -> float", "math.min(math.max($1, $2), $3)"),
+    sig("Map(float value, float inMin, float inMax, float outMin, float outMax) -> float", null),
+    sig("Wrap(float value, float min, float max) -> float", null),
+    sig("Sign(float value) -> float", "math.sign($1)"),
+    sig("Round(float value, float places?) -> float", null),
+    sig("Snap(float value, float step) -> float", null),
+    sig("PingPong(float t, float length) -> float", null),
+    sig("Saturate(float value) -> float", "math.min(math.max($1, 0), 1)"),
+    sig("Fract(float value) -> float", "@1 - math.floor(@1)"),
+    sig("InvLerp(float from, float to, float value) -> float", null),
+    sig("Approach(float current, float target, float maxDelta) -> float", null),
+    sig("IsFinite(float value) -> bool", "@1 == @1 and @1 ~= math.huge and @1 ~= -math.huge"),
+    sig("Abs(float value) -> float", "math.abs($1)"),
+    sig("Min(float a, float b) -> float", "math.min($1, $2)"),
+    sig("Max(float a, float b) -> float", "math.max($1, $2)"),
+    sig("Pow(float base, float exp) -> float", "$1 ^ $2"),
+    sig("Sqrt(float value) -> float", "math.sqrt($1)"),
+    sig("Cbrt(float value) -> float", null),
+    sig("Hypot(float a, float b) -> float", "math.sqrt(@1 * @1 + @2 * @2)"),
+    sig("Log(float value) -> float", "math.log($1)"),
+    sig("Log2(float value) -> float", "math.log($1, 2)"),
+    sig("Log10(float value) -> float", "math.log10($1)"),
+    sig("Exp(float value) -> float", "math.exp($1)"),
+    sig("Smoothstep(float edge0, float edge1, float x) -> float", null),
+    sig("Smootherstep(float edge0, float edge1, float x) -> float", null),
+    sig("Gcd(float a, float b) -> float", null),
+    sig("Lcm(float a, float b) -> float", null),
+    sig("IsEven(float value) -> bool", "$1 % 2 == 0"),
+    sig("IsOdd(float value) -> bool", "$1 % 2 == 1"),
+    sig("IsNaN(float value) -> bool", "@1 ~= @1"),
+    sig("Factorial(float n) -> float", null),
+    sig("Scale(float value, float index) -> float", null),
+    sig("Lerp(float from, float to, float alpha) -> float", "@1 + (@2 - @1) * $3"),
+    sig("LerpClamped(float from, float to, float alpha) -> float", "@1 + (@2 - @1) * math.min(math.max($3, 0), 1)"),
+    sig("LerpVector2(Vector2 from, Vector2 to, float alpha) -> Vector2", "$1:Lerp($2, $3)"),
+    sig("LerpVector3(Vector3 from, Vector3 to, float alpha) -> Vector3", "$1:Lerp($2, $3)"),
+    sig("LerpVector(Vector3 from, Vector3 to, float alpha) -> Vector3", "$1:Lerp($2, $3)"),
+    sig("LerpColor3(Color3 from, Color3 to, float alpha) -> Color3", "$1:Lerp($2, $3)"),
+    sig("LerpCFrame(CFrame from, CFrame to, float alpha) -> CFrame", "$1:Lerp($2, $3)"),
+    sig("SlerpCFrame(CFrame from, CFrame to, float alpha) -> CFrame", "$1:Lerp($2, $3)"),
+    sig("LerpUDim2(UDim2 from, UDim2 to, float alpha) -> UDim2", "$1:Lerp($2, $3)"),
+    sig("LerpAngle(float from, float to, float alpha) -> float", null),
+    sig("Inverse(float from, float to, float value) -> float", null),
+    sig("Project(Vector3 a, Vector3 b) -> Vector3", null),
+    sig("Reject(Vector3 a, Vector3 b) -> Vector3", null),
+    sig("Reflect(Vector3 incident, Vector3 normal) -> Vector3", null),
+    sig("Angle(Vector3 a, Vector3 b) -> float", "$1:Angle($2)"),
+    sig("Distance(Vector3 a, Vector3 b) -> float", "($2 - $1).Magnitude"),
+    sig("Distance2(Vector2 a, Vector2 b) -> float", "($2 - $1).Magnitude"),
+    sig("Orthonormal(Vector3 forward, Vector3 up?) -> Vector3", null),
+    sig("Slerp(Vector3 a, Vector3 b, float t) -> Vector3", null),
+    sig("LookAt(Vector3 from, Vector3 target) -> Vector3", null),
+    sig("Flat(Vector3 value) -> Vector3", null),
+    sig("Dot(Vector3 a, Vector3 b) -> float", "$1:Dot($2)"),
+    sig("Cross(Vector3 a, Vector3 b) -> Vector3", "$1:Cross($2)"),
+    sig("Length(Vector3 v) -> float", "$1.Magnitude"),
+    sig("Normalize(Vector3 v) -> Vector3", null),
+    sig("CubicBezier(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3) -> Vector3", null),
+    sig("QuadraticBezier(float t, Vector3 p0, Vector3 p1, Vector3 p2) -> Vector3", null),
+    sig("Hover(float t, Vector3 base, Vector3 amplitude) -> Vector3", null),
+    sig("Float(float t, Vector3 base, Vector3 amplitude) -> Vector3", null),
+    sig("FloatSpin(float t, Vector3 base) -> Vector3", null),
+    sig("AabbContains(Vector3 point, Vector3 min, Vector3 max) -> bool", null),
+    sig("SphereContains(Vector3 point, Vector3 center, float radius) -> bool", "($1 - $2).Magnitude <= $3"),
+    sig("RayPlane(Vector3 origin, Vector3 dir, Vector3 point, Vector3 normal) -> Vector3", null),
+    sig("Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c) -> Vector3", null),
+    sig("ClosestPointOnSegment(Vector3 p, Vector3 a, Vector3 b) -> Vector3", null),
+    sig("Deg(float rad) -> float", "math.deg($1)"),
+    sig("Rad(float deg) -> float", "math.rad($1)"),
+    sig("DeltaAngle(float from, float to) -> float", null),
+    sig("AngleDiff(float from, float to) -> float", null),
+    sig("DeltaAngleDegrees(float from, float to) -> float", null),
+    sig("NormalizeAngle(float angle) -> float", null),
+    sig("Sin(float x) -> float", "math.sin($1)"),
+    sig("Cos(float x) -> float", "math.cos($1)"),
+    sig("Tan(float x) -> float", "math.tan($1)"),
+    sig("Asin(float x) -> float", "math.asin($1)"),
+    sig("Acos(float x) -> float", "math.acos($1)"),
+    sig("Atan2(float y, float x) -> float", "math.atan2($1, $2)"),
+    sig("RandomRange(float min, float max) -> float", null),
+    sig("Random(float min, float max) -> float", null),
+    sig("Weighted(floats weights) -> int", null),
+    sig("Gaussian(float mean?, float std?) -> float", null),
+    sig("Average(floats values) -> float", null),
+    sig("Sum(floats values) -> float", null),
+    sig("HashU32(float n) -> int", null),
+    sig("Value1(float x) -> float", null),
+    sig("Value2(float x, float y) -> float", null),
+    sig("Value3(float x, float y, float z) -> float", null),
+    sig("FromHSV(float h, float s, float v) -> Color3", "Color3.fromHSV($1, $2, $3)"),
+    sig("Contrast(Color3 color, float amount) -> Color3", null),
+    sig("LerpHSV(Color3 a, Color3 b, float t) -> Color3", null),
+    sig("Floor(float value) -> float", "math.floor($1)"),
+    sig("Ceil(float value) -> float", "math.ceil($1)"),
+    sig("Trunc(float value) -> float", null),
+    sig("Pi() -> float", "math.pi"),
+];
+const TEXT = [
+    sig("trim(string text) -> string", null, { helper: "trim" }),
+    sig("lower(string text) -> string", "string.lower($1)"),
+    sig("upper(string text) -> string", "string.upper($1)"),
+    sig("contains(string text, string part) -> bool", "string.find($1, $2, 1, true) ~= nil"),
+    sig("split(string text, string separator) -> strings", "string.split($1, $2)"),
+    sig("replace(string text, string target, string replacement) -> string", null, { helper: "replace" }),
+    sig("startsWith(string text, string part) -> bool", "string.sub($1, 1, #@2) == @2"),
+    sig("endsWith(string text, string part) -> bool", null, { helper: "endsWith" }),
+    sig("repeat(string text, int count) -> string", "string.rep($1, $2)"),
+    sig("toNumber(string text) -> float", null, { helper: "toNumber" }),
+    sig("indexOf(string text, string part) -> int", null, { helper: "indexOf" }),
+    sig("joinAll(list parts, string separator) -> string", null, { helper: "joinAll" }),
+];
+const MATH = [sig("abs(float n) -> float", "math.abs($1)")];
+const HTTP = [sig("host(string url) -> string", null, { helper: "urlHost" })];
+/** @clpp.json on Roblox: HttpService JSONEncode/JSONDecode plus dotted-path helpers. */
+const JSON_FNS = [
+    sig("Parse(string text) -> any", null, { helper: "jsonParse" }),
+    sig("Valid(string text) -> bool", null, { helper: "jsonValid" }),
+    sig("Stringify(any value) -> string", null, { helper: "jsonStringify" }),
+    sig("Pretty(any value) -> string", null, { helper: "jsonPretty" }),
+    sig("Get(any value, string path) -> any", null, { helper: "jsonGet" }),
+    sig("Has(any value, string path) -> bool", null, { helper: "jsonHas" }),
+    sig("Set(any target, string key, any value) -> any", null, { helper: "jsonSet" }),
+    sig("Object() -> any", "{}"),
+    sig("Keys(any object) -> strings", null, { helper: "jsonKeys" }),
+];
+/** @clpp.time on Roblox: os.clock / DateTime / os.date / task.wait. */
+const TIME = [
+    sig("Now() -> float", "DateTime.now().UnixTimestampMillis / 1000"),
+    sig("Clock() -> float", "os.clock()"),
+    sig("Sleep(float ms) -> void", "task.wait($1 / 1000)"),
+    sig("Date() -> string", 'os.date("%Y-%m-%d")'),
+    sig("TimeOfDay() -> string", 'os.date("%H:%M:%S")'),
+    sig("Format(string pattern) -> string", "os.date($1)"),
+    sig("Year() -> int", 'os.date("*t").year'),
+    sig("Month() -> int", 'os.date("*t").month'),
+    sig("Day() -> int", 'os.date("*t").day'),
+    sig("Hour() -> int", 'os.date("*t").hour'),
+    sig("Minute() -> int", 'os.date("*t").min'),
+    sig("Second() -> int", 'os.date("*t").sec'),
+    sig("Weekday() -> int", 'os.date("*t").wday - 1'),
+    sig("DayOfYear() -> int", 'os.date("*t").yday'),
+];
+const MODULES = {
+    axiom: new Map(AXIOM.map((f) => [f.name, f])),
+    text: new Map(TEXT.map((f) => [f.name, f])),
+    math: new Map(MATH.map((f) => [f.name, f])),
+    http: new Map(HTTP.map((f) => [f.name, f])),
+    json: new Map(JSON_FNS.map((f) => [f.name, f])),
+    time: new Map(TIME.map((f) => [f.name, f])),
+};
+for (const f of AXIOM) {
+    if (!f.inline) {
+        f.runtime = f.name;
+    }
+}
+/** Desktop-only CL++ modules and what to use on Roblox instead. */
+exports.DESKTOP_ONLY = {
+    "@clpp.fs": "Roblox games have no file system; persist data with DataStoreService (or CluauppLibs Keep)",
+    "@clpp.os": "Roblox games have no process environment; use attributes or a config module",
+    "@clpp.window": "the Roblox client owns the window; use RunService.RenderStepped and UserInputService",
+    "@clpp.gfx": "draw with GUI objects (Frame, ImageLabel) or EditableImage",
+    "@clpp.ui": "build UI with ScreenGui/Frame/TextButton, or CluauppLibs Gleam",
+    "@clpp.gui": "build UI with ScreenGui instances, or the declarative CluauppLibs Gleam",
+    "@clpp.audio": "play Sound instances (SoundService) instead",
+    "@clpp.input": "read input with UserInputService/ContextActionService (scripts cannot drive the mouse)",
+    "@clpp.io": "there is no console input on Roblox; use print/warn",
+};
+exports.STD_PATHS = {
+    "@clpp.axiom": "axiom",
+    "@clpp.Axion": "axiom",
+    "@clpp.mathutils": "axiom",
+    "@clpp.text": "text",
+    "@clpp.math": "math",
+    "@clpp.http": "http",
+    "@clpp.json": "json",
+    "@clpp.time": "time",
+    "@clpp.fs": "unsupported",
+    "@clpp.os": "unsupported",
+};
+function stdModule(name) {
+    return MODULES[name];
+}
+function stdFunctionType(f) {
+    return types_js_1.T.func(f.params, f.ret);
+}

package/generated/compiler/types.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * CL++ type model for the Roblox host: the CL++ core types plus Roblox classes, datatypes,
+ * enums and signals. Types are plain immutable objects; struct/enum details live in registries
+ * keyed by `id` (`<moduleId>::<Name>`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.T = void 0;
+exports.prune = prune;
+exports.isNumeric = isNumeric;
+exports.isIntLike = isIntLike;
+exports.isDynamic = isDynamic;
+exports.isStringLike = isStringLike;
+exports.isBoolLike = isBoolLike;
+exports.widen = widen;
+exports.nonNull = nonNull;
+exports.isNullable = isNullable;
+exports.isValueTable = isValueTable;
+exports.sameType = sameType;
+exports.typeToString = typeToString;
+exports.T = {
+    any: { k: "any" },
+    unknown: { k: "unknown" },
+    never: { k: "never" },
+    void: { k: "void" },
+    null: { k: "null" },
+    int: { k: "int" },
+    float: { k: "float" },
+    bool: { k: "bool" },
+    string: { k: "string" },
+    buffer: { k: "buffer" },
+    thread: { k: "thread" },
+    instance: (cls) => ({ k: "instance", cls }),
+    datatype: (name) => ({ k: "datatype", name }),
+    list: (elem, typed = true) => ({ k: "list", elem, typed }),
+    dict: (key, value) => ({ k: "dict", key, value }),
+    option: (inner) => (inner.k === "option" || inner.k === "any" || inner.k === "unknown" || inner.k === "null" ? inner : { k: "option", inner }),
+    func: (params, ret, variadic = null) => ({ k: "func", params, ret, variadic }),
+};
+/** Follow solved inference slots. */
+function prune(t) {
+    let cur = t;
+    while (cur.k === "infer" && cur.resolved) {
+        cur = cur.resolved;
+    }
+    return cur;
+}
+function isNumeric(t) {
+    const p = prune(t);
+    return p.k === "int" || p.k === "float" || (p.k === "lit" && typeof p.value === "number");
+}
+function isIntLike(t) {
+    const p = prune(t);
+    return p.k === "int" || (p.k === "lit" && typeof p.value === "number" && Number.isInteger(p.value)) || p.k === "enum";
+}
+function isDynamic(t) {
+    const p = prune(t);
+    return p.k === "any" || p.k === "unknown" || (p.k === "infer" && !p.resolved);
+}
+function isStringLike(t) {
+    const p = prune(t);
+    return p.k === "string" || (p.k === "lit" && typeof p.value === "string");
+}
+function isBoolLike(t) {
+    const p = prune(t);
+    return p.k === "bool" || (p.k === "lit" && typeof p.value === "boolean");
+}
+/** Widen literal types: `"Idle"` → string, `3` → int. */
+function widen(t) {
+    const p = prune(t);
+    if (p.k === "lit") {
+        if (typeof p.value === "string") {
+            return exports.T.string;
+        }
+        if (typeof p.value === "boolean") {
+            return exports.T.bool;
+        }
+        return Number.isInteger(p.value) ? exports.T.int : exports.T.float;
+    }
+    return p;
+}
+/** Remove `null`/option wrappers. */
+function nonNull(t) {
+    const p = prune(t);
+    if (p.k === "option") {
+        return p.inner;
+    }
+    if (p.k === "union") {
+        const members = p.members.filter((m) => prune(m).k !== "null");
+        return members.length === 1 ? members[0] : { k: "union", members };
+    }
+    return p;
+}
+function isNullable(t) {
+    const p = prune(t);
+    return p.k === "option" || p.k === "null" || (p.k === "union" && p.members.some((m) => prune(m).k === "null"));
+}
+/** Tables that CL++ treats as values (copied on assignment). */
+function isValueTable(t) {
+    const p = prune(t);
+    return p.k === "struct" || p.k === "list" || p.k === "dict" || p.k === "result";
+}
+function sameType(a, b) {
+    const x = prune(a);
+    const y = prune(b);
+    if (x === y) {
+        return true;
+    }
+    if (x.k !== y.k) {
+        return false;
+    }
+    switch (x.k) {
+        case "lit":
+            return x.value === y.value;
+        case "list":
+            return sameType(x.elem, y.elem);
+        case "dict":
+            return sameType(x.key, y.key) && sameType(x.value, y.value);
+        case "struct":
+            return x.id === y.id && x.args.length === y.args.length && x.args.every((a2, i) => sameType(a2, y.args[i]));
+        case "enum":
+        case "variant":
+            return x.id === y.id;
+        case "option":
+            return sameType(x.inner, y.inner);
+        case "result":
+            return sameType(x.ok, y.ok) && sameType(x.err, y.err);
+        case "task":
+            return sameType(x.result, y.result);
+        case "instance":
+            return x.cls === y.cls;
+        case "datatype":
+            return x.name === y.name;
+        case "rbxEnumItem":
+        case "rbxEnum":
+            return x.enumName === y.enumName;
+        case "param":
+            return x.name === y.name;
+        case "tuple":
+            return x.elems.length === y.elems.length && x.elems.every((e, i) => sameType(e, y.elems[i]));
+        case "union":
+            return x.members.length === y.members.length && x.members.every((m) => y.members.some((n) => sameType(m, n)));
+        default:
+            return true;
+    }
+}
+/** CL++ notation, for diagnostics and hover. */
+function typeToString(t, depth = 0) {
+    const p = prune(t);
+    if (depth > 6) {
+        return "…";
+    }
+    const s = (x) => typeToString(x, depth + 1);
+    switch (p.k) {
+        case "any":
+            return "any";
+        case "unknown":
+            return "unknown";
+        case "never":
+            return "never";
+        case "void":
+            return "void";
+        case "null":
+            return "null";
+        case "int":
+        case "float":
+        case "bool":
+        case "string":
+        case "buffer":
+        case "thread":
+            return p.k;
+        case "lit":
+            return typeof p.value === "string" ? JSON.stringify(p.value) : String(p.value);
+        case "list":
+            return p.typed ? `array<${s(p.elem)}>` : "list";
+        case "dict":
+            return `dictionary<${s(p.key)}, ${s(p.value)}>`;
+        case "tuple":
+            return `(${p.elems.map(s).join(", ")})`;
+        case "table":
+            return `{ ${Object.entries(p.fields).slice(0, 6).map(([k, v]) => `${k}: ${s(v)}`).join(", ")} }`;
+        case "struct":
+            return p.args.length ? `${p.name}<${p.args.map(s).join(", ")}>` : p.name;
+        case "enum":
+        case "variant":
+            return p.name;
+        case "option":
+            return `${s(p.inner)}?`;
+        case "result":
+            return `Result<${s(p.ok)}, ${s(p.err)}>`;
+        case "task":
+            return isDynamic(p.result) || p.result.k === "void" ? "task" : `task<${s(p.result)}>`;
+        case "func": {
+            const params = p.params.map((x) => `${s(x.type)}${x.optional ? "?" : ""}`);
+            if (p.variadic) {
+                params.push(`...${s(p.variadic)}`);
+            }
+            return `func(${params.join(", ")}) -> ${s(p.ret)}`;
+        }
+        case "union":
+            return p.members.map(s).join(" | ");
+        case "param":
+            return p.name;
+        case "instance":
+            return p.cls;
+        case "datatype":
+            return p.name;
+        case "rbxEnumItem":
+            return `Enum.${p.enumName}`;
+        case "rbxEnum":
+            return `Enum.${p.enumName} (enum)`;
+        case "rbxEnums":
+            return "Enum";
+        case "rbxSignal":
+            return `RBXScriptSignal<${p.args.map(s).join(", ")}>`;
+        case "clSignal":
+            return p.params ? `signal(${p.params.map(s).join(", ")})` : "signal";
+        case "namespace":
+            return nsToString(p.ns);
+        case "infer":
+            return "unknown";
+        default:
+            return "unknown";
+    }
+}
+function nsToString(ns) {
+    switch (ns.kind) {
+        case "module":
+        case "luauModule":
+            return `module ${ns.alias}`;
+        case "library":
+            return `library ${ns.name}`;
+        case "datatype":
+            return `${ns.name} (datatype)`;
+        case "instanceStatic":
+            return "Instance";
+        case "struct":
+            return `struct ${ns.name}`;
+        case "enum":
+            return `enum ${ns.name}`;
+        case "clNamespace":
+            return `namespace ${ns.name}`;
+        case "stdlib":
+            return `module ${ns.alias}`;
+        case "result":
+            return "Result";
+        default:
+            return "namespace";
+    }
+}

package/generated/intellisense.js

@@ -13,8 +13,6 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const package_info_js_1 = require("./package-info.js");
-const contract_js_1 = require("./clpp/contract.js");
-const runner_js_1 = require("./clpp/runner.js");
 const paths_js_1 = require("./clpp/paths.js");
 const editor_install_js_1 = require("./editor-install.js");
 function copyDir(from, to) {
@@ -111,7 +109,7 @@ function writeVscode(root) {
     });
 }
 function diagnosticsFor(_source, _fileName) {
-    // Language diagnostics belong to `clpp install`. Do not spawn `clpp api compile`
+    // CL++ diagnostics are reported by the compiler during build. Do not spawn a compiler
     // from the editor — that duplicates source=clpp and freezes on every keystroke.
     return [];
 }
@@ -198,18 +196,6 @@ async function installEditorSupport() {
             console.log(" ", dest);
         }
     }
-    if ((0, runner_js_1.hasClpp)()) {
-        const result = (0, node_child_process_1.spawnSync)("clpp", ["install"], { encoding: "utf8", windowsHide: true });
-        if (result.status === 0) {
-            console.log(String(result.stderr || result.stdout || "clpp install ok").trim());
-        }
-        else {
-            console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
-        }
-    }
-    else {
-        console.log("cluaupp:", contract_js_1.CLPP_INSTALL_HINT);
-    }
     return { local };
 }
 exports.isClppSource = paths_js_1.isSourceFile;

package/generated/lsp.js

@@ -34,7 +34,7 @@ function flareDiagnostics(document) {
     }));
 }
 function start(_options = {}) {
-    const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+    const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all, process.stdin, process.stdout);
     const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
     connection.onInitialize(() => ({
         capabilities: {

package/generated/target/build-cache.js

@@ -21,7 +21,7 @@ const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-exports.COMPILE_CACHE_SCHEMA = 1;
+exports.COMPILE_CACHE_SCHEMA = 2;
 function compileCacheDir(projectRoot) {
     return node_path_1.default.join(projectRoot, ".cluaupp", "compile-cache");
 }
@@ -35,7 +35,7 @@ function indexPath(projectRoot) {
     return node_path_1.default.join(compileCacheDir(projectRoot), "index.json");
 }
 function jobPath(projectRoot, rel) {
-    const safe = rel.replace(/[\\/]/g, "__");
+    const safe = hashText(rel);
     return node_path_1.default.join(compileCacheDir(projectRoot), `${safe}.json`);
 }
 function loadCompileCacheIndex(projectRoot) {
@@ -45,7 +45,7 @@ function loadCompileCacheIndex(projectRoot) {
     }
     try {
         const raw = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
-        if (!raw || typeof raw.entries !== "object") {
+        if (!raw || raw.schemaVersion !== exports.COMPILE_CACHE_SCHEMA || !raw.entries || typeof raw.entries !== "object" || Array.isArray(raw.entries)) {
             return { schemaVersion: exports.COMPILE_CACHE_SCHEMA, entries: {} };
         }
         return { schemaVersion: exports.COMPILE_CACHE_SCHEMA, entries: raw.entries };
@@ -70,7 +70,7 @@ function readCachedJob(projectRoot, rel, sourceHash) {
     }
     try {
         const job = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
-        if (!job || job.sourceHash !== sourceHash || !Array.isArray(job.files)) {
+        if (!job || job.rel !== rel || job.sourceHash !== sourceHash || !Array.isArray(job.files) || !job.files.every(f => typeof f.name === "string" && typeof f.contents === "string")) {
             return null;
         }
         return job;

package/generated/target/datamodel-generate.js

@@ -12,6 +12,7 @@ exports.writeDatamodelArtifacts = writeDatamodelArtifacts;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const datamodel_js_1 = require("./datamodel.js");
+const paths_js_1 = require("../clpp/paths.js");
 function safeIdent(name) {
     const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
     return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
@@ -66,6 +67,17 @@ function writeDatamodelArtifacts(projectRoot, opts) {
     node_fs_1.default.mkdirSync(outDir, { recursive: true });
     const profilePath = node_path_1.default.join(outDir, "datamodel-profile.json");
     node_fs_1.default.writeFileSync(profilePath, JSON.stringify(profileWithoutIndex(profile), null, "\t") + "\n", "utf8");
+    let sourceRoot = "src";
+    const configPath = node_path_1.default.join(projectRoot, "cluaupp.config.json");
+    if (node_fs_1.default.existsSync(configPath)) {
+        const config = JSON.parse(node_fs_1.default.readFileSync(configPath, "utf8"));
+        if (typeof config.rootDir === "string")
+            sourceRoot = config.rootDir;
+    }
+    const sources = (0, paths_js_1.collectSources)(node_path_1.default.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 ||
         node_path_1.default.join(projectRoot, "include", "clpp", "generated", "datamodel.clh");
     node_fs_1.default.mkdirSync(node_path_1.default.dirname(headerPath), { recursive: true });

package/generated/target/gen-rojo-tree.js

@@ -99,6 +99,21 @@ function buildRojoTree(root, rootDir, outDir) {
     const sourceRoot = node_fs_1.default.existsSync(outRoot) ? outRoot : srcRoot;
     const tree = baseTree();
     const relRoot = node_path_1.default.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) => node_path_1.default.relative(srcRoot, file).replace(/\\/g, "/").startsWith(`${service}/`))) {
+                withPath(ensureNode(tree, [service]), `${outDir}/${service}`);
+            }
+        }
+        for (const nested of ["StarterPlayerScripts", "StarterCharacterScripts"]) {
+            if (projectSources.some((file) => node_path_1.default.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`);
     withPath(ensureNode(tree, ["StarterPlayer", "StarterPlayerScripts"]), `${relRoot}/Client`);