redscript-mc 1.0.0 → 1.1.0

package/dist/__tests__/optimizer-advanced.test.js

@@ -26,7 +26,7 @@ fn turret_tick() {
         const result = (0, index_1.compile)(source, { namespace: 'test' });
         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);
         expect(parent.indexOf(hoistedRead)).toBeLessThan(parent.indexOf(executeCall));
@@ -48,7 +48,7 @@ fn read_twice() {
         const fn = getFileContent(result.files, 'data/test/function/read_twice.mcfunction');
         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', () => {
         const source = `
@@ -65,7 +65,7 @@ fn math() {
         const fn = getFileContent(result.files, 'data/test/function/math.mcfunction');
         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');
     });
 });
 describe('setblock batching', () => {

package/dist/__tests__/runtime.test.js

@@ -58,7 +58,7 @@ function loadExample(name) {
 }
 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);
         expect(runtime.getScore('counter', 'ticks')).toBe(5);

package/dist/ast/types.d.ts

@@ -54,6 +54,11 @@ export interface SelectorFilter {
     sort?: 'nearest' | 'furthest' | 'random' | 'arbitrary';
     nbt?: string;
     gamemode?: string;
+    x?: RangeExpr;
+    y?: RangeExpr;
+    z?: RangeExpr;
+    x_rotation?: RangeExpr;
+    y_rotation?: RangeExpr;
 }
 export interface EntitySelector {
     kind: SelectorKind;
@@ -213,10 +218,14 @@ export type ExecuteSubcommand = {
     selector: EntitySelector;
 } | {
     kind: 'if_entity';
-    selector: EntitySelector;
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
 } | {
     kind: 'unless_entity';
-    selector: EntitySelector;
+    selector?: EntitySelector;
+    varName?: string;
+    filters?: SelectorFilter;
 } | {
     kind: 'in';
     dimension: string;
@@ -302,7 +311,7 @@ export type Stmt = {
 };
 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;
@@ -348,8 +357,17 @@ export interface ConstDecl {
     value: LiteralExpr;
     span?: Span;
 }
+export interface GlobalDecl {
+    kind: 'global';
+    name: string;
+    type: TypeNode;
+    init: Expr;
+    mutable: boolean;
+    span?: Span;
+}
 export interface Program {
     namespace: string;
+    globals: GlobalDecl[];
     declarations: FnDecl[];
     structs: StructDecl[];
     enums: EnumDecl[];

package/dist/cli.js

@@ -60,13 +60,15 @@ 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.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
   version   Print the RedScript version
 
@@ -275,18 +277,18 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         console.error(`Error: ${dir} is not a directory`);
         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`);
     // Debounce timer
     let debounceTimer = null;
-    // Compile all .rs files in directory
+    // Compile all .mcrs files in directory
     async function compileAll() {
         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;
         }
         let hasErrors = false;
@@ -321,7 +323,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             console.log('');
         }
     }
-    // Find all .rs files recursively
+    // Find all .mcrs files recursively
     function findRsFiles(directory) {
         const results = [];
         const entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -330,7 +332,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
             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);
             }
         }
@@ -340,7 +342,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
     void compileAll();
     // 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);
@@ -391,6 +393,22 @@ async function main() {
             }
             checkCommand(parsed.file);
             break;
+        case 'fmt':
+        case 'format': {
+            const files = args.filter(a => a.endsWith('.mcrs'));
+            if (files.length === 0) {
+                console.error('Usage: redscript fmt <file.mcrs> [file2.mcrs ...]');
+                process.exit(1);
+            }
+            const { format } = require('./formatter');
+            for (const file of files) {
+                const content = fs.readFileSync(file, 'utf8');
+                const formatted = format(content);
+                fs.writeFileSync(file, formatted);
+                console.log(`Formatted: ${file}`);
+            }
+            break;
+        }
         case 'repl':
             await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
             break;

package/dist/codegen/mcfunction/index.d.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", ...
  */

package/dist/codegen/mcfunction/index.js

@@ -12,7 +12,7 @@
  * Variable mapping:
  *   scoreboard objective: "rs"
  *   fake player:          "$<varname>"
- *   temporaries:          "$t0", "$t1", ...
+ *   temporaries:          "$_0", "$_1", ...
  *   return value:         "$ret"
  *   parameters:           "$p0", "$p1", ...
  */
@@ -258,7 +258,7 @@ function generateDatapackWithStats(module, options = {}) {
         `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
     for (const triggerName of triggerNames) {
@@ -310,6 +310,12 @@ function generateDatapackWithStats(module, options = {}) {
             files.push({ path: filePath, content: lines.join('\n') });
         }
     }
+    // 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/dist/codegen/structure/index.js

@@ -64,13 +64,19 @@ function collectCommandEntriesFromModule(module) {
     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}`,
         ]),
         ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).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 = [];
     if (loadCommands.length > 0) {
         sections.push({

package/dist/formatter/index.d.ts

@@ -0,0 +1 @@
+export declare function format(source: string): string;

package/dist/formatter/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+function format(source) {
+    const lines = source.split("\n");
+    let indent = 0;
+    const result = [];
+    for (let line of lines) {
+        line = line.trim();
+        if (!line) {
+            result.push("");
+            continue;
+        }
+        // Decrease indent before }
+        if (line.startsWith("}"))
+            indent = Math.max(0, indent - 1);
+        // Add indentation
+        result.push("    ".repeat(indent) + line);
+        // Increase indent after {
+        if (line.endsWith("{"))
+            indent++;
+    }
+    // Ensure single newline at end
+    return result.join("\n").trimEnd() + "\n";
+}
+//# sourceMappingURL=index.js.map

package/dist/ir/builder.d.ts

@@ -29,4 +29,5 @@ export declare class IRBuilder {
     emitTickYield(continuation: string): void;
     build(name: string, params: string[], isTickLoop?: boolean): IRFunction;
 }
-export declare function buildModule(namespace: string, fns: IRFunction[], globals?: string[]): IRModule;
+import type { GlobalVar } from './types';
+export declare function buildModule(namespace: string, fns: IRFunction[], globals?: GlobalVar[]): IRModule;

package/dist/ir/types.d.ts

@@ -8,7 +8,7 @@
  *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
  *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
  *   - Return value  → fake player $ret
- *   - Temporaries   → $t0, $t1, ...
+ *   - Temporaries   → $_0, $_1, ...
  */
 export type Operand = {
     kind: 'var';
@@ -103,6 +103,7 @@ export interface IRFunction {
     blocks: IRBlock[];
     commands?: IRCommand[];
     isTickLoop?: boolean;
+    isLoadInit?: boolean;
     isTriggerHandler?: boolean;
     triggerName?: string;
     eventTrigger?: {
@@ -110,8 +111,12 @@ export interface IRFunction {
         value?: string;
     };
 }
+export interface GlobalVar {
+    name: string;
+    init: number;
+}
 export interface IRModule {
     namespace: string;
     functions: IRFunction[];
-    globals: string[];
+    globals: GlobalVar[];
 }

package/dist/ir/types.js

@@ -9,7 +9,7 @@
  *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
  *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
  *   - Return value  → fake player $ret
- *   - Temporaries   → $t0, $t1, ...
+ *   - Temporaries   → $_0, $_1, ...
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/lowering/index.d.ts

@@ -16,6 +16,7 @@ export declare class Lowering {
     private namespace;
     private functions;
     private globals;
+    private globalNames;
     private fnDecls;
     private specializedFunctions;
     private currentFn;
@@ -80,6 +81,7 @@ export declare class Lowering {
     private buildRichTextJson;
     private appendRichTextExpr;
     private exprToString;
+    private exprToSnbt;
     private exprToTargetString;
     private exprToLiteral;
     private exprToQuotedString;

package/dist/lowering/index.js

@@ -20,9 +20,10 @@ const BUILTINS = {
     subtitle: ([sel, msg]) => `title ${sel} subtitle {"text":"${msg}"}`,
     title_times: ([sel, fadeIn, stay, fadeOut]) => `title ${sel} times ${fadeIn} ${stay} ${fadeOut}`,
     announce: ([msg]) => `tellraw @a {"text":"${msg}"}`,
-    give: ([sel, item, count]) => `give ${sel} ${item} ${count ?? '1'}`,
+    give: ([sel, item, count, nbt]) => nbt ? `give ${sel} ${item}${nbt} ${count ?? '1'}` : `give ${sel} ${item} ${count ?? '1'}`,
     kill: ([sel]) => `kill ${sel ?? '@s'}`,
     effect: ([sel, eff, dur, amp]) => `effect give ${sel} ${eff} ${dur ?? '30'} ${amp ?? '0'}`,
+    effect_clear: ([sel, eff]) => eff ? `effect clear ${sel} ${eff}` : `effect clear ${sel}`,
     summon: ([type, x, y, z, nbt]) => {
         const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
         return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`;
@@ -73,6 +74,12 @@ const BUILTINS = {
     team_leave: () => null, // Special handling
     team_option: () => null, // Special handling
     data_get: () => null, // Special handling (returns value from NBT)
+    data_merge: () => null, // Special handling (merge NBT)
+    set_new: () => null, // Special handling (returns set ID)
+    set_add: () => null, // Special handling
+    set_contains: () => null, // Special handling (returns 1/0)
+    set_remove: () => null, // Special handling
+    set_clear: () => null, // Special handling
 };
 function getSpan(node) {
     return node?.span;
@@ -118,6 +125,7 @@ class Lowering {
     constructor(namespace) {
         this.functions = [];
         this.globals = [];
+        this.globalNames = new Map();
         this.fnDecls = new Map();
         this.specializedFunctions = new Map();
         this.currentFn = '';
@@ -142,6 +150,7 @@ class Lowering {
         // World object counter for unique tags
         this.worldObjCounter = 0;
         this.namespace = namespace;
+        LoweringBuilder.resetTempCounter();
     }
     lower(program) {
         this.namespace = program.namespace;
@@ -164,6 +173,13 @@ class Lowering {
             this.constValues.set(constDecl.name, constDecl.value);
             this.varTypes.set(constDecl.name, this.normalizeType(constDecl.type));
         }
+        // Process global variable declarations (top-level let)
+        for (const g of program.globals ?? []) {
+            this.globalNames.set(g.name, { mutable: g.mutable });
+            this.varTypes.set(g.name, this.normalizeType(g.type));
+            const initValue = g.init.kind === 'int_lit' ? g.init.value : 0;
+            this.globals.push({ name: `$${g.name}`, init: initValue });
+        }
         for (const fn of program.declarations) {
             this.fnDecls.set(fn.name, fn);
             this.functionDefaults.set(fn.name, fn.params.map(param => param.default));
@@ -251,6 +267,10 @@ class Lowering {
                     break;
             }
         }
+        // Check for @load decorator
+        if (fn.decorators.some(d => d.name === 'load')) {
+            irFn.isLoadInit = true;
+        }
         // Handle tick rate counter if needed
         if (tickRate && tickRate > 1) {
             this.wrapWithTickRate(irFn, tickRate);
@@ -264,7 +284,7 @@ class Lowering {
     wrapWithTickRate(fn, rate) {
         // Add tick counter logic to entry block
         const counterVar = `$__tick_${fn.name}`;
-        this.globals.push(counterVar);
+        this.globals.push({ name: counterVar, init: 0 });
         // Prepend counter logic to entry block
         const entry = fn.blocks[0];
         const originalInstrs = [...entry.instrs];
@@ -357,6 +377,10 @@ class Lowering {
         }
     }
     lowerLetStmt(stmt) {
+        // Check for duplicate declaration of foreach binding
+        if (this.currentContext.binding === stmt.name) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot redeclare foreach binding '${stmt.name}'`, stmt.span ?? { line: 0, col: 0 });
+        }
         const varName = `$${stmt.name}`;
         this.varMap.set(stmt.name, varName);
         // Track variable type
@@ -406,6 +430,13 @@ class Lowering {
             }
             return;
         }
+        // Handle set_new returning a set ID string
+        if (stmt.init.kind === 'call' && stmt.init.fn === 'set_new') {
+            const setId = `__set_${this.foreachCounter++}`;
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            this.stringValues.set(stmt.name, setId);
+            return;
+        }
         // Handle spawn_object returning entity handle
         if (stmt.init.kind === 'call' && stmt.init.fn === 'spawn_object') {
             const value = this.lowerExpr(stmt.init);
@@ -760,10 +791,24 @@ class Lowering {
                     parts.push(`at ${this.selectorToString(sub.selector)}`);
                     break;
                 case 'if_entity':
-                    parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    if (sub.selector) {
+                        parts.push(`if entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        // Variable with filters - substitute with @s and apply filters
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`if entity ${this.selectorToString(sel)}`);
+                    }
                     break;
                 case 'unless_entity':
-                    parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    if (sub.selector) {
+                        parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
+                    }
+                    else if (sub.varName) {
+                        // Variable with filters - substitute with @s and apply filters
+                        const sel = { kind: '@s', filters: sub.filters };
+                        parts.push(`unless entity ${this.selectorToString(sel)}`);
+                    }
                     break;
                 case 'in':
                     parts.push(`in ${sub.dimension}`);
@@ -1051,6 +1096,14 @@ class Lowering {
         return { kind: 'var', name: dst };
     }
     lowerAssignExpr(expr) {
+        // Check for const reassignment (both compile-time consts and immutable globals)
+        if (this.constValues.has(expr.target)) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 });
+        }
+        const globalInfo = this.globalNames.get(expr.target);
+        if (globalInfo && !globalInfo.mutable) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot assign to constant '${expr.target}'`, getSpan(expr) ?? { line: 1, col: 1 });
+        }
         const blockPosValue = this.resolveBlockPosExpr(expr.value);
         if (blockPosValue) {
             this.blockPosVars.set(expr.target, blockPosValue);
@@ -1473,6 +1526,62 @@ class Lowering {
             this.builder.emitRaw(`execute store result score ${dst} rs run data get ${targetType} ${target} ${path} ${scale}`);
             return { kind: 'var', name: dst };
         }
+        // data_merge(target, nbt) — merge NBT into entity/block/storage
+        // data_merge(@s, { Invisible: 1b, Silent: 1b })
+        if (name === 'data_merge') {
+            const target = args[0];
+            const nbt = args[1];
+            const nbtStr = this.exprToSnbt ? this.exprToSnbt(nbt) : this.exprToString(nbt);
+            // Check if target is a selector (entity) or string (block/storage)
+            if (target.kind === 'selector') {
+                const sel = this.exprToTargetString(target);
+                this.builder.emitRaw(`data merge entity ${sel} ${nbtStr}`);
+            }
+            else {
+                // Assume block position or storage
+                const targetStr = this.exprToString(target);
+                // If it looks like coordinates, use block; otherwise storage
+                if (targetStr.match(/^~|^\d|^\^/)) {
+                    this.builder.emitRaw(`data merge block ${targetStr} ${nbtStr}`);
+                }
+                else {
+                    this.builder.emitRaw(`data merge storage ${targetStr} ${nbtStr}`);
+                }
+            }
+            return { kind: 'const', value: 0 };
+        }
+        // Set data structure operations — unique collections via NBT storage
+        // set_new is primarily handled in lowerLetStmt for proper string tracking.
+        // This fallback handles standalone set_new() calls without assignment.
+        if (name === 'set_new') {
+            const setId = `__set_${this.foreachCounter++}`;
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_add') {
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`execute unless data storage rs:sets ${setId}[{value:${value}}] run data modify storage rs:sets ${setId} append value {value:${value}}`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_contains') {
+            const dst = this.builder.freshTemp();
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`execute store result score ${dst} rs if data storage rs:sets ${setId}[{value:${value}}]`);
+            return { kind: 'var', name: dst };
+        }
+        if (name === 'set_remove') {
+            const setId = this.exprToString(args[0]);
+            const value = this.exprToString(args[1]);
+            this.builder.emitRaw(`data remove storage rs:sets ${setId}[{value:${value}}]`);
+            return { kind: 'const', value: 0 };
+        }
+        if (name === 'set_clear') {
+            const setId = this.exprToString(args[0]);
+            this.builder.emitRaw(`data modify storage rs:sets ${setId} set value []`);
+            return { kind: 'const', value: 0 };
+        }
         const coordCommand = this.lowerCoordinateBuiltin(name, args);
         if (coordCommand) {
             this.builder.emitRaw(coordCommand);
@@ -1497,8 +1606,10 @@ class Lowering {
             }
             return { kind: 'const', value: 0 };
         }
-        // Convert args to strings for builtin
-        const strArgs = args.map(arg => this.exprToString(arg));
+        // Convert args to strings for builtin (use SNBT for struct/array literals)
+        const strArgs = args.map(arg => arg.kind === 'struct_lit' || arg.kind === 'array_lit'
+            ? this.exprToSnbt(arg)
+            : this.exprToString(arg));
         const cmd = BUILTINS[name](strArgs);
         if (cmd) {
             this.builder.emitRaw(cmd);
@@ -1647,12 +1758,53 @@ class Lowering {
             }
             case 'selector':
                 return this.selectorToString(expr.sel);
+            case 'unary':
+                // Handle unary minus on literals directly
+                if (expr.op === '-' && expr.operand.kind === 'int_lit') {
+                    return (-expr.operand.value).toString();
+                }
+                if (expr.op === '-' && expr.operand.kind === 'float_lit') {
+                    return Math.trunc(-expr.operand.value).toString();
+                }
+                // Fall through to default for complex cases
+                const unaryOp = this.lowerExpr(expr);
+                return this.operandToVar(unaryOp);
             default:
                 // Complex expression - lower and return var name
                 const op = this.lowerExpr(expr);
                 return this.operandToVar(op);
         }
     }
+    exprToSnbt(expr) {
+        switch (expr.kind) {
+            case 'struct_lit': {
+                const entries = expr.fields.map(f => `${f.name}:${this.exprToSnbt(f.value)}`);
+                return `{${entries.join(',')}}`;
+            }
+            case 'array_lit': {
+                const items = expr.elements.map(e => this.exprToSnbt(e));
+                return `[${items.join(',')}]`;
+            }
+            case 'str_lit':
+                return `"${expr.value}"`;
+            case 'int_lit':
+                return String(expr.value);
+            case 'float_lit':
+                return String(expr.value);
+            case 'byte_lit':
+                return `${expr.value}b`;
+            case 'short_lit':
+                return `${expr.value}s`;
+            case 'long_lit':
+                return `${expr.value}L`;
+            case 'double_lit':
+                return `${expr.value}d`;
+            case 'bool_lit':
+                return expr.value ? '1b' : '0b';
+            default:
+                return this.exprToString(expr);
+        }
+    }
     exprToTargetString(expr) {
         if (expr.kind === 'selector') {
             return this.selectorToString(expr.sel);
@@ -1712,6 +1864,13 @@ class Lowering {
             }
             return null;
         }
+        if (name === 'summon') {
+            if (args.length >= 2 && pos1) {
+                const nbt = args[2] ? ` ${this.exprToString(args[2])}` : '';
+                return `summon ${this.exprToString(args[0])} ${emitBlockPos(pos1)}${nbt}`;
+            }
+            return null;
+        }
         return null;
     }
     lowerTpCommand(args) {
@@ -1941,6 +2100,18 @@ class Lowering {
             parts.push(`nbt=${filters.nbt}`);
         if (filters.gamemode)
             parts.push(`gamemode=${filters.gamemode}`);
+        // Position filters
+        if (filters.x)
+            parts.push(`x=${this.rangeToString(filters.x)}`);
+        if (filters.y)
+            parts.push(`y=${this.rangeToString(filters.y)}`);
+        if (filters.z)
+            parts.push(`z=${this.rangeToString(filters.z)}`);
+        // Rotation filters
+        if (filters.x_rotation)
+            parts.push(`x_rotation=${this.rangeToString(filters.x_rotation)}`);
+        if (filters.y_rotation)
+            parts.push(`y_rotation=${this.rangeToString(filters.y_rotation)}`);
         return this.finalizeSelector(parts.length ? `${kind}[${parts.join(',')}]` : kind);
     }
     finalizeSelector(selector) {
@@ -1965,14 +2136,17 @@ exports.Lowering = Lowering;
 // ---------------------------------------------------------------------------
 class LoweringBuilder {
     constructor() {
-        this.tempCount = 0;
         this.labelCount = 0;
         this.blocks = [];
         this.currentBlock = null;
         this.locals = new Set();
     }
+    /** Reset the global temp counter (call between compilations). */
+    static resetTempCounter() {
+        LoweringBuilder.globalTempId = 0;
+    }
     freshTemp() {
-        const name = `$t${this.tempCount++}`;
+        const name = `$_${LoweringBuilder.globalTempId++}`;
         this.locals.add(name);
         return name;
     }
@@ -2038,4 +2212,5 @@ class LoweringBuilder {
         };
     }
 }
+LoweringBuilder.globalTempId = 0;
 //# sourceMappingURL=index.js.map