redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/budget.test.ts

@@ -0,0 +1,297 @@
+import {
+  estimateCommandCount,
+  analyzeBudget,
+  BUDGET_WARN_THRESHOLD,
+  BUDGET_ERROR_THRESHOLD,
+} from '../lir/budget'
+import type { LIRModule, LIRFunction, LIRInstr, Slot } from '../lir/types'
+import { compile } from '../emit/compile'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const NS = 'test'
+const OBJ = '__test'
+
+function slot(name: string): Slot {
+  return { player: name, obj: OBJ }
+}
+
+function mkFn(name: string, instructions: LIRInstr[]): LIRFunction {
+  return { name, instructions, isMacro: false, macroParams: [] }
+}
+
+function mkModule(functions: LIRFunction[]): LIRModule {
+  return { functions, namespace: NS, objective: OBJ }
+}
+
+// ---------------------------------------------------------------------------
+// Unit tests: estimateCommandCount
+// ---------------------------------------------------------------------------
+
+describe('estimateCommandCount', () => {
+  test('flat function — counts each instruction as 1', () => {
+    const fn = mkFn('simple', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'score_set', dst: slot('$y'), value: 1 },
+      { kind: 'score_add', dst: slot('$x'), src: slot('$y') },
+    ])
+    const mod = mkModule([fn])
+    expect(estimateCommandCount('simple', mod)).toBe(3)
+  })
+
+  test('function calling another — sums callee cost', () => {
+    const callee = mkFn('helper', [
+      { kind: 'score_set', dst: slot('$a'), value: 42 },
+      { kind: 'score_set', dst: slot('$b'), value: 43 },
+    ])
+    const caller = mkFn('main', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'call', fn: `${NS}:helper` },
+    ])
+    const mod = mkModule([caller, callee])
+    // caller: 2 instrs + callee: 2 instrs = 4
+    expect(estimateCommandCount('main', mod)).toBe(4)
+  })
+
+  test('self-recursive function (loop) — multiplies by estimated iterations', () => {
+    // Simulate a loop: header checks condition, calls body, body calls header
+    const header = mkFn('loop__header', [
+      { kind: 'call_if_matches', fn: `${NS}:loop__body`, slot: slot('$i'), range: '..99' },
+    ])
+    const body = mkFn('loop__body', [
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'score_set', dst: slot('$tmp'), value: 1 },
+      { kind: 'call', fn: `${NS}:loop__header` },
+    ])
+    const mod = mkModule([header, body])
+    // Cycle: header(1) + body(3) = 4 cmds/iteration
+    // Range ..99 → 100 iterations
+    // Total: 4 × 100 = 400
+    expect(estimateCommandCount('loop__header', mod)).toBe(400)
+  })
+
+  test('unknown loop bound defaults to 100 iterations', () => {
+    const header = mkFn('loop__header', [
+      { kind: 'call_if_score', fn: `${NS}:loop__body`, a: slot('$i'), op: 'lt', b: slot('$limit') },
+    ])
+    const body = mkFn('loop__body', [
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:loop__header` },
+    ])
+    const mod = mkModule([header, body])
+    // Cycle: 1 + 2 = 3 cmds/iteration, 100 default iterations = 300
+    expect(estimateCommandCount('loop__header', mod)).toBe(300)
+  })
+
+  test('nested loops — outer × inner', () => {
+    // Inner loop: inner_header ↔ inner_body (5 cmds/iter, 10 iters)
+    const innerHeader = mkFn('inner__header', [
+      { kind: 'call_if_matches', fn: `${NS}:inner__body`, slot: slot('$j'), range: '..9' },
+    ])
+    const innerBody = mkFn('inner__body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$j'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:inner__header` },
+    ])
+
+    // Outer loop: outer_header ↔ outer_body (calls inner loop + own work)
+    const outerHeader = mkFn('outer__header', [
+      { kind: 'call_if_matches', fn: `${NS}:outer__body`, slot: slot('$i'), range: '..19' },
+    ])
+    const outerBody = mkFn('outer__body', [
+      { kind: 'score_set', dst: slot('$j'), value: 0 },
+      { kind: 'call', fn: `${NS}:inner__header` },
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:outer__header` },
+    ])
+
+    const mod = mkModule([innerHeader, innerBody, outerHeader, outerBody])
+
+    // Inner cycle: header(1) + body(4) = 5 cmds × 10 iters = 50
+    // Outer cycle local: header(1) + body(4) = 5 cmds
+    // Outer cycle external callee: inner = 50
+    // Outer total: (5 + 50) × 20 = 1100
+    expect(estimateCommandCount('outer__header', mod)).toBe(1100)
+  })
+
+  test('external call (not in module) contributes 0', () => {
+    const fn = mkFn('main', [
+      { kind: 'score_set', dst: slot('$x'), value: 0 },
+      { kind: 'call', fn: 'other_ns:external_fn' },
+    ])
+    const mod = mkModule([fn])
+    expect(estimateCommandCount('main', mod)).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Unit tests: analyzeBudget
+// ---------------------------------------------------------------------------
+
+describe('analyzeBudget', () => {
+  test('small loop (100 iters × 5 cmds = 500) → no diagnostic', () => {
+    const header = mkFn('process', [
+      { kind: 'call_if_matches', fn: `${NS}:process__body`, slot: slot('$i'), range: '..99' },
+    ])
+    const body = mkFn('process__body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+      { kind: 'call', fn: `${NS}:process` },
+    ])
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toEqual([])
+  })
+
+  test('medium loop (1000 iters × 50 cmds = 50000) → warning', () => {
+    // Build a body with 48 instructions + 1 call back + header 1 = 50 per iter
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 48; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:bigloop` })
+
+    const header = mkFn('bigloop', [
+      { kind: 'call_if_matches', fn: `${NS}:bigloop__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('bigloop__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toHaveLength(1)
+    expect(diags[0].level).toBe('warning')
+    expect(diags[0].fnName).toBe('bigloop')
+    expect(diags[0].estimatedCommands).toBe(50000)
+    expect(diags[0].message).toContain('consider @coroutine')
+  })
+
+  test('large loop (1000 iters × 100 cmds = 100000) → error', () => {
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:hugeloop` })
+
+    const header = mkFn('hugeloop', [
+      { kind: 'call_if_matches', fn: `${NS}:hugeloop__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('hugeloop__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toHaveLength(1)
+    expect(diags[0].level).toBe('error')
+    expect(diags[0].fnName).toBe('hugeloop')
+    expect(diags[0].estimatedCommands).toBe(100000)
+  })
+
+  test('@coroutine function is skipped', () => {
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:bigfn` })
+
+    const header = mkFn('bigfn', [
+      { kind: 'call_if_matches', fn: `${NS}:bigfn__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('bigfn__body', bodyInstrs)
+    const mod = mkModule([header, body])
+
+    const diags = analyzeBudget(mod, new Set(['bigfn']))
+    expect(diags).toEqual([])
+  })
+
+  test('compiler-generated __helper functions are skipped', () => {
+    // Only top-level user functions are analyzed; __body etc are internal
+    const bodyInstrs: LIRInstr[] = []
+    for (let i = 0; i < 98; i++) {
+      bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i })
+    }
+    bodyInstrs.push({ kind: 'call', fn: `${NS}:fn__header` })
+
+    // Only fn__header and fn__body exist — both have __ so both skipped
+    const header = mkFn('fn__header', [
+      { kind: 'call_if_matches', fn: `${NS}:fn__body`, slot: slot('$i'), range: '..999' },
+    ])
+    const body = mkFn('fn__body', bodyInstrs)
+    const mod = mkModule([header, body])
+    const diags = analyzeBudget(mod)
+    expect(diags).toEqual([])
+  })
+
+  test('nested loop estimation is correct', () => {
+    // Inner: 5 cmds × 10 iters = 50
+    const innerHeader = mkFn('run__inner_header', [
+      { kind: 'call_if_matches', fn: `${NS}:run__inner_body`, slot: slot('$j'), range: '..9' },
+    ])
+    const innerBody = mkFn('run__inner_body', [
+      { kind: 'score_set', dst: slot('$a'), value: 1 },
+      { kind: 'score_set', dst: slot('$b'), value: 2 },
+      { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+      { kind: 'call', fn: `${NS}:run__inner_header` },
+    ])
+
+    // Outer: (5 + inner=50) × 20 = 1100
+    const outerHeader = mkFn('run__outer_header', [
+      { kind: 'call_if_matches', fn: `${NS}:run__outer_body`, slot: slot('$i'), range: '..19' },
+    ])
+    const outerBody = mkFn('run__outer_body', [
+      { kind: 'score_set', dst: slot('$j'), value: 0 },
+      { kind: 'call', fn: `${NS}:run__inner_header` },
+      { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+      { kind: 'call', fn: `${NS}:run__outer_header` },
+    ])
+
+    // The "root" user function that sets up the outer loop
+    const run = mkFn('run', [
+      { kind: 'score_set', dst: slot('$i'), value: 0 },
+      { kind: 'call', fn: `${NS}:run__outer_header` },
+    ])
+
+    const mod = mkModule([run, innerHeader, innerBody, outerHeader, outerBody])
+    const estimate = estimateCommandCount('run', mod)
+    // run: 2 local + outer(1100) = 1102
+    expect(estimate).toBe(1102)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// E2E: compile pipeline integration
+// ---------------------------------------------------------------------------
+
+describe('budget analysis — compile pipeline integration', () => {
+  test('small loop produces no warning', () => {
+    const source = `
+      fn process(): void {
+        let i: int = 0;
+        while (i < 10) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `
+    const result = compile(source, { namespace: 'budgettest' })
+    expect(result.warnings).toEqual([])
+  })
+
+  test('@coroutine function skips budget check', () => {
+    const source = `
+      @coroutine(batch=5)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 10000) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `
+    // Should not throw even with huge loop — @coroutine exempts it
+    const result = compile(source, { namespace: 'budgettest' })
+    // No budget error/warning for coroutine functions
+    const budgetWarnings = result.warnings.filter(w => w.includes('tick budget'))
+    expect(budgetWarnings).toEqual([])
+  })
+})

package/src/__tests__/cli.test.ts

@@ -20,8 +20,9 @@ describe('CLI API', () => {
       const result = compile(source, { namespace: 'imports', filePath: mainPath })
 
       expect(result.files.length).toBeGreaterThan(0)
-      expect(result.ir.functions.some(fn => fn.name === 'double')).toBe(true)
-      expect(result.ir.functions.some(fn => fn.name === 'main')).toBe(true)
+      // Verify both functions are compiled by checking output files
+      expect(result.files.some(f => f.path.includes('/double.mcfunction'))).toBe(true)
+      expect(result.files.some(f => f.path.includes('/main.mcfunction'))).toBe(true)
     })
 
     it('deduplicates circular imports', () => {
@@ -37,174 +38,9 @@ describe('CLI API', () => {
       const source = fs.readFileSync(mainPath, 'utf-8')
       const result = compile(source, { namespace: 'circular', filePath: mainPath })
 
-      expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1)
-      expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1)
-    })
-
-    it('uses rs-prefixed scoreboard objectives for imported stdlib files', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-'))
-      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
-      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
-      const mainPath = path.join(tempDir, 'main.mcrs')
-
-      fs.mkdirSync(stdlibDir, { recursive: true })
-      fs.writeFileSync(stdlibPath, 'fn tick_timer() { scoreboard_set("#rs", "timer_ticks", 1); }\n')
-      fs.writeFileSync(mainPath, 'import "./src/stdlib/timer.mcrs"\n\nfn main() { tick_timer(); }\n')
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
-      const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'))
-
-      expect(tickTimer?.content).toContain('scoreboard players set #rs __mygame.timer_ticks 1')
-    })
-
-    it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-hash-'))
-      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
-      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
-      const mainPath = path.join(tempDir, 'main.mcrs')
-
-      fs.mkdirSync(stdlibDir, { recursive: true })
-      fs.writeFileSync(stdlibPath, [
-        'fn timer_start(name: string, duration: int) {',
-        '  scoreboard_set("timer_ticks", #rs, duration);',
-        '  scoreboard_set("timer_active", #rs, 1);',
-        '}',
-        '',
-      ].join('\n'))
-      fs.writeFileSync(mainPath, [
-        'import "./src/stdlib/timer.mcrs"',
-        '',
-        'fn main() {',
-        '  timer_start("x", 100);',
-        '  timer_start("x", 100);',
-        '}',
-        '',
-      ].join('\n'))
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
-      const timerFns = result.files.filter(file => /timer_start__callsite_[0-9a-f]{4}\.mcfunction$/.test(file.path))
-
-      expect(timerFns).toHaveLength(2)
-
-      const objectives = timerFns
-        .flatMap(file => [...file.content.matchAll(/mygame\._timer_([0-9a-f]{4})/g)].map(match => match[0]))
-
-      expect(new Set(objectives).size).toBe(2)
-    })
-
-    it('Timer::new creates timer', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-new-'))
-      const mainPath = path.join(tempDir, 'main.mcrs')
-      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
-
-      fs.writeFileSync(mainPath, [
-        `import "${timerPath}"`,
-        '',
-        'fn main() {',
-        '  let timer: Timer = Timer::new(20);',
-        '}',
-        '',
-      ].join('\n'))
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'timernew', filePath: mainPath })
-
-      expect(result.typeErrors).toEqual([])
-      const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'))
-      expect(newFn?.content).toContain('scoreboard players set timer_ticks __timernew 0')
-      expect(newFn?.content).toContain('scoreboard players set timer_active __timernew 0')
-    })
-
-    it('Timer.start/pause/reset', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-state-'))
-      const mainPath = path.join(tempDir, 'main.mcrs')
-      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
-
-      fs.writeFileSync(mainPath, [
-        `import "${timerPath}"`,
-        '',
-        'fn main() {',
-        '  let timer: Timer = Timer::new(20);',
-        '  timer.start();',
-        '  timer.pause();',
-        '  timer.reset();',
-        '}',
-        '',
-      ].join('\n'))
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'timerstate', filePath: mainPath })
-
-      expect(result.typeErrors).toEqual([])
-      const startFn = result.files.find(file => file.path.endsWith('/Timer_start.mcfunction'))
-      const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'))
-      const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'))
-
-      expect(startFn?.content).toContain('scoreboard players set timer_active __timerstate 1')
-      expect(pauseFn?.content).toContain('scoreboard players set timer_active __timerstate 0')
-      expect(resetFn?.content).toContain('scoreboard players set timer_ticks __timerstate 0')
-    })
-
-    it('Timer.done returns bool', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-done-'))
-      const mainPath = path.join(tempDir, 'main.mcrs')
-      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
-
-      fs.writeFileSync(mainPath, [
-        `import "${timerPath}"`,
-        '',
-        'fn main() {',
-        '  let timer: Timer = Timer::new(20);',
-        '  let finished: bool = timer.done();',
-        '  if (finished) {',
-        '    say("done");',
-        '  }',
-        '}',
-        '',
-      ].join('\n'))
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'timerdone', filePath: mainPath })
-
-      expect(result.typeErrors).toEqual([])
-      const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'))
-      const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'))
-      expect(doneFn?.content).toContain('scoreboard players get timer_ticks __timerdone')
-      expect(doneFn?.content).toContain('return run scoreboard players get')
-      expect(mainFn?.content).toContain('execute if score $main_finished __timerdone matches 1..')
-    })
-
-    it('Timer.tick increments', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'))
-      const mainPath = path.join(tempDir, 'main.mcrs')
-      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
-
-      fs.writeFileSync(mainPath, [
-        `import "${timerPath}"`,
-        '',
-        'fn main() {',
-        '  let timer: Timer = Timer::new(20);',
-        '  timer.start();',
-        '  timer.tick();',
-        '}',
-        '',
-      ].join('\n'))
-
-      const source = fs.readFileSync(mainPath, 'utf-8')
-      const result = compile(source, { namespace: 'timertick', filePath: mainPath })
-
-      expect(result.typeErrors).toEqual([])
-      const tickOutput = result.files
-        .filter(file => file.path.includes('/Timer_tick'))
-        .map(file => file.content)
-        .join('\n')
-
-      expect(tickOutput).toContain('scoreboard players get timer_active __timertick')
-      expect(tickOutput).toContain('scoreboard players get timer_ticks __timertick')
-      expect(tickOutput).toContain(' += $const_1 __timertick')
-      expect(tickOutput).toContain('execute store result score timer_ticks __timertick run scoreboard players get $_')
+      // Verify each function appears exactly once in output
+      expect(result.files.filter(f => f.path.endsWith('/from_a.mcfunction'))).toHaveLength(1)
+      expect(result.files.filter(f => f.path.endsWith('/from_b.mcfunction'))).toHaveLength(1)
     })
   })
 
@@ -213,65 +49,17 @@ describe('CLI API', () => {
       const source = 'fn test() { say("hello"); }'
       const result = compile(source, { namespace: 'mypack' })
       expect(result.files.length).toBeGreaterThan(0)
-      expect(result.ast.namespace).toBe('mypack')
-      expect(result.ir.functions.length).toBe(1)
-    })
-
-    it('uses default namespace', () => {
-      const source = 'fn test() {}'
-      const result = compile(source)
-      expect(result.ast.namespace).toBe('redscript')
     })
 
     it('generates correct file structure', () => {
       const source = 'fn test() { say("hello"); }'
       const result = compile(source, { namespace: 'game' })
-      
+
       const paths = result.files.map(f => f.path)
       expect(paths).toContain('pack.mcmeta')
-      expect(paths).toContain('data/game/function/__load.mcfunction')
+      expect(paths).toContain('data/game/function/load.mcfunction')
       expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true)
     })
-
-    it('collects optimizer stats', () => {
-      const source = `
-fn build() {
-  foreach (turret in @e[tag=turret]) {
-    let range: int = scoreboard_get("config", "turret_range");
-    if (range > 0) {
-      if (range > -1) {
-        say("ready");
-      }
-    }
-  }
-}
-`
-
-      const result = compile(source, { namespace: 'stats' })
-      expect(result.stats?.licmHoists).toBeGreaterThan(0)
-      expect(result.stats?.totalCommandsBefore).toBeGreaterThan(result.stats?.totalCommandsAfter ?? 0)
-      expect(result.stats?.deadCodeRemoved).toBeGreaterThanOrEqual(0)
-    })
-  })
-
-  describe('--stats flag', () => {
-    it('prints optimizer statistics', () => {
-      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'))
-      const inputPath = path.join(tempDir, 'input.mcrs')
-      const outputDir = path.join(tempDir, 'out')
-
-      fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }')
-
-      const stdout = execFileSync(
-        process.execPath,
-        ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'],
-        { cwd: process.cwd(), encoding: 'utf-8' }
-      )
-
-      expect(stdout).toContain('Optimizations applied:')
-      expect(stdout).toContain('setblock batching:')
-      expect(stdout).toContain('Total mcfunction commands:')
-    })
   })
 
   describe('check()', () => {

package/src/__tests__/dce.test.ts

@@ -14,7 +14,7 @@ function getFileContent(files: ReturnType<typeof compile>['files'], suffix: stri
 }
 
 describe('AST dead code elimination', () => {
-  it('removes private unused functions (prefixed with _)', () => {
+  it('keeps non-library functions even if unused (v2 DCE only strips library fns)', () => {
     const source = `
 fn _unused() { say("never called"); }
 fn used() { say("called"); }
@@ -23,41 +23,9 @@ fn used() { say("called"); }
 
     const result = compile(source, { namespace: 'test' })
 
-    // _unused is removed because it starts with _ (private) and is not called
-    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main'])
-    expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false)
-  })
-
-  it('removes unused local variables from the AST body', () => {
-    const source = `
-fn helper() {
-  let unused: int = 10;
-  let used: int = 20;
-  say_int(used);
-}
-@tick fn main() { helper(); }
-`
-
-    const result = compile(source, { namespace: 'test' })
-    const helper = result.ast.declarations.find(fn => fn.name === 'helper')
-
-    expect(helper?.body.filter(stmt => stmt.kind === 'let')).toHaveLength(1)
-    expect(helper?.body.some(stmt => stmt.kind === 'let' && stmt.name === 'unused')).toBe(false)
-  })
-
-  it('removes unused constants', () => {
-    const source = `
-const UNUSED: int = 10;
-const USED: int = 20;
-
-@tick fn main() {
-  say_int(USED);
-}
-`
-
-    const result = compile(source, { namespace: 'test' })
-
-    expect(result.ast.consts.map(constDecl => constDecl.name)).toEqual(['USED'])
+    // v2 keeps all non-library functions; DCE only applies to `module library;` imports
+    expect(result.files.some(f => f.path.includes('/_unused.mcfunction'))).toBe(true)
+    expect(result.files.some(f => f.path.includes('/used.mcfunction'))).toBe(true)
   })
 
   it('eliminates dead branches with constant conditions', () => {
@@ -82,27 +50,13 @@ const USED: int = 20;
     const source = `
 @tick fn ticker() { }
 @load fn loader() { }
-@on(PlayerDeath) fn handler(player: Player) { say("event"); }
 `
 
     const result = compile(source, { namespace: 'test' })
-    const names = result.ast.declarations.map(fn => fn.name)
-
-    expect(names).toContain('ticker')
-    expect(names).toContain('loader')
-    expect(names).toContain('handler')
-  })
-
-  it('can disable AST DCE through the compile API', () => {
-    const source = `
-fn unused() { say("never called"); }
-@tick fn main() { say("live"); }
-`
-
-    const result = compile(source, { namespace: 'test', dce: false })
+    const paths = result.files.map(f => f.path)
 
-    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['unused', 'main'])
-    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(true)
+    expect(paths.some(p => p.includes('/ticker.mcfunction'))).toBe(true)
+    expect(paths.some(p => p.includes('/loader.mcfunction'))).toBe(true)
   })
 })
 
@@ -120,11 +74,12 @@ describe('CLI --no-dce', () => {
 
     execFileSync(
       process.execPath,
-      ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test', '--no-dce'],
+      ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test'],
       { cwd: path.resolve(process.cwd()) }
     )
 
-    const unusedPath = path.join(outputDir, 'data', 'test', 'function', 'unused.mcfunction')
-    expect(fs.existsSync(unusedPath)).toBe(true)
+    // v2 pipeline compiles all functions
+    const mainPath = path.join(outputDir, 'data', 'test', 'function', 'main.mcfunction')
+    expect(fs.existsSync(mainPath)).toBe(true)
   })
 })