redscript-mc 1.2.30 → 2.1.0

package/src/cli.ts

@@ -1,21 +1,22 @@
 #!/usr/bin/env node
 /**
  * RedScript CLI
- * 
+ *
  * Usage:
- *   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>]
+ *   redscript compile <file> [-o <out>] [--namespace <ns>]
  *   redscript check <file>
  *   redscript repl
  *   redscript version
  */
 
-import { compile, check } from './index'
-import { generateCommandBlocks } from './codegen/cmdblock'
-import { compileToStructure } from './codegen/structure'
+import { compile, checkWithWarnings } from './index'
 import { formatError } from './diagnostics'
+import { parseMcVersion, DEFAULT_MC_VERSION } from './types/mc-version'
 import { startRepl } from './repl'
 import { generateDts } from './builtins/metadata'
-import type { OptimizationStats } from './optimizer/commands'
+import { FileCache } from './cache/index'
+import { DependencyGraph } from './cache/deps'
+import { compileIncremental } from './cache/incremental'
 import * as fs from 'fs'
 import * as path from 'path'
 import * as https from 'https'
@@ -26,10 +27,10 @@ const args = process.argv.slice(2)
 
 function printUsage(): void {
   console.log(`
-RedScript Compiler
+RedScript Compiler v2
 
 Usage:
-  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--scoreboard <obj>] [--target <target>] [--no-dce]
+  redscript compile <file> [-o <out>] [--namespace <ns>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
@@ -48,24 +49,15 @@ Commands:
   upgrade       Upgrade to the latest version (npm install -g redscript-mc@latest)
 
 Options:
-  -o, --output <path>    Output directory or file path, depending on target
-  --output-nbt <file>    Output .nbt file path for structure target
+  -o, --output <path>    Output directory or file path
   --namespace <ns>       Datapack namespace (default: derived from filename)
-  --target <target>      Output target: datapack (default), cmdblock, or structure
-  --no-dce               Disable AST dead code elimination
-  --no-mangle            Disable variable name mangling (use readable names)
-  --scoreboard <obj>     Scoreboard objective for variables (default: namespace).
-                         Each datapack automatically uses its namespace as the objective
-                         so multiple datapacks can coexist without collisions.
-  --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
+  --source-map           Generate .sourcemap.json files alongside .mcfunction output
+  --mc-version <ver>     Target Minecraft version (default: 1.21). Affects codegen features.
+                         e.g. --mc-version 1.20.2, --mc-version 1.19
+  --lenient              Treat type errors as warnings instead of blocking compilation
   -h, --help             Show this help message
-
-Targets:
-  datapack  Generate a full Minecraft datapack (default)
-  cmdblock  Generate JSON structure for command block placement
-  structure Generate a Minecraft structure .nbt file with command blocks
 `)
 }
 
@@ -163,17 +155,14 @@ function parseArgs(args: string[]): {
   command?: string
   file?: string
   output?: string
-  outputNbt?: string
   namespace?: string
-  target?: string
-  stats?: boolean
   help?: boolean
   hotReload?: string
-  dce?: boolean
-  mangle?: boolean
-  scoreboardObjective?: string
+  sourceMap?: boolean
+  mcVersionStr?: string
+  lenient?: boolean
 } {
-  const result: ReturnType<typeof parseArgs> = { dce: true, mangle: true }
+  const result: ReturnType<typeof parseArgs> = {}
   let i = 0
 
   while (i < args.length) {
@@ -185,29 +174,20 @@ function parseArgs(args: string[]): {
     } else if (arg === '-o' || arg === '--output') {
       result.output = args[++i]
       i++
-    } else if (arg === '--output-nbt') {
-      result.outputNbt = args[++i]
-      i++
     } else if (arg === '--namespace') {
       result.namespace = args[++i]
       i++
-    } else if (arg === '--target') {
-      result.target = args[++i]
-      i++
-    } else if (arg === '--stats') {
-      result.stats = true
+    } else if (arg === '--hot-reload') {
+      result.hotReload = args[++i]
       i++
-    } else if (arg === '--no-dce') {
-      result.dce = false
+    } else if (arg === '--source-map') {
+      result.sourceMap = true
       i++
-    } else if (arg === '--no-mangle') {
-      result.mangle = false
+    } else if (arg === '--mc-version') {
+      result.mcVersionStr = args[++i]
       i++
-    } else if (arg === '--scoreboard') {
-      result.scoreboardObjective = args[++i]
-      i++
-    } else if (arg === '--hot-reload') {
-      result.hotReload = args[++i]
+    } else if (arg === '--lenient') {
+      result.lenient = true
       i++
     } else if (!result.command) {
       result.command = arg
@@ -229,48 +209,13 @@ function deriveNamespace(filePath: string): string {
   return basename.toLowerCase().replace(/[^a-z0-9]/g, '_')
 }
 
-function printWarnings(warnings: Array<{ code: string; message: string; line?: number; col?: number; filePath?: string }> | undefined): void {
-  if (!warnings || warnings.length === 0) {
-    return
-  }
-
-  for (const warning of warnings) {
-    const loc = warning.filePath
-      ? `${warning.filePath}:${warning.line ?? '?'}`
-      : warning.line != null
-        ? `line ${warning.line}`
-        : null
-    const locStr = loc ? ` (${loc})` : ''
-    console.error(`Warning [${warning.code}]: ${warning.message}${locStr}`)
-  }
-}
-
-function formatReduction(before: number, after: number): string {
-  if (before === 0) return '0%'
-  return `${Math.round(((before - after) / before) * 100)}%`
-}
-
-function printOptimizationStats(stats: OptimizationStats | undefined): void {
-  if (!stats) return
-
-  console.log('Optimizations applied:')
-  console.log(`  LICM: ${stats.licmHoists} reads hoisted from ${stats.licmLoopBodies} loop bodies`)
-  console.log(`  CSE:  ${stats.cseRedundantReads + stats.cseArithmetic} expressions eliminated`)
-  console.log(`  setblock batching: ${stats.setblockMergedCommands} setblocks -> ${stats.setblockFillCommands} fills (saved ${stats.setblockSavedCommands} commands)`)
-  console.log(`  dead code: ${stats.deadCodeRemoved} commands removed`)
-  console.log(`  constant folding: ${stats.constantFolds} constants folded`)
-  console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`)
-}
-
 function compileCommand(
   file: string,
   output: string,
   namespace: string,
-  target: string = 'datapack',
-  showStats = false,
-  dce = true,
-  mangle = true,
-  scoreboardObjective: string | undefined = undefined
+  sourceMap = false,
+  mcVersionStr?: string,
+  lenient = false,
 ): void {
   // Read source file
   if (!fs.existsSync(file)) {
@@ -278,78 +223,46 @@ function compileCommand(
     process.exit(1)
   }
 
+  let mcVersion = DEFAULT_MC_VERSION
+  if (mcVersionStr) {
+    try {
+      mcVersion = parseMcVersion(mcVersionStr)
+    } catch (e) {
+      console.error(`Error: ${(e as Error).message}`)
+      process.exit(1)
+    }
+  }
+
   const source = fs.readFileSync(file, 'utf-8')
 
   try {
-    if (target === 'cmdblock') {
-      const result = compile(source, { namespace, filePath: file, dce, mangle, scoreboardObjective })
-      printWarnings(result.warnings)
-
-      // Generate command block JSON
-      const hasTick = result.files.some(f => f.path.includes('__tick.mcfunction'))
-      const hasLoad = result.files.some(f => f.path.includes('__load.mcfunction'))
-      const cmdBlocks = generateCommandBlocks(namespace, hasTick, hasLoad)
-
-      // Write command block JSON
-      fs.mkdirSync(output, { recursive: true })
-      const outputFile = path.join(output, `${namespace}_cmdblocks.json`)
-      fs.writeFileSync(outputFile, JSON.stringify(cmdBlocks, null, 2))
-
-      console.log(`✓ Generated command blocks for ${file}`)
-      console.log(`  Output: ${outputFile}`)
-      console.log(`  Blocks: ${cmdBlocks.blocks.length}`)
-      if (showStats) {
-        printOptimizationStats(result.stats)
-      }
-    } else if (target === 'structure') {
-      const structure = compileToStructure(source, namespace, file, { dce, mangle })
-      fs.mkdirSync(path.dirname(output), { recursive: true })
-      fs.writeFileSync(output, structure.buffer)
-
-      console.log(`✓ Generated structure for ${file}`)
-      console.log(`  Output: ${output}`)
-      console.log(`  Blocks: ${structure.blockCount}`)
-      if (showStats) {
-        printOptimizationStats(structure.stats)
-      }
-    } else {
-      const result = compile(source, { namespace, filePath: file, dce, mangle, scoreboardObjective })
-      printWarnings(result.warnings)
-
-      // Default: generate datapack
-      // Create output directory
-      fs.mkdirSync(output, { recursive: true })
-
-      // Write all files
-      for (const dataFile of result.files) {
-        const filePath = path.join(output, dataFile.path)
-        const dir = path.dirname(filePath)
-        fs.mkdirSync(dir, { recursive: true })
-        fs.writeFileSync(filePath, dataFile.content)
-      }
+    const result = compile(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient })
 
-      // Write sourcemap alongside datapack when mangle mode is active
-      if (mangle && result.sourceMap && Object.keys(result.sourceMap).length > 0) {
-        const mapPath = path.join(output, `${namespace}.map.json`)
-        fs.writeFileSync(mapPath, JSON.stringify(result.sourceMap, null, 2))
-        console.log(`  Sourcemap: ${mapPath}`)
-      }
+    for (const w of result.warnings) {
+      console.error(`Warning: ${w}`)
+    }
 
-      console.log(`✓ Compiled ${file} to ${output}/`)
-      console.log(`  Namespace: ${namespace}`)
-      console.log(`  Functions: ${result.ir.functions.length}`)
-      console.log(`  Files: ${result.files.length}`)
-      if (showStats) {
-        printOptimizationStats(result.stats)
-      }
+    // Create output directory
+    fs.mkdirSync(output, { recursive: true })
+
+    // Write all files
+    for (const dataFile of result.files) {
+      const filePath = path.join(output, dataFile.path)
+      const dir = path.dirname(filePath)
+      fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(filePath, dataFile.content)
     }
+
+    console.log(`✓ Compiled ${file} to ${output}/`)
+    console.log(`  Namespace: ${namespace}`)
+    console.log(`  Files: ${result.files.length}`)
   } catch (err) {
-    console.error(formatError(err as Error, source))
+    console.error(formatError(err as Error, source, file))
     process.exit(1)
   }
 }
 
-function checkCommand(file: string): void {
+function checkCommand(file: string, namespace?: string): void {
   // Read source file
   if (!fs.existsSync(file)) {
     console.error(`Error: File not found: ${file}`)
@@ -358,13 +271,19 @@ function checkCommand(file: string): void {
 
   const source = fs.readFileSync(file, 'utf-8')
 
-  const error = check(source, 'redscript', file)
-  if (error) {
-    console.error(formatError(error, source))
+  const ns = namespace ?? deriveNamespace(file)
+  const result = checkWithWarnings(source, ns, file)
+
+  for (const w of result.warnings) {
+    console.error(`Warning: ${w}`)
+  }
+
+  if (result.error) {
+    console.error(formatError(result.error, source, file))
     process.exit(1)
   }
 
-  console.log(`✓ ${file} is valid`)
+  console.log(`✓ No errors found`)
 }
 
 async function hotReload(url: string): Promise<void> {
@@ -380,7 +299,7 @@ async function hotReload(url: string): Promise<void> {
   }
 }
 
-function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string, dce = true): void {
+function watchCommand(dir: string, output: string, namespace?: string, hotReloadUrl?: string): void {
   // Check if directory exists
   if (!fs.existsSync(dir)) {
     console.error(`Error: Directory not found: ${dir}`)
@@ -396,52 +315,55 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   console.log(`👁  Watching ${dir} for .mcrs file changes...`)
   console.log(`   Output: ${output}`)
   if (hotReloadUrl) console.log(`   Hot reload: ${hotReloadUrl}`)
+  console.log(`   Incremental compilation enabled`)
   console.log(`   Press Ctrl+C to stop\n`)
 
+  // Set up incremental compilation infrastructure
+  const cacheDir = path.join(dir, '.redscript-cache')
+  const cache = new FileCache(cacheDir)
+  cache.load()
+  const depGraph = new DependencyGraph()
+
   // Debounce timer
   let debounceTimer: NodeJS.Timeout | null = null
 
-  // Compile all .mcrs files in directory
-  async function compileAll(): Promise<void> {
+  // Compile all .mcrs files in directory (incrementally)
+  async function compileAllIncremental(): Promise<void> {
     const files = findRsFiles(dir)
     if (files.length === 0) {
       console.log(`⚠  No .mcrs files found in ${dir}`)
       return
     }
 
-    let hasErrors = false
-    for (const file of files) {
-      let source = ''
-      try {
-        source = fs.readFileSync(file, 'utf-8')
-        const ns = namespace ?? deriveNamespace(file)
-        const result = compile(source, { namespace: ns, filePath: file, dce })
-        printWarnings(result.warnings)
-
-        // Create output directory
-        fs.mkdirSync(output, { recursive: true })
-
-        // Write all files
-        for (const dataFile of result.files) {
-          const filePath = path.join(output, dataFile.path)
-          const fileDir = path.dirname(filePath)
-          fs.mkdirSync(fileDir, { recursive: true })
-          fs.writeFileSync(filePath, dataFile.content)
-        }
-
-        const timestamp = new Date().toLocaleTimeString()
-        console.log(`✓ [${timestamp}] Compiled ${file} (${result.files.length} files)`)
-      } catch (err) {
-        hasErrors = true
-        const timestamp = new Date().toLocaleTimeString()
-        console.error(`✗ [${timestamp}] ${formatError(err as Error, source)}`)
+    const incResult = compileIncremental(files, cache, depGraph, {
+      namespace,
+      output,
+    })
+
+    const timestamp = new Date().toLocaleTimeString()
+
+    // Print warnings from recompiled files
+    for (const [file, compileResult] of incResult.results) {
+      for (const w of compileResult.warnings) {
+        console.error(`Warning: ${w}`)
       }
+      console.log(`✓ [${timestamp}] Compiled ${path.relative(dir, file)} (${compileResult.files.length} files)`)
+    }
+
+    if (incResult.cached > 0) {
+      console.log(`  [${timestamp}] ${incResult.cached} file(s) unchanged (cached)`)
     }
 
-    if (!hasErrors) {
-      if (hotReloadUrl) await hotReload(hotReloadUrl)
-      console.log('')
+    // Print errors
+    for (const [file, errMsg] of incResult.errors) {
+      console.error(`✗ [${timestamp}] ${path.relative(dir, file)}: ${errMsg}`)
     }
+
+    // Persist cache
+    cache.save()
+
+    if (incResult.errors.size === 0 && hotReloadUrl) await hotReload(hotReloadUrl)
+    console.log('')
   }
 
   // Find all .mcrs files recursively
@@ -451,7 +373,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
 
     for (const entry of entries) {
       const fullPath = path.join(directory, entry.name)
-      if (entry.isDirectory()) {
+      if (entry.isDirectory() && entry.name !== '.redscript-cache') {
         results.push(...findRsFiles(fullPath))
       } else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
         results.push(fullPath)
@@ -462,7 +384,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   }
 
   // Initial compile
-  void compileAll()
+  void compileAllIncremental()
 
   // Watch for changes
   fs.watch(dir, { recursive: true }, (eventType, filename) => {
@@ -473,7 +395,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       }
       debounceTimer = setTimeout(() => {
         console.log(`📝 Change detected: ${filename}`)
-        void compileAll()
+        void compileAllIncremental()
       }, 100)
     }
   })
@@ -504,20 +426,15 @@ async function main(): Promise<void> {
       }
       {
         const namespace = parsed.namespace ?? deriveNamespace(parsed.file)
-        const target = parsed.target ?? 'datapack'
-        const output = target === 'structure'
-          ? (parsed.outputNbt ?? parsed.output ?? `./${namespace}.nbt`)
-          : (parsed.output ?? './dist')
+        const output = parsed.output ?? './dist'
 
       compileCommand(
         parsed.file,
         output,
         namespace,
-        target,
-        parsed.stats,
-        parsed.dce,
-        parsed.mangle,
-        parsed.scoreboardObjective  // undefined = derive from namespace in compile()
+        parsed.sourceMap,
+        parsed.mcVersionStr,
+        parsed.lenient,
       )
       }
       break
@@ -533,7 +450,6 @@ async function main(): Promise<void> {
         parsed.output ?? './dist',
         parsed.namespace,
         parsed.hotReload,
-        parsed.dce
       )
       break
 
@@ -543,7 +459,7 @@ async function main(): Promise<void> {
         printUsage()
         process.exit(1)
       }
-      checkCommand(parsed.file)
+      checkCommand(parsed.file, parsed.namespace)
       break
 
     case 'fmt':

package/src/compile.ts

@@ -1,58 +1,25 @@
 /**
  * RedScript Compile API
  *
- * Main compile function with proper error handling and diagnostics.
+ * Preprocessing utilities and v2 compile re-export.
  */
 
 import * as fs from 'fs'
 import * as path from 'path'
 
-import { Lexer } from './lexer'
-import { Parser } from './parser'
-import { Lowering, setScoreboardObjective } from './lowering'
-import { optimize } from './optimizer/passes'
-import { eliminateDeadCode } from './optimizer/dce'
-import { generateDatapackWithStats, DatapackFile } from './codegen/mcfunction'
-import { DiagnosticError, formatError, parseErrorMessage } from './diagnostics'
-import type { IRModule } from './ir/types'
-import type { Program } from './ast/types'
+import { DiagnosticError } from './diagnostics'
 
 // ---------------------------------------------------------------------------
-// Compile Options
+// Re-export v2 compile
 // ---------------------------------------------------------------------------
 
-export interface CompileOptions {
-  namespace?: string
-  filePath?: string
-  optimize?: boolean
-  dce?: boolean
-  mangle?: boolean
-  /** Scoreboard objective used for all variable slots.
-   *  Defaults to '__<namespace>' (e.g. '__mathshow') — the double-underscore
-   *  prefix signals compiler-internal and avoids occupying the user's namespace.
-   *  Each datapack gets a unique objective automatically; no manual setup needed. */
-  scoreboardObjective?: string
-  /** Additional source files that should be treated as *library* code.
-   *  Functions in these files are DCE-eligible: they are only compiled into
-   *  the datapack when actually called from user code.  Each string is parsed
-   *  independently (as if it had `module library;` at the top), so library
-   *  mode never bleeds into the main `source`. */
-  librarySources?: string[]
-}
+export { compile, CompileOptions, CompileResult } from './emit/compile'
+export type { DatapackFile } from './emit/index'
 
 // ---------------------------------------------------------------------------
-// Compile Result
+// Source Range / Preprocessing
 // ---------------------------------------------------------------------------
 
-export interface CompileResult {
-  success: boolean
-  files?: DatapackFile[]
-  advancements?: DatapackFile[]
-  ast?: Program
-  ir?: IRModule
-  error?: DiagnosticError
-}
-
 export interface SourceRange {
   startLine: number
   endLine: number
@@ -215,126 +182,3 @@ export function preprocessSourceWithMetadata(source: string, options: Preprocess
 export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
   return preprocessSourceWithMetadata(source, options).source
 }
-
-// ---------------------------------------------------------------------------
-// Main Compile Function
-// ---------------------------------------------------------------------------
-
-export function compile(source: string, options: CompileOptions = {}): CompileResult {
-  const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options
-  const shouldRunDce = options.dce ?? shouldOptimize
-  let sourceLines = source.split('\n')
-
-  try {
-    const preprocessed = preprocessSourceWithMetadata(source, { filePath })
-    const preprocessedSource = preprocessed.source
-    sourceLines = preprocessedSource.split('\n')
-
-    // Lexing
-    const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-
-    // Parsing — user source
-    const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
-
-    // Collect all library sources: explicit `librarySources` option +
-    // auto-detected imports (files with `module library;` pulled out by the
-    // preprocessor rather than concatenated).
-    const allLibrarySources: Array<{ src: string; fp?: string }> = []
-    for (const libSrc of options.librarySources ?? []) {
-      allLibrarySources.push({ src: libSrc })
-    }
-    for (const li of preprocessed.libraryImports ?? []) {
-      allLibrarySources.push({ src: li.source, fp: li.filePath })
-    }
-
-    // Parse library sources independently (fresh Parser per source) so that
-    // `inLibraryMode` never bleeds into user code.  All resulting functions get
-    // isLibraryFn=true (either via `module library;` in the source, or forced below).
-    for (const { src, fp } of allLibrarySources) {
-      const libPreprocessed = preprocessSourceWithMetadata(src, fp ? { filePath: fp } : {})
-      const libTokens = new Lexer(libPreprocessed.source, fp).tokenize()
-      const libAst = new Parser(libTokens, libPreprocessed.source, fp).parse(namespace)
-      // Force all functions to library mode (even if source lacks `module library;`)
-      for (const fn of libAst.declarations) fn.isLibraryFn = true
-      // Merge into main AST
-      parsedAst.declarations.push(...libAst.declarations)
-      parsedAst.structs.push(...libAst.structs)
-      parsedAst.implBlocks.push(...libAst.implBlocks)
-      parsedAst.enums.push(...libAst.enums)
-      parsedAst.consts.push(...libAst.consts)
-      parsedAst.globals.push(...libAst.globals)
-    }
-    const dceResult = shouldRunDce ? eliminateDeadCode(parsedAst) : { program: parsedAst, warnings: [] }
-    const ast = dceResult.program
-
-    // Configure scoreboard objective for this compilation.
-    // Default: use the datapack namespace so each datapack gets its own objective
-    // automatically, preventing variable collisions when multiple datapacks coexist.
-    const scoreboardObj = options.scoreboardObjective ?? `__${namespace}`
-    setScoreboardObjective(scoreboardObj)
-
-    // Lowering
-    const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)
-
-    // Optimization
-    const optimized: IRModule = shouldOptimize
-      ? { ...ir, functions: ir.functions.map(fn => optimize(fn)) }
-      : ir
-
-    // Code generation — mangle=true by default to prevent cross-function
-    // scoreboard variable collisions in the global MC scoreboard namespace.
-    const generated = generateDatapackWithStats(optimized, {
-      mangle: options.mangle ?? true,
-      scoreboardObjective: scoreboardObj,
-    })
-
-    return {
-      success: true,
-      files: [...generated.files, ...generated.advancements],
-      advancements: generated.advancements,
-      ast,
-      ir: optimized,
-    }
-  } catch (err) {
-    // Already a DiagnosticError
-    if (err instanceof DiagnosticError) {
-      return { success: false, error: err }
-    }
-
-    // Try to parse the error message for line/col info
-    if (err instanceof Error) {
-      const diagnostic = parseErrorMessage(
-        'ParseError',
-        err.message,
-        sourceLines,
-        filePath
-      )
-      return { success: false, error: diagnostic }
-    }
-
-    // Unknown error
-    return {
-      success: false,
-      error: new DiagnosticError(
-        'ParseError',
-        String(err),
-        { file: filePath, line: 1, col: 1 },
-        sourceLines
-      )
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Format Compile Error
-// ---------------------------------------------------------------------------
-
-export function formatCompileError(result: CompileResult): string {
-  if (result.success) {
-    return 'Compilation successful'
-  }
-  if (result.error) {
-    return formatError(result.error, result.error.sourceLines?.join('\n'))
-  }
-  return 'Unknown error'
-}