cluaupp 1.5.0 → 1.5.1

package/generated/target/project-docs.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Generate project documentation from DataModel + graph + Flare + advice.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProjectDocs = generateProjectDocs;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const datamodel_js_1 = require("./datamodel.js");
+const project_graph_js_1 = require("./project-graph.js");
+const flare_version_js_1 = require("./flare-version.js");
+const paths_js_1 = require("../clpp/paths.js");
+const optimizer_advise_js_1 = require("./optimizer-advise.js");
+function generateProjectDocs(projectRoot, rootDir = "src") {
+    const dm = (0, datamodel_js_1.buildDatamodelProfile)(projectRoot);
+    const graph = (0, project_graph_js_1.buildProjectGraph)(projectRoot, rootDir);
+    const flare = (0, flare_version_js_1.checkFlareVersions)(projectRoot, rootDir);
+    const srcDir = node_path_1.default.join(projectRoot, rootDir);
+    const files = node_fs_1.default.existsSync(srcDir) ? (0, paths_js_1.collectSources)(srcDir) : [];
+    const advice = [];
+    for (const file of files) {
+        const rel = node_path_1.default.relative(projectRoot, file).replace(/\\/g, "/");
+        for (const a of (0, optimizer_advise_js_1.adviseOptimizer)(node_fs_1.default.readFileSync(file, "utf8"), rel)) {
+            advice.push(`- **${a.target}** (${a.kind}): ${a.message}`);
+        }
+    }
+    const paths = dm
+        ? Object.keys(dm.byPath)
+            .filter((p) => p !== "DataModel")
+            .sort()
+            .map((p) => `- \`${p}\` — ${dm.byPath[p].className}`)
+            .join("\n")
+        : "_no default.project.json_";
+    const markdown = [
+        `# Cluaupp project docs`,
+        ``,
+        `Generated: ${new Date().toISOString()}`,
+        ``,
+        `## DataModel`,
+        ``,
+        paths,
+        ``,
+        `## Modules (${graph.nodes.length})`,
+        ``,
+        graph.nodes.map((n) => `- \`${n}\``).join("\n") || "_none_",
+        ``,
+        `## Dependencies`,
+        ``,
+        graph.edges.map((e) => `- \`${e.from}\` → \`${e.to}\``).join("\n") || "_none_",
+        ``,
+        graph.cycles.length ? `### Cycles\n\n${graph.cycles.map((c) => `- ${c.join(" → ")}`).join("\n")}\n` : "",
+        `## Flare contracts`,
+        ``,
+        flare.files.map((f) => `- \`${f.file}\` name=\`${f.name}\` version=${f.version ?? "unset"}`).join("\n") || "_none_",
+        ``,
+        `## Optimizer advice`,
+        ``,
+        advice.slice(0, 40).join("\n") || "_none_",
+        ``,
+    ].join("\n");
+    const outDir = node_path_1.default.join(projectRoot, ".cluaupp");
+    node_fs_1.default.mkdirSync(outDir, { recursive: true });
+    const outPath = node_path_1.default.join(outDir, "PROJECT.md");
+    node_fs_1.default.writeFileSync(outPath, markdown, "utf8");
+    return { outPath, markdown };
+}

package/generated/target/project-graph.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectGraph = buildProjectGraph;
+/** Project include/import/require graph + circular dependency detection. */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const modules_js_1 = require("../clpp/modules.js");
+const paths_js_1 = require("../clpp/paths.js");
+function findCycles(nodes, edges) {
+    const adj = new Map();
+    for (const n of nodes)
+        adj.set(n, []);
+    for (const e of edges) {
+        if (!adj.has(e.from))
+            adj.set(e.from, []);
+        adj.get(e.from).push(e.to);
+    }
+    const cycles = [];
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    function dfs(n) {
+        if (visiting.has(n)) {
+            const i = stack.indexOf(n);
+            if (i >= 0)
+                cycles.push(stack.slice(i).concat(n));
+            return;
+        }
+        if (visited.has(n))
+            return;
+        visiting.add(n);
+        stack.push(n);
+        for (const to of adj.get(n) || [])
+            dfs(to);
+        stack.pop();
+        visiting.delete(n);
+        visited.add(n);
+    }
+    for (const n of nodes)
+        dfs(n);
+    return cycles;
+}
+function buildProjectGraph(projectRoot, rootDir = "src") {
+    const srcDir = node_path_1.default.join(projectRoot, rootDir);
+    const files = node_fs_1.default.existsSync(srcDir) ? (0, paths_js_1.collectSources)(srcDir) : [];
+    const nodes = [];
+    const edges = [];
+    const byAbs = new Map();
+    for (const file of files) {
+        const rel = node_path_1.default.relative(projectRoot, file).replace(/\\/g, "/");
+        nodes.push(rel);
+        byAbs.set(node_path_1.default.resolve(file), rel);
+    }
+    for (const file of files) {
+        const rel = node_path_1.default.relative(projectRoot, file).replace(/\\/g, "/");
+        const source = node_fs_1.default.readFileSync(file, "utf8");
+        for (const mod of (0, modules_js_1.collectLanguageModulePaths)(source)) {
+            const resolved = (0, modules_js_1.resolveModuleFile)(mod, file, srcDir);
+            if (!resolved)
+                continue;
+            const hit = byAbs.get(node_path_1.default.resolve(resolved));
+            if (hit && hit !== rel) {
+                edges.push({ from: rel, to: hit });
+            }
+        }
+    }
+    return { nodes, edges, cycles: findCycles(nodes, edges) };
+}

package/generated/target/roblox.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILE_TAG_TO_CONTEXT = void 0;
+exports.runContextFromFileName = runContextFromFileName;
+exports.defaultRobloxProject = defaultRobloxProject;
+exports.resolveGetServiceType = resolveGetServiceType;
+exports.isRegisteredService = isRegisteredService;
+exports.targetProfileSummary = targetProfileSummary;
+const model_js_1 = require("../api/model.js");
+const build_profile_js_1 = require("../api/build-profile.js");
+exports.FILE_TAG_TO_CONTEXT = {
+    ".server": "Server",
+    ".client": "Client",
+    ".plugin": "Plugin",
+};
+function runContextFromFileName(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.includes(".server.")) {
+        return "Server";
+    }
+    if (lower.includes(".client.")) {
+        return "Client";
+    }
+    if (lower.includes(".plugin.")) {
+        return "Plugin";
+    }
+    return "Shared";
+}
+function defaultRobloxProject() {
+    return {
+        kind: "roblox",
+        libsFolderName: "CluauppLibs",
+        legacyLibsAlias: "ClppLibs",
+    };
+}
+/**
+ * Target-side GetService\<T\> — **Cluaupp Roblox Target feature**, not a CL++ language rule.
+ * CL++ only provides generic-call syntax (`GetService<Players>()`); Cluaupp maps T via the
+ * Canonical Registry, Context Safety, and headers under `#include <clpp/roblox.clh>`.
+ */
+function resolveGetServiceType(typeName, profile) {
+    const p = profile || (0, build_profile_js_1.buildRobloxTargetProfile)({ skipValidate: true });
+    if (p.services[typeName]) {
+        return typeName;
+    }
+    if (p.classes[typeName]?.service || p.classes[typeName]?.creation.service) {
+        return typeName;
+    }
+    return null;
+}
+/** True when `name` is a registered Roblox service class. */
+function isRegisteredService(name, profile) {
+    return resolveGetServiceType(name, profile) != null;
+}
+function targetProfileSummary() {
+    const profile = (0, build_profile_js_1.buildRobloxTargetProfile)({ skipValidate: true });
+    return {
+        schemaVersion: model_js_1.ROBLOX_TARGET_SCHEMA_VERSION,
+        target: "roblox",
+        classes: Object.keys(profile.classes).length,
+        services: Object.keys(profile.services).length,
+    };
+}

package/generated/target/security-check.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSecurity = checkSecurity;
+/** Static security patterns (CLUAU-SEC*) — not a runtime anti-cheat. */
+const roblox_js_1 = require("./roblox.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const CLIENT_PATTERNS = [
+    { code: "CLUAU_SEC001", re: /\bCoins\s*=/, message: "Client appears to assign Coins — server must own currency" },
+    { code: "CLUAU_SEC002", re: /\bDamage\s*=\s*[^=]/, message: "Client appears to set Damage — prefer server authority" },
+    { code: "CLUAU_SEC003", re: /FireServer\s*\([^)]*Instance/, message: "Remote may accept unrestricted Instance from client" },
+    { code: "CLUAU_SEC004", re: /Inventory.*=.*FireServer|FireServer.*Inventory/, message: "Client-supplied inventory result smell" },
+];
+const SERVER_PATTERNS = [
+    { code: "CLUAU_SEC010", re: /FireServer/, message: "Server calling FireServer is inverted authority" },
+    {
+        code: "CLUAU_SEC011",
+        re: /\.Position\b[^\n]*player|player[^\n]*\.Position/,
+        message: "Server may be trusting client Position — validate or ignore client transform",
+    },
+];
+function checkSecurity(source, fileName) {
+    const ctx = (0, roblox_js_1.runContextFromFileName)(fileName);
+    const clean = (0, diagnostics_js_1.stripCommentsKeepStrings)(source);
+    const out = [];
+    const list = ctx === "Client" ? CLIENT_PATTERNS : ctx === "Server" ? SERVER_PATTERNS : [];
+    for (const p of list) {
+        const m = p.re.exec(clean);
+        if (!m)
+            continue;
+        const { line, column } = (0, diagnostics_js_1.lineColAt)(clean, m.index);
+        out.push({
+            code: p.code,
+            message: p.message,
+            line,
+            column,
+            severity: "warning",
+            file: fileName,
+        });
+    }
+    return out;
+}

package/generated/target/source-map.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSourceMap = writeSourceMap;
+/** Minimal source map: CL++ path ↔ emitted Luau (1:1 file mapping for v1). */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function writeSourceMap(opts) {
+    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, "/"),
+        },
+    };
+    const mapPath = opts.outLuauPath + ".map.json";
+    node_fs_1.default.writeFileSync(mapPath, JSON.stringify(map, null, "\t") + "\n", "utf8");
+    return mapPath;
+}

package/generated/target/studio-bridge.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Local HTTP bridge: Studio plugin ↔ IDE (VS Code / Cursor).
+ * Default port 3847. Studio POSTs open requests; IDE polls /events.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRIDGE_DEFAULT_PORT = void 0;
+exports.startStudioBridge = startStudioBridge;
+const node_http_1 = __importDefault(require("node:http"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_events_1 = require("node:events");
+exports.BRIDGE_DEFAULT_PORT = 3847;
+function startStudioBridge(opts = {}) {
+    const port = opts.port ?? exports.BRIDGE_DEFAULT_PORT;
+    const bus = new node_events_1.EventEmitter();
+    const events = [];
+    let nextId = 1;
+    const push = (partial) => {
+        const ev = {
+            id: nextId++,
+            at: new Date().toISOString(),
+            ...partial,
+        };
+        events.push(ev);
+        if (events.length > 200)
+            events.shift();
+        bus.emit("event", ev);
+        opts.onEvent?.(ev);
+        return ev;
+    };
+    const server = node_http_1.default.createServer((req, res) => {
+        const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, service: "cluaupp-bridge", port }));
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/events") {
+            const since = Number(url.searchParams.get("since") || "0");
+            const batch = events.filter((e) => e.id > since);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ events: batch }));
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/open") {
+            let body = "";
+            req.on("data", (c) => {
+                body += c;
+                if (body.length > 1_000_000)
+                    req.destroy();
+            });
+            req.on("end", () => {
+                try {
+                    const data = JSON.parse(body || "{}");
+                    const rel = (data.path || "").replace(/\\/g, "/");
+                    if (opts.projectRoot && rel && !rel.includes("..")) {
+                        const abs = node_path_1.default.resolve(opts.projectRoot, rel);
+                        if (!abs.startsWith(node_path_1.default.resolve(opts.projectRoot))) {
+                            res.writeHead(400);
+                            res.end("bad path");
+                            return;
+                        }
+                        if (!node_fs_1.default.existsSync(abs) && !rel.endsWith(".clpp") && !rel.endsWith(".clh")) {
+                            /* still emit — file may be unsaved emit path */
+                        }
+                    }
+                    const ev = push({
+                        type: data.type || "open",
+                        path: rel || undefined,
+                        line: data.line,
+                        instancePath: data.instancePath,
+                        message: data.message,
+                    });
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ ok: true, id: ev.id }));
+                }
+                catch (err) {
+                    res.writeHead(400);
+                    res.end(String(err instanceof Error ? err.message : err));
+                }
+            });
+            return;
+        }
+        res.writeHead(404);
+        res.end("not found");
+    });
+    server.listen(port, "127.0.0.1");
+    return {
+        port,
+        close: () => {
+            server.close();
+            bus.removeAllListeners();
+        },
+        onEvent: (fn) => {
+            bus.on("event", fn);
+            return () => bus.off("event", fn);
+        },
+        getEventsSince: (id) => events.filter((e) => e.id > id),
+    };
+}

package/generated/utils/project.js

@@ -13,6 +13,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 postprocess_js_1 = require("../clpp/postprocess.js");
 const paths_js_1 = require("../clpp/paths.js");
 const index_js_1 = require("../flare/index.js");
 const index_js_2 = require("../native/index.js");
@@ -21,6 +22,16 @@ const process_orchestrator_js_1 = require("./process-orchestrator.js");
 const rojo_mapper_js_1 = require("./rojo-mapper.js");
 const transpile_js_1 = require("../transpile.js");
 const safe_paths_js_1 = require("./safe-paths.js");
+const source_map_js_1 = require("../target/source-map.js");
+const luau_stamp_js_1 = require("../target/luau-stamp.js");
+const optimizer_soa_js_1 = require("../target/optimizer-soa.js");
+const index_js_3 = require("../api/index.js");
+const flare_version_js_1 = require("../target/flare-version.js");
+const component_contracts_js_1 = require("../target/component-contracts.js");
+const authority_check_js_1 = require("../target/authority-check.js");
+const datamodel_js_1 = require("../target/datamodel.js");
+const build_cache_js_1 = require("../target/build-cache.js");
+const modules_js_1 = require("../clpp/modules.js");
 function readProjectConfig(file) {
     const raw = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -40,6 +51,12 @@ function readProjectConfig(file) {
     if (typeof data.architecture === "boolean") {
         parsed.architecture = data.architecture;
     }
+    if (data.rules && typeof data.rules === "object") {
+        parsed.rules = data.rules;
+    }
+    if (Array.isArray(data.components)) {
+        parsed.components = data.components;
+    }
     return parsed;
 }
 function loadConfig(root) {
@@ -356,41 +373,128 @@ function compileFlareJobs(root, config, srcDir) {
     }
     return { jobs, errors };
 }
-function compileProject(root, config, mapper) {
+function configFingerprint(config) {
+    return JSON.stringify({
+        strict: config.strict === true,
+        architecture: config.architecture === true,
+        rootDir: config.rootDir,
+        outDir: config.outDir,
+        v: package_info_js_1.pkg.version,
+    });
+}
+function compileProject(root, config, mapper, options = {}) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
     const schema = compileSchemaJobs(root, config, srcDir);
     const files = (0, paths_js_1.collectSources)(srcDir);
     const jobs = [...schema.jobs];
     const errors = [...schema.errors];
+    const incremental = options.incremental !== false;
+    const cfgKey = configFingerprint(config);
+    let cacheHits = 0;
     for (const file of files) {
         const source = node_fs_1.default.readFileSync(file, "utf8");
         const rel = posixRel(srcDir, file);
+        const sourceHash = (0, modules_js_1.fingerprintSourceWithDeps)(source, file, cfgKey, srcDir, build_cache_js_1.hashText);
         try {
+            if (incremental) {
+                const cached = (0, build_cache_js_1.readCachedJob)(root, rel, sourceHash);
+                if (cached) {
+                    jobs.push({ rel, files: cached.files, stale: cached.stale || [] });
+                    cacheHits++;
+                    continue;
+                }
+            }
             const result = (0, transpile_js_1.transpileSource)(source, rel, compileOptions(root, config, file, rel), mapper);
             jobs.push({ rel, files: result.files, stale: result.stale || [] });
+            if (incremental) {
+                (0, build_cache_js_1.writeCachedJob)(root, {
+                    rel,
+                    sourceHash,
+                    files: result.files,
+                    stale: result.stale || [],
+                });
+            }
         }
         catch (err) {
             errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
         }
     }
+    if (cacheHits > 0) {
+        console.log(`cluaupp: incremental cache hit ${cacheHits}/${files.length}`);
+    }
     return { files, jobs, errors };
 }
-async function compileProjectAsync(root, config, mapper) {
+async function compileProjectAsync(root, config, mapper, options = {}) {
     const srcDir = node_path_1.default.join(root, config.rootDir);
     const schema = compileSchemaJobs(root, config, srcDir);
     const files = (0, paths_js_1.collectSources)(srcDir);
     const jobs = [...schema.jobs];
     const errors = [...schema.errors];
-    for (const file of files) {
+    const incremental = options.incremental !== false;
+    const cfgKey = configFingerprint(config);
+    const concurrency = options.jobs ?? (0, build_cache_js_1.defaultJobCount)();
+    let cacheHits = 0;
+    const compiled = await (0, build_cache_js_1.mapPool)(files, concurrency, async (file) => {
         const source = node_fs_1.default.readFileSync(file, "utf8");
         const rel = posixRel(srcDir, file);
+        const sourceHash = (0, modules_js_1.fingerprintSourceWithDeps)(source, file, cfgKey, srcDir, build_cache_js_1.hashText);
         try {
+            if (incremental) {
+                const cached = (0, build_cache_js_1.readCachedJob)(root, rel, sourceHash);
+                if (cached) {
+                    return {
+                        ok: true,
+                        rel,
+                        files: cached.files,
+                        stale: cached.stale || [],
+                        cached: true,
+                        sourceHash,
+                    };
+                }
+            }
             const result = await (0, transpile_js_1.transpileSourceAsync)(source, rel, compileOptions(root, config, file, rel), mapper);
-            jobs.push({ rel, files: result.files, stale: result.stale || [] });
+            return {
+                ok: true,
+                rel,
+                files: result.files,
+                stale: result.stale || [],
+                cached: false,
+                sourceHash,
+            };
         }
         catch (err) {
-            errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+            return {
+                ok: false,
+                rel,
+                prefixes: sourcePrefixes(rel),
+                message: err.message,
+            };
         }
+    });
+    for (const item of compiled) {
+        if (item.ok) {
+            jobs.push({ rel: item.rel, files: item.files, stale: item.stale });
+            if (item.cached) {
+                cacheHits++;
+            }
+            else if (incremental) {
+                (0, build_cache_js_1.writeCachedJob)(root, {
+                    rel: item.rel,
+                    sourceHash: item.sourceHash,
+                    files: item.files,
+                    stale: item.stale,
+                });
+            }
+        }
+        else {
+            errors.push({ rel: item.rel, prefixes: item.prefixes, message: item.message });
+        }
+    }
+    if (cacheHits > 0) {
+        console.log(`cluaupp: incremental cache hit ${cacheHits}/${files.length} (jobs=${concurrency})`);
+    }
+    else if (files.length > 1 && concurrency > 1) {
+        console.log(`cluaupp: parallel compile jobs=${concurrency}`);
     }
     return { files, jobs, errors };
 }
@@ -424,11 +528,25 @@ function writeJobs(root, config, jobs, format) {
             if (!dest) {
                 continue;
             }
-            const changed = writeTextIfChanged(dest, artifact.contents);
+            let contents = artifact.contents;
+            if (/\.luau$/i.test(dest)) {
+                const srcFile = node_path_1.default.join(root, config.rootDir, job.rel);
+                const clppSource = node_fs_1.default.existsSync(srcFile) ? node_fs_1.default.readFileSync(srcFile, "utf8") : undefined;
+                contents = (0, luau_stamp_js_1.stampLuauFromClpp)((0, postprocess_js_1.rewriteClppEmit)(contents), job.rel, clppSource);
+            }
+            const changed = writeTextIfChanged(dest, contents);
             written.add(resolveKey(dest));
             if (changed) {
                 console.log("cluaupp:", job.rel, "→", node_path_1.default.relative(root, dest));
             }
+            if (/\.luau$/i.test(dest)) {
+                const mapPath = (0, source_map_js_1.writeSourceMap)({
+                    outLuauPath: dest,
+                    sourceClppRel: job.rel,
+                    projectRoot: root,
+                });
+                written.add(resolveKey(mapPath));
+            }
             if (format && /\.luau$/i.test(dest)) {
                 process_orchestrator_js_1.ProcessOrchestrator.formatWithStyLuaSync(dest);
             }
@@ -468,6 +586,18 @@ function finishBuild(root, config, compiled, options) {
         }
     }
     const written = writeJobs(root, config, compiled.jobs, format);
+    try {
+        const soaPlans = (0, optimizer_soa_js_1.collectSoaPlansFromProject)(root, config.rootDir);
+        if (soaPlans.length) {
+            const files = (0, optimizer_soa_js_1.writeSoaArtifacts)(root, soaPlans, { useBuffer: false });
+            for (const f of files) {
+                console.log("cluaupp: SoA", node_path_1.default.relative(root, f));
+            }
+        }
+    }
+    catch (err) {
+        console.error("cluaupp: SoA emit failed", err.message);
+    }
     const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
     pruneOut(root, config, written, failedPrefixes);
     try {
@@ -514,20 +644,49 @@ function prepareBuild(root, options) {
     }
     return { config, mapper: createMapper(root, config, options.rojo) };
 }
+function enforceFrozen(root, config) {
+    const lock = (0, index_js_3.verifyLock)();
+    if (!lock.ok) {
+        throw new Error(`cluaupp build --frozen: API lock failed\n${lock.messages.join("\n")}`);
+    }
+    const flare = (0, flare_version_js_1.checkFlareVersions)(root, config.rootDir);
+    if (flare.conflicts.length) {
+        throw new Error(`cluaupp build --frozen: Flare version conflicts\n${flare.conflicts.map((c) => c.message).join("\n")}`);
+    }
+    const policy = (0, authority_check_js_1.loadPlatformPolicy)(root);
+    const components = config.components || policy.components || [];
+    if (components.length) {
+        const dm = (0, datamodel_js_1.buildDatamodelProfile)(root);
+        if (dm) {
+            const bad = (0, component_contracts_js_1.checkComponentContracts)(dm, components).filter((d) => d.severity === "error");
+            if (bad.length) {
+                throw new Error(`cluaupp build --frozen: component contracts\n${bad.map((b) => b.message).join("\n")}`);
+            }
+        }
+    }
+}
 function build(root, options = {}) {
+    if (options.frozen) {
+        const config = loadConfig(root);
+        enforceFrozen(root, config);
+    }
     const prepared = prepareBuild(root, options);
     if (!prepared) {
         return { failed: 0, written: new Set() };
     }
-    const compiled = compileProject(root, prepared.config, prepared.mapper);
+    const compiled = compileProject(root, prepared.config, prepared.mapper, options);
     return finishBuild(root, prepared.config, compiled, options);
 }
 async function buildAsync(root, options = {}) {
+    if (options.frozen) {
+        const config = loadConfig(root);
+        enforceFrozen(root, config);
+    }
     const prepared = prepareBuild(root, options);
     if (!prepared) {
         return { failed: 0, written: new Set() };
     }
-    const compiled = await compileProjectAsync(root, prepared.config, prepared.mapper);
+    const compiled = await compileProjectAsync(root, prepared.config, prepared.mapper, options);
     return finishBuild(root, prepared.config, compiled, options);
 }
 async function init(dest) {
@@ -536,10 +695,21 @@ async function init(dest) {
     const include = node_path_1.default.join(__dirname, "..", "..", "include");
     copyDir(template, target);
     copyDir(include, node_path_1.default.join(target, "include"));
+    const skills = node_path_1.default.join(__dirname, "..", "..", "skills");
+    if (node_fs_1.default.existsSync(skills)) {
+        copyDir(skills, node_path_1.default.join(target, ".cursor", "skills"));
+    }
     copyRuntime(target);
     (0, intellisense_js_1.syncEditorSupport)(target);
+    try {
+        (0, intellisense_js_1.installEditorExtension)();
+    }
+    catch {
+        // editor homes may be missing in CI
+    }
     console.log("Cluaupp ready in", target);
     console.log("  clpp install          (CL++ highlighting + IntelliSense)");
+    console.log("  cluaupp intellisense  (schema .flare .hive .mint .bloom .helm .shift .axiom)");
     console.log("  rokit install");
     console.log("  cluaupp build");
     console.log("  rojo serve");