cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/clpp/contract.js

@@ -1,6 +1,9 @@
 "use strict";
-/** Stable CL++ ↔ Cluaupp contract (CL++ 0.8.x). Cluaupp invokes the `clpp` binary. */
+/** Legacy adapter policy for CL++ 0.8.x. Requires an upstream compiler implementing the handshake. */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLPP_INSTALL_HINT = exports.MIN_CLPP_VERSION = void 0;
+exports.CLPP_INSTALL_HINT = exports.CLPP_CONTRACT_VERSION = exports.CLPP_VERSION_RANGE = exports.MAX_CLPP_VERSION_EXCLUSIVE = exports.MIN_CLPP_VERSION = void 0;
 exports.MIN_CLPP_VERSION = "0.8.0";
-exports.CLPP_INSTALL_HINT = "Install CL++ 0.8.0+ (`clpp` from https://github.com/KartzRbx/CLPP/releases). Put it on PATH. Prefer `import { Name } from \"./x.clh\"` for language modules; angle `#include <clpp/…>` stays for host prelude. Override with CLPP or CLPP_PATH.";
+exports.MAX_CLPP_VERSION_EXCLUSIVE = "0.9.0";
+exports.CLPP_VERSION_RANGE = ">=0.8.0 <0.9.0";
+exports.CLPP_CONTRACT_VERSION = 1;
+exports.CLPP_INSTALL_HINT = "Install the legacy Luau compiler >=0.8.0 <0.9.0 with contractVersion 1 (the CL++ VM is incompatible) (`clpp` from https://github.com/KartzRbx/CLPP/releases). Put it on PATH. Prefer `import { Name } from \"./x.clh\"` for language modules; angle `#include <clpp/…>` stays for host prelude. Override with CLPP or CLPP_PATH.";

package/generated/clpp/handshake.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCompilerVersion = parseCompilerVersion;
+exports.acceptsCompilerVersion = acceptsCompilerVersion;
+exports.validateCompilerHandshake = validateCompilerHandshake;
+const contract_js_1 = require("./contract.js");
+function parseCompilerVersion(text) {
+    const m = /^(?:clpp\s+|CL\+\+\s+)?(\d+)\.(\d+)\.(\d+)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/i.exec(text.trim());
+    return m ? m.slice(1, 4).map(Number) : null;
+}
+function compare(a, b) {
+    return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+function acceptsCompilerVersion(text) {
+    const v = parseCompilerVersion(text);
+    return !!v && compare(v, parseCompilerVersion(contract_js_1.MIN_CLPP_VERSION)) >= 0 && compare(v, parseCompilerVersion(contract_js_1.MAX_CLPP_VERSION_EXCLUSIVE)) < 0;
+}
+function validateCompilerHandshake(version, value) {
+    const fail = (reason) => { throw new Error(`cluaupp: incompatible clpp (${version || "unknown"}): ${reason}. Require Luau compiler ${contract_js_1.CLPP_VERSION_RANGE}, contractVersion ${contract_js_1.CLPP_CONTRACT_VERSION}. The clpp game VM cannot emit Roblox Luau. Set CLPP or CLPP_PATH to the Luau compiler.`); };
+    if (!acceptsCompilerVersion(version))
+        fail("unsupported version");
+    if (!value || typeof value !== "object")
+        fail("missing api manifest");
+    const m = value;
+    if (m.id !== "clpp" || m.name !== "CL++")
+        fail("wrong compiler identity");
+    if (m.contractVersion !== contract_js_1.CLPP_CONTRACT_VERSION)
+        fail("missing or unsupported contractVersion");
+    if (!acceptsCompilerVersion(m.version) || compare(parseCompilerVersion(version), parseCompilerVersion(m.version)) !== 0)
+        fail("binary and manifest versions disagree");
+    if (!Array.isArray(m.extensions) || ![".clpp", ".clp", ".clh"].every(x => m.extensions.includes(x)))
+        fail("missing source extensions");
+    if (!Array.isArray(m.tags) || ![["*.server.clpp", "server", "Script"], ["*.client.clpp", "client", "LocalScript"], ["*.clh", "header", "ModuleScript"]].every(([pattern, kind, cls]) => m.tags.some(t => t.pattern === pattern && t.scriptKind === kind && t.rojoClass === cls)))
+        fail("missing Roblox file tags");
+    return m;
+}

package/generated/clpp/modules.js

@@ -135,19 +135,30 @@ function resolveLanguageDeps(source, fromFile, srcDir) {
     return out;
 }
 /**
- * Fingerprint source + one-hop language deps so import/include edits invalidate incremental cache.
+ * Fingerprint source + transitive language deps so import/include edits invalidate incremental cache.
  */
 function fingerprintSourceWithDeps(source, fromFile, configKey, srcDir, hashText) {
     const parts = [configKey, source];
-    for (const dep of resolveLanguageDeps(source, fromFile, srcDir)) {
-        try {
-            parts.push(`\n//dep:${dep.replace(/\\/g, "/")}\n`);
-            parts.push(node_fs_1.default.readFileSync(dep, "utf8"));
-        }
-        catch {
-            parts.push(`\n//dep-missing:${dep.replace(/\\/g, "/")}\n`);
+    const seen = new Set([node_path_1.default.resolve(fromFile)]);
+    const visit = (text, file) => {
+        for (const ref of collectModuleRefs(text)) {
+            if (ref.angled)
+                continue;
+            const dep = resolveModuleFile(ref.modulePath, file, srcDir);
+            if (!dep) {
+                parts.push("\n//missing:" + file + ":" + ref.modulePath);
+                continue;
+            }
+            const key = node_path_1.default.resolve(dep);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const contents = node_fs_1.default.readFileSync(key, "utf8");
+            parts.push("\n//dep:" + key.replace(/\\/g, "/") + "\n", contents);
+            visit(contents, key);
         }
-    }
+    };
+    visit(source, fromFile);
     return hashText(parts.join(""));
 }
 /** Rewrite CL++ `script.Parent…Service…` walks to game-rooted requires. */

package/generated/clpp/runner.js

@@ -11,36 +11,68 @@ exports.compileViaClppAsync = compileViaClppAsync;
 exports.clppManifest = clppManifest;
 exports.clppVersion = clppVersion;
 exports.clppInstalls = clppInstalls;
+exports.clppCacheIdentity = clppCacheIdentity;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const contract_js_1 = require("./contract.js");
+const handshake_js_1 = require("./handshake.js");
 const MISSING_CLPP = `cluaupp: clpp not found. ${contract_js_1.CLPP_INSTALL_HINT}`;
 let cachedBin;
+let cachedSelectionKey = "";
+const contractSupport = new Map();
+function binaryKey(bin) {
+    const stat = node_fs_1.default.statSync(bin);
+    return JSON.stringify([bin, stat.size, stat.mtimeMs]);
+}
 function parseSemver(text) {
-    const match = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+    const match = String(text).match(/(\d+)\.(\d+)(?:\.(\d+))?/);
     if (!match) {
         return null;
     }
-    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+    return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3] || 0) };
 }
 function cmpSemver(a, b) {
     return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
 }
-function minClpp() {
-    return parseSemver(contract_js_1.MIN_CLPP_VERSION) || { major: 0, minor: 8, patch: 0 };
-}
-function tooOldMessage(bin, version) {
-    return `cluaupp: clpp ${version || "unknown"} is too old (${bin}). Need CL++ ${contract_js_1.MIN_CLPP_VERSION}+. Install https://github.com/KartzRbx/CLPP/releases or set CLPP / CLPP_PATH.`;
-}
 function probeVersion(bin) {
-    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true });
+    const result = (0, node_child_process_1.spawnSync)(bin, ["--version"], { encoding: "utf8", windowsHide: true, timeout: 10_000 });
     if (result.status !== 0) {
         return null;
     }
     return String(result.stdout || result.stderr || "").trim() || null;
 }
+function handshake(bin) {
+    const key = binaryKey(bin);
+    const cached = contractSupport.get(key);
+    if (cached)
+        return cached;
+    const version = probeVersion(bin) || "";
+    let manifest;
+    // Reject the VM before asking it to compile or interpret any input.
+    if ((0, handshake_js_1.acceptsCompilerVersion)(version)) {
+        const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], { encoding: "utf8", windowsHide: true, timeout: 10_000 });
+        if (result.status === 0) {
+            try {
+                manifest = JSON.parse(String(result.stdout || ""));
+            }
+            catch { }
+        }
+    }
+    const validated = (0, handshake_js_1.validateCompilerHandshake)(version, manifest);
+    contractSupport.set(key, validated);
+    return validated;
+}
+function supportsLuauContract(bin) {
+    try {
+        handshake(bin);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function pushCandidate(out, seen, item) {
     const value = String(item || "").trim();
     if (!value) {
@@ -66,9 +98,12 @@ function listClppCandidates() {
     const override = [];
     pushCandidate(override, seen, process.env.CLPP);
     pushCandidate(override, seen, process.env.CLPP_PATH);
-    const overrideExisting = override.filter(existsBin);
-    if (overrideExisting.length > 0) {
-        return overrideExisting;
+    if (override.length > 0) {
+        for (const bin of override) {
+            if (!existsBin(bin))
+                throw new Error(`cluaupp: explicit CLPP/CLPP_PATH does not exist: ${bin}`);
+        }
+        return override;
     }
     const out = [];
     const finder = process.platform === "win32" ? "where" : "which";
@@ -97,7 +132,7 @@ function pickClppBinary() {
         if (!fallback) {
             fallback = bin;
         }
-        if (!parsed) {
+        if (!parsed || !supportsLuauContract(bin)) {
             continue;
         }
         if (!best || cmpSemver(parsed, best.parsed) > 0) {
@@ -107,9 +142,11 @@ function pickClppBinary() {
     return best?.bin || fallback;
 }
 function whichClpp() {
-    if (cachedBin !== undefined) {
+    const selectionKey = JSON.stringify([process.env.CLPP, process.env.CLPP_PATH, process.env.PATH]);
+    if (cachedBin !== undefined && selectionKey === cachedSelectionKey) {
         return cachedBin;
     }
+    cachedSelectionKey = selectionKey;
     cachedBin = pickClppBinary();
     return cachedBin;
 }
@@ -121,18 +158,14 @@ function resolveClppBinary() {
     if (!bin) {
         throw new Error(MISSING_CLPP);
     }
-    const version = probeVersion(bin);
-    const parsed = parseSemver(version || "");
-    if (!parsed || cmpSemver(parsed, minClpp()) < 0) {
-        throw new Error(tooOldMessage(bin, version));
-    }
+    handshake(bin);
     return bin;
 }
 function parseArtifact(stdout, fileName, fallbackError) {
     const text = String(stdout || "").trim();
     try {
         const parsed = JSON.parse(text);
-        if (parsed && typeof parsed === "object") {
+        if (parsed && typeof parsed === "object" && typeof parsed.ok === "boolean" && typeof parsed.luau === "string" && typeof parsed.fileName === "string") {
             return parsed;
         }
     }
@@ -158,7 +191,7 @@ function formatClppFailure(artifact, fallback) {
         return diags
             .map((d) => {
             const where = `${artifact.fileName || "clpp"}:${d.line}:${d.column}`;
-            return `${where}: ${d.message}`;
+            return `${where}: ${d.severity}${d.code ? " [" + d.code + "]" : ""}: ${d.message}${d.help ? "\n  " + d.help : ""}`;
         })
             .join("\n");
     }
@@ -186,7 +219,7 @@ function compileViaClpp(request) {
     });
     const stderr = String(result.stderr || "").trim();
     const artifact = parseArtifact(result.stdout, request.fileName, stderr || result.error?.message || "clpp api compile failed");
-    if (!artifact.ok) {
+    if (result.status !== 0 || result.error || !artifact.ok) {
         throw new Error(formatClppFailure(artifact, stderr || result.error?.message || `clpp failed (${result.status})`));
     }
     return artifact;
@@ -218,7 +251,7 @@ function compileViaClppAsync(request) {
         child.on("error", reject);
         child.on("close", (code) => {
             const artifact = parseArtifact(stdout, request.fileName, stderr.trim() || `clpp api compile failed (${code})`);
-            if (!artifact.ok) {
+            if (code !== 0 || !artifact.ok) {
                 reject(new Error(formatClppFailure(artifact, stderr.trim() || `clpp failed (${code})`)));
                 return;
             }
@@ -239,14 +272,7 @@ function compileViaClppAsync(request) {
 }
 function clppManifest() {
     const bin = resolveClppBinary();
-    const result = (0, node_child_process_1.spawnSync)(bin, ["api", "manifest"], {
-        encoding: "utf8",
-        windowsHide: true,
-    });
-    if (result.status !== 0) {
-        throw new Error(String(result.stderr || result.error?.message || "clpp api manifest failed"));
-    }
-    return JSON.parse(result.stdout);
+    return handshake(bin);
 }
 function clppVersion() {
     const bin = whichClpp();
@@ -263,3 +289,8 @@ function clppInstalls() {
         selected: bin === selected,
     }));
 }
+/** Include the actual binary and handshake in incremental fingerprints. */
+function clppCacheIdentity() {
+    const bin = resolveClppBinary();
+    return JSON.stringify([binaryKey(bin), handshake(bin)]);
+}

package/generated/compile.js

@@ -21,6 +21,8 @@ const datamodel_generate_js_1 = require("./target/datamodel-generate.js");
 const parallel_check_js_1 = require("./target/parallel-check.js");
 const authority_check_js_1 = require("./target/authority-check.js");
 const get_service_js_1 = require("./target/get-service.js");
+const project_js_1 = require("./compiler/project.js");
+const diagnostics_js_1 = require("./compiler/diagnostics.js");
 function defaultTargetProfilePath() {
     const cached = node_path_1.default.join(package_info_js_1.projectRoot, "api", "normalized", "roblox-target.profile.json");
     if (node_fs_1.default.existsSync(cached)) {
@@ -122,7 +124,7 @@ function finishArtifact(artifact, relative, outName, options, skipInit, source)
     return {
         kind: (0, paths_js_1.emitKind)(relative),
         plan: { kind: (0, paths_js_1.emitKind)(relative), strict: options.strict === true },
-        files: [{ name: outName, contents: luau }],
+        files: [{ name: outName, contents: luau, sourceMap: artifact.sourceMap, generatedSource: artifact.luau }],
         stale: [],
     };
 }
@@ -130,14 +132,29 @@ function compileSource(source, fileName, options = {}) {
     return compileService(source, fileName, options).files[0]?.contents ?? "";
 }
 function compileService(source, fileName, options = {}) {
+    if (/\.clp$/i.test(options.relativeName || fileName || "")) {
+        return compileModernSource(source, fileName, options);
+    }
     const args = compileArgs(source, fileName, options);
     enforcePlatform(source, args.relative, args);
     const artifact = (0, runner_js_1.compileViaClpp)(args.request);
     return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit, source);
 }
 async function compileServiceAsync(source, fileName, options = {}) {
+    if (/\.clp$/i.test(options.relativeName || fileName || "")) {
+        return compileModernSource(source, fileName, options);
+    }
     const args = compileArgs(source, fileName, options);
     enforcePlatform(source, args.relative, args);
     const artifact = await (0, runner_js_1.compileViaClppAsync)(args.request);
     return finishArtifact(artifact, args.relative, args.outName, args.options, args.skipInit, source);
 }
+function compileModernSource(source, fileName, options) {
+    const relative = (options.relativeName || fileName || "input.clp").replace(/\\/g, "/");
+    const srcDir = options.srcDir || (options.filePath ? node_path_1.default.dirname(node_path_1.default.resolve(options.filePath)) : process.cwd());
+    const result = (0, project_js_1.compileSource)(source, relative, { srcDir, strict: options.strict === true, version: package_info_js_1.pkg.version });
+    if (result.luau === null) {
+        throw new Error(result.diagnostics.filter((d) => d.severity === "error").map((d) => (0, diagnostics_js_1.formatDiagnostic)(d, result.source)).join("\n") || `${relative}: Luau emission failed`);
+    }
+    return { kind: (0, paths_js_1.emitKind)(relative), files: [{ name: options.outName || (0, paths_js_1.toLuauPath)(relative), contents: result.luau, sourceMap: result.sourceMap, generatedSource: result.luau }], stale: [] };
+}

package/generated/compiler/ast.js

@@ -0,0 +1,3 @@
+"use strict";
+/** CL++ syntax tree. The checker annotates nodes in place (`ty`, `res`, `sym`). */
+Object.defineProperty(exports, "__esModule", { value: true });