cluaupp 1.5.2 → 2.0.0-beta.1

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/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/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`);

package/generated/target/source-map.js

@@ -3,23 +3,76 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.remapSourceLines = remapSourceLines;
+exports.embedSourceMap = embedSourceMap;
 exports.writeSourceMap = writeSourceMap;
-/** Minimal source map: CL++ path ↔ emitted Luau (1:1 file mapping for v1). */
+/** Compiler coordinates are retained only for lines that survive host transformations. */
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+/** LCS alignment: inserted headers and removed lines never become fake source locations. */
+function remapSourceLines(original, generated, mappings = []) {
+    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();
+    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 } : {}) }];
+    });
+}
+function embedSourceMap(luau, lines) {
+    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 };
+}
 function writeSourceMap(opts) {
+    const lines = opts.lines || [];
+    const source = opts.sourceClppRel.replace(/\\/g, "/");
     const map = {
         version: 1,
         file: node_path_1.default.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: node_path_1.default.relative(opts.projectRoot, opts.outLuauPath).replace(/\\/g, "/"),
-        },
+        sources: [...new Set([source, ...lines.map(m => m.file)])],
+        cluaupp: { source, generated: node_path_1.default.relative(opts.projectRoot, opts.outLuauPath).replace(/\\/g, "/"), lines },
     };
     const mapPath = opts.outLuauPath + ".map.json";
-    node_fs_1.default.writeFileSync(mapPath, JSON.stringify(map, null, "\t") + "\n", "utf8");
+    const contents = JSON.stringify(map, null, "\t") + "\n";
+    if (!node_fs_1.default.existsSync(mapPath) || node_fs_1.default.readFileSync(mapPath, "utf8") !== contents)
+        node_fs_1.default.writeFileSync(mapPath, contents, "utf8");
     return mapPath;
 }

package/generated/target/studio-bridge.js

@@ -80,6 +80,7 @@ function startStudioBridge(opts = {}) {
                         type: data.type || "open",
                         path: rel || undefined,
                         line: data.line,
+                        column: data.column,
                         instancePath: data.instancePath,
                         message: data.message,
                     });