redscript-mc 1.2.29 → 2.0.0

package/src/__tests__/diagnostics.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { DiagnosticError, DiagnosticCollector, formatError, parseErrorMessage } from '../diagnostics'
-import { compile, formatCompileError } from '../compile'
+import { compile } from '../compile'
 
 describe('DiagnosticError', () => {
   describe('formatError', () => {
@@ -126,70 +126,91 @@ describe('parseErrorMessage', () => {
 
 describe('compile function', () => {
   it('returns success for valid code', () => {
-    const result = compile('fn main() { let x = 1; }')
+    const result = compile('fn main() { let x = 1; }', { namespace: 'test' })
     expect(result.success).toBe(true)
     expect(result.files).toBeDefined()
   })
 
-  it('returns DiagnosticError for lex errors', () => {
-    const result = compile('fn main() { let x = $ }')
-    expect(result.success).toBe(false)
-    expect(result.error).toBeInstanceOf(DiagnosticError)
-    expect(result.error?.kind).toBe('LexError')
+  it('throws DiagnosticError for lex errors', () => {
+    expect(() => compile('fn main() { let x = $ }', { namespace: 'test' }))
+      .toThrow()
+    try {
+      compile('fn main() { let x = $ }', { namespace: 'test' })
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      expect((e as DiagnosticError).kind).toBe('LexError')
+    }
   })
 
-  it('returns DiagnosticError for parse errors', () => {
-    const result = compile('fn main() { let x = }')
-    expect(result.success).toBe(false)
-    expect(result.error).toBeInstanceOf(DiagnosticError)
-    expect(result.error?.kind).toBe('ParseError')
+  it('throws DiagnosticError for parse errors', () => {
+    expect(() => compile('fn main() { let x = }', { namespace: 'test' }))
+      .toThrow()
+    try {
+      compile('fn main() { let x = }', { namespace: 'test' })
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      expect((e as DiagnosticError).kind).toBe('ParseError')
+    }
   })
 
-  it('returns DiagnosticError for missing semicolon', () => {
-    const result = compile('fn main() { let x = 42 }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('ParseError')
-    expect(result.error?.message).toContain("Expected ';'")
+  it('throws DiagnosticError for missing semicolon', () => {
+    try {
+      compile('fn main() { let x = 42 }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('ParseError')
+      expect((e as DiagnosticError).message).toContain("Expected ';'")
+    }
   })
 
   it('includes file path in error', () => {
-    const result = compile('fn main() { }', { filePath: 'test.mcrs' })
-    // This is valid, but test that filePath is passed through
+    const result = compile('fn main() { }', { filePath: 'test.mcrs', namespace: 'test' })
     expect(result.success).toBe(true)
   })
 
   it('formats error nicely', () => {
-    const result = compile('fn main() {\n  let x = 42\n}')
-    expect(result.success).toBe(false)
-    const formatted = formatCompileError(result)
-    expect(formatted).toContain('Error at line')
-    expect(formatted).toContain('^')
-    // Error points to } on line 3, which is where semicolon was expected
-    expect(formatted).toContain('}')
+    try {
+      compile('fn main() {\n  let x = 42\n}', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect(e).toBeInstanceOf(DiagnosticError)
+      const formatted = (e as DiagnosticError).format()
+      expect(formatted).toContain('line')
+      expect(formatted).toContain('^')
+    }
   })
 })
 
 describe('Lexer DiagnosticError', () => {
   it('throws DiagnosticError for unexpected character', () => {
-    const result = compile('fn main() { let x = $ }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('LexError')
-    expect(result.error?.message).toContain('Unexpected character')
+    try {
+      compile('fn main() { let x = $ }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('LexError')
+      expect((e as DiagnosticError).message).toContain('Unexpected character')
+    }
   })
 
   it('throws DiagnosticError for unterminated string', () => {
-    const result = compile('fn main() { let x = "hello }')
-    expect(result.success).toBe(false)
-    expect(result.error?.kind).toBe('LexError')
-    expect(result.error?.message).toContain('Unterminated string')
+    try {
+      compile('fn main() { let x = "hello }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).kind).toBe('LexError')
+      expect((e as DiagnosticError).message).toContain('Unterminated string')
+    }
   })
 })
 
 describe('Parser DiagnosticError', () => {
   it('includes line and column info', () => {
-    const result = compile('fn main() { return }')
-    expect(result.success).toBe(false)
-    expect(result.error?.location.line).toBeGreaterThan(0)
-    expect(result.error?.location.col).toBeGreaterThan(0)
+    try {
+      compile('fn main() { return }', { namespace: 'test' })
+      fail('Expected compile to throw')
+    } catch (e) {
+      expect((e as DiagnosticError).location.line).toBeGreaterThan(0)
+      expect((e as DiagnosticError).location.col).toBeGreaterThan(0)
+    }
   })
 })

package/src/__tests__/mc-integration.test.ts

@@ -36,9 +36,8 @@ function writeFixture(source: string, namespace: string): void {
   }
 
   const result = compile(source, { namespace })
-  if (result.error) throw new Error(`Compile error in ${namespace}: ${result.error}`)
 
-  for (const file of result.files ?? []) {
+  for (const file of result.files) {
     if (file.path === 'pack.mcmeta') continue
     const filePath = path.join(DATAPACK_DIR, file.path)
     fs.mkdirSync(path.dirname(filePath), { recursive: true })

package/src/ast/types.ts

@@ -5,7 +5,12 @@
  * The AST is produced by the parser and consumed by the lowering pass.
  */
 
-import type { BinOp, CmpOp } from '../ir/types'
+// ---------------------------------------------------------------------------
+// Binary / comparison operators (shared across AST, HIR, MIR)
+// ---------------------------------------------------------------------------
+
+export type BinOp = '+' | '-' | '*' | '/' | '%'
+export type CmpOp = '==' | '!=' | '<' | '<=' | '>' | '>='
 
 // ---------------------------------------------------------------------------
 // Source Span

package/src/cli.ts

@@ -1,21 +1,18 @@
 #!/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 { formatError } from './diagnostics'
 import { startRepl } from './repl'
 import { generateDts } from './builtins/metadata'
-import type { OptimizationStats } from './optimizer/commands'
 import * as fs from 'fs'
 import * as path from 'path'
 import * as https from 'https'
@@ -26,10 +23,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 +45,11 @@ 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)
   -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 +147,11 @@ 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
 } {
-  const result: ReturnType<typeof parseArgs> = { dce: true, mangle: true }
+  const result: ReturnType<typeof parseArgs> = {}
   let i = 0
 
   while (i < args.length) {
@@ -185,27 +163,9 @@ 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
-      i++
-    } else if (arg === '--no-dce') {
-      result.dce = false
-      i++
-    } else if (arg === '--no-mangle') {
-      result.mangle = false
-      i++
-    } else if (arg === '--scoreboard') {
-      result.scoreboardObjective = args[++i]
-      i++
     } else if (arg === '--hot-reload') {
       result.hotReload = args[++i]
       i++
@@ -229,48 +189,10 @@ 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
 ): void {
   // Read source file
   if (!fs.existsSync(file)) {
@@ -281,68 +203,26 @@ function compileCommand(
   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 })
 
-      // 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))
     process.exit(1)
@@ -380,7 +260,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}`)
@@ -415,8 +295,10 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       try {
         source = fs.readFileSync(file, 'utf-8')
         const ns = namespace ?? deriveNamespace(file)
-        const result = compile(source, { namespace: ns, filePath: file, dce })
-        printWarnings(result.warnings)
+        const result = compile(source, { namespace: ns, filePath: file })
+        for (const w of result.warnings) {
+          console.error(`Warning: ${w}`)
+        }
 
         // Create output directory
         fs.mkdirSync(output, { recursive: true })
@@ -504,20 +386,12 @@ 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()
       )
       }
       break
@@ -533,7 +407,6 @@ async function main(): Promise<void> {
         parsed.output ?? './dist',
         parsed.namespace,
         parsed.hotReload,
-        parsed.dce
       )
       break
 

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 '../src2/emit/compile'
+export type { DatapackFile } from '../src2/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'
-}