redscript-mc 2.6.0 → 2.6.2

package/editors/vscode/out/extension.js

@@ -18410,6 +18410,9 @@ var require_lexer = __commonJS({
         if (char === "." && this.peek() === ".") {
           this.advance();
           let value = "..";
+          if (this.peek() === "=") {
+            value += this.advance();
+          }
           while (/[0-9]/.test(this.peek())) {
             value += this.advance();
           }
@@ -18662,6 +18665,9 @@ var require_lexer = __commonJS({
         if (this.peek() === "." && this.peek(1) === ".") {
           value += this.advance();
           value += this.advance();
+          if (this.peek() === "=") {
+            value += this.advance();
+          }
           while (/[0-9]/.test(this.peek())) {
             value += this.advance();
           }
@@ -19070,6 +19076,7 @@ var require_parser = __commonJS({
           returnType = this.parseType();
         }
         const body = this.parseBlock();
+        const closingBraceLine = this.tokens[this.pos - 1]?.line;
         const fn = this.withLoc({
           name,
           typeParams,
@@ -19080,6 +19087,8 @@ var require_parser = __commonJS({
           isLibraryFn: this.inLibraryMode || void 0,
           isExported
         }, fnToken);
+        if (fn.span && closingBraceLine)
+          fn.span.endLine = closingBraceLine;
         return fn;
       }
       /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -19167,7 +19176,7 @@ var require_parser = __commonJS({
           } else if (key === "batch") {
             args.batch = parseInt(val, 10);
           } else if (key === "onDone") {
-            args.onDone = val;
+            args.onDone = val.replace(/^["']|["']$/g, "");
           } else if (key === "trigger") {
             args.trigger = val;
           } else if (key === "advancement") {
@@ -19454,9 +19463,13 @@ var require_parser = __commonJS({
         this.expect("in");
         let start;
         let end;
+        let inclusive = false;
         if (this.check("range_lit")) {
           const rangeToken = this.advance();
-          const range = this.parseRangeValue(rangeToken.value);
+          const raw = rangeToken.value;
+          const incl = raw.includes("..=");
+          inclusive = incl;
+          const range = this.parseRangeValue(raw);
           start = this.withLoc({ kind: "int_lit", value: range.min ?? 0 }, rangeToken);
           if (range.max !== null && range.max !== void 0) {
             end = this.withLoc({ kind: "int_lit", value: range.max }, rangeToken);
@@ -19464,12 +19477,29 @@ var require_parser = __commonJS({
             end = this.parseUnaryExpr();
           }
         } else {
-          start = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
-          end = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
-          this.error("Dynamic range start requires a literal integer (e.g. 0..count)");
+          const arrayOrStart = this.parseExpr();
+          if (!this.check("range_lit")) {
+            const body2 = this.parseBlock();
+            return this.withLoc({ kind: "for_each", binding: varName, array: arrayOrStart, body: body2 }, forToken);
+          }
+          start = arrayOrStart;
+          if (this.check("range_lit")) {
+            const rangeOp = this.advance();
+            inclusive = rangeOp.value.includes("=");
+            const afterOp = rangeOp.value.replace(/^\.\.=?/, "");
+            if (afterOp.length > 0) {
+              end = this.withLoc({ kind: "int_lit", value: parseInt(afterOp, 10) }, rangeOp);
+            } else {
+              end = this.parseExpr();
+            }
+          } else {
+            this.error("Expected .. or ..= in for-range expression");
+            start = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
+            end = this.withLoc({ kind: "int_lit", value: 0 }, this.peek());
+          }
         }
         const body = this.parseBlock();
-        return this.withLoc({ kind: "for_range", varName, start, end, body }, forToken);
+        return this.withLoc({ kind: "for_range", varName, start, end, inclusive, body }, forToken);
       }
       parseForeachStmt() {
         const foreachToken = this.expect("foreach");
@@ -19490,23 +19520,51 @@ var require_parser = __commonJS({
         const body = this.parseBlock();
         return this.withLoc({ kind: "foreach", binding, iterable, body, executeContext }, foreachToken);
       }
+      parseMatchPattern() {
+        if (this.check("ident") && this.peek().value === "_") {
+          this.advance();
+          return { kind: "PatWild" };
+        }
+        if (this.check("ident") && this.peek().value === "None") {
+          this.advance();
+          return { kind: "PatNone" };
+        }
+        if (this.check("ident") && this.peek().value === "Some") {
+          this.advance();
+          this.expect("(");
+          const binding = this.expect("ident").value;
+          this.expect(")");
+          return { kind: "PatSome", binding };
+        }
+        if (this.check("int_lit")) {
+          const tok = this.advance();
+          return { kind: "PatInt", value: parseInt(tok.value, 10) };
+        }
+        if (this.check("-") && this.peek(1).kind === "int_lit") {
+          this.advance();
+          const tok = this.advance();
+          return { kind: "PatInt", value: -parseInt(tok.value, 10) };
+        }
+        const e = this.parseExpr();
+        return { kind: "PatExpr", expr: e };
+      }
       parseMatchStmt() {
         const matchToken = this.expect("match");
-        this.expect("(");
-        const expr = this.parseExpr();
-        this.expect(")");
+        let expr;
+        if (this.check("(")) {
+          this.advance();
+          expr = this.parseExpr();
+          this.expect(")");
+        } else {
+          expr = this.parseExpr();
+        }
         this.expect("{");
         const arms = [];
         while (!this.check("}") && !this.check("eof")) {
-          let pattern;
-          if (this.check("ident") && this.peek().value === "_") {
-            this.advance();
-            pattern = null;
-          } else {
-            pattern = this.parseExpr();
-          }
+          const pattern = this.parseMatchPattern();
           this.expect("=>");
           const body = this.parseBlock();
+          this.match(",");
           arms.push({ pattern, body });
         }
         this.expect("}");
@@ -19962,6 +20020,10 @@ var require_parser = __commonJS({
             sel: this.parseSelectorValue(token.value)
           }, token);
         }
+        if (token.kind === "ident" && this.peek(1).kind === "{" && this.peek(2).kind === "ident" && this.peek(3).kind === ":") {
+          this.advance();
+          return this.parseStructLit();
+        }
         if (token.kind === "ident" && token.value === "Some" && this.peek(1).kind === "(") {
           this.advance();
           this.advance();
@@ -20483,18 +20545,36 @@ var require_parser = __commonJS({
         return scores;
       }
       parseRangeValue(value) {
+        if (value.startsWith("..=")) {
+          const rest = value.slice(3);
+          if (!rest)
+            return {};
+          const max = parseInt(rest, 10);
+          return { max };
+        }
         if (value.startsWith("..")) {
-          const max = parseInt(value.slice(2), 10);
+          const rest = value.slice(2);
+          if (!rest)
+            return {};
+          const max = parseInt(rest, 10);
           return { max };
         }
-        if (value.endsWith("..")) {
-          const min = parseInt(value.slice(0, -2), 10);
-          return { min };
+        const inclIdx = value.indexOf("..=");
+        if (inclIdx !== -1) {
+          const min = parseInt(value.slice(0, inclIdx), 10);
+          const rest = value.slice(inclIdx + 3);
+          if (!rest)
+            return { min };
+          const max = parseInt(rest, 10);
+          return { min, max };
         }
         const dotIndex = value.indexOf("..");
         if (dotIndex !== -1) {
           const min = parseInt(value.slice(0, dotIndex), 10);
-          const max = parseInt(value.slice(dotIndex + 2), 10);
+          const rest = value.slice(dotIndex + 2);
+          if (!rest)
+            return { min };
+          const max = parseInt(rest, 10);
           return { min, max };
         }
         const val = parseInt(value, 10);
@@ -20714,6 +20794,20 @@ var require_lower = __commonJS({
         isLibrary: program.isLibrary
       };
     }
+    function lowerMatchPattern(pat) {
+      switch (pat.kind) {
+        case "PatSome":
+          return pat;
+        case "PatNone":
+          return pat;
+        case "PatInt":
+          return pat;
+        case "PatWild":
+          return pat;
+        case "PatExpr":
+          return { kind: "PatExpr", expr: lowerExpr(pat.expr) };
+      }
+    }
     function lowerGlobal(g) {
       return {
         name: g.name,
@@ -20822,7 +20916,7 @@ var require_lower = __commonJS({
             kind: "while",
             cond: {
               kind: "binary",
-              op: "<",
+              op: stmt.inclusive ? "<=" : "<",
               left: { kind: "ident", name: varName },
               right: lowerExpr(stmt.end)
             },
@@ -20883,6 +20977,71 @@ var require_lower = __commonJS({
           };
           return [initStmt, whileStmt];
         }
+        // --- Desugaring: for_each → let __for_len = arr.len(); let __for_i = 0; while(__for_i < __for_len) { let item = arr[__for_i]; body; __for_i = __for_i + 1 } ---
+        case "for_each": {
+          const id = forEachCounter++;
+          const idxName = `__foreach_i_${id}`;
+          const lenName = `__foreach_len_${id}`;
+          const arrExpr = lowerExpr(stmt.array);
+          const lenInitStmt = {
+            kind: "let",
+            name: lenName,
+            type: { kind: "named", name: "int" },
+            init: {
+              kind: "invoke",
+              callee: { kind: "member", obj: arrExpr, field: "len" },
+              args: []
+            },
+            span: stmt.span
+          };
+          const idxInitStmt = {
+            kind: "let",
+            name: idxName,
+            type: { kind: "named", name: "int" },
+            init: { kind: "int_lit", value: 0 },
+            span: stmt.span
+          };
+          const bindingInit = {
+            kind: "let",
+            name: stmt.binding,
+            type: void 0,
+            init: {
+              kind: "index",
+              obj: arrExpr,
+              index: { kind: "ident", name: idxName }
+            },
+            span: stmt.span
+          };
+          const stepStmt = {
+            kind: "expr",
+            expr: {
+              kind: "assign",
+              target: idxName,
+              value: {
+                kind: "binary",
+                op: "+",
+                left: { kind: "ident", name: idxName },
+                right: { kind: "int_lit", value: 1 }
+              }
+            },
+            span: stmt.span
+          };
+          const body = [bindingInit, ...lowerBlock(stmt.body)];
+          const step = [stepStmt];
+          const whileStmt = {
+            kind: "while",
+            cond: {
+              kind: "binary",
+              op: "<",
+              left: { kind: "ident", name: idxName },
+              right: { kind: "ident", name: lenName }
+            },
+            body,
+            step,
+            span: stmt.span
+          };
+          return [lenInitStmt, idxInitStmt, whileStmt];
+        }
         case "foreach":
           return {
             kind: "foreach",
@@ -20897,7 +21056,7 @@ var require_lower = __commonJS({
             kind: "match",
             expr: lowerExpr(stmt.expr),
             arms: stmt.arms.map((arm) => ({
-              pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+              pattern: lowerMatchPattern(arm.pattern),
               body: lowerBlock(arm.body)
             })),
             span: stmt.span
@@ -20956,6 +21115,7 @@ var require_lower = __commonJS({
     function lowerExecuteSubcommand(sub) {
       return sub;
     }
+    var forEachCounter = 0;
     var COMPOUND_TO_BINOP = {
       "+=": "+",
       "-=": "-",
@@ -21323,10 +21483,15 @@ var require_monomorphize = __commonJS({
             return {
               ...stmt,
               expr: this.rewriteExpr(stmt.expr, ctx),
-              arms: stmt.arms.map((arm) => ({
-                pattern: arm.pattern ? this.rewriteExpr(arm.pattern, ctx) : null,
-                body: this.rewriteBlock(arm.body, ctx)
-              }))
+              arms: stmt.arms.map((arm) => {
+                let pattern;
+                if (arm.pattern.kind === "PatExpr") {
+                  pattern = { kind: "PatExpr", expr: this.rewriteExpr(arm.pattern.expr, ctx) };
+                } else {
+                  pattern = arm.pattern;
+                }
+                return { pattern, body: this.rewriteBlock(arm.body, ctx) };
+              })
             };
           case "execute":
             return { ...stmt, body: this.rewriteBlock(stmt.body, ctx) };
@@ -21874,15 +22039,40 @@ var require_lower2 = __commonJS({
         }
         ctx.structVars.set("self", { typeName, fields: selfFields });
         for (let i = 1; i < method.params.length; i++) {
-          const t = ctx.freshTemp();
-          params.push({ name: t, isMacroParam: false });
-          scope.set(method.params[i].name, t);
+          const p = method.params[i];
+          const paramTypeName = p.type.kind === "named" ? p.type.name : p.type.kind === "struct" ? p.type.name : null;
+          const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null;
+          if (paramFields && paramFields.length > 0) {
+            const paramFieldTemps = /* @__PURE__ */ new Map();
+            for (const fieldName of paramFields) {
+              const t = ctx.freshTemp();
+              params.push({ name: t, isMacroParam: false });
+              paramFieldTemps.set(fieldName, t);
+            }
+            ctx.structVars.set(p.name, { typeName: paramTypeName, fields: paramFieldTemps });
+          } else {
+            const t = ctx.freshTemp();
+            params.push({ name: t, isMacroParam: false });
+            scope.set(p.name, t);
+          }
         }
       } else {
         for (const p of method.params) {
-          const t = ctx.freshTemp();
-          params.push({ name: t, isMacroParam: false });
-          scope.set(p.name, t);
+          const paramTypeName = p.type.kind === "named" ? p.type.name : p.type.kind === "struct" ? p.type.name : null;
+          const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null;
+          if (paramFields && paramFields.length > 0) {
+            const paramFieldTemps = /* @__PURE__ */ new Map();
+            for (const fieldName of paramFields) {
+              const t = ctx.freshTemp();
+              params.push({ name: t, isMacroParam: false });
+              paramFieldTemps.set(fieldName, t);
+            }
+            ctx.structVars.set(p.name, { typeName: paramTypeName, fields: paramFieldTemps });
+          } else {
+            const t = ctx.freshTemp();
+            params.push({ name: t, isMacroParam: false });
+            scope.set(p.name, t);
+          }
         }
       }
       lowerBlock(method.body, ctx, scope);
@@ -21978,10 +22168,26 @@ var require_lower2 = __commonJS({
             const typeName = stmt.type?.kind === "struct" ? stmt.type.name : "__anon";
             const fieldTemps = /* @__PURE__ */ 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") {
+                const nestedVarName = `${stmt.name}.${field.name}`;
+                const nestedTypeName = "__anon";
+                const nestedFieldTemps = /* @__PURE__ */ 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 });
+                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 });
           } else if (stmt.type?.kind === "option") {
@@ -22031,25 +22237,33 @@ var require_lower2 = __commonJS({
           } else if (stmt.init.kind === "array_lit") {
             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;
             const allConst = elems.every((e) => e.kind === "int_lit");
             if (allConst) {
               const vals = elems.map((e) => e.value).join(", ");
               ctx.emit({ kind: "call", dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] });
             } else {
-              const zeros = elems.map(() => "0").join(", ");
-              ctx.emit({ kind: "call", dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] });
+              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;
                 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 });
               }
             }
             const lenTemp = ctx.freshTemp();
             ctx.emit({ kind: "const", dst: lenTemp, value: elems.length });
             scope.set(stmt.name, lenTemp);
+          } else if (stmt.type?.kind === "array") {
+            const ns = `${ctx.getNamespace()}:arrays`;
+            const pathPrefix = stmt.name;
+            ctx.arrayVars.set(stmt.name, { ns, pathPrefix });
+            lowerExpr(stmt.init, ctx, scope);
+            const lenTemp = ctx.freshTemp();
+            ctx.emit({ kind: "const", dst: lenTemp, value: 0 });
+            scope.set(stmt.name, lenTemp);
           } else {
             const valOp = lowerExpr(stmt.init, ctx, scope);
             const t = ctx.freshTemp();
@@ -22268,47 +22482,74 @@ var require_lower2 = __commonJS({
           break;
         }
         case "match": {
-          const matchVal = lowerExpr(stmt.expr, ctx, scope);
           const mergeBlock = ctx.newBlock("match_merge");
+          const hasOptionPats = stmt.arms.some((a) => a.pattern.kind === "PatSome" || a.pattern.kind === "PatNone");
+          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 {
+                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;
+            }
+          }
+          const matchVal = hasOptionPats ? optHasOp : lowerExpr(stmt.expr, ctx, scope);
           for (let i = 0; i < stmt.arms.length; i++) {
             const arm = stmt.arms[i];
-            if (arm.pattern === null) {
+            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 });
               }
-            } else if (arm.pattern.kind === "range_lit") {
-              const range = arm.pattern.range;
+            } else if (pat.kind === "PatNone") {
+              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");
-              const checks = [];
-              if (range.min !== void 0)
-                checks.push({ op: "ge", bound: range.min });
-              if (range.max !== void 0)
-                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.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);
-            } else {
-              const patOp = lowerExpr(arm.pattern, ctx, scope);
+            } else if (pat.kind === "PatSome") {
               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: 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);
+              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 });
@@ -22318,6 +22559,50 @@ var require_lower2 = __commonJS({
                 ctx.terminate({ kind: "jump", target: mergeBlock.id });
               }
               ctx.switchTo(nextArm);
+            } else if (pat.kind === "PatExpr") {
+              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 !== void 0)
+                  checks.push({ op: "ge", bound: range.min });
+                if (range.max !== void 0)
+                  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 (isPlaceholderTerm(ctx.current().term)) {
@@ -22571,6 +22856,15 @@ var require_lower2 = __commonJS({
                 return { kind: "temp", name: fieldTemp };
             }
           }
+          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 };
+            }
+          }
           const obj = lowerExpr(expr.obj, ctx, scope);
           const t = ctx.freshTemp();
           ctx.emit({ kind: "copy", dst: t, src: obj });
@@ -22613,15 +22907,35 @@ var require_lower2 = __commonJS({
           return valOp;
         }
         case "call": {
+          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 !== void 0) {
+                const t3 = ctx.freshTemp();
+                ctx.emit({ kind: "const", dst: t3, value: arrInfo.knownLen });
+                return { kind: "temp", name: t3 };
+              }
+              const t2 = ctx.freshTemp();
+              ctx.emit({ kind: "nbt_list_len", dst: t2, ns: arrInfo.ns, path: arrInfo.pathPrefix });
+              return { kind: "temp", name: t2 };
+            }
+            const lenTemp = scope.get(arrName);
+            if (lenTemp !== void 0) {
+              return { kind: "temp", name: lenTemp };
+            }
+          }
           if (expr.fn === "scoreboard_get" || expr.fn === "score") {
-            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 t2 = ctx.freshTemp();
             ctx.emit({ kind: "score_read", dst: t2, player, obj });
             return { kind: "temp", name: t2 };
           }
           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 });
@@ -22629,6 +22943,82 @@ var require_lower2 = __commonJS({
             ctx.emit({ kind: "const", dst: t2, value: 0 });
             return { kind: "temp", name: t2 };
           }
+          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 t2 = ctx.freshTemp();
+            ctx.emit({ kind: "const", dst: t2, value: 0 });
+            return { kind: "temp", name: t2 };
+          }
+          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 t2 = ctx.freshTemp();
+            if (indexOp.kind === "const") {
+              ctx.emit({ kind: "nbt_read", dst: t2, ns: storagePath, path: `${fieldName}[${indexOp.value}]`, scale: 1 });
+            } else {
+              ctx.emit({ kind: "nbt_read_dynamic", dst: t2, ns: storagePath, pathPrefix: fieldName, indexSrc: indexOp });
+            }
+            return { kind: "temp", name: t2 };
+          }
+          if (expr.fn === "__entity_tag" || expr.fn === "__entity_untag") {
+            const selArg = expr.args[0];
+            const tagArg = expr.args[1];
+            const tagStr = tagArg.kind === "str_lit" ? tagArg.value : "unknown";
+            const selStr = selArg.kind === "selector" ? selectorToString(selArg.sel ?? selArg) : "@s";
+            const op = expr.fn === "__entity_tag" ? "add" : "remove";
+            const t2 = ctx.freshTemp();
+            ctx.emit({ kind: "call", dst: null, fn: `__raw:tag ${selStr} ${op} ${tagStr}`, args: [] });
+            ctx.emit({ kind: "const", dst: t2, value: 0 });
+            return { kind: "temp", name: t2 };
+          }
+          if (expr.fn === "__entity_has_tag") {
+            const tagArg = expr.args[1];
+            const tagStr = tagArg.kind === "str_lit" ? tagArg.value : "unknown";
+            const selArg = expr.args[0];
+            const selStr = selArg.kind === "selector" ? selectorToString(selArg.sel ?? selArg) : "@s";
+            const t2 = ctx.freshTemp();
+            const ns = ctx.getNamespace();
+            ctx.emit({ kind: "call", dst: t2, fn: `__raw:execute store success score $ret __${ns} if entity ${selStr}[tag=${tagStr}]`, args: [] });
+            return { kind: "temp", name: t2 };
+          }
+          if (expr.fn === "__array_push") {
+            if (expr.args[0].kind === "ident") {
+              const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+              if (arrInfo) {
+                const valOp = lowerExpr(expr.args[1], ctx, scope);
+                ctx.emit({ kind: "call", dst: null, fn: `__raw:data modify storage ${arrInfo.ns} ${arrInfo.pathPrefix} append value 0`, args: [] });
+                ctx.emit({ kind: "nbt_write", ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[-1]`, type: "int", scale: 1, src: valOp });
+                const t2 = ctx.freshTemp();
+                ctx.emit({ kind: "const", dst: t2, value: 0 });
+                return { kind: "temp", name: t2 };
+              }
+            }
+          }
+          if (expr.fn === "__array_pop") {
+            if (expr.args[0].kind === "ident") {
+              const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+              if (arrInfo) {
+                ctx.emit({ kind: "call", dst: null, fn: `__raw:data remove storage ${arrInfo.ns} ${arrInfo.pathPrefix}[-1]`, args: [] });
+                const t2 = ctx.freshTemp();
+                ctx.emit({ kind: "const", dst: t2, value: 0 });
+                return { kind: "temp", name: t2 };
+              }
+            }
+          }
+          if (expr.fn === "__array_length") {
+            if (expr.args[0].kind === "ident") {
+              const arrInfo = ctx.arrayVars.get(expr.args[0].name);
+              if (arrInfo) {
+                const t2 = ctx.freshTemp();
+                ctx.emit({ kind: "nbt_read", dst: t2, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}`, scale: 1 });
+                return { kind: "temp", name: t2 };
+              }
+            }
+          }
           if (expr.fn === "list_push") {
             if (expr.args[0].kind === "ident") {
               const arrInfo = ctx.arrayVars.get(expr.args[0].name);
@@ -22712,7 +23102,7 @@ var require_lower2 = __commonJS({
             return { kind: "temp", name: t2 };
           }
           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 t2 = ctx.freshTemp();
             ctx.emit({ kind: "const", dst: t2, value: 0 });
@@ -22735,7 +23125,21 @@ var require_lower2 = __commonJS({
                   const temp = sv.fields.get(f);
                   return temp ? { kind: "temp", name: temp } : { kind: "const", value: 0 };
                 });
-                const explicitArgs = expr.args.slice(1).map((a) => lowerExpr(a, ctx, scope));
+                const explicitArgs = [];
+                for (const argExpr of expr.args.slice(1)) {
+                  if (argExpr.kind === "ident") {
+                    const argSv = ctx.structVars.get(argExpr.name);
+                    if (argSv) {
+                      const argFields = ctx.structDefs.get(argSv.typeName) ?? [];
+                      for (const fieldName of argFields) {
+                        const ft = argSv.fields.get(fieldName);
+                        explicitArgs.push(ft ? { kind: "temp", name: ft } : { kind: "const", value: 0 });
+                      }
+                      continue;
+                    }
+                  }
+                  explicitArgs.push(lowerExpr(argExpr, ctx, scope));
+                }
                 const allArgs = [...selfArgs, ...explicitArgs];
                 const t2 = ctx.freshTemp();
                 ctx.emit({ kind: "call", dst: t2, fn: `${sv.typeName}::${expr.fn}`, args: allArgs });
@@ -22841,6 +23245,23 @@ var require_lower2 = __commonJS({
           return { kind: "temp", name: t };
         }
         case "invoke": {
+          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 !== void 0) {
+                const t3 = ctx.freshTemp();
+                ctx.emit({ kind: "const", dst: t3, value: arrInfo.knownLen });
+                return { kind: "temp", name: t3 };
+              }
+              const t2 = ctx.freshTemp();
+              ctx.emit({ kind: "nbt_list_len", dst: t2, ns: arrInfo.ns, path: arrInfo.pathPrefix });
+              return { kind: "temp", name: t2 };
+            }
+            const lenTemp = scope.get(expr.callee.obj.name);
+            if (lenTemp !== void 0) {
+              return { kind: "temp", name: lenTemp };
+            }
+          }
           if (expr.callee.kind === "member" && expr.callee.obj.kind === "ident") {
             const sv = ctx.structVars.get(expr.callee.obj.name);
             if (sv) {
@@ -23158,7 +23579,39 @@ var require_lower2 = __commonJS({
       return `${sel.kind}[${parts.join(",")}]`;
     }
     var MACRO_SENTINEL = "
";
-    function formatBuiltinCall(fn, args, macroParams) {
+    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 {
+          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 = "") {
+      const TEXT_BUILTINS = /* @__PURE__ */ 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);
@@ -23212,24 +23665,34 @@ var require_lower2 = __commonJS({
           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"}`;
@@ -23268,6 +23731,13 @@ var require_lower2 = __commonJS({
         case "tag_remove":
           cmd = `tag ${strs[0]} remove ${strs[1]}`;
           break;
+        // entity.tag(name) / entity.untag(name) sugar — same as tag_add/tag_remove
+        case "__entity_tag":
+          cmd = `tag ${strs[0]} add ${strs[1]}`;
+          break;
+        case "__entity_untag":
+          cmd = `tag ${strs[0]} remove ${strs[1]}`;
+          break;
         case "kick":
           cmd = `kick ${strs[0]} ${strs[1] ?? ""}`.trim();
           break;
@@ -24266,6 +24736,10 @@ var require_interprocedural = __commonJS({
           return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
         case "nbt_write":
           return { ...instr, src: substituteOp(instr.src, sub) };
+        case "nbt_read_dynamic":
+          return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub) };
+        case "nbt_write_dynamic":
+          return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) };
         case "call":
           return { ...instr, args: instr.args.map((a) => substituteOp(a, sub)) };
         case "call_macro":
@@ -24722,6 +25196,12 @@ var require_lower3 = __commonJS({
           });
           break;
         }
+        case "nbt_list_len": {
+          const dst = ctx.slot(instr.dst);
+          const ns = ctx.namespace;
+          instrs.push({ kind: "raw", cmd: `execute store result score ${dst} __${ns} run data get storage ${instr.ns} ${instr.path}` });
+          break;
+        }
         case "nbt_read_dynamic": {
           const dst = ctx.slot(instr.dst);
           const idxSlot = operandToSlot(instr.indexSrc, ctx, instrs);
@@ -25442,6 +25922,24 @@ var require_emit = __commonJS({
           content: JSON.stringify({ values: tickValues }, null, 2) + "\n"
         });
       }
+      const EVENT_TAG_NAMES = {
+        PlayerJoin: "on_player_join",
+        PlayerDeath: "on_player_death",
+        EntityKill: "on_entity_kill",
+        ItemUse: "on_item_use",
+        BlockBreak: "on_block_break"
+      };
+      if (options.eventHandlers) {
+        for (const [evType, handlers] of options.eventHandlers) {
+          const tagName = EVENT_TAG_NAMES[evType];
+          if (tagName && handlers.length > 0) {
+            files.push({
+              path: `data/rs/tags/function/${tagName}.json`,
+              content: JSON.stringify({ values: handlers }, null, 2) + "\n"
+            });
+          }
+        }
+      }
       return files;
     }
     function emitFunction(fn, namespace, objective, mcVersion) {
@@ -25649,15 +26147,17 @@ var require_coroutine = __commonJS({
       }
       const loopHeaders = new Set(backEdges.map((e) => e.target));
       const continuations = partitionIntoContinuations(fn, loopHeaders, backEdges);
+      const dispatcherName = `${prefix}_tick`;
+      const pcPlayer = `$${dispatcherName}_${pcTemp}`;
       const contFunctions = [];
       for (let i = 0; i < continuations.length; i++) {
         const contId = i + 1;
         const cont = continuations[i];
-        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name);
+        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name, pcPlayer);
         contFunctions.push(contFn);
       }
-      const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective);
-      const dispatcher = buildDispatcher(`${prefix}_tick`, contFunctions, pcTemp, objective, fn.name);
+      const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective, pcPlayer);
+      const dispatcher = buildDispatcher(dispatcherName, contFunctions, pcTemp, objective, fn.name);
       return { initFn, continuations: contFunctions, dispatcher };
     }
     function computeDominators(blocks, entry) {
@@ -25869,14 +26369,14 @@ var require_coroutine = __commonJS({
       }
       return conts;
     }
-    function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName) {
+    function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName, pcPlayer) {
       if (cont.isLoopBody) {
-        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone);
+        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer);
       } else {
-        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone);
+        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer);
       }
     }
-    function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone) {
+    function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer) {
       const blocks = [];
       const batchCmpTemp = `${batchCountTemp}_cmp`;
       const entryBlock = {
@@ -25929,7 +26429,9 @@ var require_coroutine = __commonJS({
             const exitBlockId = `${block.id}_exit`;
             const exitBlock = {
               id: exitBlockId,
-              instrs: [],
+              instrs: [
+                { kind: "score_write", player: pcPlayer, obj: objective, src: { kind: "const", value: contId + 1 } }
+              ],
               term: { kind: "return", value: null },
               preds: [block.id]
             };
@@ -25975,23 +26477,23 @@ var require_coroutine = __commonJS({
         isMacro: false
       };
     }
-    function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone) {
+    function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer) {
       const blocks = [];
       for (const block of cont.blocks) {
         blocks.push(rewriteBlock(block, promoted));
       }
       const entry = cont.blocks[0]?.id ?? "entry";
-      if (onDone) {
-        for (let i = 0; i < blocks.length; i++) {
-          if (blocks[i].term.kind === "return") {
-            blocks[i] = {
-              ...blocks[i],
-              instrs: [
-                ...blocks[i].instrs,
-                { kind: "call", dst: null, fn: onDone, args: [] }
-              ]
-            };
-          }
+      for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i].term.kind === "return") {
+          const extraInstrs = [];
+          if (onDone) {
+            extraInstrs.push({ kind: "call", dst: null, fn: onDone, args: [] });
+          }
+          extraInstrs.push({ kind: "score_write", player: pcPlayer, obj: objective, src: { kind: "const", value: 0 } });
+          blocks[i] = {
+            ...blocks[i],
+            instrs: [...blocks[i].instrs, ...extraInstrs]
+          };
         }
       }
       return {
@@ -26002,15 +26504,31 @@ var require_coroutine = __commonJS({
         isMacro: false
       };
     }
-    function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective) {
+    function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective, pcPlayer) {
       const instrs = [];
-      instrs.push({ kind: "const", dst: pcTemp, value: 1 });
+      instrs.push({ kind: "score_write", player: pcPlayer, obj: objective, src: { kind: "const", value: 1 } });
+      const dispatcherName = `${prefix}_cont_1`;
       const entryBlock = originalFn.blocks.find((b) => b.id === originalFn.entry);
       if (entryBlock) {
         for (const instr of entryBlock.instrs) {
           const dst = getDst(instr);
           if (dst && promoted.has(dst)) {
-            instrs.push(rewriteInstr(instr, promoted));
+            const promotedTemp = promoted.get(dst);
+            const player = `$${dispatcherName}_${promotedTemp}`;
+            if (instr.kind === "const") {
+              instrs.push({ kind: "score_write", player, obj: objective, src: { kind: "const", value: instr.value } });
+            } else if (instr.kind === "copy") {
+              let src;
+              if (instr.src.kind === "temp") {
+                const srcTemp = promoted.get(instr.src.name) ?? instr.src.name;
+                src = { kind: "temp", name: srcTemp };
+              } else {
+                src = instr.src;
+              }
+              instrs.push({ kind: "score_write", player, obj: objective, src });
+            } else {
+              instrs.push(rewriteInstr(instr, promoted));
+            }
           }
         }
       }
@@ -26078,12 +26596,15 @@ var require_coroutine = __commonJS({
     }
     function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
       const contName = `${prefix}_cont_1`;
+      const dispatcherName = `${prefix}_tick`;
+      const pcPlayer = `$${dispatcherName}_${pcTemp}`;
       const contBlocks = fn.blocks.map((block) => {
         if (block.term.kind === "return") {
           const instrs = [...block.instrs];
           if (info.onDone) {
             instrs.push({ kind: "call", dst: null, fn: info.onDone, args: [] });
           }
+          instrs.push({ kind: "score_write", player: pcPlayer, obj: objective, src: { kind: "const", value: 0 } });
           return { ...block, instrs };
         }
         return block;
@@ -26098,7 +26619,7 @@ var require_coroutine = __commonJS({
       const initBlock = {
         id: "entry",
         instrs: [
-          { kind: "const", dst: pcTemp, value: 1 }
+          { kind: "score_write", player: pcPlayer, obj: objective, src: { kind: "const", value: 1 } }
         ],
         term: { kind: "return", value: null },
         preds: []
@@ -26110,7 +26631,7 @@ var require_coroutine = __commonJS({
         entry: "entry",
         isMacro: fn.isMacro
       };
-      const dispatcher = buildDispatcher(`${prefix}_tick`, [contFn], pcTemp, objective, fn.name);
+      const dispatcher = buildDispatcher(dispatcherName, [contFn], pcTemp, objective, fn.name);
       return { initFn, continuations: [contFn], dispatcher };
     }
     function rewriteBlock(block, promoted) {
@@ -26151,6 +26672,10 @@ var require_coroutine = __commonJS({
           return { ...instr, src: rOp(instr.src) };
         case "nbt_write_dynamic":
           return { ...instr, indexSrc: rOp(instr.indexSrc), valueSrc: rOp(instr.valueSrc) };
+        case "score_read":
+          return { ...instr, dst: rTemp(instr.dst) };
+        case "score_write":
+          return { ...instr, src: rOp(instr.src) };
         case "call":
           return { ...instr, dst: instr.dst ? rTemp(instr.dst) : null, args: instr.args.map(rOp) };
         case "call_macro":
@@ -26234,6 +26759,9 @@ var require_coroutine = __commonJS({
         case "nbt_read_dynamic":
           addOp(instr.indexSrc);
           break;
+        case "score_write":
+          addOp(instr.src);
+          break;
         case "call":
           instr.args.forEach(addOp);
           break;
@@ -26484,8 +27012,11 @@ var require_types = __commonJS({
       },
       BlockBreak: {
         tag: "rs.just_broke_block",
-        params: ["player: Player", "block: string"],
+        params: ["player: Player"],
         detection: "advancement"
+        // Note: block type is NOT available as a runtime parameter — MC has no mechanism
+        // to pass event data to function tags. Use minecraft.mined:<block> scoreboard
+        // stats for per-block detection, or check the block at player's position in handler.
       },
       EntityKill: {
         tag: "rs.just_killed",
@@ -26869,13 +27400,13 @@ var require_typechecker = __commonJS({
           case "match":
             this.checkExpr(stmt.expr);
             for (const arm of stmt.arms) {
-              if (arm.pattern) {
-                this.checkExpr(arm.pattern);
+              if (arm.pattern.kind === "PatExpr") {
+                this.checkExpr(arm.pattern.expr);
                 const subjectType = this.inferType(stmt.expr);
-                const patternType = this.inferType(arm.pattern);
+                const patternType = this.inferType(arm.pattern.expr);
                 const isUnknown = (t) => t.kind === "named" && t.name === "void";
                 if (!isUnknown(subjectType) && !isUnknown(patternType) && !this.typesMatch(subjectType, patternType)) {
-                  this.report("Match arm pattern type must match subject type", arm.pattern);
+                  this.report("Match arm pattern type must match subject type", arm.pattern.expr);
                 }
               }
               this.checkBlock(arm.body);
@@ -27014,6 +27545,11 @@ var require_typechecker = __commonJS({
             if (arithmeticOps.includes(expr.op)) {
               const leftType = this.inferType(expr.left);
               const rightType = this.inferType(expr.right);
+              const leftIsString = leftType.kind === "named" && (leftType.name === "string" || leftType.name === "format_string");
+              const rightIsString = rightType.kind === "named" && (rightType.name === "string" || rightType.name === "format_string");
+              if (leftIsString || rightIsString) {
+                this.report(`[StringConcat] String concatenation with '+' is not supported. Use f-strings instead: f"text{variable}" \u2014 e.g. f"Score: {score}"`, expr);
+              }
               const leftIsFloat = leftType.kind === "named" && leftType.name === "float";
               const rightIsFloat = rightType.kind === "named" && rightType.name === "float";
               if (leftIsFloat || rightIsFloat) {
@@ -27078,7 +27614,7 @@ var require_typechecker = __commonJS({
               this.checkExpr(part.expr);
               const partType = this.inferType(part.expr);
               const isUnknown = partType.kind === "named" && partType.name === "void";
-              if (!isUnknown && !(partType.kind === "named" && (partType.name === "int" || partType.name === "string" || partType.name === "format_string"))) {
+              if (!isUnknown && !(partType.kind === "named" && ["int", "string", "format_string", "fixed", "double", "bool", "byte", "short", "long"].includes(partType.name))) {
                 this.report(`f-string placeholder must be int or string, got ${this.typeToString(partType)}`, part.expr);
               }
             }
@@ -27764,6 +28300,7 @@ var require_compile2 = __commonJS({
     var budget_1 = require_budget();
     var mc_version_1 = require_mc_version();
     var typechecker_1 = require_typechecker();
+    var types_1 = require_types();
     function compile(source, options = {}) {
       const { namespace = "redscript", filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false, includeDirs } = options;
       const warnings = [];
@@ -27824,6 +28361,7 @@ var require_compile2 = __commonJS({
         const loadFunctions = [];
         const coroutineInfos = [];
         const scheduleFunctions = [];
+        const eventHandlers = /* @__PURE__ */ new Map();
         for (const fn of hir.functions) {
           for (const dec of fn.decorators) {
             if (dec.name === "tick")
@@ -27840,6 +28378,14 @@ var require_compile2 = __commonJS({
             if (dec.name === "schedule") {
               scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
             }
+            if (dec.name === "on" && dec.args?.eventType) {
+              const evType = dec.args.eventType;
+              if ((0, types_1.isEventTypeName)(evType)) {
+                if (!eventHandlers.has(evType))
+                  eventHandlers.set(evType, []);
+                eventHandlers.get(evType).push(`${namespace}:${fn.name}`);
+              }
+            }
           }
         }
         const mir = (0, lower_2.lowerToMIR)(hir, filePath);
@@ -27867,7 +28413,7 @@ var require_compile2 = __commonJS({
             }
           }
         }
-        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion, eventHandlers });
         return { files, warnings, success: true };
       } catch (err) {
         if (err instanceof diagnostics_1.DiagnosticError)
@@ -28208,8 +28754,8 @@ var require_modules = __commonJS({
         case "match":
           rewriteExpr(stmt.expr, symbolMap);
           for (const arm of stmt.arms) {
-            if (arm.pattern)
-              rewriteExpr(arm.pattern, symbolMap);
+            if (arm.pattern.kind === "PatExpr")
+              rewriteExpr(arm.pattern.expr, symbolMap);
             rewriteBlock(arm.body, symbolMap);
           }
           break;
@@ -30627,9 +31173,16 @@ function getCompile() {
 var DEBOUNCE_MS = 600;
 var lspClient;
 function resolveLspServerPath() {
+  const fs2 = require("fs");
+  try {
+    const bundled = path2.join(__dirname, "lsp-server.js");
+    fs2.accessSync(bundled);
+    return bundled;
+  } catch {
+  }
   try {
     const candidate = path2.join(__dirname, "..", "node_modules", "redscript", "dist", "src", "lsp", "main.js");
-    require("fs").accessSync(candidate);
+    fs2.accessSync(candidate);
     return candidate;
   } catch {
     return null;
@@ -30659,9 +31212,9 @@ function activate(context) {
     context.subscriptions.push({ dispose: () => lspClient?.stop() });
   } else {
     activateFallbackDiagnostics(context);
+    registerHoverProvider(context);
+    registerCompletionProvider(context);
   }
-  registerHoverProvider(context);
-  registerCompletionProvider(context);
   registerCodeActions(context);
   registerSymbolProviders(context);
   const statusBar = vscode5.window.createStatusBarItem(vscode5.StatusBarAlignment.Left, 10);