fix(compiler): dynamic array indexing on function parameters

Two bugs fixed:

1. Array literal init with mixed const/non-const elements (mir/lower.ts):
   When an array literal like [10000, 0, -10000, 0] had any non-int_lit element,
   the fallback path initialised the whole array to zeros and then only patched
   non-literal (dynamic) slots.  Non-zero int_lit values at any position were
   silently left as 0.
   Fix: pre-populate the 'set value [...]' with actual int_lit values; skip only
   the purely-zero slots, and emit nbt_write only for the remaining dynamic elems.

2. Interprocedural const-prop did not substitute nbt_read_dynamic.indexSrc
   (optimizer/interprocedural.ts):
   The substituteInstr switch had no case for nbt_read_dynamic / nbt_write_dynamic,
   so when a callee was specialised with a constant index (e.g. dft_magnitude(re,im,1)),
   the index operand inside the specialised function stayed as the unset param temp
   (value 0) instead of the concrete constant (1).
   Fix: add cases for both nbt_read_dynamic and nbt_write_dynamic so indexSrc and
   valueSrc are properly substituted.

Together these fix DFT/FFT-style functions that pass int[] parameters and index
them with a runtime variable or a call-site constant argument.

Author: bkmashiro

src/__tests__/array-dynamic.test.ts

@@ -145,3 +145,45 @@ describe('Dynamic array index: multiple arrays, separate helpers', () => {
     expect(contents).toContain('b[$(arr_idx)]')
   })
 })
+
+describe('Array literal with mixed int/non-const elements initializes correctly', () => {
+  test('non-zero int_lit at index 0 is not zeroed out when array has dynamic elements', () => {
+    const src = `
+      fn test(): void {
+        let a: int[] = [10000, 0, -10000, 0];
+      }
+    `
+    const { files } = compile(src, { namespace: 'test' })
+    const body = getFunctionBody(files, 'test')
+    // The NBT init array should start with 10000, not 0
+    expect(body).toContain('set value [10000,')
+    // The dynamic element (-10000 = unary neg) should be patched
+    expect(body).toContain('a[2]')
+  })
+})
+
+describe('interprocedural const prop substitutes nbt_read_dynamic indexSrc', () => {
+  test('dft_magnitude with constant k reads re[k] and im[k] correctly', () => {
+    const { MCRuntime } = require('../runtime')
+    const MATH = require('fs').readFileSync('./src/stdlib/math.mcrs', 'utf8')
+    const FFT = require('fs').readFileSync('./src/stdlib/fft.mcrs', 'utf8')
+    const src = `
+      fn test_mag(): int {
+        let re: int[] = [0, 20000, 0, 0];
+        let im: int[] = [0, 0, 0, 0];
+        return dft_magnitude(re, im, 1);
+      }
+    `
+    const r = compile(src, { namespace: 'test', librarySources: [MATH, FFT] })
+    const rt = new MCRuntime('test')
+    for (const f of r.files) {
+      if (!f.path.endsWith('.mcfunction')) continue
+      const m = f.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction/)
+      if (!m) continue
+      rt.loadFunction(m[1] + ':' + m[2], f.content.split('\n'))
+    }
+    rt.execFunction('test:load')
+    rt.execFunction('test:test_mag')
+    expect(rt.getScore('$ret', '__test')).toBe(20000)
+  })
+})

src/mir/lower.ts

@@ -587,14 +587,15 @@ function lowerStmt(
           const vals = elems.map(e => (e as { kind: 'int_lit'; value: number }).value).join(', ')
           ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] })
         } else {
-          // Initialize with zeros, then overwrite dynamic elements
-          const zeros = elems.map(() => '0').join(', ')
-          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] })
+          // Initialize with known int_lit values (0 for dynamic slots), then overwrite dynamic elements.
+          // Using actual int_lit values avoids a bug where non-zero literals (e.g. 10000) would be
+          // left as 0 because the nbt_write for pure int_lits was skipped.
+          const initVals = elems.map(e => (e.kind === 'int_lit' ? String(e.value) : '0')).join(', ')
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${initVals}]`, args: [] })
           for (let i = 0; i < elems.length; i++) {
+            if (elems[i].kind === 'int_lit') continue  // already in the init array
             const elemOp = lowerExpr(elems[i], ctx, scope)
-            if (elemOp.kind !== 'const' || (elems[i].kind !== 'int_lit')) {
-              ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
-            }
+            ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
           }
         }
         // Store array length as a temp in scope (for .len access)
@@ -1338,6 +1339,36 @@ function lowerExpr(
         return { kind: 'temp', name: t }
       }
 
+      // Handle storage_set_array(storagePath, fieldName, nbtArrayLiteral)
+      // Writes a literal NBT int array to data storage (used in @load for tables).
+      // Emits: data modify storage <storagePath> <fieldName> set value <nbtArray>
+      if (expr.fn === 'storage_set_array' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const nbtLiteral = hirExprToStringLiteral(expr.args[2])
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${storagePath} ${fieldName} set value ${nbtLiteral}`, args: [] })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle storage_get_int(storagePath, fieldName, index) → int
+      // Reads one element from an NBT int-array stored in data storage.
+      // Const index: execute store result score $dst run data get storage <ns> <field>[N] 1
+      // Runtime index: nbt_read_dynamic via macro sub-function
+      if (expr.fn === 'storage_get_int' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const indexOp = lowerExpr(expr.args[2], ctx, scope)
+        const t = ctx.freshTemp()
+        if (indexOp.kind === 'const') {
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: storagePath, path: `${fieldName}[${indexOp.value}]`, scale: 1 })
+        } else {
+          ctx.emit({ kind: 'nbt_read_dynamic', dst: t, ns: storagePath, pathPrefix: fieldName, indexSrc: indexOp })
+        }
+        return { kind: 'temp', name: t }
+      }
+
       // Handle __entity_tag / __entity_untag — entity.tag("name") / entity.untag("name") sugar
       if (expr.fn === '__entity_tag' || expr.fn === '__entity_untag') {
         const selArg = expr.args[0]

src/optimizer/interprocedural.ts

@@ -134,6 +134,10 @@ function substituteInstr(instr: MIRInstr, sub: Map<Temp, Operand>): MIRInstr {
       return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) }
     case 'nbt_write':
       return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'nbt_read_dynamic':
+      return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub) }
+    case 'nbt_write_dynamic':
+      return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) }
     case 'call':
       return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) }
     case 'call_macro':