@adiholick/nvstudio-mcp 2.2.3 → 2.4.0

package/dist/luau-validator.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateLuauSyntax = validateLuauSyntax;
+/**
+ * Heuristic pre-commit syntax validator for Luau.
+ * Validates bracket parity, string literals, multiline comments,
+ * and block keywords (function, do, statement if ... then, repeat ... until, end).
+ */
 function validateLuauSyntax(source) {
     const lines = source.split('\n');
-    // Stack for blocks: function, do, if, for, while, repeat
-    // We'll keep it simple: just count block openers vs block closers (end, until)
-    // Note: This is a heuristic pre-commit check. It doesn't replace a full AST parser,
-    // Bracket stacks
     let parenDepth = 0; // ()
     let braceDepth = 0; // {}
     let bracketDepth = 0; // []
+    let blockDepth = 0; // function, do, if ... then -> end
+    let repeatDepth = 0; // repeat -> until
     let inString = false;
     let stringChar = '';
     let inMultilineString = false;
@@ -18,10 +21,11 @@ function validateLuauSyntax(source) {
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         let j = 0;
+        const lineTokens = [];
         while (j < line.length) {
             const char = line[j];
             const nextChar = line[j + 1] || '';
-            // Handle multiline comments
+            // Multiline comment start: --[[ or --[===[
             if (!inString && !inMultilineString && !inMultilineComment) {
                 if (char === '-' && nextChar === '-') {
                     const nextNextChar = line[j + 2] || '';
@@ -39,7 +43,7 @@ function validateLuauSyntax(source) {
                             continue;
                         }
                     }
-                    // Single line comment, skip rest of line
+                    // Single-line comment, ignore rest of line
                     break;
                 }
             }
@@ -60,7 +64,7 @@ function validateLuauSyntax(source) {
                 j++;
                 continue;
             }
-            // Handle strings
+            // String literals
             if (!inString && !inMultilineString) {
                 if (char === '"' || char === "'") {
                     inString = true;
@@ -81,10 +85,6 @@ function validateLuauSyntax(source) {
                         j = k + 1;
                         continue;
                     }
-                    // If it ended at end of line, we can't reliably detect it. Let's just avoid bracket counting
-                    if (line[k] === undefined) {
-                        break;
-                    }
                 }
             }
             if (inString) {
@@ -115,36 +115,97 @@ function validateLuauSyntax(source) {
                 j++;
                 continue;
             }
-            // At this point, we are outside strings and comments.
-            // Check brackets
-            if (!inString && !inMultilineString && !inMultilineComment) {
-                if (char === '(')
-                    parenDepth++;
-                else if (char === ')') {
-                    parenDepth--;
-                    if (parenDepth < 0)
-                        return { valid: false, error: 'Kelebihan tutup kurung ")"', line: i + 1 };
-                }
-                else if (char === '{')
-                    braceDepth++;
-                else if (char === '}') {
-                    braceDepth--;
-                    if (braceDepth < 0)
-                        return { valid: false, error: 'Kelebihan tutup kurawal "}"', line: i + 1 };
-                }
-                else if (char === '[')
-                    bracketDepth++;
-                else if (char === ']') {
-                    bracketDepth--;
-                    if (bracketDepth < 0)
-                        return { valid: false, error: 'Kelebihan tutup siku "]"', line: i + 1 };
+            // Outside strings & comments: collect bracket depth & tokens
+            if (char === '(') {
+                parenDepth++;
+                lineTokens.push('(');
+            }
+            else if (char === ')') {
+                parenDepth--;
+                lineTokens.push(')');
+                if (parenDepth < 0)
+                    return { valid: false, error: 'Kelebihan tutup kurung ")"', line: i + 1 };
+            }
+            else if (char === '{') {
+                braceDepth++;
+                lineTokens.push('{');
+            }
+            else if (char === '}') {
+                braceDepth--;
+                lineTokens.push('}');
+                if (braceDepth < 0)
+                    return { valid: false, error: 'Kelebihan tutup kurawal "}"', line: i + 1 };
+            }
+            else if (char === '[') {
+                bracketDepth++;
+                lineTokens.push('[');
+            }
+            else if (char === ']') {
+                bracketDepth--;
+                lineTokens.push(']');
+                if (bracketDepth < 0)
+                    return { valid: false, error: 'Kelebihan tutup siku "]"', line: i + 1 };
+            }
+            else if (char === '=') {
+                lineTokens.push('=');
+            }
+            else if (char === ',') {
+                lineTokens.push(',');
+            }
+            else if (/[a-zA-Z_]/.test(char)) {
+                let start = j;
+                while (j < line.length && /[a-zA-Z0-9_]/.test(line[j])) {
+                    j++;
                 }
+                lineTokens.push(line.substring(start, j));
+                continue;
             }
             j++;
         }
         if (inString) {
             return { valid: false, error: 'String tidak ditutup (unclosed string literal)', line: i + 1 };
         }
+        // Process line tokens for block balance
+        let statementIfCount = 0;
+        for (let t = 0; t < lineTokens.length; t++) {
+            const tok = lineTokens[t];
+            const prevTok = t > 0 ? lineTokens[t - 1] : null;
+            if (tok === 'function') {
+                blockDepth++;
+            }
+            else if (tok === 'do') {
+                blockDepth++;
+            }
+            else if (tok === 'if') {
+                // Luau expression if is preceded by '=', 'return', '(', ',', '{', '[', 'and', 'or', 'not'
+                const isExpr = prevTok && ['=', 'return', '(', ',', '{', '[', 'and', 'or', 'not'].includes(prevTok);
+                if (!isExpr) {
+                    statementIfCount++;
+                }
+            }
+            else if (tok === 'then') {
+                const isElseIf = lineTokens.includes('elseif');
+                if (!isElseIf) {
+                    if (statementIfCount > 0) {
+                        blockDepth++;
+                        statementIfCount--;
+                    }
+                }
+            }
+            else if (tok === 'repeat') {
+                repeatDepth++;
+            }
+            else if (tok === 'until') {
+                repeatDepth--;
+                if (repeatDepth < 0)
+                    return { valid: false, error: 'Kelebihan kata kunci "until"', line: i + 1 };
+            }
+            else if (tok === 'end') {
+                blockDepth--;
+                if (blockDepth < 0)
+                    return { valid: false, error: 'Kelebihan kata kunci "end"', line: i + 1 };
+            }
+        }
     }
     if (inMultilineString)
         return { valid: false, error: 'Multiline string tidak ditutup (unclosed [[ ]])' };
@@ -156,5 +217,9 @@ function validateLuauSyntax(source) {
         return { valid: false, error: 'Kekurangan tutup kurawal "}"' };
     if (bracketDepth > 0)
         return { valid: false, error: 'Kekurangan tutup siku "]"' };
+    if (repeatDepth > 0)
+        return { valid: false, error: 'Kekurangan kata kunci "until"' };
+    if (blockDepth > 0)
+        return { valid: false, error: 'Kekurangan kata kunci "end" (blok tidak ditutup)' };
     return { valid: true };
 }

package/dist/roblox-bridge.js

@@ -18,6 +18,8 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const task_queue_1 = require("./task-queue");
 const ws_gateway_1 = require("./ws-gateway");
+const roblox_docs_1 = require("./roblox-docs");
+const vfx_database_1 = require("./vfx-database");
 const { version: SERVER_VERSION } = require('../package.json');
 exports.isBridgeHosting = false;
 let resolveBridgeReady;
@@ -349,7 +351,17 @@ function addLog(io, type, message) {
         activityLogs.pop();
     if (io.engine && io.engine.clientsCount > 0) {
         io.emit('log', log);
-        io.emit('stats', { totalTasks, successCount, errorCount, sessionStart });
+        io.emit('stats', {
+            totalTasks,
+            successCount,
+            errorCount,
+            sessionStart,
+            studioConnected: isStudioConnected(),
+            studioCount: getConnectedStudioCount(),
+            wsStudios: (0, ws_gateway_1.getWsPeerCount)(),
+            connectedStudios: getConnectedStudios(),
+            version: SERVER_VERSION
+        });
     }
 }
 /**
@@ -422,7 +434,12 @@ function startBridgeServer(port, isDaemon = false) {
         onStudioStatusChange: () => {
             const connected = isStudioConnected();
             const studioCount = getConnectedStudioCount();
-            io.emit('studio-status', { connected, studioCount });
+            io.emit('studio-status', {
+                connected,
+                studioCount,
+                connectedStudios: getConnectedStudios(),
+                version: SERVER_VERSION
+            });
             broadcastStatus();
             if (!connected && (0, task_queue_1.hasPendingTasks)()) {
                 checkPendingTasksOnStudioDisconnect();
@@ -464,10 +481,135 @@ function startBridgeServer(port, isDaemon = false) {
                 studioConnected: isStudioConnected(),
                 studioCount: getConnectedStudioCount(),
                 wsStudios: (0, ws_gateway_1.getWsPeerCount)(),
-                port
+                port,
+                version: SERVER_VERSION,
+                connectedStudios: getConnectedStudios(),
             },
         });
     });
+    // ── /api/docs (Endpoint pencarian dokumentasi engine untuk web dashboard) ──
+    app.get('/api/docs', async (req, res) => {
+        try {
+            const query = String(req.query.query || '').trim();
+            const member = req.query.member ? String(req.query.member).trim() : undefined;
+            const category = req.query.category ? String(req.query.category).trim() : 'auto';
+            if (!query) {
+                return res.status(400).json({ error: "Parameter 'query' wajib diisi." });
+            }
+            const result = await (0, roblox_docs_1.getRobloxDocs)(query, member, category);
+            res.json({ success: true, result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ── /api/vfx Endpoints (NV-VFX Database Management) ───────────────────────
+    app.get('/api/vfx', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const category = req.query.category ? String(req.query.category) : undefined;
+            const query = req.query.query ? String(req.query.query) : undefined;
+            const items = db.listVfx({ category, query });
+            res.json({ success: true, count: items.length, items });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/vfx/categories', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            res.json({ success: true, categories: db.getCategories() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/vfx/:id', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const item = db.getVfx(req.params.id);
+            if (!item)
+                return res.status(404).json({ error: 'VFX tidak ditemukan' });
+            res.json({ success: true, item });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const saved = db.saveVfx(req.body);
+            io.emit('vfx_updated', { action: 'saved', item: saved });
+            res.json({ success: true, item: saved });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/vfx/:id', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const ok = db.deleteVfx(req.params.id);
+            if (ok) {
+                io.emit('vfx_updated', { action: 'deleted', id: req.params.id });
+                res.json({ success: true });
+            }
+            else {
+                res.status(404).json({ error: 'VFX tidak ditemukan' });
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx/apply', async (req, res) => {
+        try {
+            const { id, target, scale, enabled, placeId, studioId } = req.body;
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const item = db.getVfx(id);
+            if (!item)
+                return res.status(404).json({ error: 'VFX tidak ditemukan di database' });
+            const targetPath = target || 'Workspace';
+            const payload = JSON.stringify({ data: item.data, scale: scale || 1, enabled });
+            const result = await (0, task_queue_1.addTaskToQueue)('apply_vfx', targetPath, payload, { placeId, studioId });
+            res.json({ success: true, result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx/scan', async (req, res) => {
+        try {
+            const { target, name, category, tags, placeId, studioId } = req.body;
+            const targetPath = target || 'Workspace';
+            const scanPayload = JSON.stringify({ name, category, tags });
+            const result = await (0, task_queue_1.addTaskToQueue)('scan_vfx', targetPath, scanPayload, { placeId, studioId });
+            if (result && (result.status === 'success' || !result.error)) {
+                const scanned = result.result || result;
+                const db = (0, vfx_database_1.getVfxDatabase)();
+                const saved = db.saveVfx({
+                    name: scanned.name || name || 'Scanned_VFX',
+                    category: scanned.category || category || 'Ambient',
+                    tags: scanned.tags || tags || [],
+                    description: scanned.description,
+                    sourcePlaceId: placeId,
+                    stats: scanned.stats,
+                    nodeCount: scanned.nodeCount,
+                    data: scanned.data,
+                });
+                io.emit('vfx_updated', { action: 'saved', item: saved });
+                res.json({ success: true, item: saved, rawResult: result });
+            }
+            else {
+                res.status(400).json({ error: result?.error || 'Gagal memindai VFX dari Studio' });
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // ── /api/stats ─────────────────────────────────────────────────────────────
     app.get('/api/stats', (req, res) => {
         const activeStudios = getConnectedStudioCount();
@@ -514,7 +656,13 @@ function startBridgeServer(port, isDaemon = false) {
         // Daftarkan studio jika belum ada
         if (!studioEventQueues.has(studioId)) {
             studioEventQueues.set(studioId, []);
-            io.emit('studio-status', { connected: true, studioCount: Math.max(studioEventQueues.size, 1), studioId });
+            io.emit('studio-status', {
+                connected: true,
+                studioCount: Math.max(studioEventQueues.size, 1),
+                studioId,
+                connectedStudios: getConnectedStudios(),
+                version: SERVER_VERSION
+            });
             addLog(io, 'system', `Studio terdaftar. (ID: ${studioId.substring(0, 8)}…, Place: ${placeId ?? 'Local'}, Total: ${studioEventQueues.size})`);
             if (!isDaemon && !dashboardOpened) {
                 dashboardOpened = true;

package/dist/roblox-docs.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanRobloxMarkdown = cleanRobloxMarkdown;
+exports.getRobloxDocs = getRobloxDocs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const BASE_URL = 'https://raw.githubusercontent.com/Roblox/creator-docs/main/content/en-us/reference/engine';
+const CACHE_DIR = path_1.default.join(__dirname, '..', '.cache', 'roblox-docs');
+if (!fs_1.default.existsSync(CACHE_DIR)) {
+    fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+}
+function cleanRobloxMarkdown(text) {
+    if (!text)
+        return '';
+    return text
+        // Replace `Type.Target|Label` with `Label`
+        .replace(/`(?:Class|Datatype|Enum|Library)\.[^|`]+\|([^`]+)`/g, '`$1`')
+        // Replace `Type.Target` with `Target`
+        .replace(/`(?:Class|Datatype|Enum|Library)\.([^`]+)`/g, '`$1`')
+        .trim();
+}
+const CATEGORIES = ['classes', 'datatypes', 'enums', 'libraries'];
+function getCategoryFolder(cat) {
+    const c = cat.toLowerCase();
+    if (c.startsWith('class'))
+        return 'classes';
+    if (c.startsWith('data') || c.startsWith('type'))
+        return 'datatypes';
+    if (c.startsWith('enum'))
+        return 'enums';
+    if (c.startsWith('lib'))
+        return 'libraries';
+    return 'classes';
+}
+function getCachePath(category, name) {
+    const catFolder = path_1.default.join(CACHE_DIR, category);
+    if (!fs_1.default.existsSync(catFolder)) {
+        fs_1.default.mkdirSync(catFolder, { recursive: true });
+    }
+    return path_1.default.join(catFolder, `${name}.yaml`);
+}
+async function fetchFromNetwork(category, query) {
+    const url = `${BASE_URL}/${category}/${query}.yaml`;
+    try {
+        const res = await fetch(url, { headers: { 'User-Agent': 'nvstudio-mcp-roblox-docs' } });
+        if (!res.ok)
+            return null;
+        return await res.text();
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveDocYaml(query, categoryFilter = 'auto') {
+    // Normalize query casing (capitalized first letter standard)
+    const normalizedQuery = query.trim();
+    const searchCategories = categoryFilter !== 'auto'
+        ? [getCategoryFolder(categoryFilter)]
+        : ['classes', 'datatypes', 'enums', 'libraries'];
+    // 1. Cek disk cache
+    for (const cat of searchCategories) {
+        const cacheFile = getCachePath(cat, normalizedQuery);
+        if (fs_1.default.existsSync(cacheFile)) {
+            try {
+                const cached = fs_1.default.readFileSync(cacheFile, 'utf-8');
+                if (cached && cached.length > 50) {
+                    return { yamlText: cached, category: cat };
+                }
+            }
+            catch {
+                // ignore cache read error
+            }
+        }
+    }
+    // 2. Fetch dari network
+    for (const cat of searchCategories) {
+        const rawYaml = await fetchFromNetwork(cat, normalizedQuery);
+        if (rawYaml && rawYaml.length > 50) {
+            // Simpan ke cache
+            try {
+                fs_1.default.writeFileSync(getCachePath(cat, normalizedQuery), rawYaml, 'utf-8');
+            }
+            catch {
+                // ignore cache write error
+            }
+            return { yamlText: rawYaml, category: cat };
+        }
+    }
+    return null;
+}
+function formatSingleMember(parentName, member, kind) {
+    const name = member.name || member.Name || 'Unknown';
+    const summary = cleanRobloxMarkdown(member.summary || member.description || '');
+    const desc = cleanRobloxMarkdown(member.description || '');
+    let out = `## \`${name}\` (${kind})\n\n`;
+    if (summary)
+        out += `> ${summary}\n\n`;
+    if (member.type)
+        out += `* **Type:** \`${member.type}\`\n`;
+    if (member.default !== undefined && member.default !== null)
+        out += `* **Default:** \`${member.default}\`\n`;
+    const tags = (member.tags || []).join(', ');
+    if (tags)
+        out += `* **Tags:** ${tags}\n`;
+    if (member.deprecation_message) {
+        out += `\n> ⚠️ **Deprecated:** ${cleanRobloxMarkdown(member.deprecation_message)}\n\n`;
+    }
+    // Parameters
+    if (Array.isArray(member.parameters) && member.parameters.length > 0) {
+        out += `\n### Parameters\n`;
+        for (const p of member.parameters) {
+            const def = p.default !== undefined && p.default !== null ? ` = \`${p.default}\`` : '';
+            out += `* \`${p.name}\`: \`${p.type || 'any'}\`${def} — ${cleanRobloxMarkdown(p.summary || '')}\n`;
+        }
+    }
+    // Returns
+    if (Array.isArray(member.returns) && member.returns.length > 0) {
+        out += `\n### Returns\n`;
+        for (const r of member.returns) {
+            out += `* \`${r.type || 'void'}\` — ${cleanRobloxMarkdown(r.summary || '')}\n`;
+        }
+    }
+    if (desc && desc !== summary) {
+        out += `\n### Details\n${desc}\n`;
+    }
+    return out;
+}
+async function getRobloxDocs(query, member, category = 'auto') {
+    const resolved = await resolveDocYaml(query, category);
+    if (!resolved) {
+        return `❌ Dokumentasi Roblox untuk "${query}" tidak ditemukan di Classes, Data types, Enums, maupun Libraries.\nPastikan ejaan ClassName atau Enum sudah benar (case-sensitive, contoh: 'TweenService', 'CanvasGroup', 'Vector3', 'EasingStyle').`;
+    }
+    let doc;
+    try {
+        doc = yaml_1.default.parse(resolved.yamlText);
+    }
+    catch (err) {
+        return `❌ Gagal mem-parse format YAML untuk "${query}": ${err.message}`;
+    }
+    const name = doc.name || query;
+    const docType = doc.type || resolved.category;
+    const summary = cleanRobloxMarkdown(doc.summary || '');
+    const description = cleanRobloxMarkdown(doc.description || '');
+    // JIKA MEMBER SPESIFIK DICARI (Contoh: 'Create', 'GroupTransparency')
+    if (member) {
+        const memberNorm = member.trim().toLowerCase();
+        const allMembers = [];
+        const collect = (arr, kind) => {
+            if (Array.isArray(arr)) {
+                for (const item of arr)
+                    allMembers.push({ item, kind });
+            }
+        };
+        collect(doc.constructors, 'Constructor');
+        collect(doc.properties, 'Property');
+        collect(doc.methods, 'Method');
+        collect(doc.functions, 'Function');
+        collect(doc.events, 'Event');
+        collect(doc.callbacks, 'Callback');
+        collect(doc.items, 'Enum Item');
+        collect(doc.constants, 'Constant');
+        const matched = allMembers.find(({ item }) => {
+            const full = String(item.name || '').toLowerCase();
+            return full === memberNorm || full.endsWith(`.${memberNorm}`) || full.endsWith(`:${memberNorm}`);
+        });
+        if (matched) {
+            let out = `# ${name} : ${matched.item.name || member}\n\n`;
+            out += formatSingleMember(name, matched.item, matched.kind);
+            return out;
+        }
+        return `⚠️ Member "${member}" tidak ditemukan di dalam ${name}.\nAnggota yang tersedia: ` +
+            allMembers.slice(0, 15).map(({ item }) => `\`${item.name}\``).join(', ') +
+            (allMembers.length > 15 ? ` ...dan ${allMembers.length - 15} lainnya.` : '');
+    }
+    // TAMPILAN PENUH OVERVIEW DOKUMENTASI
+    let md = `# Roblox Engine: ${name} (${docType})\n\n`;
+    if (doc.deprecation_message) {
+        md += `> ⚠️ **DEPRECATED:** ${cleanRobloxMarkdown(doc.deprecation_message)}\n\n`;
+    }
+    if (summary) {
+        md += `> ${summary}\n\n`;
+    }
+    if (doc.inherits) {
+        md += `* **Inherits from:** \`${doc.inherits}\`\n`;
+    }
+    if (doc.memory_category) {
+        md += `* **Memory Category:** \`${doc.memory_category}\`\n`;
+    }
+    if (Array.isArray(doc.tags) && doc.tags.length > 0) {
+        md += `* **Tags:** ${doc.tags.join(', ')}\n`;
+    }
+    md += `\n---\n\n`;
+    if (description && description !== summary) {
+        md += `### Description\n${description}\n\n`;
+    }
+    // CONSTRUCTORS
+    if (Array.isArray(doc.constructors) && doc.constructors.length > 0) {
+        md += `### Constructors\n`;
+        for (const c of doc.constructors) {
+            const params = (c.parameters || []).map((p) => `${p.name}: ${p.type || 'any'}`).join(', ');
+            md += `* \`${c.name}(${params})\`\n  ${cleanRobloxMarkdown(c.summary || '')}\n`;
+        }
+        md += `\n`;
+    }
+    // PROPERTIES TABLE
+    if (Array.isArray(doc.properties) && doc.properties.length > 0) {
+        md += `### Properties\n\n`;
+        md += `| Property | Type | Security | Summary |\n`;
+        md += `| :--- | :--- | :--- | :--- |\n`;
+        for (const p of doc.properties) {
+            const pName = p.name ? p.name.replace(/^[^.]+\./, '') : 'Unknown';
+            const pType = `\`${p.type || 'any'}\``;
+            const sec = p.security?.read ? `${p.security.read}` : 'None';
+            const pSummary = cleanRobloxMarkdown(p.summary || '').replace(/[\r\n]+/g, ' ').slice(0, 100);
+            md += `| **\`${pName}\`** | ${pType} | ${sec} | ${pSummary} |\n`;
+        }
+        md += `\n`;
+    }
+    // METHODS
+    if (Array.isArray(doc.methods) && doc.methods.length > 0) {
+        md += `### Methods\n`;
+        for (const m of doc.methods) {
+            const params = (m.parameters || []).map((p) => `${p.name}: ${p.type || 'any'}`).join(', ');
+            const returns = (m.returns || []).map((r) => r.type || 'void').join(', ') || 'void';
+            md += `* \`${m.name}(${params}) -> ${returns}\`\n  ${cleanRobloxMarkdown(m.summary || '')}\n`;
+        }
+        md += `\n`;
+    }
+    // FUNCTIONS (Libraries / Static)
+    if (Array.isArray(doc.functions) && doc.functions.length > 0) {
+        md += `### Functions\n`;
+        for (const f of doc.functions) {
+            const params = (f.parameters || []).map((p) => `${p.name}: ${p.type || 'any'}`).join(', ');
+            const returns = (f.returns || []).map((r) => r.type || 'void').join(', ') || 'void';
+            md += `* \`${f.name}(${params}) -> ${returns}\`\n  ${cleanRobloxMarkdown(f.summary || '')}\n`;
+        }
+        md += `\n`;
+    }
+    // EVENTS
+    if (Array.isArray(doc.events) && doc.events.length > 0) {
+        md += `### Events\n`;
+        for (const e of doc.events) {
+            const params = (e.parameters || []).map((p) => `${p.name}: ${p.type || 'any'}`).join(', ');
+            md += `* \`${e.name}(${params})\`\n  ${cleanRobloxMarkdown(e.summary || '')}\n`;
+        }
+        md += `\n`;
+    }
+    // ENUM ITEMS
+    if (Array.isArray(doc.items) && doc.items.length > 0) {
+        md += `### Enum Items\n\n`;
+        md += `| Item | Value | Summary |\n`;
+        md += `| :--- | :--- | :--- |\n`;
+        for (const it of doc.items) {
+            const itSummary = cleanRobloxMarkdown(it.summary || '').replace(/[\r\n]+/g, ' ');
+            md += `| **\`${it.name}\`** | \`${it.value}\` | ${itSummary} |\n`;
+        }
+        md += `\n`;
+    }
+    return md.trim();
+}