@doccident/doccident 0.0.4 → 0.0.6

package/bin/cmd.js

@@ -22,7 +22,8 @@ const config = {
     require: {},
     globals: {},
     ignore: [],
-    testOutput: false
+    testOutput: false,
+    timeout: 300000 // Default 5 minutes
 };
 
 // Setup commander
@@ -34,6 +35,8 @@ program
     .helpOption('-h, --help', 'output usage informations')
     .option('-c, --config <path>', 'custom config location', path.join(process.cwd(), '/.doccident-setup.js'))
     .option('--test-output', 'output the test results to the console')
+    .option('--update-output', 'update the output blocks in markdown files')
+    .option('--timeout <ms>', 'timeout for each snippet execution in milliseconds', '300000')
     .parse(process.argv);
 
 const options = program.opts();
@@ -57,6 +60,14 @@ const options = program.opts();
     if (options.testOutput) {
         config.testOutput = true;
     }
+    
+    if (options.updateOutput) {
+        config.updateOutput = true;
+    }
+    
+    if (options.timeout) {
+        config.timeout = parseInt(options.timeout, 10);
+    }
 
     // Resolve files
     try {

package/dist/doctest.js

@@ -18,12 +18,27 @@ const rust_1 = require("./languages/rust");
 const fortran_1 = require("./languages/fortran");
 const cobol_1 = require("./languages/cobol");
 const c_1 = require("./languages/c");
+const basic_1 = require("./languages/basic");
+const java_1 = require("./languages/java");
+const csharp_1 = require("./languages/csharp");
+const perl_1 = require("./languages/perl");
+const r_1 = require("./languages/r");
+const pascal_1 = require("./languages/pascal");
 const javascript_1 = require("./languages/javascript");
 function runTests(files, config) {
     const results = files
         .map(read)
-        .map(parse_code_snippets_from_markdown_1.default)
-        .map(testFile(config));
+        .map(fileInfo => {
+        const parsed = (0, parse_code_snippets_from_markdown_1.default)(fileInfo);
+        // Attach original contents to parsed file if needed for updates?
+        // Actually testFile closure captures it if we pass it correctly?
+        // But map pipeline separates them.
+        // Let's modify testFile to accept FileInfo + ParsedFile or just re-read?
+        // Or better: `read` returns FileInfo. `parseCodeSnippets` returns ParsedFile (without contents).
+        // We can wrap this better.
+        return { parsed, fileInfo };
+    })
+        .map(({ parsed, fileInfo }) => testFile(config)(parsed, fileInfo));
     return (0, utils_1.flatten)(results);
 }
 function read(fileName) {
@@ -52,28 +67,168 @@ function makeTestSandbox(config) {
     return sandbox;
 }
 function testFile(config) {
-    return function testFileWithConfig(args) {
+    return function testFileWithConfig(args, fileInfo) {
         const codeSnippets = args.codeSnippets;
         const fileName = args.fileName;
         const shareCodeInFile = args.shareCodeInFile;
         let results;
+        // Map to store outputs by ID
+        const outputs = {};
+        // Store edits if updating output
+        const edits = [];
         if (shareCodeInFile) {
             const sandbox = makeTestSandbox(config);
-            results = codeSnippets.map(test(config, fileName, sandbox));
+            results = codeSnippets.map(test(config, fileName, sandbox, outputs, edits));
         }
         else {
-            results = codeSnippets.map(test(config, fileName));
+            results = codeSnippets.map(test(config, fileName, undefined, outputs, edits));
+        }
+        // Apply edits if updateOutput is true and we have file info
+        if (config.updateOutput && edits.length > 0 && fileInfo) {
+            applyEdits(fileInfo, edits);
         }
         return results;
     };
 }
-function test(config, _filename, sandbox) {
+function applyEdits(fileInfo, edits) {
+    // Sort edits by startLine descending to safely modify file
+    // Note: We need endLine for snippets. Currently Snippet only has lineNumber (start).
+    // The parser needs to provide endLine or we need to calculate it.
+    // If we assume standard fences ```...```, we can try to guess or update parser.
+    // Parser update is safer. But let's check snippet first.
+    // For now, let's assume we can't do it safely without endLine.
+    // Snippet interface needs endLine.
+    // Sort descending
+    edits.sort((a, b) => b.startLine - a.startLine);
+    const lines = fileInfo.contents.split('\n');
+    for (const edit of edits) {
+        if (edit.endLine === undefined)
+            continue;
+        // Snippet startLine is 1-based index of the first line of content (inside fences) usually?
+        // Let's check parser.
+        // In parser: `lineNumber` is `index + 1`. `index` is passed from split('\n').map.
+        // `isStartOfSnippet` detects the opening fence.
+        // `startNewSnippet` called with that line number.
+        // So `lineNumber` is the line of the OPENING FENCE ```.
+        // Code content starts at lineNumber + 1?
+        // Wait, parser:
+        // `parseLine` calls `startNewSnippet` on `isStartOfSnippet`.
+        // So snippet.lineNumber is the line index (1-based) of the ```lang line.
+        // `endSnippet` is called on `isEndOfSnippet` (closing ```).
+        // We need to capture that line number too.
+        // We replace from `startLine` (exclusive? no, replace the CONTENT)
+        // Actually, we want to replace the content BETWEEN the fences.
+        // So from `startLine` (0-based index) + 1 to `endLine` (0-based index) - 1.
+        // Let's rely on parser providing `endLine`.
+        const startIdx = edit.startLine; // 1-based index of opening fence
+        const endIdx = edit.endLine; // 1-based index of closing fence
+        // Content lines are startIdx...endIdx-2 (0-based: startIdx is fence line)
+        // Example:
+        // 1: ```text  <- startLine
+        // 2: Old      <- content
+        // 3: ```      <- endLine
+        // We want to replace lines between startLine and endLine with new content.
+        // 0-based indexes:
+        // startLineIndex = startLine - 1;
+        // endLineIndex = endLine - 1;
+        // We want to replace lines from (startLineIndex + 1) to (endLineIndex - 1).
+        // splice(start, deleteCount, items...)
+        const startReplace = startIdx; // index after opening fence
+        const deleteCount = (endIdx - 1) - startReplace;
+        // If content is empty/new, we just splice.
+        lines.splice(startReplace, deleteCount, edit.content);
+    }
+    (0, fs_1.writeFileSync)(fileInfo.fileName, lines.join('\n'));
+}
+function test(config, _filename, sandbox, outputs, edits) {
     return (codeSnippet) => {
+        const startTime = performance.now();
         if (codeSnippet.skip) {
             return { status: "skip", codeSnippet, stack: "" };
         }
+        // Output verification / update logic
+        if (codeSnippet.outputOf) {
+            const expectedOutput = codeSnippet.code.trim(); // Trim for comparison
+            // For update, we want the raw output (maybe trimmed of trailing newline but preserving structure)
+            const actualOutput = outputs && outputs[codeSnippet.outputOf] ? outputs[codeSnippet.outputOf] : "";
+            const actualOutputTrimmed = actualOutput.trim();
+            // console.log(`[DEBUG] Verifying '${codeSnippet.outputOf}' Mode=${codeSnippet.outputMode}`);
+            // console.log(`[DEBUG] Expected: "${expectedOutput}"`);
+            // console.log(`[DEBUG] Actual: "${actualOutputTrimmed}"`);
+            if (!outputs || outputs[codeSnippet.outputOf] === undefined) {
+                return { status: "fail", codeSnippet, stack: `Snippet with id '${codeSnippet.outputOf}' not executed or not found.` };
+            }
+            if (config.updateOutput) {
+                // Schedule update
+                if (edits) {
+                    // Normalize actual output: usually we want to preserve it exactly, 
+                    // but standard console.log adds newline. 
+                    // Markdown blocks usually end with newline before ```.
+                    // Let's strip the very last newline if present to avoid growing gaps?
+                    // Or just use trimEnd()?
+                    // Generally, code blocks look like:
+                    // ```text
+                    // Output
+                    // ```
+                    // If actualOutput is "Output\n", we put "Output" inside?
+                    // Or "Output\n"?
+                    // If we put "Output\n", it becomes:
+                    // ```text
+                    // Output
+                    // 
+                    // ```
+                    // Let's trim trailing whitespace from actualOutput for the replacement content.
+                    edits.push({
+                        startLine: codeSnippet.lineNumber,
+                        endLine: codeSnippet.endLine, // We need this!
+                        content: actualOutput.trimEnd()
+                    });
+                }
+                process.stdout.write(chalk_1.default.yellow("u"));
+                return { status: "pass", codeSnippet, stack: "" };
+            }
+            if (actualOutputTrimmed !== expectedOutput) {
+                if (codeSnippet.outputMode === 'ignore-whitespace') {
+                    // Normalize both strings: replace all whitespace sequences with single space and trim
+                    const normalize = (s) => s.replace(/\s+/g, ' ').trim();
+                    if (normalize(actualOutput) === normalize(expectedOutput)) {
+                        process.stdout.write(chalk_1.default.green("."));
+                        return { status: "pass", codeSnippet, stack: "" };
+                    }
+                }
+                else if (codeSnippet.outputMode === 'regex') {
+                    // Treat expectedOutput as regex pattern
+                    try {
+                        const pattern = expectedOutput.trim();
+                        // For regex, we match against trimmed actual output
+                        const re = new RegExp(pattern);
+                        if (re.test(actualOutput.trim())) {
+                            process.stdout.write(chalk_1.default.green("."));
+                            return { status: "pass", codeSnippet, stack: "" };
+                        }
+                    }
+                    catch (e) {
+                        process.stdout.write(chalk_1.default.red("x"));
+                        return {
+                            status: "fail",
+                            codeSnippet,
+                            stack: `Invalid Regex Pattern: ${e}\nPattern:\n${expectedOutput}`
+                        };
+                    }
+                }
+                process.stdout.write(chalk_1.default.red("x"));
+                return {
+                    status: "fail",
+                    codeSnippet,
+                    stack: `Output verification failed (${codeSnippet.outputMode || 'exact'}).\nExpected:\n${expectedOutput}\n\nActual:\n${actualOutputTrimmed}`
+                };
+            }
+            process.stdout.write(chalk_1.default.green("."));
+            return { status: "pass", codeSnippet, stack: "" };
+        }
         let success = false;
         let stack = "";
+        let output = "";
         let code = codeSnippet.code;
         if (config.transformCode) {
             try {
@@ -119,14 +274,41 @@ function test(config, _filename, sandbox) {
         else if (codeSnippet.language === 'c') {
             result = (0, c_1.cHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
+        else if (codeSnippet.language === 'basic') {
+            result = (0, basic_1.basicHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'java') {
+            result = (0, java_1.javaHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'perl') {
+            result = (0, perl_1.perlHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'r') {
+            result = (0, r_1.rHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'pascal') {
+            result = (0, pascal_1.pascalHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'csharp') {
+            result = (0, csharp_1.csharpHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'text') {
+            result = { success: true, stack: "" };
+        }
         else {
             result = (0, javascript_1.javascriptHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
         success = result.success;
         stack = result.stack;
+        output = result.output || "";
+        // Store output if ID is present
+        if (codeSnippet.id && outputs) {
+            outputs[codeSnippet.id] = output;
+        }
         const status = success ? "pass" : "fail";
+        const executionTime = performance.now() - startTime;
         process.stdout.write(success ? chalk_1.default.green(".") : chalk_1.default.red("x"));
-        return { status, codeSnippet, stack };
+        return { status, codeSnippet, stack, executionTime };
     };
 }
 function moduleNotFoundError(moduleName) {

package/dist/languages/basic.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicHandler = void 0;
+const child_process_1 = require("child_process");
+// Check if BASIC code is a complete program (has END statement)
+function isCompleteBASIC(code) {
+    // Look for END as a statement (possibly with line number prefix)
+    // Matches: "END", "10 END", "END\n", etc.
+    return /^\d*\s*END\s*$/im.test(code);
+}
+const basicHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous basic snippets
+    if (isSharedSandbox) {
+        if (!context._basicContext) {
+            context._basicContext = "";
+        }
+        // Trim trailing newline from code before adding to avoid blank lines
+        // (code already has trailing newline from parser)
+        const trimmedCode = code.replace(/\n+$/, '');
+        context._basicContext += trimmedCode + "\n";
+        code = context._basicContext;
+        // In shared mode, only run when program is complete (has END)
+        // Incomplete snippets are setup code - mark as pass without running
+        if (!isCompleteBASIC(code)) {
+            return { success: true, stack: "", output: "" };
+        }
+    }
+    try {
+        // cbmbasic accepts input from stdin
+        const timeout = config.timeout || 30000;
+        const result = (0, child_process_1.spawnSync)('cbmbasic', [], { input: code, encoding: 'utf-8', timeout });
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "BASIC execution failed with non-zero exit code";
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn cbmbasic";
+        return { success, stack };
+    }
+};
+exports.basicHandler = basicHandler;

package/dist/languages/c.js

@@ -5,38 +5,149 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
-const cHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+// Helper to parse C code
+function parseCCode(fullCode) {
+    const lines = fullCode.split('\n');
+    const includes = [];
+    let topLevel = "";
+    let mainBody = "";
+    let state = 'NORMAL';
+    let braceCount = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            // Empty lines preserve structure slightly better if added to last active section
+            // or just ignore. Let's add to mainBody if normal, or topLevel if in block.
+            if (state === 'IN_TOP_LEVEL_BLOCK')
+                topLevel += "\n";
+            else
+                mainBody += "\n";
+            continue;
+        }
+        if (state === 'NORMAL') {
+            if (trimmed.startsWith('#')) {
+                includes.push(line);
+            }
+            else if (trimmed.startsWith('struct ') ||
+                trimmed.startsWith('union ') ||
+                trimmed.startsWith('enum ') ||
+                trimmed.startsWith('typedef ') ||
+                // Function definition heuristic: ReturnType Name(Args) {
+                // Must end with {
+                (trimmed.endsWith('{') && !trimmed.startsWith('if') && !trimmed.startsWith('for') && !trimmed.startsWith('while') && !trimmed.startsWith('switch') && !trimmed.startsWith('do'))) {
+                topLevel += line + "\n";
+                // Count braces
+                const open = (line.match(/\{/g) || []).length;
+                const close = (line.match(/\}/g) || []).length;
+                braceCount = open - close;
+                if (braceCount > 0) {
+                    state = 'IN_TOP_LEVEL_BLOCK';
+                }
+            }
+            else {
+                // Statements, variable declarations (int x;), etc. go to main
+                mainBody += line + "\n";
+            }
+        }
+        else if (state === 'IN_TOP_LEVEL_BLOCK') {
+            topLevel += line + "\n";
+            const open = (line.match(/\{/g) || []).length;
+            const close = (line.match(/\}/g) || []).length;
+            braceCount += open - close;
+            if (braceCount <= 0) {
+                state = 'NORMAL';
+                braceCount = 0;
+            }
+        }
+    }
+    return { includes, topLevel, mainBody };
+}
+const cHandler = (code, snippet, config, sandbox, isSharedSandbox) => {
     let success = false;
     let stack = "";
-    // C execution logic
-    // Auto-wrap in main function if not present
+    const context = sandbox;
     let cCode = code;
-    if (!cCode.includes('main(')) {
-        cCode = `#include <stdio.h>
- int main() {
- ${cCode}
- return 0;
- }`;
+    // Handle shared state
+    if (isSharedSandbox) {
+        if (!context._cCode) {
+            context._cCode = "";
+        }
+        context._cCode += code + "\n";
+        cCode = context._cCode;
+    }
+    let finalSource = "";
+    // If main is explicitly provided, use it (disable parsing/wrapping)
+    // But in shared mode, we usually want to compose.
+    // If user provides "int main() { ... }" in a snippet, we assume they take full control?
+    // Or do we try to merge? 
+    // Merging multiple mains is impossible.
+    // So if any snippet contains "int main", we might just assume it's the full program so far?
+    // But earlier snippets might be structs/includes.
+    // Let's assume if "int main" or "void main" is present, we respect it, 
+    // but we still might want to prepend includes from previous snippets if they were separate?
+    // For simplicity: If "main(" found, treat as full program.
+    // But parsing is safer for "includes" + "functions" + "statements".
+    if (cCode.includes('main(')) {
+        // If shared sandbox, we might have accumulated a main from previous snippets?
+        // No, if we are parsing, we construct main.
+        // If the USER typed main, we trust them.
+        finalSource = cCode;
+        // Auto-add stdio.h if missing and needed?
+        if (!finalSource.includes('<stdio.h>') && finalSource.includes('printf')) {
+            finalSource = `#include <stdio.h>\n${finalSource}`;
+        }
+    }
+    else {
+        const { includes, topLevel, mainBody } = parseCCode(cCode);
+        // Auto-add stdio.h if needed
+        let autoIncludes = "";
+        const includesStr = includes.join('\n');
+        if (!includesStr.includes('<stdio.h>') && (topLevel.includes('printf') || mainBody.includes('printf'))) {
+            autoIncludes = `#include <stdio.h>\n`;
+        }
+        finalSource = `${autoIncludes}${includesStr}
+
+${topLevel}
+
+int main() {
+${mainBody}
+    return 0;
+}`;
     }
     const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
     const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}.c`);
     const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}`);
     try {
-        (0, fs_1.writeFileSync)(tempSourceFile, cCode);
+        const args = snippet.args || [];
+        const env = snippet.env ? { ...process.env, ...snippet.env } : undefined;
+        const timeout = config.timeout || 30000;
+        (0, fs_1.writeFileSync)(tempSourceFile, finalSource);
         // Compile with gcc
-        const compileResult = (0, child_process_1.spawnSync)('gcc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        // args passed to GCC (compiler flags)
+        const compileResult = (0, child_process_1.spawnSync)('gcc', [tempSourceFile, '-o', tempExeFile, ...args], { encoding: 'utf-8', timeout });
         if (compileResult.status !== 0) {
             stack = compileResult.stderr || "C compilation failed";
+            if (isSharedSandbox) {
+                stack += `\n\nGenerated Source:\n${finalSource}`;
+            }
         }
         else {
             // Run
-            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            // What if we want runtime args? 
+            // Currently args are compiler flags.
+            // Maybe we need separate config for runtime args? 
+            // For now, adhering to "arguments to compilers/interpreters".
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8', env, timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
             if (runResult.status === 0) {
                 success = true;
             }
             else {
                 stack = runResult.stderr || "C execution failed with non-zero exit code";
             }
+            return { success, stack, output: runResult.stdout };
         }
     }
     catch (e) {

package/dist/languages/cobol.js

@@ -5,7 +5,7 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
-const cobolHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+const cobolHandler = (code, _snippet, config, _sandbox, _isSharedSandbox) => {
     let success = false;
     let stack = "";
     // COBOL execution logic
@@ -13,22 +13,27 @@ const cobolHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
     const uniqueId = Math.random().toString(36).substring(2, 10);
     const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}.cob`);
     const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}`);
+    const timeout = config.timeout || 30000;
     try {
         (0, fs_1.writeFileSync)(tempSourceFile, code);
         // Compile with cobc -x (executable) -free (free format)
-        const compileResult = (0, child_process_1.spawnSync)('cobc', ['-x', '-free', '-o', tempExeFile, tempSourceFile], { encoding: 'utf-8' });
+        const compileResult = (0, child_process_1.spawnSync)('cobc', ['-x', '-free', '-o', tempExeFile, tempSourceFile], { encoding: 'utf-8', timeout });
         if (compileResult.status !== 0) {
             stack = compileResult.stderr || "COBOL compilation failed";
         }
         else {
             // Run
-            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8', timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
             if (runResult.status === 0) {
                 success = true;
             }
             else {
                 stack = runResult.stderr || "COBOL execution failed with non-zero exit code";
             }
+            return { success, stack, output: runResult.stdout };
         }
     }
     catch (e) {

package/dist/languages/csharp.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const csharpHandler = (code, _snippet, config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // C# execution logic
+    // Auto-wrap in class Program and Main method if not present
+    let csCode = code;
+    const className = "Program";
+    // Simple heuristic to detect if class is provided
+    if (!csCode.includes("class ")) {
+        csCode = `using System;
+public class ${className} {
+    public static void Main(string[] args) {
+        ${csCode}
+    }
+}`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_csharp_${uniqueId}`);
+    const timeout = config.timeout || 30000;
+    try {
+        if (!(0, fs_1.existsSync)(tempDir)) {
+            (0, fs_1.mkdirSync)(tempDir);
+        }
+        const tempSourceFile = (0, path_1.join)(tempDir, `${className}.cs`);
+        const tempExeFile = (0, path_1.join)(tempDir, `${className}.exe`);
+        (0, fs_1.writeFileSync)(tempSourceFile, csCode);
+        // Compile with mcs (Mono Compiler)
+        const compileResult = (0, child_process_1.spawnSync)('mcs', ['-out:' + tempExeFile, tempSourceFile], { encoding: 'utf-8', cwd: tempDir, timeout });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "C# compilation failed (mcs)";
+        }
+        else {
+            // Run with mono
+            const runResult = (0, child_process_1.spawnSync)('mono', [tempExeFile], { encoding: 'utf-8', cwd: tempDir, timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "C# execution failed with non-zero exit code";
+            }
+            return { success, stack, output: runResult.stdout };
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute mcs or mono";
+    }
+    finally {
+        try {
+            if (fs_1.rmSync) {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            else {
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${className}.cs`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${className}.cs`));
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${className}.exe`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${className}.exe`));
+                if ((0, fs_1.existsSync)(tempDir))
+                    (0, fs_1.rmdirSync)(tempDir);
+            }
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.csharpHandler = csharpHandler;