redscript-mc 1.2.11 → 1.2.12

package/dist/__tests__/dce.test.js

@@ -46,15 +46,16 @@ function getFileContent(files, suffix) {
     return file.content;
 }
 describe('AST dead code elimination', () => {
-    it('removes unused functions reachable from entry points', () => {
+    it('removes private unused functions (prefixed with _)', () => {
         const source = `
-fn unused() { say("never called"); }
+fn _unused() { say("never called"); }
 fn used() { say("called"); }
 @tick fn main() { used(); }
 `;
         const result = (0, index_1.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);
+        expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false);
     });
     it('removes unused local variables from the AST body', () => {
         const source = `

package/dist/__tests__/e2e.test.js

@@ -171,8 +171,8 @@ fn main() {
             const foreachFn = getSubFunction(files, 'main', 'foreach_0');
             const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'));
             expect(mainFn).toContain('execute as @e run function test:main/foreach_0');
-            expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_');
-            expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:player] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:zombie] run function test:main/then_');
             expect(thenFiles).toHaveLength(2);
         });
     });

package/dist/__tests__/lowering.test.js

@@ -251,7 +251,7 @@ fn scan() {
 `);
             const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'));
             const rawCmds = getRawCommands(foreachFn);
-            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'));
+            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=minecraft:player] run function test:scan/then_'));
             expect(isCheckCmd).toBeDefined();
             const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'));
             expect(getRawCommands(thenFn)).toContain('kill @s');
@@ -315,8 +315,8 @@ fn test() {
             const [playerThenFn, zombieThenFn] = thenFns;
             expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0');
             expect(thenFns).toHaveLength(2);
-            expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`);
-            expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=minecraft:player] run function test:${playerThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=minecraft:zombie] run function test:${zombieThenFn.name}`);
             expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true);
             expect(getRawCommands(zombieThenFn)).toContain('kill @s');
         });

package/dist/__tests__/mc-integration.test.js

@@ -694,28 +694,28 @@ describe('MC Integration - New Features', () => {
         expect(count).toBeGreaterThanOrEqual(3);
         expect(count).toBeLessThanOrEqual(3);
     });
-    test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+    test('is-check-test.mcrs: foreach is-narrowing correctly matches entity types', async () => {
         if (!serverOnline)
             return;
         await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
-        await mc.command('/scoreboard players set #is_check players 0');
-        await mc.command('/scoreboard players set #is_check zombies 0');
+        await mc.command('/forceload add 0 0').catch(() => { }); // Ensure chunk is loaded
+        await mc.command('/scoreboard objectives add armor_stands dummy').catch(() => { });
+        await mc.command('/scoreboard objectives add items dummy').catch(() => { });
+        await mc.command('/scoreboard players set #is_check armor_stands 0');
+        await mc.command('/scoreboard players set #is_check items 0');
         await mc.command('/function is_check_test:__load').catch(() => { });
-        await mc.command('/summon minecraft:zombie 0 65 0');
-        await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target');
-        await mc.command('/summon minecraft:armor_stand 2 65 0');
-        await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target');
+        // Spawn 2 armor_stands and 1 item (all persist without players)
+        await mc.command('/summon minecraft:armor_stand 0 65 0 {Tags:["is_check_target"],NoGravity:1b}');
+        await mc.command('/summon minecraft:armor_stand 2 65 0 {Tags:["is_check_target"],NoGravity:1b}');
+        await mc.command('/summon minecraft:item 4 65 0 {Tags:["is_check_target"],Item:{id:"minecraft:stone",count:1},Age:-32768}');
+        await mc.ticks(5);
         await mc.command('/function is_check_test:check_types');
         await mc.ticks(5);
-        const zombies = await mc.scoreboard('#is_check', 'zombies');
-        const players = await mc.scoreboard('#is_check', 'players');
-        const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]');
-        const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]');
-        expect(zombies).toBe(1);
-        expect(players).toBe(0);
-        expect(zombieEntities).toHaveLength(0);
-        expect(standEntities).toHaveLength(1);
-        await mc.command('/kill @e[tag=is_check_target]').catch(() => { });
+        const armorStands = await mc.scoreboard('#is_check', 'armor_stands');
+        const items = await mc.scoreboard('#is_check', 'items');
+        expect(armorStands).toBe(2); // 2 armor_stands matched
+        expect(items).toBe(1); // 1 item matched
+        await mc.command('/function is_check_test:cleanup').catch(() => { });
     });
     test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {
         if (!serverOnline)

package/dist/lowering/index.d.ts

@@ -38,6 +38,7 @@ export declare class Lowering {
     private currentContext;
     private blockPosVars;
     private structDefs;
+    private structDecls;
     private enumDefs;
     private functionDefaults;
     private constValues;

package/dist/lowering/index.js

@@ -126,20 +126,20 @@ function getSpan(node) {
 const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/;
 const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/;
 const ENTITY_TO_MC_TYPE = {
-    Player: 'player',
-    Zombie: 'zombie',
-    Skeleton: 'skeleton',
-    Creeper: 'creeper',
-    Spider: 'spider',
-    Enderman: 'enderman',
-    Pig: 'pig',
-    Cow: 'cow',
-    Sheep: 'sheep',
-    Chicken: 'chicken',
-    Villager: 'villager',
-    ArmorStand: 'armor_stand',
-    Item: 'item',
-    Arrow: 'arrow',
+    Player: 'minecraft:player',
+    Zombie: 'minecraft:zombie',
+    Skeleton: 'minecraft:skeleton',
+    Creeper: 'minecraft:creeper',
+    Spider: 'minecraft:spider',
+    Enderman: 'minecraft:enderman',
+    Pig: 'minecraft:pig',
+    Cow: 'minecraft:cow',
+    Sheep: 'minecraft:sheep',
+    Chicken: 'minecraft:chicken',
+    Villager: 'minecraft:villager',
+    ArmorStand: 'minecraft:armor_stand',
+    Item: 'minecraft:item',
+    Arrow: 'minecraft:arrow',
 };
 function normalizeSelector(selector, warnings) {
     return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
@@ -199,6 +199,8 @@ class Lowering {
         this.blockPosVars = new Map();
         // Struct definitions: name → { fieldName: TypeNode }
         this.structDefs = new Map();
+        // Full struct declarations for field iteration
+        this.structDecls = new Map();
         this.enumDefs = new Map();
         this.functionDefaults = new Map();
         this.constValues = new Map();
@@ -224,6 +226,7 @@ class Lowering {
                 fields.set(field.name, field.type);
             }
             this.structDefs.set(struct.name, fields);
+            this.structDecls.set(struct.name, struct);
         }
         for (const enumDecl of program.enums ?? []) {
             const variants = new Map();
@@ -551,6 +554,22 @@ class Lowering {
             }
             return;
         }
+        // Handle struct initialization from function call (copy from __ret_struct)
+        if ((stmt.init.kind === 'call' || stmt.init.kind === 'static_call') && stmt.type?.kind === 'struct') {
+            // First, execute the function call
+            this.lowerExpr(stmt.init);
+            // Then copy all fields from __ret_struct to the variable's storage
+            const structDecl = this.structDecls.get(stmt.type.name);
+            if (structDecl) {
+                const structName = stmt.type.name.toLowerCase();
+                for (const field of structDecl.fields) {
+                    const srcPath = `rs:heap __ret_struct.${field.name}`;
+                    const dstPath = `rs:heap ${structName}_${stmt.name}.${field.name}`;
+                    this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                }
+            }
+            return;
+        }
         // Handle array literal initialization
         if (stmt.init.kind === 'array_lit') {
             // Initialize empty NBT array
@@ -600,6 +619,21 @@ class Lowering {
     }
     lowerReturnStmt(stmt) {
         if (stmt.value) {
+            // Handle struct literal return: store fields to __ret_struct storage
+            if (stmt.value.kind === 'struct_lit') {
+                for (const field of stmt.value.fields) {
+                    const path = `rs:heap __ret_struct.${field.name}`;
+                    const fieldValue = this.lowerExpr(field.value);
+                    if (fieldValue.kind === 'const') {
+                        this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`);
+                    }
+                    else if (fieldValue.kind === 'var') {
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`);
+                    }
+                }
+                this.builder.emitReturn({ kind: 'const', value: 0 });
+                return;
+            }
             const value = this.lowerExpr(stmt.value);
             this.builder.emitReturn(value);
         }
@@ -1506,6 +1540,22 @@ class Lowering {
         }
         const implMethod = this.resolveInstanceMethod(expr);
         if (implMethod) {
+            // Copy struct fields from instance to 'self' storage before calling
+            const receiver = expr.args[0];
+            if (receiver?.kind === 'ident') {
+                const receiverType = this.inferExprType(receiver);
+                if (receiverType?.kind === 'struct') {
+                    const structDecl = this.structDecls.get(receiverType.name);
+                    const structName = receiverType.name.toLowerCase();
+                    if (structDecl) {
+                        for (const field of structDecl.fields) {
+                            const srcPath = `rs:heap ${structName}_${receiver.name}.${field.name}`;
+                            const dstPath = `rs:heap ${structName}_self.${field.name}`;
+                            this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                        }
+                    }
+                }
+            }
             return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args);
         }
         // Regular function call

package/dist/optimizer/dce.js

@@ -115,9 +115,12 @@ class DeadCodeEliminator {
     findEntryPoints(program) {
         const entries = new Set();
         for (const fn of program.declarations) {
-            if (fn.name === 'main') {
+            // All top-level functions are entry points (callable via /function)
+            // Exception: functions starting with _ are considered private/internal
+            if (!fn.name.startsWith('_')) {
                 entries.add(fn.name);
             }
+            // Decorated functions are always entry points (even if prefixed with _)
             if (fn.decorators.some(decorator => [
                 'tick',
                 'load',
@@ -128,7 +131,7 @@ class DeadCodeEliminator {
                 'on_death',
                 'on_login',
                 'on_join_team',
-                'keep', // Prevent DCE from removing this function
+                'keep',
             ].includes(decorator.name))) {
                 entries.add(fn.name);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/dce.test.ts

@@ -14,17 +14,18 @@ function getFileContent(files: ReturnType<typeof compile>['files'], suffix: stri
 }
 
 describe('AST dead code elimination', () => {
-  it('removes unused functions reachable from entry points', () => {
+  it('removes private unused functions (prefixed with _)', () => {
     const source = `
-fn unused() { say("never called"); }
+fn _unused() { say("never called"); }
 fn used() { say("called"); }
 @tick fn main() { used(); }
 `
 
     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)
+    expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false)
   })
 
   it('removes unused local variables from the AST body', () => {

package/src/__tests__/e2e.test.ts

@@ -196,8 +196,8 @@ fn main() {
       const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'))
 
       expect(mainFn).toContain('execute as @e run function test:main/foreach_0')
-      expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_')
-      expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_')
+      expect(foreachFn).toContain('execute if entity @s[type=minecraft:player] run function test:main/then_')
+      expect(foreachFn).toContain('execute if entity @s[type=minecraft:zombie] run function test:main/then_')
       expect(thenFiles).toHaveLength(2)
     })
   })

package/src/__tests__/fixtures/array-test.mcrs

@@ -1,6 +1,6 @@
 // Array operations test
 
-@keep fn test_array() {
+@tick fn test_array() {
     // Array initialization
     let nums: int[] = [10, 20, 30, 40, 50];
     

package/src/__tests__/fixtures/break-continue-test.mcrs

@@ -1,6 +1,6 @@
 // Break and continue statements test
 
-@keep fn test_break_continue() {
+fn test_break_continue() {
     // Test break - should stop at i=5
     let break_at: int = -1;
     for (let i: int = 0; i < 10; i = i + 1) {

package/src/__tests__/fixtures/enum-test.mcrs

@@ -14,7 +14,7 @@ enum Rank {
     Diamond = 10
 }
 
-@keep fn test_enum() {
+fn test_enum() {
     // Basic enum value (use . not ::)
     let phase: int = GamePhase.Playing;
     scoreboard_set("#enum_phase", #rs, phase);

package/src/__tests__/fixtures/foreach-at-test.mcrs

@@ -6,7 +6,7 @@
     scoreboard_set("#foreach_at_count", #rs, 0);
 }
 
-@keep fn test_foreach_at() {
+fn test_foreach_at() {
     // Spawn test entities
     raw("summon minecraft:armor_stand ~ ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
     raw("summon minecraft:armor_stand ~2 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");

package/src/__tests__/fixtures/is-check-test.mcrs

@@ -1,20 +1,27 @@
+@load fn setup() {
+    scoreboard_add("armor_stands");
+    scoreboard_add("items");
+}
+
+// Test is-check type narrowing using armor_stands (don't despawn without players)
 fn check_types() {
-    scoreboard_set("#is_check", #players, 0);
-    scoreboard_set("#is_check", #zombies, 0);
+    scoreboard_set("#is_check", #armor_stands, 0);
+    scoreboard_set("#is_check", #items, 0);
 
-    foreach (e in @e[type=zombie,tag=is_check_target]) {
-        if (e is Player) {
-            let players: int = scoreboard_get("#is_check", #players);
-            scoreboard_set("#is_check", #players, players + 1);
+    // Test foreach with is-check on armor_stands
+    foreach (e in @e[tag=is_check_target]) {
+        if (e is ArmorStand) {
+            let count: int = scoreboard_get("#is_check", #armor_stands);
+            scoreboard_set("#is_check", #armor_stands, count + 1);
         }
 
-        if (e is Zombie) {
-            let players: int = scoreboard_get("#is_check", #players);
-            scoreboard_set("#is_check", #players, players);
+        if (e is Item) {
+            let count: int = scoreboard_get("#is_check", #items);
+            scoreboard_set("#is_check", #items, count + 1);
         }
-
-        let zombies: int = scoreboard_get("#is_check", #zombies);
-        scoreboard_set("#is_check", #zombies, zombies + 1);
-        kill(e);
     }
 }
+
+fn cleanup() {
+    raw("kill @e[tag=is_check_target]");
+}

package/src/__tests__/fixtures/match-range-test.mcrs

@@ -1,6 +1,6 @@
 // Match with range patterns test
 
-@keep fn test_match_range() {
+fn test_match_range() {
     // Test score grading
     let score: int = 85;
     let grade: int = 0;

package/src/__tests__/fixtures/struct-test.mcrs

@@ -11,7 +11,7 @@ struct Player {
     alive: bool
 }
 
-@keep fn test_struct() {
+fn test_struct() {
     // Create struct instance
     let p: Point = { x: 10, y: 64, z: -5 };
     

package/src/__tests__/lowering.test.ts

@@ -285,7 +285,7 @@ fn scan() {
 `)
       const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'))!
       const rawCmds = getRawCommands(foreachFn)
-      const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'))
+      const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=minecraft:player] run function test:scan/then_'))
       expect(isCheckCmd).toBeDefined()
 
       const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'))!
@@ -360,8 +360,8 @@ fn test() {
 
       expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0')
       expect(thenFns).toHaveLength(2)
-      expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`)
-      expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`)
+      expect(rawCmds).toContain(`execute if entity @s[type=minecraft:player] run function test:${playerThenFn.name}`)
+      expect(rawCmds).toContain(`execute if entity @s[type=minecraft:zombie] run function test:${zombieThenFn.name}`)
       expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true)
       expect(getRawCommands(zombieThenFn)).toContain('kill @s')
     })

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

@@ -753,32 +753,33 @@ describe('MC Integration - New Features', () => {
     expect(count).toBeLessThanOrEqual(3)
   })
 
-  test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+  test('is-check-test.mcrs: foreach is-narrowing correctly matches entity types', async () => {
     if (!serverOnline) return
 
     await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false })
-    await mc.command('/scoreboard players set #is_check players 0')
-    await mc.command('/scoreboard players set #is_check zombies 0')
+    await mc.command('/forceload add 0 0').catch(() => {})  // Ensure chunk is loaded
+    await mc.command('/scoreboard objectives add armor_stands dummy').catch(() => {})
+    await mc.command('/scoreboard objectives add items dummy').catch(() => {})
+    await mc.command('/scoreboard players set #is_check armor_stands 0')
+    await mc.command('/scoreboard players set #is_check items 0')
     await mc.command('/function is_check_test:__load').catch(() => {})
-    await mc.command('/summon minecraft:zombie 0 65 0')
-    await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target')
-    await mc.command('/summon minecraft:armor_stand 2 65 0')
-    await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target')
+    
+    // Spawn 2 armor_stands and 1 item (all persist without players)
+    await mc.command('/summon minecraft:armor_stand 0 65 0 {Tags:["is_check_target"],NoGravity:1b}')
+    await mc.command('/summon minecraft:armor_stand 2 65 0 {Tags:["is_check_target"],NoGravity:1b}')
+    await mc.command('/summon minecraft:item 4 65 0 {Tags:["is_check_target"],Item:{id:"minecraft:stone",count:1},Age:-32768}')
+    await mc.ticks(5)
 
     await mc.command('/function is_check_test:check_types')
     await mc.ticks(5)
 
-    const zombies = await mc.scoreboard('#is_check', 'zombies')
-    const players = await mc.scoreboard('#is_check', 'players')
-    const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]')
-    const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]')
+    const armorStands = await mc.scoreboard('#is_check', 'armor_stands')
+    const items = await mc.scoreboard('#is_check', 'items')
 
-    expect(zombies).toBe(1)
-    expect(players).toBe(0)
-    expect(zombieEntities).toHaveLength(0)
-    expect(standEntities).toHaveLength(1)
+    expect(armorStands).toBe(2)  // 2 armor_stands matched
+    expect(items).toBe(1)        // 1 item matched
 
-    await mc.command('/kill @e[tag=is_check_target]').catch(() => {})
+    await mc.command('/function is_check_test:cleanup').catch(() => {})
   })
 
   test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {

package/src/lowering/index.ts

@@ -118,20 +118,20 @@ const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/
 const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/
 
 const ENTITY_TO_MC_TYPE: Partial<Record<EntityTypeName, string>> = {
-  Player: 'player',
-  Zombie: 'zombie',
-  Skeleton: 'skeleton',
-  Creeper: 'creeper',
-  Spider: 'spider',
-  Enderman: 'enderman',
-  Pig: 'pig',
-  Cow: 'cow',
-  Sheep: 'sheep',
-  Chicken: 'chicken',
-  Villager: 'villager',
-  ArmorStand: 'armor_stand',
-  Item: 'item',
-  Arrow: 'arrow',
+  Player: 'minecraft:player',
+  Zombie: 'minecraft:zombie',
+  Skeleton: 'minecraft:skeleton',
+  Creeper: 'minecraft:creeper',
+  Spider: 'minecraft:spider',
+  Enderman: 'minecraft:enderman',
+  Pig: 'minecraft:pig',
+  Cow: 'minecraft:cow',
+  Sheep: 'minecraft:sheep',
+  Chicken: 'minecraft:chicken',
+  Villager: 'minecraft:villager',
+  ArmorStand: 'minecraft:armor_stand',
+  Item: 'minecraft:item',
+  Arrow: 'minecraft:arrow',
 }
 
 function normalizeSelector(selector: string, warnings: Warning[]): string {
@@ -213,6 +213,8 @@ export class Lowering {
 
   // Struct definitions: name → { fieldName: TypeNode }
   private structDefs: Map<string, Map<string, TypeNode>> = new Map()
+  // Full struct declarations for field iteration
+  private structDecls: Map<string, StructDecl> = new Map()
   private enumDefs: Map<string, Map<string, number>> = new Map()
   private functionDefaults: Map<string, Array<Expr | undefined>> = new Map()
   private constValues: Map<string, ConstDecl['value']> = new Map()
@@ -243,6 +245,7 @@ export class Lowering {
         fields.set(field.name, field.type)
       }
       this.structDefs.set(struct.name, fields)
+      this.structDecls.set(struct.name, struct)
     }
 
     for (const enumDecl of program.enums ?? []) {
@@ -630,6 +633,23 @@ export class Lowering {
       return
     }
 
+    // Handle struct initialization from function call (copy from __ret_struct)
+    if ((stmt.init.kind === 'call' || stmt.init.kind === 'static_call') && stmt.type?.kind === 'struct') {
+      // First, execute the function call
+      this.lowerExpr(stmt.init)
+      // Then copy all fields from __ret_struct to the variable's storage
+      const structDecl = this.structDecls.get(stmt.type.name)
+      if (structDecl) {
+        const structName = stmt.type.name.toLowerCase()
+        for (const field of structDecl.fields) {
+          const srcPath = `rs:heap __ret_struct.${field.name}`
+          const dstPath = `rs:heap ${structName}_${stmt.name}.${field.name}`
+          this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`)
+        }
+      }
+      return
+    }
+
     // Handle array literal initialization
     if (stmt.init.kind === 'array_lit') {
       // Initialize empty NBT array
@@ -684,6 +704,20 @@ export class Lowering {
 
   private lowerReturnStmt(stmt: Extract<Stmt, { kind: 'return' }>): void {
     if (stmt.value) {
+      // Handle struct literal return: store fields to __ret_struct storage
+      if (stmt.value.kind === 'struct_lit') {
+        for (const field of stmt.value.fields) {
+          const path = `rs:heap __ret_struct.${field.name}`
+          const fieldValue = this.lowerExpr(field.value)
+          if (fieldValue.kind === 'const') {
+            this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`)
+          } else if (fieldValue.kind === 'var') {
+            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`)
+          }
+        }
+        this.builder.emitReturn({ kind: 'const', value: 0 })
+        return
+      }
       const value = this.lowerExpr(stmt.value)
       this.builder.emitReturn(value)
     } else {
@@ -1761,6 +1795,22 @@ export class Lowering {
 
     const implMethod = this.resolveInstanceMethod(expr)
     if (implMethod) {
+      // Copy struct fields from instance to 'self' storage before calling
+      const receiver = expr.args[0]
+      if (receiver?.kind === 'ident') {
+        const receiverType = this.inferExprType(receiver)
+        if (receiverType?.kind === 'struct') {
+          const structDecl = this.structDecls.get(receiverType.name)
+          const structName = receiverType.name.toLowerCase()
+          if (structDecl) {
+            for (const field of structDecl.fields) {
+              const srcPath = `rs:heap ${structName}_${receiver.name}.${field.name}`
+              const dstPath = `rs:heap ${structName}_self.${field.name}`
+              this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`)
+            }
+          }
+        }
+      }
       return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args)
     }
 

package/src/optimizer/dce.ts

@@ -133,10 +133,13 @@ export class DeadCodeEliminator {
     const entries = new Set<string>()
 
     for (const fn of program.declarations) {
-      if (fn.name === 'main') {
+      // All top-level functions are entry points (callable via /function)
+      // Exception: functions starting with _ are considered private/internal
+      if (!fn.name.startsWith('_')) {
         entries.add(fn.name)
       }
 
+      // Decorated functions are always entry points (even if prefixed with _)
       if (fn.decorators.some(decorator => [
         'tick',
         'load',
@@ -147,7 +150,7 @@ export class DeadCodeEliminator {
         'on_death',
         'on_login',
         'on_join_team',
-        'keep',  // Prevent DCE from removing this function
+        'keep',
       ].includes(decorator.name))) {
         entries.add(fn.name)
       }