redscript-mc 1.2.30 → 2.0.0

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.2.0",
+      "version": "1.2.2",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -23,7 +23,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "1.2.29",
+      "version": "1.2.30",
       "license": "MIT",
       "bin": {
         "redscript": "dist/cli.js",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  roots: ['<rootDir>/src'],
+  roots: ['<rootDir>/src', '<rootDir>/src2'],
 };

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.30",
+  "version": "2.0.0",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
-  "main": "dist/index.js",
+  "main": "dist/src/index.js",
   "bin": {
-    "redscript": "dist/cli.js",
-    "rsc": "dist/cli.js"
+    "redscript": "dist/src/cli.js",
+    "rsc": "dist/src/cli.js"
   },
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w",
     "test": "jest",
     "cli": "ts-node src/cli.ts",
-    "validate-mc": "jest src/__tests__/mc-syntax.test.ts --verbose"
+    "validate-mc": "jest src/__tests__/mc-syntax.test.ts --verbose",
+    "postbuild": "node scripts/postbuild.js"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

package/scripts/postbuild.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+
+const shims = [
+  ['dist/cli.js', './src/cli'],
+  ['dist/index.js', './src/index'],
+  ['dist/compile.js', './src/compile'],
+]
+
+for (const [outPath, target] of shims) {
+  fs.mkdirSync(path.dirname(outPath), { recursive: true })
+  fs.writeFileSync(outPath, `// shim — delegates to dist/src/\nmodule.exports = require('${target}');\n`)
+}
+console.log('postbuild: shims written')

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)
   })
 })

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