cluaupp 1.5.0 → 1.5.1

package/generated/target/optimizer-advise.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Cluaupp Optimizer advisor (v1) — suggestions only; does not rewrite Luau yet.
+ * Philosophy: write idiomatic CL++; compiler advises best representation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adviseOptimizer = adviseOptimizer;
+exports.adviceAsDiagnostics = adviceAsDiagnostics;
+const diagnostics_js_1 = require("./diagnostics.js");
+function adviseOptimizer(source, fileName) {
+    const clean = (0, diagnostics_js_1.stripCommentsKeepStrings)(source);
+    const advice = [];
+    const structRe = /struct\s+([A-Za-z_]\w*)\s*\{([^}]*)\}/g;
+    let m;
+    while ((m = structRe.exec(clean))) {
+        const name = m[1];
+        const body = m[2];
+        const fields = body.split(";").map((s) => s.trim()).filter(Boolean);
+        if (fields.length < 2)
+            continue;
+        const numeric = fields.filter((f) => /^(float|double|int|i32|f32|f64|bool)\b/.test(f) || /\bVector3\b/.test(f));
+        const ratio = numeric.length / fields.length;
+        if (ratio >= 0.75 && fields.length >= 3) {
+            advice.push({
+                kind: "storage",
+                target: name,
+                message: `Hot numeric struct ${name} (${numeric.length}/${fields.length} fields) — candidate for SoA / dense storage (Optimizer Level 1–3)`,
+                severity: "info",
+            });
+        }
+        const bools = fields.filter((f) => /^bool\b/.test(f));
+        if (bools.length >= 4) {
+            advice.push({
+                kind: "layout",
+                target: name,
+                message: `${name} has ${bools.length} bool fields — candidate for internal bitset packing`,
+                severity: "info",
+            });
+        }
+    }
+    const fnRe = /(?:void|int|float|double|bool|auto)\s+([A-Za-z_]\w*)\s*\([^)]*\)\s*\{/g;
+    while ((m = fnRe.exec(clean))) {
+        const name = m[1];
+        if (name === "init")
+            continue;
+        const start = m.index + m[0].length;
+        let depth = 1;
+        let i = start;
+        for (; i < clean.length && depth > 0; i++) {
+            if (clean[i] === "{")
+                depth++;
+            else if (clean[i] === "}")
+                depth--;
+        }
+        const body = clean.slice(start, i);
+        const apiHits = (body.match(/GetService|WaitForChild|Instance|FindFirstChild|FireServer|FireClient/g) || []).length;
+        const numericHits = (body.match(/\b(sin|cos|sqrt|Vector3|CFrame|math::)\b|[+\-*/]=|[+\-*/]/g) || []).length;
+        if (numericHits >= 6 && apiHits <= 1 && body.length > 40) {
+            advice.push({
+                kind: "native",
+                target: name,
+                message: `${name} looks numeric-hot / low Instance API — good @native / --!native candidate (CLUAU-PERF-001)`,
+                severity: "info",
+            });
+        }
+        if (apiHits === 0 && /for\s*\(/.test(body) && !/shared|static/.test(body)) {
+            advice.push({
+                kind: "parallel",
+                target: name,
+                message: `${name} may be parallelizable (independent loop, no shared Instance API) — review ThreadSafety`,
+                severity: "info",
+            });
+        }
+    }
+    void fileName;
+    void diagnostics_js_1.lineColAt;
+    return advice;
+}
+function adviceAsDiagnostics(advice, fileName) {
+    return advice.map((a) => ({
+        code: a.kind === "native" ? "CLUAU_PERF001" : a.kind === "parallel" ? "CLUAU_PAR_ADVISE" : "CLUAU_OPT001",
+        message: a.message,
+        line: 1,
+        column: 1,
+        severity: a.severity === "warning" ? "warning" : "info",
+        file: fileName,
+    }));
+}

package/generated/target/optimizer-apply.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Apply Optimizer transforms to CL++ source:
+ * - `#pragma native` on numeric-hot functions
+ * - `#pragma layout soa` + SoA Luau modules when --layout
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOptimizerHints = applyOptimizerHints;
+const optimizer_advise_js_1 = require("./optimizer-advise.js");
+const pgo_js_1 = require("./pgo.js");
+const optimizer_soa_js_1 = require("./optimizer-soa.js");
+function applyOptimizerHints(source, fileName, profile = null, opts = {}) {
+    const advice = (0, pgo_js_1.rankAdvice)((0, optimizer_advise_js_1.adviseOptimizer)(source, fileName), profile);
+    const nativeTargets = new Set(advice.filter((a) => a.kind === "native").map((a) => a.target));
+    let out = source;
+    const applied = [];
+    for (const name of nativeTargets) {
+        const re = new RegExp(`((?:^|\\n)(?:\\s*))((?:void|int|float|double|bool|auto)\\s+${name}\\s*\\()`, "m");
+        const m = out.match(re);
+        if (!m)
+            continue;
+        const before = out.slice(0, m.index + m[1].length);
+        if (/#pragma\s+native\s*$/m.test(before.slice(-80)) ||
+            /#pragma\s+native/.test(out.slice(Math.max(0, m.index - 40), m.index))) {
+            continue;
+        }
+        out = out.replace(re, `$1#pragma native\n$1$2`);
+        applied.push(`#pragma native → ${name}`);
+    }
+    let soaPlans;
+    if (opts.layout) {
+        const layout = (0, optimizer_soa_js_1.applyLayoutPragmas)(out, fileName, profile);
+        out = layout.source;
+        applied.push(...layout.applied);
+        soaPlans = layout.plans;
+        if (opts.projectRoot && layout.plans.length) {
+            const files = (0, optimizer_soa_js_1.writeSoaArtifacts)(opts.projectRoot, layout.plans, { useBuffer: opts.useBuffer });
+            for (const f of files) {
+                applied.push(`SoA emit → ${f.replace(/\\/g, "/")}`);
+            }
+        }
+    }
+    return { source: out, changed: applied.length > 0 || out !== source, applied, soaPlans };
+}

package/generated/target/optimizer-soa.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Opt-in SoA / dense storage codegen.
+ * Triggered by `#pragma layout soa StructName` (or optimize --apply --layout).
+ * Emits a Luau ModuleScript companion — does not silently rewrite gameplay structs.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSoaFields = parseSoaFields;
+exports.findStructBody = findStructBody;
+exports.listLayoutTargets = listLayoutTargets;
+exports.planSoa = planSoa;
+exports.generateSoaLuau = generateSoaLuau;
+exports.applyLayoutPragmas = applyLayoutPragmas;
+exports.writeSoaArtifacts = writeSoaArtifacts;
+exports.collectSoaPlansFromProject = collectSoaPlansFromProject;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const optimizer_advise_js_1 = require("./optimizer-advise.js");
+const pgo_js_1 = require("./pgo.js");
+const FIELD_RE = /^(?:float|f32|double|f64)\s+([A-Za-z_]\w*)|^(?:int|i32)\s+([A-Za-z_]\w*)|^bool\s+([A-Za-z_]\w*)|^Vector3\s+([A-Za-z_]\w*)/;
+function parseSoaFields(structBody) {
+    const fields = [];
+    for (const piece of structBody.split(";")) {
+        const line = piece.trim().replace(/=.*/, "").trim();
+        if (!line)
+            continue;
+        const m = line.match(FIELD_RE);
+        if (!m)
+            continue;
+        if (m[1])
+            fields.push({ name: m[1], kind: "f32" });
+        else if (m[2])
+            fields.push({ name: m[2], kind: "i32" });
+        else if (m[3])
+            fields.push({ name: m[3], kind: "bool" });
+        else if (m[4])
+            fields.push({ name: m[4], kind: "Vector3" });
+    }
+    return fields;
+}
+function findStructBody(source, structName) {
+    const re = new RegExp(`struct\\s+${structName}\\s*\\{([^}]*)\\}`);
+    const m = source.match(re);
+    return m ? m[1] : null;
+}
+function listLayoutTargets(source) {
+    const names = new Set();
+    const re = /#pragma\s+layout\s+soa\s+([A-Za-z_]\w*)/g;
+    let m;
+    while ((m = re.exec(source))) {
+        names.add(m[1]);
+    }
+    return [...names];
+}
+function planSoa(source, structName) {
+    const body = findStructBody(source, structName);
+    if (!body)
+        return null;
+    const fields = parseSoaFields(body);
+    if (fields.length < 2)
+        return null;
+    return { structName, fields };
+}
+function defaultFor(kind) {
+    if (kind === "f32")
+        return "0";
+    if (kind === "i32")
+        return "0";
+    if (kind === "bool")
+        return "false";
+    return "Vector3.zero";
+}
+/** Generate a standalone Luau SoA module (table-columns; buffer pack optional for floats). */
+function generateSoaLuau(plan, useBuffer = false) {
+    const { structName, fields } = plan;
+    const cols = fields
+        .map((f) => {
+        if (useBuffer && (f.kind === "f32" || f.kind === "i32")) {
+            return `\t\t${f.name} = buffer.create(0), -- grown on ensure`;
+        }
+        return `\t\t${f.name} = table.create(capacity),`;
+    })
+        .join("\n");
+    const pushLines = fields
+        .map((f) => {
+        if (useBuffer && f.kind === "f32") {
+            return `\tbuffer.writef32(store.${f.name}, (i - 1) * 4, row.${f.name} or 0)`;
+        }
+        if (useBuffer && f.kind === "i32") {
+            return `\tbuffer.writei32(store.${f.name}, (i - 1) * 4, row.${f.name} or 0)`;
+        }
+        return `\tstore.${f.name}[i] = row.${f.name}`;
+    })
+        .join("\n");
+    const getLines = fields
+        .map((f) => {
+        if (useBuffer && f.kind === "f32") {
+            return `\t\t${f.name} = buffer.readf32(store.${f.name}, (i - 1) * 4),`;
+        }
+        if (useBuffer && f.kind === "i32") {
+            return `\t\t${f.name} = buffer.readi32(store.${f.name}, (i - 1) * 4),`;
+        }
+        return `\t\t${f.name} = store.${f.name}[i],`;
+    })
+        .join("\n");
+    const ensureBuf = useBuffer
+        ? fields
+            .filter((f) => f.kind === "f32" || f.kind === "i32")
+            .map((f) => `
+	local need = capacity * 4
+	if buffer.len(store.${f.name}) < need then
+		local nb = buffer.create(need)
+		buffer.copy(nb, 0, store.${f.name})
+		store.${f.name} = nb
+	end`)
+            .join("\n")
+        : "";
+    return `--!native
+--!optimize 2
+--!strict
+-- cluaupp generated SoA for ${structName} — do not edit by hand.
+-- Use via: local ${structName}Soa = require(...${structName}Soa)
+
+export type ${structName}Row = {
+${fields.map((f) => `\t${f.name}: ${f.kind === "f32" ? "number" : f.kind === "i32" ? "number" : f.kind === "bool" ? "boolean" : "Vector3"},`).join("\n")}
+}
+
+export type ${structName}Store = {
+	len: number,
+	capacity: number,
+${fields.map((f) => `\t${f.name}: ${useBuffer && (f.kind === "f32" || f.kind === "i32") ? "buffer" : "{}"},`).join("\n")}
+}
+
+local ${structName}Soa = {}
+
+function ${structName}Soa.new(capacity: number): ${structName}Store
+	capacity = math.max(1, capacity or 64)
+	local store = {
+		len = 0,
+		capacity = capacity,
+${cols}
+	}
+	return store
+end
+
+function ${structName}Soa.ensure(store: ${structName}Store, capacity: number)
+	if capacity <= store.capacity then
+		return
+	end
+	store.capacity = capacity
+${ensureBuf}
+${useBuffer ? "" : fields.map((f) => `\t-- table.create columns grow on index assign`).join("\n")}
+end
+
+function ${structName}Soa.push(store: ${structName}Store, row: ${structName}Row): number
+	local i = store.len + 1
+	${structName}Soa.ensure(store, i)
+	store.len = i
+${pushLines}
+	return i
+end
+
+function ${structName}Soa.get(store: ${structName}Store, i: number): ${structName}Row
+	return {
+${getLines}
+	}
+end
+
+function ${structName}Soa.set(store: ${structName}Store, i: number, row: ${structName}Row)
+${pushLines}
+end
+
+return ${structName}Soa
+`;
+}
+/** Insert `#pragma layout soa Name` before advised storage structs. */
+function applyLayoutPragmas(source, fileName, profile = null) {
+    const advice = (0, pgo_js_1.rankAdvice)((0, optimizer_advise_js_1.adviseOptimizer)(source, fileName), profile);
+    const targets = new Set(advice.filter((a) => a.kind === "storage").map((a) => a.target));
+    const applied = [];
+    const plans = [];
+    let out = source;
+    for (const name of targets) {
+        if (new RegExp(`#pragma\\s+layout\\s+soa\\s+${name}\\b`).test(out)) {
+            const plan = planSoa(out, name);
+            if (plan)
+                plans.push(plan);
+            continue;
+        }
+        const re = new RegExp(`((?:^|\\n)(?:\\s*))(struct\\s+${name}\\s*\\{)`, "m");
+        if (!re.test(out))
+            continue;
+        out = out.replace(re, `$1#pragma layout soa ${name}\n$1$2`);
+        applied.push(`#pragma layout soa → ${name}`);
+        const plan = planSoa(out, name);
+        if (plan)
+            plans.push(plan);
+    }
+    for (const name of listLayoutTargets(out)) {
+        if (plans.some((p) => p.structName === name))
+            continue;
+        const plan = planSoa(out, name);
+        if (plan)
+            plans.push(plan);
+    }
+    return { source: out, changed: applied.length > 0, applied, plans };
+}
+function writeSoaArtifacts(projectRoot, plans, opts = {}) {
+    if (!plans.length)
+        return [];
+    const outDir = node_path_1.default.join(projectRoot, ".cluaupp", "generated", "soa");
+    node_fs_1.default.mkdirSync(outDir, { recursive: true });
+    const written = [];
+    for (const plan of plans) {
+        const file = node_path_1.default.join(outDir, `${plan.structName}Soa.luau`);
+        node_fs_1.default.writeFileSync(file, generateSoaLuau(plan, opts.useBuffer === true), "utf8");
+        written.push(file);
+    }
+    return written;
+}
+/** Collect SoA plans from all sources that already have layout pragmas. */
+function collectSoaPlansFromProject(projectRoot, rootDir = "src") {
+    const srcDir = node_path_1.default.join(projectRoot, rootDir);
+    if (!node_fs_1.default.existsSync(srcDir))
+        return [];
+    const plans = [];
+    const seen = new Set();
+    const walk = (dir) => {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const full = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!/\.(clpp|clp|clh)$/i.test(entry.name))
+                continue;
+            const source = node_fs_1.default.readFileSync(full, "utf8");
+            for (const name of listLayoutTargets(source)) {
+                if (seen.has(name))
+                    continue;
+                const plan = planSoa(source, name);
+                if (plan) {
+                    seen.add(name);
+                    plans.push(plan);
+                }
+            }
+        }
+    };
+    walk(srcDir);
+    return plans;
+}

package/generated/target/parallel-check.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Parallel Luau / ThreadSafety diagnostics (CLUAU-PAR*).
+ * Flags Unsafe mutations inside parallel { } / desynchronize regions.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkParallelSafety = checkParallelSafety;
+exports.assertParallelSafe = assertParallelSafe;
+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 diagnostics_js_1 = require("./diagnostics.js");
+let cachedUnsafeMembers = null;
+function loadUnsafeMemberNames() {
+    if (cachedUnsafeMembers) {
+        return cachedUnsafeMembers;
+    }
+    const set = new Set(["Parent", "Name"]); // Parent writes always unsafe in parallel
+    const profilePath = node_path_1.default.join(package_info_js_1.projectRoot, "api", "normalized", "roblox-target.profile.json");
+    if (node_fs_1.default.existsSync(profilePath)) {
+        try {
+            const profile = JSON.parse(node_fs_1.default.readFileSync(profilePath, "utf8"));
+            for (const cls of Object.values(profile.classes || {})) {
+                for (const prop of Object.values(cls.properties || {})) {
+                    if (prop.threadSafety === "Unsafe") {
+                        set.add(prop.name);
+                    }
+                }
+                for (const method of Object.values(cls.methods || {})) {
+                    if (method.threadSafety === "Unsafe") {
+                        set.add(method.name);
+                    }
+                }
+            }
+        }
+        catch {
+            /* fallback set only */
+        }
+    }
+    cachedUnsafeMembers = set;
+    return set;
+}
+function extractParallelRegions(source) {
+    const regions = [];
+    const reParallel = /\bparallel\s*\{/g;
+    let m;
+    while ((m = reParallel.exec(source))) {
+        const open = m.index + m[0].length - 1;
+        let depth = 0;
+        for (let i = open; i < source.length; i++) {
+            if (source[i] === "{")
+                depth++;
+            else if (source[i] === "}") {
+                depth--;
+                if (depth === 0) {
+                    regions.push({ start: m.index, body: source.slice(open + 1, i) });
+                    break;
+                }
+            }
+        }
+    }
+    const reDesync = /task\s*::\s*desynchronize\s*\(\s*\)/g;
+    while ((m = reDesync.exec(source))) {
+        const rest = source.slice(m.index);
+        const sync = rest.search(/task\s*::\s*synchronize\s*\(\s*\)/);
+        const body = sync >= 0 ? rest.slice(0, sync) : rest.slice(0, Math.min(rest.length, 800));
+        regions.push({ start: m.index, body });
+    }
+    if (/\bConnectParallel\b/.test(source)) {
+        regions.push({ start: source.indexOf("ConnectParallel"), body: source });
+    }
+    return regions;
+}
+function checkParallelSafety(source, fileName = "input.clpp") {
+    const clean = (0, diagnostics_js_1.stripCommentsKeepStrings)(source);
+    const unsafe = loadUnsafeMemberNames();
+    const out = [];
+    const regions = extractParallelRegions(clean);
+    if (!regions.length) {
+        return out;
+    }
+    for (const region of regions) {
+        const parentAssign = /\.Parent\s*=/g;
+        let pm;
+        while ((pm = parentAssign.exec(region.body))) {
+            const { line, column } = (0, diagnostics_js_1.lineColAt)(clean, region.start + pm.index);
+            out.push({
+                code: "CLUAU_PAR001",
+                message: "Unsafe Instance write `.Parent =` inside parallel / desynchronized region",
+                line,
+                column,
+                severity: "error",
+                file: fileName,
+            });
+        }
+        const memberWrite = /\.([A-Za-z_]\w*)\s*=/g;
+        while ((pm = memberWrite.exec(region.body))) {
+            const name = pm[1];
+            if (name === "Parent")
+                continue;
+            if (!unsafe.has(name))
+                continue;
+            const { line, column } = (0, diagnostics_js_1.lineColAt)(clean, region.start + pm.index);
+            out.push({
+                code: "CLUAU_PAR002",
+                message: `API member \`.${name}\` is ThreadSafety=Unsafe inside parallel region`,
+                line,
+                column,
+                severity: "error",
+                file: fileName,
+            });
+        }
+        const destroy = /\.Destroy\s*\(/g;
+        while ((pm = destroy.exec(region.body))) {
+            const { line, column } = (0, diagnostics_js_1.lineColAt)(clean, region.start + pm.index);
+            out.push({
+                code: "CLUAU_PAR003",
+                message: "`Destroy()` is Unsafe inside parallel region",
+                line,
+                column,
+                severity: "error",
+                file: fileName,
+            });
+        }
+    }
+    return out;
+}
+function assertParallelSafe(source, fileName) {
+    const errors = checkParallelSafety(source, fileName).filter((d) => d.severity === "error");
+    if (!errors.length)
+        return;
+    throw new Error(`Parallel safety:\n${errors.map((e) => `  ${e.line}:${e.column} ${e.code} ${e.message}`).join("\n")}`);
+}

package/generated/target/pgo.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Profile-Guided Optimization (PGO) — format, load, Studio ingest.
+ * cluaupp.profile.json weights optimizer advice toward hot symbols.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGO_SCHEMA_VERSION = void 0;
+exports.defaultProfilePath = defaultProfilePath;
+exports.loadProfile = loadProfile;
+exports.writeProfileTemplate = writeProfileTemplate;
+exports.ingestProfile = ingestProfile;
+exports.rankAdvice = rankAdvice;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.PGO_SCHEMA_VERSION = 1;
+function defaultProfilePath(projectRoot) {
+    return node_path_1.default.join(projectRoot, "cluaupp.profile.json");
+}
+function loadProfile(file) {
+    if (!node_fs_1.default.existsSync(file)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        if (!raw || typeof raw.hot !== "object") {
+            return null;
+        }
+        return { schemaVersion: exports.PGO_SCHEMA_VERSION, hot: raw.hot, structs: raw.structs, generatedAt: raw.generatedAt };
+    }
+    catch {
+        return null;
+    }
+}
+/** Write an empty / template profile for games to fill from Studio logging. */
+function writeProfileTemplate(projectRoot) {
+    const file = defaultProfilePath(projectRoot);
+    const template = {
+        schemaVersion: exports.PGO_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        hot: {
+            CalculateDamage: 0,
+            EnemyUpdate: 0,
+        },
+        structs: {
+            EnemyState: 0,
+        },
+    };
+    node_fs_1.default.writeFileSync(file, JSON.stringify(template, null, "\t") + "\n", "utf8");
+    return file;
+}
+function parseEvents(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        const arr = JSON.parse(trimmed);
+        if (!Array.isArray(arr))
+            return [];
+        return arr.filter((e) => e && typeof e.symbol === "string");
+    }
+    if (trimmed.startsWith("{") && !trimmed.includes("\n")) {
+        const one = JSON.parse(trimmed);
+        if (typeof one.symbol === "string") {
+            return [one];
+        }
+        if (one.hot && typeof one.hot === "object") {
+            return Object.entries(one.hot).map(([symbol, count]) => ({
+                symbol,
+                kind: "hot",
+                count: Number(count) || 0,
+            }));
+        }
+    }
+    const events = [];
+    for (const line of trimmed.split(/\r?\n/)) {
+        const t = line.trim();
+        if (!t || t.startsWith("#"))
+            continue;
+        try {
+            const e = JSON.parse(t);
+            if (e && typeof e.symbol === "string")
+                events.push(e);
+        }
+        catch {
+            /* skip bad line */
+        }
+    }
+    return events;
+}
+/** Merge Studio/playtest events into cluaupp.profile.json (additive counts). */
+function ingestProfile(projectRoot, eventsPath) {
+    const eventsFile = node_path_1.default.resolve(eventsPath);
+    if (!node_fs_1.default.existsSync(eventsFile)) {
+        throw new Error(`cluaupp profile ingest: missing ${eventsFile}`);
+    }
+    const events = parseEvents(node_fs_1.default.readFileSync(eventsFile, "utf8"));
+    const profilePath = defaultProfilePath(projectRoot);
+    const existing = loadProfile(profilePath) || {
+        schemaVersion: exports.PGO_SCHEMA_VERSION,
+        hot: {},
+        structs: {},
+    };
+    const hot = { ...(existing.hot || {}) };
+    const structs = { ...(existing.structs || {}) };
+    let merged = 0;
+    for (const e of events) {
+        const n = typeof e.count === "number" && Number.isFinite(e.count) ? e.count : 1;
+        if (e.kind === "struct") {
+            structs[e.symbol] = (structs[e.symbol] || 0) + n;
+        }
+        else {
+            hot[e.symbol] = (hot[e.symbol] || 0) + n;
+        }
+        merged++;
+    }
+    const profile = {
+        schemaVersion: exports.PGO_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        hot,
+        structs,
+    };
+    node_fs_1.default.writeFileSync(profilePath, JSON.stringify(profile, null, "\t") + "\n", "utf8");
+    return { profilePath, profile, merged };
+}
+function rankAdvice(advice, profile) {
+    if (!profile) {
+        return advice;
+    }
+    return [...advice]
+        .sort((a, b) => {
+        const wa = profile.hot[a.target] || profile.structs?.[a.target] || 0;
+        const wb = profile.hot[b.target] || profile.structs?.[b.target] || 0;
+        return wb - wa;
+    })
+        .map((a) => {
+        const w = profile.hot[a.target] || profile.structs?.[a.target];
+        if (!w)
+            return a;
+        return {
+            ...a,
+            message: `${a.message} [PGO weight=${w}]`,
+            severity: w > 1000 ? "warning" : a.severity,
+        };
+    });
+}