redscript-mc 2.6.0 → 2.6.2

package/dist/src/mir/lower.js

@@ -409,10 +409,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 });
             }
@@ -478,7 +498,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 +508,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)
@@ -777,45 +799,62 @@ function lowerStmt(stmt, ctx, scope) {
         }
         case 'match': {
             // 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 });
-                    }
-                    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.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,10 +862,27 @@ function lowerStmt(stmt, ctx, scope) {
                     }
                     ctx.switchTo(nextArm);
                 }
-                else {
-                    const patOp = lowerExpr(arm.pattern, ctx, scope);
+                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: patOp });
+                    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 });
@@ -837,6 +893,54 @@ function lowerStmt(stmt, ctx, scope) {
                     }
                     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)) {
@@ -1126,6 +1230,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 +1290,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 +1327,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 +1338,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];
@@ -1364,7 +1537,7 @@ function lowerExpr(expr, ctx, scope) {
             }
             // Handle builtin calls → raw MC commands
             if (macro_1.BUILTIN_SET.has(expr.fn)) {
-                const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams);
+                const cmd = formatBuiltinCall(expr.fn, expr.args, 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 });
@@ -1533,6 +1706,28 @@ 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);
@@ -1921,7 +2116,48 @@ 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.
+ */
+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)
+            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 {
+                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 +2215,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'}`;

package/dist/src/mir/types.d.ts

@@ -149,6 +149,11 @@ export type MIRInstr = MIRInstrBase & ({
     pathPrefix: string;
     indexSrc: Operand;
     valueSrc: Operand;
+} | {
+    kind: 'nbt_list_len';
+    dst: Temp;
+    ns: string;
+    path: string;
 } | {
     kind: 'score_read';
     dst: Temp;

package/dist/src/mir/verify.js

@@ -156,6 +156,7 @@ function getDst(instr) {
         case 'not':
         case 'nbt_read':
         case 'nbt_read_dynamic':
+        case 'nbt_list_len':
             return instr.dst;
         case 'call':
         case 'call_macro':
@@ -188,6 +189,7 @@ function getUsedTemps(instr) {
             temps.push(...getOperandTemps(instr.a), ...getOperandTemps(instr.b));
             break;
         case 'nbt_read':
+        case 'nbt_list_len':
             break;
         case 'nbt_read_dynamic':
             temps.push(...getOperandTemps(instr.indexSrc));

package/dist/src/optimizer/commands.d.ts

@@ -0,0 +1,38 @@
+import type { IRCommand } from '../ir/types';
+export interface OptimizationStats {
+    licmHoists: number;
+    licmLoopBodies: number;
+    cseRedundantReads: number;
+    cseArithmetic: number;
+    setblockMergedCommands: number;
+    setblockFillCommands: number;
+    setblockSavedCommands: number;
+    deadCodeRemoved: number;
+    constantFolds: number;
+    inlinedTrivialFunctions: number;
+    totalCommandsBefore: number;
+    totalCommandsAfter: number;
+}
+export interface CommandFunction {
+    name: string;
+    commands: IRCommand[];
+}
+export declare function setOptimizerObjective(obj: string): void;
+export declare function createEmptyOptimizationStats(): OptimizationStats;
+export declare function mergeOptimizationStats(base: OptimizationStats, delta: Partial<OptimizationStats>): void;
+export declare function applyLICM(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function applyCSE(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function batchSetblocks(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};
+export declare function optimizeCommandFunctions(functions: CommandFunction[]): {
+    functions: CommandFunction[];
+    stats: OptimizationStats;
+};