redscript-mc 1.2.30 → 2.1.0

package/src/__tests__/optimizer/lir/const_imm.test.ts

@@ -0,0 +1,151 @@
+import { constImmFold } from '../../../optimizer/lir/const_imm'
+import type { LIRFunction, LIRInstr, Slot } from '../../../lir/types'
+
+const obj = '__test'
+
+function mkSlot(player: string): Slot {
+  return { player, obj }
+}
+
+function mkFn(instructions: LIRInstr[]): LIRFunction {
+  return { name: 'test', instructions, isMacro: false, macroParams: [] }
+}
+
+describe('constant immediate folding', () => {
+  test('folds score_set + score_add into scoreboard players add', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players add $x __test 5',
+    })
+  })
+
+  test('folds score_set + score_sub into scoreboard players remove', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+      { kind: 'score_sub', dst: mkSlot('$y'), src: mkSlot('$__const_3') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players remove $y __test 3',
+    })
+  })
+
+  test('folds negative constant add into remove', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_-7'), value: -7 },
+      { kind: 'score_add', dst: mkSlot('$z'), src: mkSlot('$__const_-7') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players remove $z __test 7',
+    })
+  })
+
+  test('folds negative constant sub into add', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_-2'), value: -2 },
+      { kind: 'score_sub', dst: mkSlot('$w'), src: mkSlot('$__const_-2') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players add $w __test 2',
+    })
+  })
+
+  test('eliminates add 0 (no-op)', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_0'), value: 0 },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_0') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(0)
+  })
+
+  test('eliminates sub 0 (no-op)', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_0'), value: 0 },
+      { kind: 'score_sub', dst: mkSlot('$x'), src: mkSlot('$__const_0') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(0)
+  })
+
+  test('does not fold when const slot has multiple uses', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+      { kind: 'score_add', dst: mkSlot('$y'), src: mkSlot('$__const_5') },
+    ])
+    const result = constImmFold(fn)
+    // Should not fold because $__const_5 is used twice
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('does not fold non-const slots', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$temp'), value: 5 },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$temp') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('does not fold when instructions are not adjacent', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+      { kind: 'call', fn: 'test:foo' },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('does not fold score_mul (no single MC command)', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+      { kind: 'score_mul', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('folds multiple independent pairs', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+      { kind: 'score_add', dst: mkSlot('$a'), src: mkSlot('$__const_3') },
+      { kind: 'score_set', dst: mkSlot('$__const_7'), value: 7 },
+      { kind: 'score_sub', dst: mkSlot('$b'), src: mkSlot('$__const_7') },
+    ])
+    const result = constImmFold(fn)
+    expect(result.instructions).toHaveLength(2)
+    expect(result.instructions[0]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players add $a __test 3',
+    })
+    expect(result.instructions[1]).toEqual({
+      kind: 'raw',
+      cmd: 'scoreboard players remove $b __test 7',
+    })
+  })
+
+  test('returns same reference when nothing changed', () => {
+    const fn = mkFn([
+      { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+      { kind: 'return_value', slot: mkSlot('$x') },
+    ])
+    const result = constImmFold(fn)
+    expect(result).toBe(fn)
+  })
+})

package/src/__tests__/optimizer/lir/dead_slot.test.ts

@@ -0,0 +1,156 @@
+import { deadSlotElim, deadSlotElimModule } from '../../../optimizer/lir/dead_slot'
+import type { LIRFunction, LIRInstr, LIRModule, Slot } from '../../../lir/types'
+
+const obj = '__test'
+
+function mkSlot(player: string): Slot {
+  return { player, obj }
+}
+
+function mkFn(name: string, instructions: LIRInstr[]): LIRFunction {
+  return { name, instructions, isMacro: false, macroParams: [] }
+}
+
+function mkModule(functions: LIRFunction[]): LIRModule {
+  return { functions, namespace: 'test', objective: obj }
+}
+
+describe('dead slot elimination', () => {
+  test('removes score_set when dst is never read', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$dead'), value: 42 },
+      { kind: 'score_set', dst: mkSlot('$live'), value: 1 },
+      { kind: 'return_value', slot: mkSlot('$live') },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(2)
+    expect(result.instructions[0]).toEqual({ kind: 'score_set', dst: mkSlot('$live'), value: 1 })
+  })
+
+  test('removes score_copy when dst is never read', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$src'), value: 5 },
+      { kind: 'score_copy', dst: mkSlot('$dead'), src: mkSlot('$src') },
+      { kind: 'return_value', slot: mkSlot('$src') },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(2)
+    expect(result.instructions.some(i => i.kind === 'score_copy')).toBe(false)
+  })
+
+  test('keeps writes to $ret slot', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$ret'), value: 10 },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(1)
+  })
+
+  test('keeps writes to $ret_field slots', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$ret_x'), value: 10 },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(1)
+  })
+
+  test('keeps writes to $p0 parameter slots', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$p0'), value: 3 },
+      { kind: 'score_set', dst: mkSlot('$p1'), value: 7 },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('keeps non-pure-write instructions even if dst is unread', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$y') },
+      { kind: 'call', fn: 'test:foo' },
+      { kind: 'raw', cmd: 'say hello' },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('keeps score_set when dst is read by score_add', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$t'), value: 5 },
+      { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$t') },
+      { kind: 'return_value', slot: mkSlot('$x') },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('returns same reference when nothing removed', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+      { kind: 'return_value', slot: mkSlot('$x') },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result).toBe(fn)
+  })
+
+  test('handles call_if_matches slot reads', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$cond'), value: 1 },
+      { kind: 'call_if_matches', fn: 'test:branch', slot: mkSlot('$cond'), range: '1' },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('keeps score_set when slot is referenced in raw command', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$cond'), value: 0 },
+      { kind: 'raw', cmd: 'execute if score $a __test > $b __test run scoreboard players set $cond __test 1' },
+      { kind: 'call_if_matches', fn: 'test:branch', slot: mkSlot('$cond'), range: '1' },
+    ])
+    const result = deadSlotElim(fn)
+    // $cond is referenced in the raw command — must not be removed
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('handles call_if_score slot reads', () => {
+    const fn = mkFn('test', [
+      { kind: 'score_set', dst: mkSlot('$a'), value: 1 },
+      { kind: 'score_set', dst: mkSlot('$b'), value: 2 },
+      { kind: 'call_if_score', fn: 'test:cmp', a: mkSlot('$a'), op: 'lt', b: mkSlot('$b') },
+    ])
+    const result = deadSlotElim(fn)
+    expect(result.instructions).toHaveLength(3)
+  })
+})
+
+describe('dead slot elimination (module-level)', () => {
+  test('removes slot dead across all functions', () => {
+    const mod = mkModule([
+      mkFn('fn1', [
+        { kind: 'score_set', dst: mkSlot('$dead'), value: 99 },
+        { kind: 'score_set', dst: mkSlot('$live'), value: 1 },
+      ]),
+      mkFn('fn2', [
+        { kind: 'return_value', slot: mkSlot('$live') },
+      ]),
+    ])
+    const result = deadSlotElimModule(mod)
+    expect(result.functions[0].instructions).toHaveLength(1)
+    expect(result.functions[0].instructions[0]).toEqual({
+      kind: 'score_set', dst: mkSlot('$live'), value: 1,
+    })
+  })
+
+  test('keeps slot read in another function', () => {
+    const mod = mkModule([
+      mkFn('fn1', [
+        { kind: 'score_set', dst: mkSlot('$shared'), value: 5 },
+      ]),
+      mkFn('fn2', [
+        { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$shared') },
+      ]),
+    ])
+    const result = deadSlotElimModule(mod)
+    expect(result.functions[0].instructions).toHaveLength(1)
+  })
+})

package/src/__tests__/optimizer/lir/peephole.test.ts

@@ -0,0 +1,136 @@
+import { execStorePeephole } from '../../../optimizer/lir/peephole'
+import type { LIRFunction, LIRInstr, Slot } from '../../../lir/types'
+
+const obj = '__test'
+
+function mkSlot(player: string): Slot {
+  return { player, obj }
+}
+
+function mkFn(instructions: LIRInstr[]): LIRFunction {
+  return { name: 'test', instructions, isMacro: false, macroParams: [] }
+}
+
+describe('execute store peephole', () => {
+  test('merges call_context + score_set into store_cmd_to_score', () => {
+    const callCtx: LIRInstr = {
+      kind: 'call_context',
+      fn: 'ns:myfn',
+      subcommands: [{ kind: 'as', selector: '@s' }],
+    }
+    const fn = mkFn([
+      callCtx,
+      { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0]).toEqual({
+      kind: 'store_cmd_to_score',
+      dst: mkSlot('$result'),
+      cmd: callCtx,
+    })
+  })
+
+  test('merges call_context + score_set with zero value', () => {
+    const callCtx: LIRInstr = {
+      kind: 'call_context',
+      fn: 'ns:check',
+      subcommands: [{ kind: 'at_self' }],
+    }
+    const fn = mkFn([
+      callCtx,
+      { kind: 'score_set', dst: mkSlot('$flag'), value: 0 },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(1)
+    expect(result.instructions[0].kind).toBe('store_cmd_to_score')
+  })
+
+  test('does not merge when call_context and score_set are not adjacent', () => {
+    const fn = mkFn([
+      {
+        kind: 'call_context',
+        fn: 'ns:myfn',
+        subcommands: [{ kind: 'as', selector: '@s' }],
+      },
+      { kind: 'call', fn: 'ns:other' },
+      { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(3)
+  })
+
+  test('does not merge plain call + score_set', () => {
+    const fn = mkFn([
+      { kind: 'call', fn: 'ns:myfn' },
+      { kind: 'score_set', dst: mkSlot('$result'), value: 1 },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('does not merge call_context + score_copy', () => {
+    const fn = mkFn([
+      {
+        kind: 'call_context',
+        fn: 'ns:myfn',
+        subcommands: [{ kind: 'as', selector: '@s' }],
+      },
+      { kind: 'score_copy', dst: mkSlot('$result'), src: mkSlot('$src') },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(2)
+  })
+
+  test('merges multiple adjacent call_context + score_set pairs', () => {
+    const ctx1: LIRInstr = {
+      kind: 'call_context',
+      fn: 'ns:fn1',
+      subcommands: [{ kind: 'as', selector: '@s' }],
+    }
+    const ctx2: LIRInstr = {
+      kind: 'call_context',
+      fn: 'ns:fn2',
+      subcommands: [{ kind: 'at_self' }],
+    }
+    const fn = mkFn([
+      ctx1,
+      { kind: 'score_set', dst: mkSlot('$r1'), value: 1 },
+      ctx2,
+      { kind: 'score_set', dst: mkSlot('$r2'), value: 1 },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result.instructions).toHaveLength(2)
+    expect(result.instructions[0]).toEqual({
+      kind: 'store_cmd_to_score',
+      dst: mkSlot('$r1'),
+      cmd: ctx1,
+    })
+    expect(result.instructions[1]).toEqual({
+      kind: 'store_cmd_to_score',
+      dst: mkSlot('$r2'),
+      cmd: ctx2,
+    })
+  })
+
+  test('returns same reference when nothing changed', () => {
+    const fn = mkFn([
+      { kind: 'call', fn: 'ns:myfn' },
+      { kind: 'score_copy', dst: mkSlot('$a'), src: mkSlot('$b') },
+    ])
+    const result = execStorePeephole(fn)
+    expect(result).toBe(fn)
+  })
+
+  test('handles empty instruction list', () => {
+    const fn = mkFn([])
+    const result = execStorePeephole(fn)
+    expect(result).toBe(fn)
+  })
+
+  test('handles single instruction', () => {
+    const fn = mkFn([{ kind: 'score_set', dst: mkSlot('$x'), value: 5 }])
+    const result = execStorePeephole(fn)
+    expect(result).toBe(fn)
+  })
+})

package/src/__tests__/optimizer/lir/pipeline.test.ts

@@ -0,0 +1,113 @@
+import { lirOptimizeModule } from '../../../optimizer/lir/pipeline'
+import type { LIRFunction, LIRInstr, LIRModule, Slot } from '../../../lir/types'
+
+const obj = '__test'
+
+function mkSlot(player: string): Slot {
+  return { player, obj }
+}
+
+function mkFn(name: string, instructions: LIRInstr[]): LIRFunction {
+  return { name, instructions, isMacro: false, macroParams: [] }
+}
+
+function mkModule(functions: LIRFunction[]): LIRModule {
+  return { functions, namespace: 'test', objective: obj }
+}
+
+describe('LIR optimization pipeline', () => {
+  test('dead slot + const_imm combined: removes dead write and folds constant', () => {
+    const mod = mkModule([
+      mkFn('main', [
+        // Dead write — $dead is never read anywhere
+        { kind: 'score_set', dst: mkSlot('$dead'), value: 99 },
+        // Constant add pattern
+        { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+        { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+        { kind: 'return_value', slot: mkSlot('$x') },
+      ]),
+    ])
+
+    const result = lirOptimizeModule(mod)
+    const instrs = result.functions[0].instructions
+
+    // $dead should be removed by dead_slot
+    expect(instrs.some(i =>
+      i.kind === 'score_set' && i.dst.player === '$dead'
+    )).toBe(false)
+
+    // const+add should be folded by const_imm
+    expect(instrs.some(i =>
+      i.kind === 'raw' && i.cmd.includes('scoreboard players add $x')
+    )).toBe(true)
+  })
+
+  test('dead slot enables const_imm: removing extra use makes const single-use', () => {
+    // $__const_5 is used twice: once in score_add and once in a dead score_copy
+    // After dead_slot removes the dead copy, $__const_5 becomes single-use → foldable
+    const mod = mkModule([
+      mkFn('main', [
+        { kind: 'score_set', dst: mkSlot('$__const_5'), value: 5 },
+        { kind: 'score_copy', dst: mkSlot('$dead'), src: mkSlot('$__const_5') },
+        { kind: 'score_add', dst: mkSlot('$x'), src: mkSlot('$__const_5') },
+        { kind: 'return_value', slot: mkSlot('$x') },
+      ]),
+    ])
+
+    const result = lirOptimizeModule(mod)
+    const instrs = result.functions[0].instructions
+
+    // The dead copy should be gone and const_imm should fold
+    expect(instrs.some(i =>
+      i.kind === 'raw' && i.cmd.includes('scoreboard players add $x')
+    )).toBe(true)
+    expect(instrs.some(i =>
+      i.kind === 'score_copy' && i.dst.player === '$dead'
+    )).toBe(false)
+  })
+
+  test('preserves module when no optimizations apply', () => {
+    const mod = mkModule([
+      mkFn('main', [
+        { kind: 'score_set', dst: mkSlot('$x'), value: 1 },
+        { kind: 'return_value', slot: mkSlot('$x') },
+      ]),
+    ])
+
+    const result = lirOptimizeModule(mod)
+    expect(result.functions[0].instructions).toHaveLength(2)
+  })
+
+  test('works across multiple functions', () => {
+    const mod = mkModule([
+      mkFn('fn1', [
+        { kind: 'score_set', dst: mkSlot('$dead_in_fn1'), value: 0 },
+        { kind: 'score_set', dst: mkSlot('$__const_10'), value: 10 },
+        { kind: 'score_add', dst: mkSlot('$a'), src: mkSlot('$__const_10') },
+        { kind: 'return_value', slot: mkSlot('$a') },
+      ]),
+      mkFn('fn2', [
+        { kind: 'score_set', dst: mkSlot('$__const_3'), value: 3 },
+        { kind: 'score_sub', dst: mkSlot('$b'), src: mkSlot('$__const_3') },
+        { kind: 'return_value', slot: mkSlot('$b') },
+      ]),
+    ])
+
+    const result = lirOptimizeModule(mod)
+
+    // fn1: dead write removed, const folded
+    const fn1 = result.functions[0]
+    expect(fn1.instructions.some(i =>
+      i.kind === 'score_set' && i.dst.player === '$dead_in_fn1'
+    )).toBe(false)
+    expect(fn1.instructions.some(i =>
+      i.kind === 'raw' && i.cmd.includes('add $a')
+    )).toBe(true)
+
+    // fn2: const folded
+    const fn2 = result.functions[1]
+    expect(fn2.instructions.some(i =>
+      i.kind === 'raw' && i.cmd.includes('remove $b')
+    )).toBe(true)
+  })
+})

package/src/__tests__/optimizer/nbt-batch.test.ts

@@ -0,0 +1,119 @@
+import { nbtBatchRead } from '../../optimizer/nbt-batch'
+import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../../mir/types'
+
+function mkFn(blocks: MIRBlock[]): MIRFunction {
+  return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false }
+}
+
+function mkBlock(id: string, instrs: MIRInstr[], term: MIRInstr): MIRBlock {
+  return { id, instrs, term, preds: [] }
+}
+
+const t = (n: string): Operand => ({ kind: 'temp', name: n })
+
+describe('nbtBatchRead', () => {
+  test('deduplicates identical nbt_read in same block', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs[0].kind).toBe('nbt_read')
+    expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } })
+  })
+
+  test('does not deduplicate reads with different path', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'FoodLevel', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs[0].kind).toBe('nbt_read')
+    expect(instrs[1].kind).toBe('nbt_read')
+  })
+
+  test('does not deduplicate reads with different ns', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't1', ns: '@p', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs[0].kind).toBe('nbt_read')
+    expect(instrs[1].kind).toBe('nbt_read')
+  })
+
+  test('invalidates cache after nbt_write to same ns', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_write', ns: '@s', path: 'Health', type: 'int', scale: 1, src: { kind: 'const', value: 20 } },
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs[0].kind).toBe('nbt_read')
+    expect(instrs[1].kind).toBe('nbt_write')
+    expect(instrs[2].kind).toBe('nbt_read')
+  })
+
+  test('deduplicates third read that has no intervening write', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't2', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    const instrs = result.blocks[0].instrs
+    expect(instrs[0].kind).toBe('nbt_read')
+    expect(instrs[1]).toEqual({ kind: 'copy', dst: 't1', src: { kind: 'temp', name: 't0' } })
+    expect(instrs[2]).toEqual({ kind: 'copy', dst: 't2', src: { kind: 'temp', name: 't0' } })
+  })
+
+  test('does not deduplicate across blocks', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'jump', target: 'b1' }),
+      mkBlock('b1', [
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    expect(result.blocks[0].instrs[0].kind).toBe('nbt_read')
+    expect(result.blocks[1].instrs[0].kind).toBe('nbt_read')
+  })
+
+  test('does not deduplicate reads with different scale', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+        { kind: 'nbt_read', dst: 't1', ns: '@s', path: 'Health', scale: 2 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    expect(result.blocks[0].instrs[0].kind).toBe('nbt_read')
+    expect(result.blocks[0].instrs[1].kind).toBe('nbt_read')
+  })
+
+  test('no change when no duplicates', () => {
+    const fn = mkFn([
+      mkBlock('entry', [
+        { kind: 'nbt_read', dst: 't0', ns: '@s', path: 'Health', scale: 1 },
+      ], { kind: 'return', value: null }),
+    ])
+    const result = nbtBatchRead(fn)
+    expect(result.blocks[0].instrs[0].kind).toBe('nbt_read')
+  })
+})