redscript-mc 2.6.0 → 3.0.0

package/dist/src/mir/lower.js

@@ -8,34 +8,89 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lowerToMIR = lowerToMIR;
 const macro_1 = require("./macro");
+function formatTypeNode(type) {
+    switch (type.kind) {
+        case 'named':
+            return type.name;
+        case 'array':
+            return `${formatTypeNode(type.elem)}[]`;
+        case 'struct':
+        case 'enum':
+            return type.name;
+        case 'function_type':
+            return `fn(${type.params.map(formatTypeNode).join(', ')}) -> ${formatTypeNode(type.return)}`;
+        case 'entity':
+            return type.entityType;
+        case 'selector':
+            return type.entityType ? `selector<${type.entityType}>` : 'selector';
+        case 'tuple':
+            return `(${type.elements.map(formatTypeNode).join(', ')})`;
+        case 'option':
+            return `Option<${formatTypeNode(type.inner)}>`;
+    }
+}
+function formatFunctionSignature(fn) {
+    const params = fn.params
+        .map(param => `${param.name}: ${formatTypeNode(param.type)}`)
+        .join(', ');
+    return `fn ${fn.name}(${params}) -> ${formatTypeNode(fn.returnType)}`;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 function lowerToMIR(hir, sourceFile) {
     // Build struct definitions: name → field names
     const structDefs = new Map();
+    // Track @singleton struct names for special expansion of GameState::set(gs) calls
+    const singletonStructs = new Set();
     for (const s of hir.structs) {
         structDefs.set(s.name, s.fields.map(f => f.name));
+        if (s.isSingleton)
+            singletonStructs.add(s.name);
     }
     // Build enum definitions: enumName → variantName → integer value
     const enumDefs = new Map();
+    // Build enum payload info: enumName → variantName → field list
+    const enumPayloads = new Map();
     for (const e of hir.enums) {
         const variants = new Map();
+        const payloads = new Map();
         for (const v of e.variants) {
             variants.set(v.name, v.value ?? 0);
+            if (v.fields && v.fields.length > 0) {
+                payloads.set(v.name, v.fields);
+            }
         }
         enumDefs.set(e.name, variants);
+        if (payloads.size > 0) {
+            enumPayloads.set(e.name, payloads);
+        }
     }
-    // Build impl method info: typeName → methodName → { hasSelf }
+    // Build impl method info: typeName → methodName → { hasSelf, returnStructName? }
     const implMethods = new Map();
     for (const ib of hir.implBlocks) {
         const methods = new Map();
         for (const m of ib.methods) {
             const hasSelf = m.params.length > 0 && m.params[0].name === 'self';
-            methods.set(m.name, { hasSelf });
+            const returnStructName = m.returnType.kind === 'struct' ? m.returnType.name : undefined;
+            methods.set(m.name, { hasSelf, returnStructName });
         }
         implMethods.set(ib.typeName, methods);
     }
+    // Build Display impl registry: typeName → f-string parts from to_string body
+    // Used to inline Display::to_string() calls at call sites instead of generating a function.
+    const displayImpls = new Map();
+    for (const ib of hir.implBlocks) {
+        if (ib.traitName === 'Display') {
+            const toStringMethod = ib.methods.find(m => m.name === 'to_string');
+            if (toStringMethod && toStringMethod.body.length > 0) {
+                const firstStmt = toStringMethod.body[0];
+                if (firstStmt.kind === 'return' && firstStmt.value && firstStmt.value.kind === 'f_string') {
+                    displayImpls.set(ib.typeName, firstStmt.value.parts);
+                }
+            }
+        }
+    }
     // Pre-scan for macro functions
     const macroInfo = (0, macro_1.detectMacroFunctions)(hir);
     // Build function param info for call_macro generation at call sites
@@ -56,15 +111,27 @@ function lowerToMIR(hir, sourceFile) {
     }
     // Shared registry: specializedName → [mirFn, ...helpers]
     const specializedFnsRegistry = new Map();
+    // Build module-level const map: name → integer value (for inlining at use sites)
+    const constValues = new Map();
+    for (const c of hir.consts) {
+        if (c.value.kind === 'int_lit')
+            constValues.set(c.name, c.value.value);
+        else if (c.value.kind === 'bool_lit')
+            constValues.set(c.name, c.value.value ? 1 : 0);
+        else if (c.value.kind === 'float_lit')
+            constValues.set(c.name, Math.round(c.value.value * 10000));
+    }
     const allFunctions = [];
     for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry, undefined, enumPayloads, constValues, singletonStructs, displayImpls);
         allFunctions.push(fn, ...helpers);
     }
-    // Lower impl block methods
+    // Lower impl block methods (skip Display::to_string — inlined at call sites instead)
     for (const ib of hir.implBlocks) {
+        if (ib.traitName === 'Display')
+            continue; // Display impls are inlined, not emitted as functions
         for (const m of ib.methods) {
-            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter);
+            const { fn, helpers } = lowerImplMethod(m, ib.typeName, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, enumPayloads, constValues);
             allFunctions.push(fn, ...helpers);
         }
     }
@@ -82,12 +149,14 @@ function lowerToMIR(hir, sourceFile) {
 // Function lowering context
 // ---------------------------------------------------------------------------
 class FnContext {
-    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), timerCounter = { count: 0, timerId: 0 }) {
+    constructor(namespace, fnName, structDefs = new Map(), implMethods = new Map(), macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), timerCounter = { count: 0, timerId: 0 }, enumPayloads = new Map()) {
         this.tempCounter = 0;
         this.blockCounter = 0;
         this.blocks = [];
-        /** Stack of (loopHeader, loopExit, continueTo) for break/continue */
+        /** Stack of (loopHeader, loopExit, continueTo, label?) for break/continue */
         this.loopStack = [];
+        /** Pending label to attach to the next pushLoop call (set by labeled_loop lowering) */
+        this.pendingLoopLabel = undefined;
         /** Extracted helper functions for execute blocks */
         this.helperFunctions = [];
         /** Struct variable tracking: varName → { typeName, fields: fieldName → temp } */
@@ -96,6 +165,8 @@ class FnContext {
         this.tupleVars = new Map();
         /** Array variable tracking: varName → { ns, pathPrefix } for NBT-backed int[] */
         this.arrayVars = new Map();
+        /** String variable tracking: varName → storage path within rs:strings */
+        this.stringVars = new Map();
         /** Current source location (set during statement lowering) */
         this.currentSourceLoc = undefined;
         /** Source file path for the module being compiled */
@@ -107,10 +178,17 @@ class FnContext {
         /** Tracks double variables: varName → NBT storage path (without "rs:d " prefix) */
         this.doubleVars = new Map();
         this.doubleVarCount = 0;
+        this.stringVarCount = 0;
         /** HIR function definitions for array-arg monomorphization */
         this.hirFunctions = new Map();
         /** Shared registry of already-generated specialized (monomorphized) MIR functions */
         this.specializedFnsRegistry = new Map();
+        /** Module-level const values: name → integer value (inlined at use sites) */
+        this.constValues = new Map();
+        /** @singleton struct names — static_call GameState::set(gs) expands struct fields */
+        this.singletonStructs = new Set();
+        /** Display trait impls: typeName → f-string parts from to_string body (inlined at call sites) */
+        this.displayImpls = new Map();
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -119,6 +197,7 @@ class FnContext {
         this.fnParamInfo = fnParamInfo;
         this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? new Set();
         this.enumDefs = enumDefs;
+        this.enumPayloads = enumPayloads;
         this.timerCounter = timerCounter;
         const entry = this.makeBlock('entry');
         this.currentBlock = entry;
@@ -157,8 +236,13 @@ class FnContext {
     current() {
         return this.currentBlock;
     }
-    pushLoop(header, exit, continueTo) {
-        this.loopStack.push({ header, exit, continueTo: continueTo ?? header });
+    setPendingLoopLabel(label) {
+        this.pendingLoopLabel = label;
+    }
+    pushLoop(header, exit, continueTo, label) {
+        const effectiveLabel = label ?? this.pendingLoopLabel;
+        this.pendingLoopLabel = undefined;
+        this.loopStack.push({ header, exit, continueTo: continueTo ?? header, label: effectiveLabel });
     }
     popLoop() {
         this.loopStack.pop();
@@ -166,6 +250,14 @@ class FnContext {
     currentLoop() {
         return this.loopStack[this.loopStack.length - 1];
     }
+    /** Find loop by label — searches from innermost to outermost */
+    findLoopByLabel(label) {
+        for (let i = this.loopStack.length - 1; i >= 0; i--) {
+            if (this.loopStack[i].label === label)
+                return this.loopStack[i];
+        }
+        return undefined;
+    }
     getNamespace() {
         return this.namespace;
     }
@@ -178,6 +270,10 @@ class FnContext {
         this.doubleVars.set(varName, path);
         return path;
     }
+    /** Allocate a unique NBT storage path for a string value */
+    freshStringVar(varName) {
+        return `${this.namespace}_${this.fnName}_${varName}_${this.stringVarCount++}`;
+    }
 }
 // ---------------------------------------------------------------------------
 // Function lowering
@@ -190,10 +286,13 @@ hirFnMap,
 /** Shared registry of already-generated specialized MIR functions */
 specializedFnsRegistry, 
 /** Override the MIR function name (used when generating specialized versions) */
-overrideName) {
+overrideName, enumPayloads = new Map(), constValues = new Map(), singletonStructs = new Set(), displayImpls = new Map()) {
     const mirFnName = overrideName ?? fn.name;
-    const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
-    ctx.sourceFile = sourceFile;
+    const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
+    ctx.sourceFile = fn.sourceFile ?? sourceFile;
+    ctx.constValues = constValues;
+    ctx.singletonStructs = singletonStructs;
+    ctx.displayImpls = displayImpls;
     if (hirFnMap)
         ctx.hirFunctions = hirFnMap;
     if (specializedFnsRegistry)
@@ -210,6 +309,7 @@ overrideName) {
     const params = [];
     const scope = new Map();
     let doubleParamSlot = 0;
+    let stringParamSlot = 0;
     fn.params.forEach((p) => {
         if (p.type.kind === 'array' && arrayArgBindings?.has(p.name)) {
             // Array param already bound via arrayVars; no scoreboard slot needed
@@ -222,6 +322,10 @@ overrideName) {
             // No scoreboard param slot; callee reads from rs:d __dp<i> via doubleVars
             return;
         }
+        if (p.type.kind === 'named' && (p.type.name === 'string' || p.type.name === 'format_string')) {
+            ctx.stringVars.set(p.name, `__sp${stringParamSlot++}`);
+            return;
+        }
         const t = ctx.freshTemp();
         params.push({ name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false });
         scope.set(p.name, t);
@@ -243,13 +347,16 @@ overrideName) {
         blocks: liveBlocks,
         entry: 'entry',
         isMacro: fnMacroInfo != null,
+        sourceLoc: fn.span && (fn.sourceFile ?? sourceFile) ? { file: fn.sourceFile ?? sourceFile, line: fn.span.line, col: fn.span.col } : undefined,
+        sourceSnippet: formatFunctionSignature(fn),
     };
     return { fn: result, helpers: ctx.helperFunctions };
 }
-function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }) {
+function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = new Map(), fnParamInfo = new Map(), enumDefs = new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, enumPayloads = new Map(), constValues = new Map()) {
     const fnName = `${typeName}::${method.name}`;
-    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
-    ctx.sourceFile = sourceFile;
+    const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
+    ctx.sourceFile = method.sourceFile ?? sourceFile;
+    ctx.constValues = constValues;
     const fields = structDefs.get(typeName) ?? [];
     const hasSelf = method.params.length > 0 && method.params[0].name === 'self';
     const params = [];
@@ -322,6 +429,8 @@ function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, m
         blocks: liveBlocks,
         entry: 'entry',
         isMacro: macroInfo.has(fnName),
+        sourceLoc: method.span && (method.sourceFile ?? sourceFile) ? { file: method.sourceFile ?? sourceFile, line: method.span.line, col: method.span.col } : undefined,
+        sourceSnippet: formatFunctionSignature(method),
     };
     return { fn: result, helpers: ctx.helperFunctions };
 }
@@ -384,7 +493,14 @@ function lowerStmt(stmt, ctx, scope) {
     }
     switch (stmt.kind) {
         case 'let': {
-            if (stmt.init.kind === 'some_lit') {
+            if (stmt.type?.kind === 'named' && (stmt.type.name === 'string' || stmt.type.name === 'format_string')) {
+                const path = lowerStringExprToPath(stmt.init, ctx, scope, stmt.name) ?? ctx.freshStringVar(stmt.name);
+                ctx.stringVars.set(stmt.name, path);
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                scope.set(stmt.name, t);
+            }
+            else if (stmt.init.kind === 'some_lit') {
                 // Some(expr) — create option struct vars: has=1, val=expr
                 // Use __opt_ prefix so DCE treats these as side-effectful scoreboard writes
                 const hasTemp = `__opt_${stmt.name}_has`;
@@ -409,10 +525,30 @@ function lowerStmt(stmt, ctx, scope) {
                 const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon';
                 const fieldTemps = new Map();
                 for (const field of stmt.init.fields) {
-                    const val = lowerExpr(field.value, ctx, scope);
-                    const t = ctx.freshTemp();
-                    ctx.emit({ kind: 'copy', dst: t, src: val });
-                    fieldTemps.set(field.name, t);
+                    if (field.value.kind === 'struct_lit') {
+                        // Nested struct literal: register it as a synthetic var "${parentName}.${fieldName}"
+                        // so that chained access like r.pos.x can be resolved
+                        const nestedVarName = `${stmt.name}.${field.name}`;
+                        const nestedTypeName = '__anon';
+                        const nestedFieldTemps = new Map();
+                        for (const nestedField of field.value.fields) {
+                            const nval = lowerExpr(nestedField.value, ctx, scope);
+                            const nt = ctx.freshTemp();
+                            ctx.emit({ kind: 'copy', dst: nt, src: nval });
+                            nestedFieldTemps.set(nestedField.name, nt);
+                        }
+                        ctx.structVars.set(nestedVarName, { typeName: nestedTypeName, fields: nestedFieldTemps });
+                        // Store a placeholder temp (0) for the field itself in the parent struct
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        fieldTemps.set(field.name, t);
+                    }
+                    else {
+                        const val = lowerExpr(field.value, ctx, scope);
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'copy', dst: t, src: val });
+                        fieldTemps.set(field.name, t);
+                    }
                 }
                 ctx.structVars.set(stmt.name, { typeName, fields: fieldTemps });
             }
@@ -426,9 +562,17 @@ function lowerStmt(stmt, ctx, scope) {
                 const fieldTemps = new Map([['has', hasTemp], ['val', valTemp]]);
                 ctx.structVars.set(stmt.name, { typeName: '__option', fields: fieldTemps });
             }
-            else if (stmt.type?.kind === 'struct') {
+            else if (
+            // Struct-typed let: explicit annotation OR inferred from @singleton::get() return
+            stmt.type?.kind === 'struct' ||
+                (stmt.init.kind === 'static_call' &&
+                    ctx.singletonStructs.has(stmt.init.type) &&
+                    stmt.init.method === 'get')) {
                 // Struct-typed let with non-literal init (e.g., call returning struct)
-                const fields = ctx.structDefs.get(stmt.type.name);
+                const inferredStructName = stmt.type?.kind === 'struct'
+                    ? stmt.type.name
+                    : stmt.init.type;
+                const fields = ctx.structDefs.get(inferredStructName);
                 if (fields) {
                     lowerExpr(stmt.init, ctx, scope);
                     // Copy from return field slots into struct variable temps
@@ -444,7 +588,7 @@ function lowerStmt(stmt, ctx, scope) {
                             ctx.constTemps.set(t, constVal);
                         }
                     }
-                    ctx.structVars.set(stmt.name, { typeName: stmt.type.name, fields: fieldTemps });
+                    ctx.structVars.set(stmt.name, { typeName: inferredStructName, fields: fieldTemps });
                 }
                 else {
                     const valOp = lowerExpr(stmt.init, ctx, scope);
@@ -478,7 +622,7 @@ function lowerStmt(stmt, ctx, scope) {
                 // Array literal: write to NBT storage, track the var for index access
                 const ns = `${ctx.getNamespace()}:arrays`;
                 const pathPrefix = stmt.name;
-                ctx.arrayVars.set(stmt.name, { ns, pathPrefix });
+                ctx.arrayVars.set(stmt.name, { ns, pathPrefix, knownLen: stmt.init.elements.length });
                 const elems = stmt.init.elements;
                 // Check if all elements are pure integer literals (no side-effects)
                 const allConst = elems.every(e => e.kind === 'int_lit');
@@ -488,14 +632,16 @@ function lowerStmt(stmt, ctx, scope) {
                     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)
@@ -584,6 +730,13 @@ function lowerStmt(stmt, ctx, scope) {
             }
             break;
         }
+        case 'const_decl': {
+            // Evaluate the literal at compile time and store in constValues for inlining at use sites
+            const op = lowerExpr(stmt.value, ctx, scope);
+            const numericValue = op.kind === 'const' ? op.value : 0;
+            ctx.constValues.set(stmt.name, numericValue);
+            break;
+        }
         case 'expr': {
             lowerExpr(stmt.expr, ctx, scope);
             break;
@@ -660,6 +813,32 @@ function lowerStmt(stmt, ctx, scope) {
             ctx.switchTo(dead);
             break;
         }
+        case 'break_label': {
+            const loop = ctx.findLoopByLabel(stmt.label);
+            if (!loop)
+                throw new Error(`break: label '${stmt.label}' not found`);
+            ctx.terminate({ kind: 'jump', target: loop.exit });
+            const dead = ctx.newBlock('post_break_label');
+            ctx.switchTo(dead);
+            break;
+        }
+        case 'continue_label': {
+            const loop = ctx.findLoopByLabel(stmt.label);
+            if (!loop)
+                throw new Error(`continue: label '${stmt.label}' not found`);
+            ctx.terminate({ kind: 'jump', target: loop.continueTo });
+            const dead = ctx.newBlock('post_continue_label');
+            ctx.switchTo(dead);
+            break;
+        }
+        case 'labeled_loop': {
+            // The body is a while/foreach stmt; we need to push the label into the loop stack.
+            // We do this by injecting the label into the next pushLoop call by temporarily
+            // storing the pending label in ctx, then letting the inner loop case handle it.
+            ctx.setPendingLoopLabel(stmt.label);
+            lowerStmt(stmt.body, ctx, scope);
+            break;
+        }
         case 'if': {
             const condOp = lowerExpr(stmt.cond, ctx, scope);
             const thenBlock = ctx.newBlock('then');
@@ -748,6 +927,8 @@ function lowerStmt(stmt, ctx, scope) {
                 blocks: helperBlocks,
                 entry: 'entry',
                 isMacro: false,
+                sourceLoc: stmt.span && ctx.sourceFile ? { file: ctx.sourceFile, line: stmt.span.line, col: stmt.span.col } : undefined,
+                sourceSnippet: 'foreach helper',
             });
             ctx.emit({ kind: 'call_context', fn: helperName, subcommands });
             break;
@@ -771,51 +952,140 @@ function lowerStmt(stmt, ctx, scope) {
                 blocks: execBlocks,
                 entry: 'entry',
                 isMacro: false,
+                sourceLoc: stmt.span && ctx.sourceFile ? { file: ctx.sourceFile, line: stmt.span.line, col: stmt.span.col } : undefined,
+                sourceSnippet: 'execute helper',
             });
             ctx.emit({ kind: 'call_context', fn: helperName, subcommands });
             break;
         }
         case 'match': {
+            const hasStringPats = stmt.arms.some(a => a.pattern.kind === 'PatExpr' && a.pattern.expr.kind === 'str_lit');
+            if (hasStringPats) {
+                const matchPath = lowerStringExprToPath(stmt.expr, ctx, scope, 'match');
+                if (!matchPath) {
+                    throw new Error('String match requires a string literal or tracked string variable');
+                }
+                const mergeBlock = ctx.newBlock('match_merge');
+                for (let i = 0; i < stmt.arms.length; i++) {
+                    const arm = stmt.arms[i];
+                    const pat = arm.pattern;
+                    if (pat.kind === 'PatWild') {
+                        lowerBlock(arm.body, ctx, new Map(scope));
+                        if (isPlaceholderTerm(ctx.current().term)) {
+                            ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                        }
+                        continue;
+                    }
+                    if (pat.kind === 'PatExpr' && pat.expr.kind === 'str_lit') {
+                        const cmpTemp = ctx.freshTemp();
+                        ctx.emit({ kind: 'string_match', dst: cmpTemp, ns: 'rs:strings', path: matchPath, value: pat.expr.value });
+                        const armBody = ctx.newBlock('match_arm');
+                        const nextArm = ctx.newBlock('match_next');
+                        ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
+                        ctx.switchTo(armBody);
+                        lowerBlock(arm.body, ctx, new Map(scope));
+                        if (isPlaceholderTerm(ctx.current().term)) {
+                            ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                        }
+                        ctx.switchTo(nextArm);
+                        continue;
+                    }
+                    throw new Error(`Unsupported string match pattern: ${pat.kind}`);
+                }
+                if (isPlaceholderTerm(ctx.current().term)) {
+                    ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                }
+                ctx.switchTo(mergeBlock);
+                break;
+            }
             // Lower match as chained if/else
-            const matchVal = lowerExpr(stmt.expr, ctx, scope);
             const mergeBlock = ctx.newBlock('match_merge');
+            // Determine if any arm uses Option patterns (PatSome / PatNone).
+            // If so, resolve the Option has/val slots from the subject ident.
+            const hasOptionPats = stmt.arms.some(a => a.pattern.kind === 'PatSome' || a.pattern.kind === 'PatNone');
+            // For Option match: resolve has/val temps from subject (must be an ident)
+            let optHasOp;
+            let optValTemp;
+            if (hasOptionPats) {
+                if (stmt.expr.kind === 'ident') {
+                    const sv = ctx.structVars.get(stmt.expr.name);
+                    if (sv && sv.typeName === '__option') {
+                        optHasOp = { kind: 'temp', name: sv.fields.get('has') };
+                        optValTemp = sv.fields.get('val');
+                    }
+                    else {
+                        // Fall back: evaluate and use __rf_has/__rf_val convention
+                        lowerExpr(stmt.expr, ctx, scope);
+                        const hasT = ctx.freshTemp();
+                        const valT = ctx.freshTemp();
+                        ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } });
+                        ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } });
+                        optHasOp = { kind: 'temp', name: hasT };
+                        optValTemp = valT;
+                    }
+                }
+                else {
+                    lowerExpr(stmt.expr, ctx, scope);
+                    const hasT = ctx.freshTemp();
+                    const valT = ctx.freshTemp();
+                    ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } });
+                    ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } });
+                    optHasOp = { kind: 'temp', name: hasT };
+                    optValTemp = valT;
+                }
+            }
+            // For non-option match, evaluate the subject once
+            const matchVal = hasOptionPats
+                ? optHasOp // unused for non-option path
+                : lowerExpr(stmt.expr, ctx, scope);
             for (let i = 0; i < stmt.arms.length; i++) {
                 const arm = stmt.arms[i];
-                if (arm.pattern === null) {
-                    // Default arm — just emit the body
+                const pat = arm.pattern;
+                if (pat.kind === 'PatWild') {
+                    // Wildcard/default arm — always matches
                     lowerBlock(arm.body, ctx, new Map(scope));
                     if (isPlaceholderTerm(ctx.current().term)) {
                         ctx.terminate({ kind: 'jump', target: mergeBlock.id });
                     }
                 }
-                else if (arm.pattern.kind === 'range_lit') {
-                    // Range pattern: e.g. 0..59 => emit ge/le comparisons
-                    const range = arm.pattern.range;
+                else if (pat.kind === 'PatNone') {
+                    // None arm: optHasOp == 0
+                    const cmpTemp = ctx.freshTemp();
+                    ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp, b: { kind: 'const', value: 0 } });
                     const armBody = ctx.newBlock('match_arm');
                     const nextArm = ctx.newBlock('match_next');
-                    // Chain checks: if min defined, check matchVal >= min; if max defined, check matchVal <= max
-                    // Each failed check jumps to nextArm
-                    const checks = [];
-                    if (range.min !== undefined)
-                        checks.push({ op: 'ge', bound: range.min });
-                    if (range.max !== undefined)
-                        checks.push({ op: 'le', bound: range.max });
-                    if (checks.length === 0) {
-                        // Open range — always matches
-                        ctx.terminate({ kind: 'jump', target: armBody.id });
+                    ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
+                    ctx.switchTo(armBody);
+                    lowerBlock(arm.body, ctx, new Map(scope));
+                    if (isPlaceholderTerm(ctx.current().term)) {
+                        ctx.terminate({ kind: 'jump', target: mergeBlock.id });
                     }
-                    else {
-                        // Emit checks sequentially; each check passes → continue to next or armBody
-                        for (let ci = 0; ci < checks.length; ci++) {
-                            const { op, bound } = checks[ci];
-                            const cmpTemp = ctx.freshTemp();
-                            ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } });
-                            const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check');
-                            ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id });
-                            if (ci < checks.length - 1)
-                                ctx.switchTo(passBlock);
-                        }
+                    ctx.switchTo(nextArm);
+                }
+                else if (pat.kind === 'PatSome') {
+                    // Some(x) arm: optHasOp == 1, bind x = optValTemp
+                    const cmpTemp = ctx.freshTemp();
+                    ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp, b: { kind: 'const', value: 1 } });
+                    const armBody = ctx.newBlock('match_arm');
+                    const nextArm = ctx.newBlock('match_next');
+                    ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
+                    ctx.switchTo(armBody);
+                    const armScope = new Map(scope);
+                    // Bind the pattern variable to the option value temp
+                    if (optValTemp)
+                        armScope.set(pat.binding, optValTemp);
+                    lowerBlock(arm.body, ctx, armScope);
+                    if (isPlaceholderTerm(ctx.current().term)) {
+                        ctx.terminate({ kind: 'jump', target: mergeBlock.id });
                     }
+                    ctx.switchTo(nextArm);
+                }
+                else if (pat.kind === 'PatInt') {
+                    const cmpTemp = ctx.freshTemp();
+                    ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: { kind: 'const', value: pat.value } });
+                    const armBody = ctx.newBlock('match_arm');
+                    const nextArm = ctx.newBlock('match_next');
+                    ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
                     ctx.switchTo(armBody);
                     lowerBlock(arm.body, ctx, new Map(scope));
                     if (isPlaceholderTerm(ctx.current().term)) {
@@ -823,20 +1093,86 @@ function lowerStmt(stmt, ctx, scope) {
                     }
                     ctx.switchTo(nextArm);
                 }
-                else {
-                    const patOp = lowerExpr(arm.pattern, ctx, scope);
+                else if (pat.kind === 'PatEnum') {
+                    // Enum pattern: check tag value matches, then bind payload fields via NBT reads
+                    const tagValue = ctx.enumDefs.get(pat.enumName)?.get(pat.variant) ?? 0;
                     const cmpTemp = ctx.freshTemp();
-                    ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp });
+                    ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: { kind: 'const', value: tagValue } });
                     const armBody = ctx.newBlock('match_arm');
                     const nextArm = ctx.newBlock('match_next');
                     ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
                     ctx.switchTo(armBody);
-                    lowerBlock(arm.body, ctx, new Map(scope));
+                    const armScope = new Map(scope);
+                    // Bind each pattern variable by reading the corresponding NBT payload field
+                    const payloadFields = ctx.enumPayloads.get(pat.enumName)?.get(pat.variant) ?? [];
+                    for (let bi = 0; bi < pat.bindings.length; bi++) {
+                        const binding = pat.bindings[bi];
+                        const fieldDef = payloadFields[bi];
+                        const fieldName = fieldDef ? fieldDef.name : binding;
+                        const bindTemp = ctx.freshTemp();
+                        ctx.emit({
+                            kind: 'nbt_read',
+                            dst: bindTemp,
+                            ns: 'rs:enums',
+                            path: `${pat.enumName}_${fieldName}`,
+                            scale: 1,
+                        });
+                        armScope.set(binding, bindTemp);
+                    }
+                    lowerBlock(arm.body, ctx, armScope);
                     if (isPlaceholderTerm(ctx.current().term)) {
                         ctx.terminate({ kind: 'jump', target: mergeBlock.id });
                     }
                     ctx.switchTo(nextArm);
                 }
+                else if (pat.kind === 'PatExpr') {
+                    // Legacy: range_lit or other expression
+                    const expr = pat.expr;
+                    if (expr.kind === 'range_lit') {
+                        const range = expr.range;
+                        const armBody = ctx.newBlock('match_arm');
+                        const nextArm = ctx.newBlock('match_next');
+                        const checks = [];
+                        if (range.min !== undefined)
+                            checks.push({ op: 'ge', bound: range.min });
+                        if (range.max !== undefined)
+                            checks.push({ op: 'le', bound: range.max });
+                        if (checks.length === 0) {
+                            ctx.terminate({ kind: 'jump', target: armBody.id });
+                        }
+                        else {
+                            for (let ci = 0; ci < checks.length; ci++) {
+                                const { op, bound } = checks[ci];
+                                const cmpTemp = ctx.freshTemp();
+                                ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } });
+                                const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check');
+                                ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id });
+                                if (ci < checks.length - 1)
+                                    ctx.switchTo(passBlock);
+                            }
+                        }
+                        ctx.switchTo(armBody);
+                        lowerBlock(arm.body, ctx, new Map(scope));
+                        if (isPlaceholderTerm(ctx.current().term)) {
+                            ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                        }
+                        ctx.switchTo(nextArm);
+                    }
+                    else {
+                        const patOp = lowerExpr(expr, ctx, scope);
+                        const cmpTemp = ctx.freshTemp();
+                        ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp });
+                        const armBody = ctx.newBlock('match_arm');
+                        const nextArm = ctx.newBlock('match_next');
+                        ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id });
+                        ctx.switchTo(armBody);
+                        lowerBlock(arm.body, ctx, new Map(scope));
+                        if (isPlaceholderTerm(ctx.current().term)) {
+                            ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+                        }
+                        ctx.switchTo(nextArm);
+                    }
+                }
             }
             // If no default arm matched, jump to merge
             if (isPlaceholderTerm(ctx.current().term)) {
@@ -906,6 +1242,52 @@ function lowerStmt(stmt, ctx, scope) {
             ctx.switchTo(mergeBlock);
             break;
         }
+        case 'while_let_some': {
+            // while let Some(x) = init { body }
+            // Compiles to: loop { check opt.has; if 0 break; bind x = opt.val; body }
+            const headerBlock = ctx.newBlock('whl_header');
+            const bodyBlock = ctx.newBlock('whl_body');
+            const exitBlock = ctx.newBlock('whl_exit');
+            ctx.terminate({ kind: 'jump', target: headerBlock.id });
+            // Header: re-evaluate init and check has
+            ctx.switchTo(headerBlock);
+            let hasOp;
+            let valTemp;
+            const sv = (() => {
+                if (stmt.init.kind === 'ident')
+                    return ctx.structVars.get(stmt.init.name);
+                return undefined;
+            })();
+            if (sv && sv.typeName === '__option') {
+                const hasT = sv.fields.get('has');
+                const valT = sv.fields.get('val');
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            else {
+                lowerExpr(stmt.init, ctx, scope);
+                const hasT = ctx.freshTemp();
+                const valT = ctx.freshTemp();
+                ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } });
+                ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } });
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            ctx.terminate({ kind: 'branch', cond: hasOp, then: bodyBlock.id, else: exitBlock.id });
+            // Body: bind x = val, run body
+            ctx.switchTo(bodyBlock);
+            const bodyScope = new Map(scope);
+            if (valTemp)
+                bodyScope.set(stmt.binding, valTemp);
+            ctx.pushLoop(headerBlock.id, exitBlock.id, headerBlock.id);
+            lowerBlock(stmt.body, ctx, bodyScope);
+            ctx.popLoop();
+            if (isPlaceholderTerm(ctx.current().term)) {
+                ctx.terminate({ kind: 'jump', target: headerBlock.id });
+            }
+            ctx.switchTo(exitBlock);
+            break;
+        }
         default: {
             const _exhaustive = stmt;
             throw new Error(`Unknown HIR statement kind: ${_exhaustive.kind}`);
@@ -981,6 +1363,10 @@ function lowerExpr(expr, ctx, scope) {
             const temp = scope.get(expr.name);
             if (temp)
                 return { kind: 'temp', name: temp };
+            // Module-level const: inline the literal value directly (no scoreboard slot)
+            if (ctx.constValues.has(expr.name)) {
+                return { kind: 'const', value: ctx.constValues.get(expr.name) };
+            }
             // Unresolved ident — could be a global or external reference
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'copy', dst: t, src: { kind: 'const', value: 0 } });
@@ -1109,6 +1495,35 @@ function lowerExpr(expr, ctx, scope) {
             const value = variants?.get(expr.variant) ?? 0;
             return { kind: 'const', value };
         }
+        case 'enum_construct': {
+            // Enum variant construction with payload:
+            //   Color::RGB(r: 10, g: 20, b: 30)
+            // → scoreboard set tag = variant int value
+            // → nbt_write rs:enums Color_r = 10, Color_g = 20, Color_b = 30
+            const variants = ctx.enumDefs.get(expr.enumName);
+            const tagValue = variants?.get(expr.variant) ?? 0;
+            // Write tag to a temp (the result of the expression is the integer tag)
+            const tagTemp = ctx.freshTemp();
+            ctx.emit({ kind: 'const', dst: tagTemp, value: tagValue });
+            // Write payload fields to NBT storage rs:enums
+            const payloadFields = ctx.enumPayloads.get(expr.enumName)?.get(expr.variant) ?? [];
+            for (const arg of expr.args) {
+                const fieldDef = payloadFields.find(f => f.name === arg.name);
+                const argOp = lowerExpr(arg.value, ctx, scope);
+                // Determine NBT type from field definition
+                const nbtType = fieldDef && (fieldDef.type.kind === 'named') &&
+                    (fieldDef.type.name === 'float' || fieldDef.type.name === 'fixed') ? 'float' : 'int';
+                ctx.emit({
+                    kind: 'nbt_write',
+                    ns: 'rs:enums',
+                    path: `${expr.enumName}_${arg.name}`,
+                    type: nbtType,
+                    scale: 1,
+                    src: argOp,
+                });
+            }
+            return { kind: 'temp', name: tagTemp };
+        }
         case 'member': {
             // Enum variant access via dot syntax: Phase.Idle → integer constant
             if (expr.obj.kind === 'ident') {
@@ -1126,6 +1541,16 @@ function lowerExpr(expr, ctx, scope) {
                         return { kind: 'temp', name: fieldTemp };
                 }
             }
+            // Chained struct field access: v.pos.x → look up synthetic var "v.pos" in structVars
+            if (expr.obj.kind === 'member' && expr.obj.obj.kind === 'ident') {
+                const syntheticName = `${expr.obj.obj.name}.${expr.obj.field}`;
+                const nestedSv = ctx.structVars.get(syntheticName);
+                if (nestedSv) {
+                    const fieldTemp = nestedSv.fields.get(expr.field);
+                    if (fieldTemp)
+                        return { kind: 'temp', name: fieldTemp };
+                }
+            }
             // Fallback: opaque
             const obj = lowerExpr(expr.obj, ctx, scope);
             const t = ctx.freshTemp();
@@ -1176,9 +1601,36 @@ function lowerExpr(expr, ctx, scope) {
             return valOp;
         }
         case 'call': {
+            // Handle arr.len() — parser desugars obj.len() → call { fn: 'len', args: [obj] }
+            if (expr.fn === 'len' && expr.args.length === 1 && expr.args[0].kind === 'ident') {
+                const arrName = expr.args[0].name;
+                const arrInfo = ctx.arrayVars.get(arrName);
+                if (arrInfo) {
+                    if (arrInfo.knownLen !== undefined) {
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen });
+                        return { kind: 'temp', name: t };
+                    }
+                    // Dynamic array: read length at runtime via data get
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix });
+                    return { kind: 'temp', name: t };
+                }
+                // Also check scope (literal array length temp)
+                const lenTemp = scope.get(arrName);
+                if (lenTemp !== undefined) {
+                    return { kind: 'temp', name: lenTemp };
+                }
+            }
             // Handle scoreboard_get / score — read from vanilla MC scoreboard
             if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
-                const player = hirExprToStringLiteral(expr.args[0]);
+                const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams);
+                // If the arg is a plain ident (Player variable, not a macro param), use @s —
+                // event handlers are always called via `execute as <player> run function ...`
+                // so @s correctly refers to the player in context.
+                const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+                    ? '@s'
+                    : (playerArg.str || '@s');
                 const obj = hirExprToStringLiteral(expr.args[1]);
                 const t = ctx.freshTemp();
                 ctx.emit({ kind: 'score_read', dst: t, player, obj });
@@ -1186,7 +1638,10 @@ function lowerExpr(expr, ctx, scope) {
             }
             // Handle scoreboard_set — write to vanilla MC scoreboard
             if (expr.fn === 'scoreboard_set') {
-                const player = hirExprToStringLiteral(expr.args[0]);
+                const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams);
+                const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+                    ? '@s'
+                    : (playerArg.str || '@s');
                 const obj = hirExprToStringLiteral(expr.args[1]);
                 const src = lowerExpr(expr.args[2], ctx, scope);
                 ctx.emit({ kind: 'score_write', player, obj, src });
@@ -1194,6 +1649,35 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 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];
@@ -1362,18 +1846,78 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 return { kind: 'temp', name: t };
             }
+            // Handle int_to_str / bool_to_str — identity functions for scoreboard int/bool → string
+            // In f-string context these are handled by precomputeFStringParts; outside that, just
+            // evaluate the argument and return it (integer stays as integer for scoreboard purposes).
+            if (expr.fn === 'int_to_str' || expr.fn === 'bool_to_str') {
+                if (expr.args.length === 1) {
+                    return lowerExpr(expr.args[0], ctx, scope);
+                }
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                return { kind: 'temp', name: t };
+            }
+            // Handle assert(cond[, message]) — test framework builtin
+            if (expr.fn === 'assert') {
+                const condArg = expr.args[0];
+                const msgArg = expr.args[1];
+                const condOp = condArg ? lowerExpr(condArg, ctx, scope) : { kind: 'const', value: 0 };
+                // Evaluate condition to a temp
+                let condTemp;
+                if (condOp.kind === 'temp') {
+                    condTemp = condOp.name;
+                }
+                else {
+                    condTemp = ctx.freshTemp();
+                    ctx.emit({ kind: 'const', dst: condTemp, value: condOp.value });
+                }
+                // Get message string
+                let msgStr = 'assert failed';
+                if (msgArg && msgArg.kind === 'str_lit') {
+                    msgStr = msgArg.value;
+                }
+                const obj = `__${ctx.getNamespace()}`;
+                // emit: execute unless score $condTemp <obj> matches 1 run tellraw @a "FAIL: <msg>"
+                const failMsg = JSON.stringify({ text: `FAIL: ${msgStr}`, color: 'red' });
+                ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute unless score $${ctx.getFnName()}_${condTemp} ${obj} matches 1 run tellraw @a ${failMsg}`, args: [] });
+                ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute unless score $${ctx.getFnName()}_${condTemp} ${obj} matches 1 run scoreboard players add rs.test_failed rs.meta 1`, args: [] });
+                const t = ctx.freshTemp();
+                ctx.emit({ kind: 'const', dst: t, value: 0 });
+                return { kind: 'temp', name: t };
+            }
             // Handle builtin calls → raw MC commands
             if (macro_1.BUILTIN_SET.has(expr.fn)) {
-                const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams);
+                // For text builtins with f-string args, precompute complex expressions to temp vars
+                const TEXT_BUILTINS_SET = new Set(['tell', 'tellraw', 'title', 'subtitle', 'actionbar', 'announce']);
+                let resolvedArgs = expr.args;
+                if (TEXT_BUILTINS_SET.has(expr.fn)) {
+                    resolvedArgs = expr.args.map(arg => arg.kind === 'f_string' ? precomputeFStringParts(arg, ctx, scope) : arg);
+                }
+                const cmd = formatBuiltinCall(expr.fn, resolvedArgs, ctx.currentMacroParams, ctx.getNamespace());
                 ctx.emit({ kind: 'call', dst: null, fn: `__raw:${cmd}`, args: [] });
                 const t = ctx.freshTemp();
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 return { kind: 'temp', name: t };
             }
             // Check for struct instance method call: parser desugars v.method() → call('method', [v, ...])
+            // Some method names are remapped by the parser (e.g. add→set_add for set builtins).
+            // We reverse-map them here to support impl methods with those names.
+            const PARSER_METHOD_REMAP = {
+                'set_add': 'add', 'set_contains': 'contains', 'set_remove': 'remove', 'set_clear': 'clear',
+                '__array_push': 'push', '__array_pop': 'pop',
+                '__entity_tag': 'tag', '__entity_untag': 'untag', '__entity_has_tag': 'has_tag',
+            };
             if (expr.args.length > 0 && expr.args[0].kind === 'ident') {
                 const sv = ctx.structVars.get(expr.args[0].name);
                 if (sv) {
+                    // Intercept Display::to_string() calls — inlined at f-string call sites; return 0 otherwise
+                    if (expr.fn === 'to_string' && ctx.displayImpls.has(sv.typeName)) {
+                        // Display::to_string() is expanded inline in f-string context (precomputeFStringParts).
+                        // Outside of that context, return a dummy 0 (the call is not valid standalone).
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        return { kind: 'temp', name: t };
+                    }
                     // Intercept Timer method calls when _id is a known compile-time constant
                     if (sv.typeName === 'Timer') {
                         const idTemp = sv.fields.get('_id');
@@ -1382,7 +1926,10 @@ function lowerExpr(expr, ctx, scope) {
                             return lowerTimerMethod(expr.fn, timerId, sv, ctx, scope, expr.args.slice(1));
                         }
                     }
-                    const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.fn);
+                    // Try direct name, then try reverse-mapped name (for parser-remapped builtins)
+                    const originalMethodName = PARSER_METHOD_REMAP[expr.fn] ?? expr.fn;
+                    const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.fn)
+                        ?? ctx.implMethods.get(sv.typeName)?.get(originalMethodName);
                     if (methodInfo?.hasSelf) {
                         // Build args: self fields first, then remaining explicit args
                         const fields = ctx.structDefs.get(sv.typeName) ?? [];
@@ -1411,7 +1958,7 @@ function lowerExpr(expr, ctx, scope) {
                         }
                         const allArgs = [...selfArgs, ...explicitArgs];
                         const t = ctx.freshTemp();
-                        ctx.emit({ kind: 'call', dst: t, fn: `${sv.typeName}::${expr.fn}`, args: allArgs });
+                        ctx.emit({ kind: 'call', dst: t, fn: `${sv.typeName}::${originalMethodName}`, args: allArgs });
                         return { kind: 'temp', name: t };
                     }
                 }
@@ -1419,21 +1966,47 @@ function lowerExpr(expr, ctx, scope) {
             // Check if calling a macro function → emit call_macro
             const targetMacro = ctx.macroInfo.get(expr.fn);
             if (targetMacro) {
-                const args = expr.args.map(a => lowerExpr(a, ctx, scope));
                 const targetParams = ctx.fnParamInfo.get(expr.fn) ?? [];
                 const macroArgs = [];
-                for (let i = 0; i < targetParams.length && i < args.length; i++) {
+                for (let i = 0; i < targetParams.length && i < expr.args.length; i++) {
                     const paramName = targetParams[i].name;
                     if (targetMacro.macroParams.has(paramName)) {
                         const paramTypeName = targetMacro.paramTypes.get(paramName) ?? 'int';
-                        const isFloat = paramTypeName === 'float';
-                        const isFixed = paramTypeName === 'fixed';
-                        macroArgs.push({
-                            name: paramName,
-                            value: args[i],
-                            type: (isFloat || isFixed) ? 'double' : 'int',
-                            scale: isFloat ? 0.01 : isFixed ? 0.0001 : 1,
-                        });
+                        const isString = paramTypeName === 'string' || paramTypeName === 'format_string';
+                        const isSelector = paramTypeName === 'selector';
+                        if (isString) {
+                            // String macro params: store directly to rs:macro_args as NBT string
+                            const srcPath = lowerStringExprToPath(expr.args[i], ctx, scope, paramName);
+                            if (srcPath) {
+                                ctx.emit({
+                                    kind: 'call',
+                                    dst: null,
+                                    fn: `__raw:data modify storage rs:macro_args ${paramName} set from storage rs:strings ${srcPath}`,
+                                    args: [],
+                                });
+                            }
+                        }
+                        else if (isSelector) {
+                            // Selector macro params: store the selector string as an NBT string in rs:macro_args
+                            const arg = expr.args[i];
+                            const selStr = arg.kind === 'selector' ? arg.raw : '@s';
+                            ctx.emit({
+                                kind: 'call',
+                                dst: null,
+                                fn: `__raw:data modify storage rs:macro_args ${paramName} set value ${JSON.stringify(selStr)}`,
+                                args: [],
+                            });
+                        }
+                        else {
+                            const isFloat = paramTypeName === 'float';
+                            const isFixed = paramTypeName === 'fixed';
+                            macroArgs.push({
+                                name: paramName,
+                                value: lowerExpr(expr.args[i], ctx, scope),
+                                type: (isFloat || isFixed) ? 'double' : 'int',
+                                scale: isFloat ? 0.01 : isFixed ? 0.0001 : 1,
+                            });
+                        }
                     }
                 }
                 const t = ctx.freshTemp();
@@ -1467,7 +2040,7 @@ function lowerExpr(expr, ctx, scope) {
                         if (!ctx.specializedFnsRegistry.has(specializedName)) {
                             // Placeholder to prevent re-entry
                             ctx.specializedFnsRegistry.set(specializedName, []);
-                            const { fn: specFn, helpers: specHelpers } = lowerFunction(targetHirFn, ctx.getNamespace(), ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.sourceFile, ctx.timerCounter, arrayArgBindings, ctx.hirFunctions, ctx.specializedFnsRegistry, specializedName);
+                            const { fn: specFn, helpers: specHelpers } = lowerFunction(targetHirFn, ctx.getNamespace(), ctx.structDefs, ctx.implMethods, ctx.macroInfo, ctx.fnParamInfo, ctx.enumDefs, ctx.sourceFile, ctx.timerCounter, arrayArgBindings, ctx.hirFunctions, ctx.specializedFnsRegistry, specializedName, ctx.enumPayloads, ctx.constValues, ctx.singletonStructs, ctx.displayImpls);
                             ctx.specializedFnsRegistry.set(specializedName, [specFn, ...specHelpers]);
                         }
                         // Emit call to the specialized function, passing only non-array args
@@ -1489,6 +2062,35 @@ function lowerExpr(expr, ctx, scope) {
             {
                 const targetParams = ctx.fnParamInfo.get(expr.fn);
                 if (targetParams) {
+                    const hasStringParam = targetParams.some(p => p.type.kind === 'named' && (p.type.name === 'string' || p.type.name === 'format_string'));
+                    if (hasStringParam) {
+                        const nonStringArgs = [];
+                        let stringSlot = 0;
+                        for (let i = 0; i < targetParams.length && i < expr.args.length; i++) {
+                            const p = targetParams[i];
+                            if (p.type.kind === 'named' && (p.type.name === 'string' || p.type.name === 'format_string')) {
+                                const srcPath = lowerStringExprToPath(expr.args[i], ctx, scope, `arg${stringSlot}`);
+                                if (srcPath) {
+                                    ctx.emit({
+                                        kind: 'call',
+                                        dst: null,
+                                        fn: `__raw:data modify storage rs:strings __sp${stringSlot} set from storage rs:strings ${srcPath}`,
+                                        args: [],
+                                    });
+                                }
+                                stringSlot++;
+                            }
+                            else {
+                                nonStringArgs.push(lowerExpr(expr.args[i], ctx, scope));
+                            }
+                        }
+                        for (let i = targetParams.length; i < expr.args.length; i++) {
+                            nonStringArgs.push(lowerExpr(expr.args[i], ctx, scope));
+                        }
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args: nonStringArgs });
+                        return { kind: 'temp', name: t };
+                    }
                     const hasDoubleParam = targetParams.some(p => p.type.kind === 'named' && p.type.name === 'double');
                     if (hasDoubleParam) {
                         const ns = ctx.getNamespace();
@@ -1533,10 +2135,38 @@ function lowerExpr(expr, ctx, scope) {
             return { kind: 'temp', name: t };
         }
         case 'invoke': {
+            // Check for array.len() call: arr.len() → compile-time constant or NBT length
+            if (expr.callee.kind === 'member' && expr.callee.field === 'len' && expr.callee.obj.kind === 'ident') {
+                const arrInfo = ctx.arrayVars.get(expr.callee.obj.name);
+                if (arrInfo) {
+                    if (arrInfo.knownLen !== undefined) {
+                        // Compile-time constant length (literal array)
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen });
+                        return { kind: 'temp', name: t };
+                    }
+                    // Dynamic array (function parameter, heap_new, etc.): read length at runtime
+                    // emit: execute store result score $t __ns run data get storage ns:arrays path
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix });
+                    return { kind: 'temp', name: t };
+                }
+                // Also check scope-tracked length temp for literal arrays
+                const lenTemp = scope.get(expr.callee.obj.name);
+                if (lenTemp !== undefined) {
+                    return { kind: 'temp', name: lenTemp };
+                }
+            }
             // Check for struct method call: v.method(args)
             if (expr.callee.kind === 'member' && expr.callee.obj.kind === 'ident') {
                 const sv = ctx.structVars.get(expr.callee.obj.name);
                 if (sv) {
+                    // Intercept Display::to_string() — inlined in f-string context; return 0 otherwise
+                    if (expr.callee.field === 'to_string' && ctx.displayImpls.has(sv.typeName)) {
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'const', dst: t, value: 0 });
+                        return { kind: 'temp', name: t };
+                    }
                     // Intercept Timer method calls when _id is a known compile-time constant
                     if (sv.typeName === 'Timer') {
                         const idTemp = sv.fields.get('_id');
@@ -1561,6 +2191,35 @@ function lowerExpr(expr, ctx, scope) {
                     }
                 }
             }
+            // Method chaining: callee obj is not a simple ident (e.g. v.scale(2).add(...))
+            // Determine if the callee obj expression returns a struct via __rf_ slots
+            if (expr.callee.kind === 'member' && expr.callee.obj.kind !== 'ident') {
+                const returnedStructType = inferInvokeReturnStructType(expr.callee.obj, ctx);
+                if (returnedStructType) {
+                    // Lower the inner call — result goes into __rf_ slots
+                    lowerExpr(expr.callee.obj, ctx, scope);
+                    // Read __rf_ slots into temps for this chained call
+                    const chainFields = ctx.structDefs.get(returnedStructType) ?? [];
+                    const chainFieldTemps = new Map();
+                    for (const fieldName of chainFields) {
+                        const ft = ctx.freshTemp();
+                        ctx.emit({ kind: 'copy', dst: ft, src: { kind: 'temp', name: `__rf_${fieldName}` } });
+                        chainFieldTemps.set(fieldName, ft);
+                    }
+                    const methodInfo = ctx.implMethods.get(returnedStructType)?.get(expr.callee.field);
+                    if (methodInfo?.hasSelf) {
+                        const selfArgs = chainFields.map(f => {
+                            const temp = chainFieldTemps.get(f);
+                            return temp ? { kind: 'temp', name: temp } : { kind: 'const', value: 0 };
+                        });
+                        const explicitArgs = expr.args.map(a => lowerExpr(a, ctx, scope));
+                        const allArgs = [...selfArgs, ...explicitArgs];
+                        const ct = ctx.freshTemp();
+                        ctx.emit({ kind: 'call', dst: ct, fn: `${returnedStructType}::${expr.callee.field}`, args: allArgs });
+                        return { kind: 'temp', name: ct };
+                    }
+                }
+            }
             // Fallback: generic invoke
             const calleeOp = lowerExpr(expr.callee, ctx, scope);
             const args = expr.args.map(a => lowerExpr(a, ctx, scope));
@@ -1587,6 +2246,29 @@ function lowerExpr(expr, ctx, scope) {
                 ctx.emit({ kind: 'const', dst: t, value: 0 });
                 return { kind: 'temp', name: t };
             }
+            // @singleton struct static calls: expand struct arg field-by-field for ::set
+            if (ctx.singletonStructs.has(expr.type)) {
+                if (expr.method === 'get') {
+                    // GameState::get() — no struct args, our synthetic LIR fn writes to $__rf_<field> slots
+                    const t = ctx.freshTemp();
+                    ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args: [] });
+                    return { kind: 'temp', name: t };
+                }
+                else if (expr.method === 'set' && expr.args.length === 1 && expr.args[0].kind === 'ident') {
+                    // GameState::set(gs) — flatten struct arg into individual field args ($p0, $p1, ...)
+                    const sv = ctx.structVars.get(expr.args[0].name);
+                    if (sv) {
+                        const fields = ctx.structDefs.get(sv.typeName) ?? [];
+                        const fieldArgs = fields.map(f => {
+                            const temp = sv.fields.get(f);
+                            return temp ? { kind: 'temp', name: temp } : { kind: 'const', value: 0 };
+                        });
+                        const t = ctx.freshTemp();
+                        ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args: fieldArgs });
+                        return { kind: 'temp', name: t };
+                    }
+                }
+            }
             const args = expr.args.map(a => lowerExpr(a, ctx, scope));
             const t = ctx.freshTemp();
             ctx.emit({ kind: 'call', dst: t, fn: `${expr.type}::${expr.method}`, args });
@@ -1620,6 +2302,43 @@ function lowerExpr(expr, ctx, scope) {
             ctx.emit({ kind: 'const', dst: t, value: 0 });
             return { kind: 'temp', name: t };
         }
+        case 'unwrap_or': {
+            // opt.unwrap_or(default) → evaluate opt, if has=1 return val else return default
+            const resultTemp = ctx.freshTemp();
+            const defaultOp = lowerExpr(expr.default_, ctx, scope);
+            ctx.emit({ kind: 'copy', dst: resultTemp, src: defaultOp });
+            const sv = (() => {
+                if (expr.opt.kind === 'ident')
+                    return ctx.structVars.get(expr.opt.name);
+                return undefined;
+            })();
+            let hasOp;
+            let valTemp;
+            if (sv && sv.typeName === '__option') {
+                const hasT = sv.fields.get('has');
+                const valT = sv.fields.get('val');
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            else {
+                lowerExpr(expr.opt, ctx, scope);
+                const hasT = ctx.freshTemp();
+                const valT = ctx.freshTemp();
+                ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } });
+                ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } });
+                hasOp = { kind: 'temp', name: hasT };
+                valTemp = valT;
+            }
+            const someBlock = ctx.newBlock('unwrap_some');
+            const mergeBlock = ctx.newBlock('unwrap_merge');
+            ctx.terminate({ kind: 'branch', cond: hasOp, then: someBlock.id, else: mergeBlock.id });
+            ctx.switchTo(someBlock);
+            if (valTemp)
+                ctx.emit({ kind: 'copy', dst: resultTemp, src: { kind: 'temp', name: valTemp } });
+            ctx.terminate({ kind: 'jump', target: mergeBlock.id });
+            ctx.switchTo(mergeBlock);
+            return { kind: 'temp', name: resultTemp };
+        }
         case 'type_cast': {
             const ns = ctx.getNamespace();
             const targetName = expr.targetType.kind === 'named' ? expr.targetType.name : null;
@@ -1747,6 +2466,31 @@ function lowerShortCircuitOr(expr, ctx, scope) {
 // ---------------------------------------------------------------------------
 // Timer method inlining
 // ---------------------------------------------------------------------------
+/**
+ * Infer the struct type name returned by a chained invoke/call expression.
+ * Used to support method chaining: v.scale(2).add(...) where scale() returns Vec2.
+ * Returns the struct type name if determinable, otherwise undefined.
+ */
+function inferInvokeReturnStructType(expr, ctx) {
+    if (expr.kind === 'invoke' && expr.callee.kind === 'member') {
+        // Find the receiver type via structVars
+        let receiverTypeName;
+        if (expr.callee.obj.kind === 'ident') {
+            receiverTypeName = ctx.structVars.get(expr.callee.obj.name)?.typeName;
+        }
+        else {
+            // Recursively infer the type for deeper chains
+            receiverTypeName = inferInvokeReturnStructType(expr.callee.obj, ctx);
+        }
+        if (receiverTypeName) {
+            const methodInfo = ctx.implMethods.get(receiverTypeName)?.get(expr.callee.field);
+            if (methodInfo?.returnStructName) {
+                return methodInfo.returnStructName;
+            }
+        }
+    }
+    return undefined;
+}
 /**
  * Inline a Timer instance method call using the statically-assigned timer ID.
  * Emits scoreboard operations directly, bypassing the Timer::* function calls.
@@ -1885,6 +2629,39 @@ function lowerExecuteSubcmd(sub) {
         }
     }
 }
+function lowerStringExprToPath(expr, ctx, scope, hint = 'str') {
+    switch (expr.kind) {
+        case 'str_lit': {
+            const path = ctx.freshStringVar(hint);
+            ctx.emit({
+                kind: 'call',
+                dst: null,
+                fn: `__raw:data modify storage rs:strings ${path} set value ${JSON.stringify(expr.value)}`,
+                args: [],
+            });
+            return path;
+        }
+        case 'ident':
+            return ctx.stringVars.get(expr.name) ?? null;
+        case 'assign': {
+            if (!ctx.stringVars.has(expr.target))
+                return null;
+            const dstPath = ctx.stringVars.get(expr.target);
+            const srcPath = lowerStringExprToPath(expr.value, ctx, scope, expr.target);
+            if (!srcPath || srcPath === dstPath)
+                return dstPath;
+            ctx.emit({
+                kind: 'call',
+                dst: null,
+                fn: `__raw:data modify storage rs:strings ${dstPath} set from storage rs:strings ${srcPath}`,
+                args: [],
+            });
+            return dstPath;
+        }
+        default:
+            return null;
+    }
+}
 function selectorToString(sel) {
     // EntitySelector has kind like '@a', '@e', '@s', etc.
     // Filters are key=value pairs that become [key=value,key=value]
@@ -1921,7 +2698,147 @@ const MACRO_SENTINEL = '\x01';
  * If any argument uses a macro param, the command is prefixed with \x01
  * (converted to $ in LIR emission).
  */
-function formatBuiltinCall(fn, args, macroParams) {
+/**
+ * Convert an f_string HIRExpr to a Minecraft JSON text component string.
+ * Each interpolated variable becomes a {"score":{"name":"$var","objective":"__ns"}} component.
+ */
+/**
+ * Pre-evaluate complex f-string expression parts to MIR temp vars,
+ * returning a rewritten HIRExpr where each complex part is replaced by a simple ident.
+ */
+function precomputeFStringParts(expr, ctx, scope) {
+    if (expr.kind !== 'f_string')
+        return expr;
+    const newParts = [];
+    for (const part of expr.parts) {
+        if (part.kind === 'text') {
+            newParts.push(part);
+            continue;
+        }
+        const inner = part.expr;
+        // Simple cases that fStringToJsonText already handles
+        if (inner.kind === 'ident' || inner.kind === 'int_lit' || inner.kind === 'bool_lit') {
+            newParts.push({ kind: 'expr', expr: inner });
+            continue;
+        }
+        // Display::to_string() inline expansion in f-string context:
+        // v.to_string() (desugared as call{fn:'to_string', args:[v]}) → inline the Display impl's f-string
+        if (inner.kind === 'call' && inner.fn === 'to_string' && inner.args.length === 1 && inner.args[0].kind === 'ident') {
+            const argName = inner.args[0].name;
+            const sv = ctx.structVars.get(argName);
+            if (sv && ctx.displayImpls.has(sv.typeName)) {
+                const displayParts = ctx.displayImpls.get(sv.typeName);
+                // Expand Display impl parts, substituting self.<field> with the actual struct field temps
+                for (const dp of displayParts) {
+                    if (dp.kind === 'text') {
+                        newParts.push(dp);
+                    }
+                    else {
+                        const dpExpr = dp.expr;
+                        // member(ident('self'), field) → lookup struct field temp
+                        if (dpExpr.kind === 'member' && dpExpr.obj.kind === 'ident' && dpExpr.obj.name === 'self') {
+                            const fieldTemp = sv.fields.get(dpExpr.field);
+                            if (fieldTemp) {
+                                newParts.push({ kind: 'expr', expr: { kind: 'ident', name: fieldTemp } });
+                            }
+                            else {
+                                newParts.push({ kind: 'expr', expr: { kind: 'int_lit', value: 0 } });
+                            }
+                        }
+                        else {
+                            // Other expressions: lower them with self fields in scope
+                            const selfScope = new Map(scope);
+                            for (const [fieldName, fieldTemp] of sv.fields) {
+                                selfScope.set(`self.${fieldName}`, fieldTemp);
+                            }
+                            const tempOp = lowerExpr(dpExpr, ctx, selfScope);
+                            if (tempOp.kind === 'temp') {
+                                newParts.push({ kind: 'expr', expr: { kind: 'ident', name: tempOp.name } });
+                            }
+                            else if (tempOp.kind === 'const') {
+                                newParts.push({ kind: 'expr', expr: { kind: 'int_lit', value: tempOp.value } });
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+        // int_to_str(x) / bool_to_str(x) in f-string: pass through the inner arg as a scoreboard score ref
+        if (inner.kind === 'call' && (inner.fn === 'int_to_str' || inner.fn === 'bool_to_str') && inner.args.length === 1) {
+            const arg = inner.args[0];
+            if (arg.kind === 'ident') {
+                newParts.push({ kind: 'expr', expr: arg });
+                continue;
+            }
+            // If arg is complex, lower it first
+            const argOp = lowerExpr(arg, ctx, scope);
+            if (argOp.kind === 'temp') {
+                newParts.push({ kind: 'expr', expr: { kind: 'ident', name: argOp.name } });
+            }
+            else if (argOp.kind === 'const') {
+                newParts.push({ kind: 'expr', expr: { kind: 'int_lit', value: argOp.value } });
+            }
+            else {
+                newParts.push(part);
+            }
+            continue;
+        }
+        // Complex expression: lower to a temp var, then reference it as ident
+        const tempOp = lowerExpr(inner, ctx, scope);
+        if (tempOp.kind === 'temp') {
+            newParts.push({ kind: 'expr', expr: { kind: 'ident', name: tempOp.name } });
+        }
+        else if (tempOp.kind === 'const') {
+            newParts.push({ kind: 'expr', expr: { kind: 'int_lit', value: tempOp.value } });
+        }
+        else {
+            newParts.push(part);
+        }
+    }
+    return { kind: 'f_string', parts: newParts };
+}
+function fStringToJsonText(expr, namespace) {
+    if (expr.kind !== 'f_string')
+        return JSON.stringify(expr.kind === 'str_lit' ? { text: expr.value } : { text: '~' });
+    const objective = `__${namespace}`;
+    const extra = [];
+    for (const part of expr.parts) {
+        if (part.kind === 'text') {
+            if (part.value)
+                extra.push({ text: part.value });
+        }
+        else {
+            // expr part — must be a scoreboard variable (ident) or literal
+            const inner = part.expr;
+            if (inner.kind === 'ident') {
+                extra.push({ score: { name: `$${inner.name}`, objective } });
+            }
+            else if (inner.kind === 'int_lit') {
+                extra.push({ text: String(inner.value) });
+            }
+            else if (inner.kind === 'bool_lit') {
+                extra.push({ text: inner.value ? 'true' : 'false' });
+            }
+            else {
+                extra.push({ text: '?' });
+            }
+        }
+    }
+    if (extra.length === 0)
+        return '{"text":""}';
+    if (extra.length === 1)
+        return JSON.stringify(extra[0]);
+    return JSON.stringify({ text: '', extra });
+}
+function formatBuiltinCall(fn, args, macroParams, namespace = '') {
+    // For text-display builtins, the message arg may be an f_string — convert to JSON text
+    const TEXT_BUILTINS = new Set(['tell', 'tellraw', 'title', 'subtitle', 'actionbar', 'announce']);
+    const resolveTextArg = (arg) => {
+        if (arg.kind === 'f_string')
+            return fStringToJsonText(arg, namespace);
+        return JSON.stringify({ text: exprToCommandArg(arg, macroParams).str });
+    };
     const fmtArgs = args.map(a => exprToCommandArg(a, macroParams));
     const strs = fmtArgs.map(a => a.str);
     const hasMacro = fmtArgs.some(a => a.isMacro);
@@ -1979,24 +2896,34 @@ function formatBuiltinCall(fn, args, macroParams) {
             cmd = `say ${strs[0] ?? ''}`;
             break;
         case 'tell':
-        case 'tellraw':
-            cmd = `tellraw ${strs[0]} {"text":"${strs[1]}"}`;
+        case 'tellraw': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `tellraw ${strs[0]} ${msgJson}`;
             break;
-        case 'title':
-            cmd = `title ${strs[0]} title {"text":"${strs[1]}"}`;
+        }
+        case 'title': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `title ${strs[0]} title ${msgJson}`;
             break;
-        case 'actionbar':
-            cmd = `title ${strs[0]} actionbar {"text":"${strs[1]}"}`;
+        }
+        case 'actionbar': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `title ${strs[0]} actionbar ${msgJson}`;
             break;
-        case 'subtitle':
-            cmd = `title ${strs[0]} subtitle {"text":"${strs[1]}"}`;
+        }
+        case 'subtitle': {
+            const msgJson = resolveTextArg(args[1]);
+            cmd = `title ${strs[0]} subtitle ${msgJson}`;
             break;
+        }
         case 'title_times':
             cmd = `title ${strs[0]} times ${strs[1]} ${strs[2]} ${strs[3]}`;
             break;
-        case 'announce':
-            cmd = `tellraw @a {"text":"${strs[0]}"}`;
+        case 'announce': {
+            const msgJson = resolveTextArg(args[0]);
+            cmd = `tellraw @a ${msgJson}`;
             break;
+        }
         case 'give': {
             const nbt = strs[3] ? strs[3] : '';
             cmd = `give ${strs[0]} ${strs[1]}${nbt} ${strs[2] ?? '1'}`;
@@ -2057,6 +2984,66 @@ function formatBuiltinCall(fn, args, macroParams) {
         case 'xp_set':
             cmd = `xp set ${strs[0]} ${strs[1]} ${strs[2] ?? 'points'}`;
             break;
+        case 'scoreboard_add_objective':
+            cmd = strs[2] ? `scoreboard objectives add ${strs[0]} ${strs[1]} ${strs[2]}` : `scoreboard objectives add ${strs[0]} ${strs[1]}`;
+            break;
+        case 'scoreboard_remove_objective':
+            cmd = `scoreboard objectives remove ${strs[0]}`;
+            break;
+        case 'scoreboard_display':
+            cmd = `scoreboard objectives setdisplay ${strs[0]} ${strs[1] ?? ''}`;
+            break;
+        case 'scoreboard_hide':
+            cmd = `scoreboard objectives setdisplay ${strs[0]}`;
+            break;
+        case 'team_add':
+            cmd = strs[1] ? `team add ${strs[0]} ${strs[1]}` : `team add ${strs[0]}`;
+            break;
+        case 'team_remove':
+            cmd = `team remove ${strs[0]}`;
+            break;
+        case 'team_join':
+            cmd = `team join ${strs[0]} ${strs[1]}`;
+            break;
+        case 'team_leave':
+            cmd = `team leave ${strs[0]}`;
+            break;
+        case 'team_option':
+            cmd = `team modify ${strs[0]} ${strs[1]} ${strs[2]}`;
+            break;
+        case 'bossbar_add':
+            cmd = `bossbar add ${strs[0]} ${strs[1] ? JSON.stringify({ text: strs[1] }) : '""'}`;
+            break;
+        case 'bossbar_remove':
+            cmd = `bossbar remove ${strs[0]}`;
+            break;
+        case 'bossbar_set_value':
+            cmd = `bossbar set ${strs[0]} value ${strs[1]}`;
+            break;
+        case 'bossbar_get_value':
+            cmd = `bossbar get ${strs[0]} value`;
+            break;
+        case 'bossbar_set_max':
+            cmd = `bossbar set ${strs[0]} max ${strs[1]}`;
+            break;
+        case 'bossbar_set_color':
+            cmd = `bossbar set ${strs[0]} color ${strs[1]}`;
+            break;
+        case 'bossbar_set_style':
+            cmd = `bossbar set ${strs[0]} style ${strs[1]}`;
+            break;
+        case 'bossbar_set_visible':
+            cmd = `bossbar set ${strs[0]} visible ${strs[1]}`;
+            break;
+        case 'bossbar_set_players':
+            cmd = `bossbar set ${strs[0]} players ${strs[1]}`;
+            break;
+        case 'data_get':
+            cmd = `data get ${strs[0]} ${strs[1]} ${strs[2] ?? ''}`.trimEnd();
+            break;
+        case 'data_merge':
+            cmd = `data merge ${strs[0]} ${strs[1]} ${strs[2]}`;
+            break;
         default: cmd = `${fn} ${strs.join(' ')}`;
     }
     return hasMacro ? `${MACRO_SENTINEL}${cmd}` : cmd;