redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/stdlib-math.test.ts

@@ -1,374 +0,0 @@
-/**
- * stdlib/math.mcrs — Runtime behavioural tests
- *
- * Each test compiles the math stdlib together with a small driver function,
- * runs it through MCRuntime, and checks scoreboard values.
- */
-
-import * as fs from 'fs'
-import * as path from 'path'
-import { compile } from '../compile'
-import { MCRuntime } from '../runtime'
-
-const MATH_SRC = fs.readFileSync(
-  path.join(__dirname, '../../src/stdlib/math.mcrs'),
-  'utf-8'
-)
-
-function run(driver: string): MCRuntime {
-  // Use librarySources so math functions are only compiled when actually called
-  const result = compile(driver, { namespace: 'mathtest', librarySources: [MATH_SRC] })
-  if (!result.success) throw new Error(result.error?.message ?? 'compile failed')
-  const runtime = new MCRuntime('mathtest')
-  for (const file of result.files ?? []) {
-    if (!file.path.endsWith('.mcfunction')) continue
-    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
-    if (!match) continue
-    runtime.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'))
-  }
-  runtime.load()
-  return runtime
-}
-
-function scoreOf(rt: MCRuntime, key: string): number {
-  return rt.getScore('out', `mathtest.${key}`)
-}
-
-// ─── abs ─────────────────────────────────────────────────────────────────────
-
-describe('abs', () => {
-  it('abs of positive', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", abs(42)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(42)
-  })
-
-  it('abs of negative', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", abs(-7)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(7)
-  })
-
-  it('abs of zero', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", abs(0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-// ─── sign ────────────────────────────────────────────────────────────────────
-
-describe('sign', () => {
-  it.each([
-    [5, 1],
-    [-3, -1],
-    [0, 0],
-  ])('sign(%d) == %d', (x, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", sign(${x})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── min / max ───────────────────────────────────────────────────────────────
-
-describe('min', () => {
-  it.each([
-    [3, 7, 3],
-    [7, 3, 3],
-    [5, 5, 5],
-    [-2, 0, -2],
-  ])('min(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", min(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('max', () => {
-  it.each([
-    [3, 7, 7],
-    [7, 3, 7],
-    [5, 5, 5],
-    [-2, 0, 0],
-  ])('max(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", max(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── clamp ───────────────────────────────────────────────────────────────────
-
-describe('clamp', () => {
-  it.each([
-    [5, 0, 10, 5],   // in range
-    [-5, 0, 10, 0],  // below lo
-    [15, 0, 10, 10], // above hi
-    [0, 0, 10, 0],   // at lo
-    [10, 0, 10, 10], // at hi
-  ])('clamp(%d, %d, %d) == %d', (x, lo, hi, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", clamp(${x}, ${lo}, ${hi})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── lerp ────────────────────────────────────────────────────────────────────
-
-describe('lerp', () => {
-  it.each([
-    [0, 1000, 0, 0],      // t=0 → a
-    [0, 1000, 1000, 1000], // t=1000 → b
-    [0, 1000, 500, 500],   // t=0.5 → midpoint
-    [100, 200, 750, 175],  // 100 + (200-100)*0.75 = 175
-    [0, 100, 333, 33],     // integer division truncation
-  ])('lerp(%d, %d, %d) == %d', (a, b, t, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", lerp(${a}, ${b}, ${t})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── isqrt ───────────────────────────────────────────────────────────────────
-
-describe('isqrt', () => {
-  it.each([
-    [0, 0],
-    [1, 1],
-    [4, 2],
-    [9, 3],
-    [10, 3],  // floor
-    [16, 4],
-    [24, 4],  // floor
-    [25, 5],
-    [100, 10],
-    [1000000, 1000],
-  ])('isqrt(%d) == %d', (n, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", isqrt(${n})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── sqrt_fixed ──────────────────────────────────────────────────────────────
-
-describe('sqrt_fixed (scale=1000)', () => {
-  it.each([
-    [1000, 1000],  // sqrt(1.0) = 1.0
-    [4000, 2000],  // sqrt(4.0) = 2.0
-    [2000, 1414],  // sqrt(2.0) ≈ 1.414 (truncated)
-    [9000, 3000],  // sqrt(9.0) = 3.0
-  ])('sqrt_fixed(%d) ≈ %d', (x, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", sqrt_fixed(${x})); }`)
-    rt.execFunction('test')
-    // Allow ±1 from integer truncation
-    expect(Math.abs(scoreOf(rt, 'r') - expected)).toBeLessThanOrEqual(1)
-  })
-})
-
-// ─── pow_int ─────────────────────────────────────────────────────────────────
-
-describe('pow_int', () => {
-  it.each([
-    [2, 0, 1],
-    [2, 1, 2],
-    [2, 10, 1024],
-    [3, 3, 27],
-    [5, 4, 625],
-    [10, 5, 100000],
-    [7, 0, 1],
-    [1, 100, 1],
-  ])('pow_int(%d, %d) == %d', (base, exp, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", pow_int(${base}, ${exp})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── gcd ─────────────────────────────────────────────────────────────────────
-
-describe('gcd', () => {
-  it.each([
-    [12, 8, 4],
-    [7, 5, 1],
-    [100, 25, 25],
-    [0, 5, 5],
-    [5, 0, 5],
-    [12, 12, 12],
-    [-12, 8, 4],  // abs handled internally
-  ])('gcd(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", gcd(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── Phase 4: Number theory & utilities ──────────────────────────────────────
-
-describe('lcm', () => {
-  it.each([
-    [4, 6, 12],
-    [3, 5, 15],
-    [0, 5, 0],
-    [12, 12, 12],
-    [7, 1, 7],
-  ])('lcm(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", lcm(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('map', () => {
-  it.each([
-    [5,  0, 10,  0, 100, 50],
-    [0,  0, 10,  0, 100, 0],
-    [10, 0, 10,  0, 100, 100],
-    [1,  0, 10, 100, 200, 110],
-    [5,  0, 10, -100, 100, 0],
-  ])('map(%d, %d, %d, %d, %d) == %d', (x, il, ih, ol, oh, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", map(${x}, ${il}, ${ih}, ${ol}, ${oh})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('ceil_div', () => {
-  it.each([
-    [7, 3, 3],
-    [6, 3, 2],
-    [9, 3, 3],
-    [1, 5, 1],
-    [10, 10, 1],
-  ])('ceil_div(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", ceil_div(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('log2_int', () => {
-  it.each([
-    [1, 0],
-    [2, 1],
-    [4, 2],
-    [8, 3],
-    [7, 2],
-    [1024, 10],
-    [0, -1],
-  ])('log2_int(%d) == %d', (n, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", log2_int(${n})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// ─── Phase 3: Trigonometry ────────────────────────────────────────────────────
-// MCRuntime doesn't support real NBT storage macro functions (data get storage
-// path[$(i)]) — those require Minecraft 1.20.2+.
-// We test what we can: compile-only + sin table initialisation check,
-// and verify sin_fixed output for key angles where the MCRuntime
-// can simulate the scoreboard value after we manually stub the lookup.
-
-describe('sin table init', () => {
-  it('_math_init in __load when sin_fixed is called (via librarySources)', () => {
-    const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", sin_fixed(30)); }',
-      { namespace: 'mathtest', librarySources: [mathSrc] }
-    )
-    expect(result.success).toBe(true)
-    const hasSinTable = result.files?.some((f: any) =>
-      f.content?.includes('data modify storage math:tables sin set value')
-    )
-    expect(hasSinTable).toBe(true)
-  })
-
-  it('_math_init NOT in output when sin_fixed is not used (library DCE)', () => {
-    const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", abs(-5)); }',
-      { namespace: 'mathtest', librarySources: [mathSrc] }
-    )
-    expect(result.success).toBe(true)
-    const hasSinTable = result.files?.some((f: any) =>
-      f.content?.includes('data modify storage math:tables sin set value')
-    )
-    expect(hasSinTable).toBe(false)
-  })
-})
-
-describe('sin_fixed compile check', () => {
-  it('sin_fixed compiles without errors', () => {
-    const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", sin_fixed(30)); }',
-      { namespace: 'mathtest', librarySources: [mathSrc] }
-    )
-    expect(result.success).toBe(true)
-  })
-
-  it('cos_fixed compiles without errors', () => {
-    const mathSrc = require('fs').readFileSync(require('path').join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", cos_fixed(0)); }',
-      { namespace: 'mathtest', librarySources: [mathSrc] }
-    )
-    expect(result.success).toBe(true)
-  })
-})
-
-// ─── Phase 5: Vectors, directions & easing ───────────────────────────────────
-
-describe('mulfix / divfix', () => {
-  it.each([
-    [500, 707, 353],   // 0.5 × 0.707 ≈ 0.353
-    [1000, 1000, 1000],
-    [1000, 500, 500],
-    [0, 999, 0],
-  ])('mulfix(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", mulfix(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-
-  it.each([
-    [1, 3, 333],
-    [1, 2, 500],
-    [2, 1, 2000],
-    [0, 5, 0],
-  ])('divfix(%d, %d) == %d', (a, b, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", divfix(${a}, ${b})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-// dot2d, cross2d, length2d_fixed, manhattan, chebyshev, atan2_fixed
-// have moved to vec.mcrs — tested in stdlib-vec.test.ts
-
-describe('smoothstep', () => {
-  it.each([
-    [0,   0],
-    [100, 1000],
-    [50,  500],  // midpoint: 3×0.5²−2×0.5³ = 0.5 → 500
-  ])('smoothstep(0,100,%d) == %d', (x, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", smoothstep(0, 100, ${x})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-
-  it('smoothstep is monotonically increasing', () => {
-    let prev = -1
-    for (const x of [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) {
-      const rt = run(`fn test() { scoreboard_set("out", "r", smoothstep(0, 100, ${x})); }`)
-      rt.execFunction('test')
-      const v = scoreOf(rt, 'r')
-      expect(v).toBeGreaterThanOrEqual(prev)
-      prev = v
-    }
-  })
-})
-
-// atan2_fixed / _atan_init tests moved to stdlib-vec.test.ts

package/src/__tests__/stdlib-vec.test.ts

@@ -1,259 +0,0 @@
-/**
- * stdlib/vec.mcrs — runtime behavioural tests
- */
-
-import * as fs from 'fs'
-import * as path from 'path'
-import { compile } from '../compile'
-import { MCRuntime } from '../runtime'
-
-const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
-const VEC_SRC  = fs.readFileSync(path.join(__dirname, '../../src/stdlib/vec.mcrs'),  'utf-8')
-
-function run(driver: string): MCRuntime {
-  const result = compile(driver, {
-    namespace: 'vectest',
-    librarySources: [MATH_SRC, VEC_SRC],
-  })
-  if (!result.success) throw new Error(result.error?.message ?? 'compile failed')
-  const rt = new MCRuntime('vectest')
-  for (const file of result.files ?? []) {
-    if (!file.path.endsWith('.mcfunction')) continue
-    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
-    if (!match) continue
-    rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'))
-  }
-  rt.load()
-  return rt
-}
-
-function scoreOf(rt: MCRuntime, key: string): number {
-  return rt.getScore('out', `vectest.${key}`)
-}
-
-// ─── 2D basic ────────────────────────────────────────────────────────────────
-
-describe('dot2d', () => {
-  it('dot2d(3,4,3,4) == 25', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", dot2d(3,4,3,4)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(25)
-  })
-  it('perpendicular == 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", dot2d(1,0,0,1)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('cross2d', () => {
-  it('cross2d(1,0,0,1) == 1', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", cross2d(1,0,0,1)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(1)
-  })
-  it('cross2d parallel == 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", cross2d(3,0,6,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('length2d_fixed', () => {
-  it.each([
-    [3, 4, 5000],
-    [0, 5, 5000],
-    [5, 0, 5000],
-    [1, 1, 1414],
-  ])('length2d_fixed(%d,%d) == %d', (x, y, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", length2d_fixed(${x},${y})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('distance2d_fixed', () => {
-  it('distance2d_fixed(0,0,3,4) == 5000', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", distance2d_fixed(0,0,3,4)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(5000)
-  })
-  it('distance2d_fixed(p,p) == 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", distance2d_fixed(5,7,5,7)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('manhattan', () => {
-  it.each([
-    [0,0,3,4, 7],
-    [0,0,0,5, 5],
-    [1,1,1,1, 0],
-  ])('manhattan(%d,%d,%d,%d) == %d', (x1,y1,x2,y2,e) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", manhattan(${x1},${y1},${x2},${y2})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(e)
-  })
-})
-
-describe('chebyshev', () => {
-  it.each([
-    [0,0,3,4, 4],
-    [0,0,4,3, 4],
-    [0,0,5,5, 5],
-  ])('chebyshev(%d,%d,%d,%d) == %d', (x1,y1,x2,y2,e) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", chebyshev(${x1},${y1},${x2},${y2})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(e)
-  })
-})
-
-describe('normalize2d', () => {
-  it('normalize2d_x(3,4) == 600', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_x(3,4)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(600)
-  })
-  it('normalize2d_y(3,4) == 800', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_y(3,4)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(800)
-  })
-  it('zero vector → 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", normalize2d_x(0,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('lerp2d', () => {
-  it('lerp2d_x midpoint', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", lerp2d_x(0,0,100,200,500)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(50)
-  })
-  it('lerp2d_y midpoint', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", lerp2d_y(0,0,100,200,500)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(100)
-  })
-})
-
-// ─── 2D direction ────────────────────────────────────────────────────────────
-
-describe('atan2_fixed', () => {
-  it.each([
-    [0,  1,   0],
-    [1,  0,  90],
-    [0, -1, 180],
-    [-1, 0, 270],
-    [1,  1,  45],
-  ])('atan2_fixed(%d,%d) == %d', (y, x, expected) => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", atan2_fixed(${y},${x})); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(expected)
-  })
-})
-
-describe('rotate2d', () => {
-  it('rotate 90°: (1000,0) → x≈0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_x(1000,0,90)); }`)
-    rt.execFunction('test')
-    expect(Math.abs(scoreOf(rt, 'r'))).toBeLessThan(5)  // ≈0, allow rounding
-  })
-  it('rotate 90°: (1000,0) → y≈1000', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_y(1000,0,90)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(1000)
-  })
-  it('rotate 0°: no change', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", rotate2d_x(700,0,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(700)
-  })
-})
-
-// ─── 3D geometry ─────────────────────────────────────────────────────────────
-
-describe('dot3d', () => {
-  it('dot3d(1,0,0,1,0,0) == 1', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", dot3d(1,0,0,1,0,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(1)
-  })
-  it('perpendicular == 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", dot3d(1,0,0,0,1,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('cross3d', () => {
-  // (1,0,0) × (0,1,0) = (0,0,1)
-  it('cross3d_z(1,0,0,0,1,0) == 1', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", cross3d_z(1,0,0,0,1,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(1)
-  })
-  it('cross3d_x(1,0,0,0,1,0) == 0', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", cross3d_x(1,0,0,0,1,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(0)
-  })
-})
-
-describe('length3d_fixed', () => {
-  it('length3d_fixed(1,1,1) == 1732', () => {  // √3 × 1000 ≈ 1732
-    const rt = run(`fn test() { scoreboard_set("out", "r", length3d_fixed(1,1,1)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(1732)
-  })
-  it('length3d_fixed(3,4,0) == 5000', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", length3d_fixed(3,4,0)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(5000)
-  })
-})
-
-describe('manhattan3d / chebyshev3d', () => {
-  it('manhattan3d(0,0,0,1,2,3) == 6', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", manhattan3d(0,0,0,1,2,3)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(6)
-  })
-  it('chebyshev3d(0,0,0,3,1,2) == 3', () => {
-    const rt = run(`fn test() { scoreboard_set("out", "r", chebyshev3d(0,0,0,3,1,2)); }`)
-    rt.execFunction('test')
-    expect(scoreOf(rt, 'r')).toBe(3)
-  })
-})
-
-// ─── library DCE check ────────────────────────────────────────────────────────
-
-describe('library DCE: vec.mcrs', () => {
-  it('only dot2d compiled when only dot2d called', () => {
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", dot2d(1,0,0,1)); }',
-      { namespace: 'vectest', librarySources: [MATH_SRC, VEC_SRC] }
-    )
-    expect(result.success).toBe(true)
-    // atan2_fixed not called → no tan table in __load
-    const hasTanTable = result.files?.some((f: any) =>
-      f.content?.includes('data modify storage math:tables tan set value')
-    )
-    expect(hasTanTable).toBe(false)
-  })
-
-  it('_atan_init in __load when atan2_fixed is called', () => {
-    const result = require('../compile').compile(
-      'fn test() { scoreboard_set("out", "r", atan2_fixed(1,0)); }',
-      { namespace: 'vectest', librarySources: [MATH_SRC, VEC_SRC] }
-    )
-    expect(result.success).toBe(true)
-    const hasTanTable = result.files?.some((f: any) =>
-      f.content?.includes('data modify storage math:tables tan set value')
-    )
-    expect(hasTanTable).toBe(true)
-  })
-})

package/src/__tests__/structure-optimizer.test.ts

@@ -1,38 +0,0 @@
-import { compileToStructure } from '../codegen/structure'
-
-describe('structure target optimizer', () => {
-  test('inlines small then-branch into conditional chain', () => {
-    const source = `
-fn test() {
-  let x: int = 5;
-  if (x > 3) {
-    say("big");
-  }
-}
-`
-
-    const result = compileToStructure(source, 'test')
-
-    expect(result.blocks.some(block => block.command.includes('run function test:test/'))).toBe(false)
-    expect(result.blocks.some(block => block.command.includes('say big'))).toBe(true)
-  })
-
-  test('emits conditional chain blocks for an inlined if body', () => {
-    const source = `
-fn test(x: int) {
-  if (x > 3) {
-    say("big");
-    say("still big");
-  }
-}
-`
-
-    const result = compileToStructure(source, 'test')
-    const bodyBlocks = result.blocks.filter(block =>
-      block.command.includes('say big') || block.command.includes('say still big')
-    )
-
-    expect(bodyBlocks).toHaveLength(2)
-    expect(bodyBlocks.every(block => block.conditional)).toBe(true)
-  })
-})