redscript-mc 1.0.0 → 1.1.0

package/src/__tests__/mc-integration.test.ts

@@ -65,12 +65,12 @@ beforeAll(async () => {
   }
 
   // ── Write fixtures + use safe reloadData (no /reload confirm) ───────
-  // counter.rs
-  if (fs.existsSync(path.join(__dirname, '../examples/counter.rs'))) {
-    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.rs'), 'utf-8'), 'counter')
+  // counter.mcrs
+  if (fs.existsSync(path.join(__dirname, '../examples/counter.mcrs'))) {
+    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.mcrs'), 'utf-8'), 'counter')
   }
-  if (fs.existsSync(path.join(__dirname, '../examples/world_manager.rs'))) {
-    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.rs'), 'utf-8'), 'world_manager')
+  if (fs.existsSync(path.join(__dirname, '../examples/world_manager.mcrs'))) {
+    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.mcrs'), 'utf-8'), 'world_manager')
   }
   writeFixture(`
     @tick
@@ -154,12 +154,118 @@ beforeAll(async () => {
     }
   `, 'fill_test')
 
+  // Scenario E: for-range loop — loop counter increments exactly N times
+  writeFixture(`
+    fn count_to_five() {
+      scoreboard_set("#range", "counter", 0);
+      for i in 0..5 {
+        let c: int = scoreboard_get("#range", "counter");
+        scoreboard_set("#range", "counter", c + 1);
+      }
+    }
+  `, 'range_test')
+
+  // Scenario F: function call with return value — verifies $ret propagation
+  writeFixture(`
+    fn triple(x: int) -> int {
+      return x * 3;
+    }
+    fn run_nested() {
+      let a: int = triple(4);
+      scoreboard_set("#nested", "result", a);
+    }
+  `, 'nested_test')
+
+  // Scenario G: match statement dispatches to correct branch
+  writeFixture(`
+    fn classify(x: int) {
+      match (x) {
+        1 => { scoreboard_set("#match", "out", 10); }
+        2 => { scoreboard_set("#match", "out", 20); }
+        3 => { scoreboard_set("#match", "out", 30); }
+        _ => { scoreboard_set("#match", "out", -1); }
+      }
+    }
+  `, 'match_test')
+
+  // Scenario H: while loop counts down
+  writeFixture(`
+    fn countdown() {
+      scoreboard_set("#wloop", "i", 10);
+      scoreboard_set("#wloop", "steps", 0);
+      let i: int = scoreboard_get("#wloop", "i");
+      while (i > 0) {
+        let s: int = scoreboard_get("#wloop", "steps");
+        scoreboard_set("#wloop", "steps", s + 1);
+        i = i - 1;
+        scoreboard_set("#wloop", "i", i);
+      }
+    }
+  `, 'while_test')
+
+  // Scenario I: multiple if/else branches (boundary test)
+  writeFixture(`
+    fn classify_score() {
+      let x: int = scoreboard_get("#boundary", "input");
+      if (x > 100) {
+        scoreboard_set("#boundary", "tier", 3);
+      } else {
+        if (x > 50) {
+          scoreboard_set("#boundary", "tier", 2);
+        } else {
+          if (x > 0) {
+            scoreboard_set("#boundary", "tier", 1);
+          } else {
+            scoreboard_set("#boundary", "tier", 0);
+          }
+        }
+      }
+    }
+  `, 'boundary_test')
+
+  // Scenario J: entity management — summon via raw commands
+  writeFixture(`
+    fn tag_entities() {
+      raw("summon minecraft:armor_stand 10 65 10");
+      raw("summon minecraft:armor_stand 11 65 10");
+      raw("summon minecraft:armor_stand 12 65 10");
+    }
+  `, 'tag_test')
+
+  // Scenario K: mixed arithmetic — order of operations
+  writeFixture(`
+    fn math_order() {
+      let a: int = 2;
+      let b: int = 3;
+      let c: int = 4;
+      scoreboard_set("#order", "r1", a + b * c);
+      scoreboard_set("#order", "r2", (a + b) * c);
+      let d: int = 100;
+      let e: int = d / 3;
+      scoreboard_set("#order", "r3", e);
+    }
+  `, 'order_test')
+
+  // Scenario L: scoreboard read-modify-write chain
+  writeFixture(`
+    fn chain_rmw() {
+      scoreboard_set("#rmw", "v", 1);
+      let v: int = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+      v = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+      v = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+    }
+  `, 'rmw_test')
+
   // ── Full reset + safe data reload ────────────────────────────────────
   await mc.fullReset()
 
   // Pre-create scoreboards
   for (const obj of ['ticks', 'seconds', 'test_score', 'result', 'calc', 'rs',
-                     'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val']) {
+                     'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val',
+                     'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v']) {
     await mc.command(`/scoreboard objectives add ${obj} dummy`).catch(() => {})
   }
   await mc.command('/scoreboard players set counter ticks 0')
@@ -192,7 +298,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 2: Counter tick ─────────────────────────────────────────────
-  test('counter.rs: tick function increments scoreboard over time', async () => {
+  test('counter.mcrs: tick function increments scoreboard over time', async () => {
     if (!serverOnline) return
     
     await mc.ticks(40) // Wait 2s (counter was already init'd in beforeAll)
@@ -202,7 +308,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 3: setblock ────────────────────────────────────────────────
-  test('world_manager.rs: setblock places correct block', async () => {
+  test('world_manager.mcrs: setblock places correct block', async () => {
     if (!serverOnline) return
     
     // Clear just the lobby area, keep other state
@@ -217,7 +323,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 4: fill ────────────────────────────────────────────────────
-  test('world_manager.rs: fill creates smooth_stone floor', async () => {
+  test('world_manager.mcrs: fill creates smooth_stone floor', async () => {
     if (!serverOnline) return
     // Runs after test 3, floor should still be there
     const block = await mc.block(4, 64, 4)
@@ -344,7 +450,7 @@ describe('E2E Scenario Tests', () => {
   })
 
   // Scenario B: No temp var collision between two functions called in sequence
-  // Verifies: each function's $t0/$t1 temp vars are isolated per-call, not globally shared
+  // Verifies: each function's temp vars are isolated per-call via globally unique names
   // If there's a bug, calc_product would see sum's leftover $t vars and produce wrong result
   test('B: calc_sum + calc_product called in sequence — no temp var collision', async () => {
     if (!serverOnline) return
@@ -406,4 +512,173 @@ describe('E2E Scenario Tests', () => {
     console.log(`  fill_test: blocks [0-3,70,0]=stone, [-1]/[4]=air ✓`)
   })
 
+  // Scenario E: for-range loop executes body exactly N times
+  // Verifies: for i in 0..5 increments counter 5 times
+  test('E: for-range loop increments counter exactly 5 times', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function range_test:__load')
+    await mc.command('/function range_test:count_to_five')
+    await mc.ticks(10)
+
+    const counter = await mc.scoreboard('#range', 'counter')
+    expect(counter).toBe(5)
+    console.log(`  for-range 0..5 → counter=${counter} (expect 5) ✓`)
+  })
+
+  // Scenario F: function return value propagation
+  // Verifies: $ret from callee is correctly captured in caller's variable
+  test('F: function return value — triple(4) = 12', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function nested_test:__load')
+    await mc.command('/function nested_test:run_nested')
+    await mc.ticks(10)
+
+    const result = await mc.scoreboard('#nested', 'result')
+    expect(result).toBe(12) // triple(4) = 4*3 = 12
+    console.log(`  triple(4) = ${result} (expect 12) ✓`)
+  })
+
+  // Scenario G: match dispatches to correct branch
+  // Verifies: match statement selects right arm for values 1, 2, 3, and default
+  test('G: match statement dispatches to correct branch', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function match_test:__load')
+
+    // Test match on value 2
+    await mc.command('/scoreboard players set $p0 rs 2')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    let out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(20)
+    console.log(`  match(2) → out=${out} (expect 20) ✓`)
+
+    // Test match on value 3
+    await mc.command('/scoreboard players set $p0 rs 3')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(30)
+    console.log(`  match(3) → out=${out} (expect 30) ✓`)
+
+    // Test default branch (value 99)
+    await mc.command('/scoreboard players set $p0 rs 99')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(-1)
+    console.log(`  match(99) → out=${out} (expect -1, default) ✓`)
+  })
+
+  // Scenario H: while loop counts down from 10 to 0
+  // Verifies: while loop body executes correct number of iterations
+  test('H: while loop counts down 10 steps', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function while_test:__load')
+    await mc.command('/function while_test:countdown')
+    await mc.ticks(10)
+
+    const i = await mc.scoreboard('#wloop', 'i')
+    const steps = await mc.scoreboard('#wloop', 'steps')
+    expect(i).toBe(0)
+    expect(steps).toBe(10)
+    console.log(`  while countdown: i=${i} (expect 0), steps=${steps} (expect 10) ✓`)
+  })
+
+  // Scenario I: nested if/else boundary classification
+  // Verifies: correct branch taken at boundaries (0, 50, 100)
+  test('I: nested if/else boundary classification', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function boundary_test:__load')
+
+    // Test x=0 → tier 0
+    await mc.command('/scoreboard players set #boundary input 0')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    let tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(0)
+    console.log(`  classify(0) → tier=${tier} (expect 0) ✓`)
+
+    // Test x=50 → tier 1 (> 0 but not > 50)
+    await mc.command('/scoreboard players set #boundary input 50')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(1)
+    console.log(`  classify(50) → tier=${tier} (expect 1) ✓`)
+
+    // Test x=51 → tier 2 (> 50 but not > 100)
+    await mc.command('/scoreboard players set #boundary input 51')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(2)
+    console.log(`  classify(51) → tier=${tier} (expect 2) ✓`)
+
+    // Test x=101 → tier 3
+    await mc.command('/scoreboard players set #boundary input 101')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(3)
+    console.log(`  classify(101) → tier=${tier} (expect 3) ✓`)
+  })
+
+  // Scenario J: entity summon and query
+  // Verifies: entities spawned via compiled function are queryable
+  test('J: summon entities via compiled function', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/kill @e[type=minecraft:armor_stand]')
+    await mc.ticks(2)
+    await mc.command('/function tag_test:__load')
+    await mc.command('/function tag_test:tag_entities')
+    await mc.ticks(5)
+
+    const stands = await mc.entities('@e[type=minecraft:armor_stand]')
+    expect(stands.length).toBe(3)
+    console.log(`  Summoned 3 armor_stands via tag_test, found: ${stands.length} ✓`)
+
+    await mc.command('/kill @e[type=minecraft:armor_stand]')
+  })
+
+  // Scenario K: arithmetic order of operations
+  // Verifies: MC scoreboard arithmetic matches expected evaluation order
+  test('K: arithmetic order of operations', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function order_test:__load')
+    await mc.command('/function order_test:math_order')
+    await mc.ticks(10)
+
+    const r1 = await mc.scoreboard('#order', 'r1')
+    const r2 = await mc.scoreboard('#order', 'r2')
+    const r3 = await mc.scoreboard('#order', 'r3')
+    // a + b * c = 2 + 3*4 = 14 (if precedence respected) or (2+3)*4 = 20 (left-to-right)
+    // MC scoreboard does left-to-right, so compiler may emit either depending on lowering
+    // (a + b) * c = 5 * 4 = 20 (explicit parens)
+    expect(r2).toBe(20) // This one is unambiguous
+    // 100 / 3 = 33 (integer division)
+    expect(r3).toBe(33)
+    console.log(`  r1=${r1}, r2=${r2} (expect 20), r3=${r3} (expect 33) ✓`)
+  })
+
+  // Scenario L: scoreboard read-modify-write chain (1 → 2 → 4 → 8)
+  // Verifies: sequential RMW operations don't lose intermediate state
+  test('L: scoreboard RMW chain — 1*2*2*2 = 8', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function rmw_test:__load')
+    await mc.command('/function rmw_test:chain_rmw')
+    await mc.ticks(10)
+
+    const v = await mc.scoreboard('#rmw', 'v')
+    expect(v).toBe(8)
+    console.log(`  RMW chain: 1→2→4→8, got ${v} (expect 8) ✓`)
+  })
+
 })

package/src/__tests__/mc-syntax.test.ts

@@ -33,14 +33,14 @@ describe('MC Command Syntax Validation', () => {
   const validator = new MCCommandValidator(FIXTURE_PATH)
 
   test('counter example generates valid MC commands', () => {
-    const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.rs'), 'utf-8')
+    const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8')
     const errors = validateSource(validator, src, 'counter')
     expect(errors).toHaveLength(0)
   })
 
   EXAMPLES.forEach(name => {
-    test(`${name}.rs generates valid MC commands`, () => {
-      const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.rs`), 'utf-8')
+    test(`${name}.mcrs generates valid MC commands`, () => {
+      const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8')
       const errors = validateSource(validator, src, name)
 
       if (errors.length > 0) {

package/src/__tests__/nbt.test.ts

@@ -40,8 +40,8 @@ describe('NBT codec', () => {
 })
 
 describe('Structure generator', () => {
-  test('compiles counter.rs to a non-empty structure', () => {
-    const filePath = 'src/examples/counter.rs'
+  test('compiles counter.mcrs to a non-empty structure', () => {
+    const filePath = 'src/examples/counter.mcrs'
     const src = fs.readFileSync(filePath, 'utf-8')
     const { buffer, blockCount } = compileToStructure(src, 'counter', filePath)
 

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

@@ -28,7 +28,7 @@ fn turret_tick() {
     const parent = getFileContent(result.files, 'data/test/function/turret_tick.mcfunction')
     const loopBody = getFileContent(result.files, 'data/test/function/turret_tick/foreach_0.mcfunction')
 
-    const hoistedRead = 'execute store result score $t0 rs run scoreboard players get config turret_range'
+    const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config turret_range'
     const executeCall = 'execute as @e[tag=turret] run function test:turret_tick/foreach_0'
 
     expect(parent).toContain(hoistedRead)
@@ -54,7 +54,7 @@ fn read_twice() {
     const readMatches = fn.match(/scoreboard players get @s coins/g) ?? []
 
     expect(readMatches).toHaveLength(1)
-    expect(fn).toContain('scoreboard players operation $t1 rs = $t0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
   })
 
   test('reuses duplicate arithmetic sequences', () => {
@@ -74,7 +74,7 @@ fn math() {
     const addMatches = fn.match(/\+= \$const_2 rs/g) ?? []
 
     expect(addMatches).toHaveLength(1)
-    expect(fn).toContain('scoreboard players operation $t1 rs = $t0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
   })
 })
 

package/src/__tests__/runtime.test.ts

@@ -29,7 +29,7 @@ function loadExample(name: string): string {
 
 describe('MCRuntime behavioral integration', () => {
   it('runs the counter example and increments the scoreboard across ticks', () => {
-    const runtime = loadCompiledProgram(loadExample('counter.rs'))
+    const runtime = loadCompiledProgram(loadExample('counter.mcrs'))
 
     runtime.load()
     runtime.ticks(5)

package/src/ast/types.ts

@@ -68,6 +68,13 @@ export interface SelectorFilter {
   sort?: 'nearest' | 'furthest' | 'random' | 'arbitrary'
   nbt?: string
   gamemode?: string
+  // Position filters
+  x?: RangeExpr
+  y?: RangeExpr
+  z?: RangeExpr
+  // Rotation filters
+  x_rotation?: RangeExpr
+  y_rotation?: RangeExpr
 }
 
 export interface EntitySelector {
@@ -146,8 +153,8 @@ export type LiteralExpr =
 export type ExecuteSubcommand =
   | { kind: 'as'; selector: EntitySelector }
   | { kind: 'at'; selector: EntitySelector }
-  | { kind: 'if_entity'; selector: EntitySelector }
-  | { kind: 'unless_entity'; selector: EntitySelector }
+  | { kind: 'if_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
+  | { kind: 'unless_entity'; selector?: EntitySelector; varName?: string; filters?: SelectorFilter }
   | { kind: 'in'; dimension: string }
 
 export type Stmt =
@@ -173,7 +180,7 @@ export type Block = Stmt[]
 // ---------------------------------------------------------------------------
 
 export interface Decorator {
-  name: 'tick' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team'
+  name: 'tick' | 'load' | 'on_trigger' | 'on_advancement' | 'on_craft' | 'on_death' | 'on_login' | 'on_join_team'
   args?: {
     rate?: number
     trigger?: string
@@ -235,12 +242,22 @@ export interface ConstDecl {
   span?: Span
 }
 
+export interface GlobalDecl {
+  kind: 'global'
+  name: string
+  type: TypeNode
+  init: Expr
+  mutable: boolean  // let = true, const = false
+  span?: Span
+}
+
 // ---------------------------------------------------------------------------
 // Program (Top-Level)
 // ---------------------------------------------------------------------------
 
 export interface Program {
   namespace: string    // Inferred from filename or `namespace mypack;`
+  globals: GlobalDecl[]
   declarations: FnDecl[]
   structs: StructDecl[]
   enums: EnumDecl[]

package/src/cli.ts

@@ -29,13 +29,13 @@ Usage:
   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
-  redscript fmt <file.rs> [file2.rs ...]
+  redscript fmt <file.mcrs> [file2.mcrs ...]
   redscript repl
   redscript version
 
 Commands:
   compile   Compile a RedScript file to a Minecraft datapack
-  watch     Watch a directory for .rs file changes, recompile, and hot reload
+  watch     Watch a directory for .mcrs file changes, recompile, and hot reload
   check     Check a RedScript file for errors without generating output
   fmt       Auto-format RedScript source files
   repl      Start an interactive RedScript REPL
@@ -268,7 +268,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
     process.exit(1)
   }
 
-  console.log(`👁  Watching ${dir} for .rs file changes...`)
+  console.log(`👁  Watching ${dir} for .mcrs file changes...`)
   console.log(`   Output: ${output}`)
   if (hotReloadUrl) console.log(`   Hot reload: ${hotReloadUrl}`)
   console.log(`   Press Ctrl+C to stop\n`)
@@ -276,11 +276,11 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
   // Debounce timer
   let debounceTimer: NodeJS.Timeout | null = null
 
-  // Compile all .rs files in directory
+  // Compile all .mcrs files in directory
   async function compileAll(): Promise<void> {
     const files = findRsFiles(dir)
     if (files.length === 0) {
-      console.log(`⚠  No .rs files found in ${dir}`)
+      console.log(`⚠  No .mcrs files found in ${dir}`)
       return
     }
 
@@ -319,7 +319,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
     }
   }
 
-  // Find all .rs files recursively
+  // Find all .mcrs files recursively
   function findRsFiles(directory: string): string[] {
     const results: string[] = []
     const entries = fs.readdirSync(directory, { withFileTypes: true })
@@ -328,7 +328,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
       const fullPath = path.join(directory, entry.name)
       if (entry.isDirectory()) {
         results.push(...findRsFiles(fullPath))
-      } else if (entry.isFile() && entry.name.endsWith('.rs')) {
+      } else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
         results.push(fullPath)
       }
     }
@@ -341,7 +341,7 @@ function watchCommand(dir: string, output: string, namespace?: string, hotReload
 
   // Watch for changes
   fs.watch(dir, { recursive: true }, (eventType, filename) => {
-    if (filename && filename.endsWith('.rs')) {
+    if (filename && filename.endsWith('.mcrs')) {
       // Debounce rapid changes
       if (debounceTimer) {
         clearTimeout(debounceTimer)
@@ -412,9 +412,9 @@ async function main(): Promise<void> {
 
     case 'fmt':
     case 'format': {
-      const files = args.filter(a => a.endsWith('.rs'))
+      const files = args.filter(a => a.endsWith('.mcrs'))
       if (files.length === 0) {
-        console.error('Usage: redscript fmt <file.rs> [file2.rs ...]')
+        console.error('Usage: redscript fmt <file.mcrs> [file2.mcrs ...]')
         process.exit(1)
       }
       const { format } = require('./formatter')

package/src/codegen/mcfunction/index.ts

@@ -11,7 +11,7 @@
  * Variable mapping:
  *   scoreboard objective: "rs"
  *   fake player:          "$<varname>"
- *   temporaries:          "$t0", "$t1", ...
+ *   temporaries:          "$_0", "$_1", ...
  *   return value:         "$ret"
  *   parameters:           "$p0", "$p1", ...
  */
@@ -293,7 +293,7 @@ export function generateDatapackWithStats(
     `scoreboard objectives add ${OBJ} dummy`,
   ]
   for (const g of module.globals) {
-    loadLines.push(`scoreboard players set ${varRef(g)} ${OBJ} 0`)
+    loadLines.push(`scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`)
   }
 
   // Add trigger objectives
@@ -356,6 +356,13 @@ export function generateDatapackWithStats(
     }
   }
 
+  // Call @load functions from __load
+  for (const fn of module.functions) {
+    if (fn.isLoadInit) {
+      loadLines.push(`function ${ns}:${fn.name}`)
+    }
+  }
+
   // Write __load.mcfunction
   files.push({
     path: `data/${ns}/function/__load.mcfunction`,

package/src/codegen/structure/index.ts

@@ -89,7 +89,7 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
   const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
   const loadCommands = [
     `scoreboard objectives add ${OBJ} dummy`,
-    ...module.globals.map(globalName => `scoreboard players set ${varRef(globalName)} ${OBJ} 0`),
+    ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
     ...Array.from(triggerNames).flatMap(triggerName => [
       `scoreboard objectives add ${triggerName} trigger`,
       `scoreboard players enable @a ${triggerName}`,
@@ -99,6 +99,13 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
     ).map(constSetup),
   ]
 
+  // Call @load functions from __load
+  for (const fn of module.functions) {
+    if (fn.isLoadInit) {
+      loadCommands.push(`function ${module.namespace}:${fn.name}`)
+    }
+  }
+
   const sections: Array<{ name: string; commands: IRCommand[]; repeat?: boolean }> = []
 
   if (loadCommands.length > 0) {