redscript-mc 2.6.0 → 3.0.0

package/editors/vscode/out/extension.js

@@ -18107,7 +18107,7 @@ var require_diagnostics = __commonJS({
   "../../dist/src/diagnostics/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DiagnosticCollector = exports2.DiagnosticError = void 0;
+    exports2.DiagnosticCollector = exports2.CheckFailedError = exports2.DiagnosticBundleError = exports2.DiagnosticError = void 0;
     exports2.parseErrorMessage = parseErrorMessage;
     exports2.formatError = formatError;
     function formatSourcePointer(sourceLines, line, col) {
@@ -18164,6 +18164,23 @@ var require_diagnostics = __commonJS({
       }
     };
     exports2.DiagnosticError = DiagnosticError;
+    var DiagnosticBundleError = class extends Error {
+      constructor(diagnostics) {
+        super(diagnostics[0]?.message ?? "Multiple diagnostics");
+        this.name = "DiagnosticBundleError";
+        this.diagnostics = diagnostics;
+      }
+    };
+    exports2.DiagnosticBundleError = DiagnosticBundleError;
+    var CheckFailedError = class extends Error {
+      constructor(diagnostics, warnings) {
+        super(diagnostics[0]?.message ?? "Check failed");
+        this.name = "CheckFailedError";
+        this.diagnostics = diagnostics;
+        this.warnings = warnings;
+      }
+    };
+    exports2.CheckFailedError = CheckFailedError;
     var DiagnosticCollector = class {
       constructor(source, filePath) {
         this.diagnostics = [];
@@ -18241,6 +18258,8 @@ var require_lexer = __commonJS({
       while: "while",
       for: "for",
       foreach: "foreach",
+      do: "do",
+      repeat: "repeat",
       match: "match",
       return: "return",
       break: "break",
@@ -18260,6 +18279,8 @@ var require_lexer = __commonJS({
       unless: "unless",
       declare: "declare",
       export: "export",
+      import: "import",
+      interface: "interface",
       int: "int",
       bool: "bool",
       float: "float",
@@ -18410,6 +18431,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();
           }
@@ -18499,7 +18523,13 @@ var require_lexer = __commonJS({
           return;
         }
         if (char === '"') {
-          this.scanString(startLine, startCol);
+          if (this.peek() === '"' && this.peek(1) === '"') {
+            this.advance();
+            this.advance();
+            this.scanMultiLineString(startLine, startCol);
+          } else {
+            this.scanString(startLine, startCol);
+          }
           return;
         }
         if (char === "#") {
@@ -18573,6 +18603,28 @@ var require_lexer = __commonJS({
         }
         return result;
       }
+      scanMultiLineString(startLine, startCol) {
+        let value = "";
+        while (!this.isAtEnd()) {
+          if (this.peek() === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
+            this.advance();
+            this.advance();
+            this.advance();
+            break;
+          }
+          if (this.peek() === "\\" && this.peek(1) === '"') {
+            this.advance();
+            value += this.advance();
+            continue;
+          }
+          value += this.advance();
+        }
+        if (value.startsWith("\n"))
+          value = value.slice(1);
+        if (value.endsWith("\n"))
+          value = value.slice(0, -1);
+        this.addToken("string_lit", value, startLine, startCol);
+      }
       scanString(startLine, startCol) {
         let value = "";
         let interpolationDepth = 0;
@@ -18662,6 +18714,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();
           }
@@ -18828,6 +18883,7 @@ var require_parser = __commonJS({
         this.pos = 0;
         this.inLibraryMode = false;
         this.warnings = [];
+        this.parseErrors = [];
         this.tokens = tokens;
         this.sourceLines = source?.split("\n") ?? [];
         this.filePath = filePath;
@@ -18889,6 +18945,60 @@ var require_parser = __commonJS({
         return { kind: "eof", value: "", line: span.line, col: span.col };
       }
       // -------------------------------------------------------------------------
+      // Error Recovery
+      // -------------------------------------------------------------------------
+      /**
+       * Synchronize to the next top-level declaration boundary after a parse error.
+       * Skips tokens until we find a keyword that starts a top-level declaration,
+       * or a `}` (end of a block), or EOF.
+       */
+      syncToNextDecl() {
+        const TOP_LEVEL_KEYWORDS = /* @__PURE__ */ new Set([
+          "fn",
+          "struct",
+          "impl",
+          "enum",
+          "const",
+          "let",
+          "export",
+          "declare",
+          "import",
+          "namespace",
+          "module"
+        ]);
+        while (!this.check("eof")) {
+          const kind = this.peek().kind;
+          if (kind === "}") {
+            this.advance();
+            return;
+          }
+          if (TOP_LEVEL_KEYWORDS.has(kind)) {
+            return;
+          }
+          if (kind === "ident" && this.peek().value === "import") {
+            return;
+          }
+          this.advance();
+        }
+      }
+      /**
+       * Synchronize to the next statement boundary inside a block after a parse error.
+       * Skips tokens until we reach `;`, `}`, or EOF.
+       */
+      syncToNextStmt() {
+        while (!this.check("eof")) {
+          const kind = this.peek().kind;
+          if (kind === ";") {
+            this.advance();
+            return;
+          }
+          if (kind === "}") {
+            return;
+          }
+          this.advance();
+        }
+      }
+      // -------------------------------------------------------------------------
       // Program
       // -------------------------------------------------------------------------
       parse(defaultNamespace = "redscript") {
@@ -18900,6 +19010,7 @@ var require_parser = __commonJS({
         const enums = [];
         const consts = [];
         const imports = [];
+        const interfaces = [];
         let isLibrary = false;
         let moduleName;
         if (this.check("namespace")) {
@@ -18920,40 +19031,74 @@ var require_parser = __commonJS({
           this.match(";");
         }
         while (!this.check("eof")) {
-          if (this.check("let")) {
-            globals.push(this.parseGlobalDecl(true));
-          } else if (this.check("struct")) {
-            structs.push(this.parseStructDecl());
-          } else if (this.check("impl")) {
-            implBlocks.push(this.parseImplBlock());
-          } else if (this.check("enum")) {
-            enums.push(this.parseEnumDecl());
-          } else if (this.check("const")) {
-            consts.push(this.parseConstDecl());
-          } else if (this.check("declare")) {
-            this.advance();
-            this.parseDeclareStub();
-          } else if (this.check("export")) {
-            declarations.push(this.parseExportedFnDecl());
-          } else if (this.check("ident") && this.peek().value === "import") {
-            this.advance();
-            const importToken = this.peek();
-            const modName = this.expect("ident").value;
-            this.expect("::");
-            let symbol;
-            if (this.check("*")) {
+          try {
+            if (this.check("decorator") && this.peek().value.startsWith("@config")) {
+              const decorToken = this.advance();
+              const decorator = this.parseDecoratorValue(decorToken.value);
+              if (!this.check("let")) {
+                this.error("@config decorator must be followed by a let declaration");
+              }
+              const g = this.parseGlobalDecl(true);
+              g.configKey = decorator.args?.configKey;
+              g.configDefault = decorator.args?.configDefault;
+              globals.push(g);
+            } else if (this.check("let")) {
+              globals.push(this.parseGlobalDecl(true));
+            } else if (this.check("decorator") && this.peek().value === "@singleton") {
+              this.advance();
+              if (!this.check("struct")) {
+                this.error("@singleton decorator must be followed by a struct declaration");
+              }
+              const s = this.parseStructDecl();
+              s.isSingleton = true;
+              structs.push(s);
+            } else if (this.check("struct")) {
+              structs.push(this.parseStructDecl());
+            } else if (this.check("impl")) {
+              implBlocks.push(this.parseImplBlock());
+            } else if (this.check("interface")) {
+              interfaces.push(this.parseInterfaceDecl());
+            } else if (this.check("enum")) {
+              enums.push(this.parseEnumDecl());
+            } else if (this.check("const")) {
+              consts.push(this.parseConstDecl());
+            } else if (this.check("declare")) {
+              this.advance();
+              this.parseDeclareStub();
+            } else if (this.check("export")) {
+              declarations.push(this.parseExportedFnDecl());
+            } else if (this.check("import") || this.check("ident") && this.peek().value === "import") {
               this.advance();
-              symbol = "*";
+              const importToken = this.peek();
+              const modName = this.expect("ident").value;
+              if (this.check("::")) {
+                this.advance();
+                let symbol;
+                if (this.check("*")) {
+                  this.advance();
+                  symbol = "*";
+                } else {
+                  symbol = this.expect("ident").value;
+                }
+                this.match(";");
+                imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
+              } else {
+                this.match(";");
+                imports.push(this.withLoc({ moduleName: modName, symbol: void 0 }, importToken));
+              }
             } else {
-              symbol = this.expect("ident").value;
+              declarations.push(this.parseFnDecl());
+            }
+          } catch (err) {
+            if (err instanceof diagnostics_1.DiagnosticError) {
+              this.parseErrors.push(err);
+              this.syncToNextDecl();
+            } else {
+              throw err;
             }
-            this.match(";");
-            imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
-          } else {
-            declarations.push(this.parseFnDecl());
           }
         }
-        return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary };
+        return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, interfaces, isLibrary };
       }
       // -------------------------------------------------------------------------
       // Struct Declaration
@@ -18982,6 +19127,20 @@ var require_parser = __commonJS({
         while (!this.check("}") && !this.check("eof")) {
           const variantToken = this.expect("ident");
           const variant = { name: variantToken.value };
+          if (this.check("(")) {
+            this.advance();
+            const fields = [];
+            while (!this.check(")") && !this.check("eof")) {
+              const fieldName = this.expect("ident").value;
+              this.expect(":");
+              const fieldType = this.parseType();
+              fields.push({ name: fieldName, type: fieldType });
+              if (!this.match(","))
+                break;
+            }
+            this.expect(")");
+            variant.fields = fields;
+          }
           if (this.match("=")) {
             const valueToken = this.expect("int_lit");
             variant.value = parseInt(valueToken.value, 10);
@@ -18999,14 +19158,72 @@ var require_parser = __commonJS({
       }
       parseImplBlock() {
         const implToken = this.expect("impl");
-        const typeName = this.expect("ident").value;
+        let traitName;
+        let typeName;
+        const firstName = this.expect("ident").value;
+        if (this.match("for")) {
+          traitName = firstName;
+          typeName = this.expect("ident").value;
+        } else {
+          typeName = firstName;
+        }
         this.expect("{");
         const methods = [];
         while (!this.check("}") && !this.check("eof")) {
           methods.push(this.parseFnDecl(typeName));
         }
         this.expect("}");
-        return this.withLoc({ kind: "impl_block", typeName, methods }, implToken);
+        return this.withLoc({ kind: "impl_block", traitName, typeName, methods }, implToken);
+      }
+      /**
+       * Parse an interface declaration:
+       *   interface <Name> {
+       *     fn <method>(<params>): <retType>
+       *     ...
+       *   }
+       * Method signatures have no body — they are prototype-only.
+       */
+      parseInterfaceDecl() {
+        const ifaceToken = this.expect("interface");
+        const name = this.expect("ident").value;
+        this.expect("{");
+        const methods = [];
+        while (!this.check("}") && !this.check("eof")) {
+          const fnToken = this.expect("fn");
+          const methodName = this.expect("ident").value;
+          this.expect("(");
+          const params = this.parseInterfaceParams();
+          this.expect(")");
+          let returnType;
+          if (this.match(":")) {
+            returnType = this.parseType();
+          }
+          methods.push(this.withLoc({ name: methodName, params, returnType }, fnToken));
+        }
+        this.expect("}");
+        return this.withLoc({ name, methods }, ifaceToken);
+      }
+      /**
+       * Parse interface method params — like parseParams but allows bare `self`
+       * (no `:` required for the first param named 'self').
+       */
+      parseInterfaceParams() {
+        const params = [];
+        if (!this.check(")")) {
+          do {
+            const paramToken = this.expect("ident");
+            const paramName = paramToken.value;
+            let type;
+            if (params.length === 0 && paramName === "self" && !this.check(":")) {
+              type = { kind: "named", name: "void" };
+            } else {
+              this.expect(":");
+              type = this.parseType();
+            }
+            params.push(this.withLoc({ name: paramName, type }, paramToken));
+          } while (this.match(","));
+        }
+        return params;
       }
       parseConstDecl() {
         const constToken = this.expect("const");
@@ -19026,8 +19243,12 @@ var require_parser = __commonJS({
         const name = this.expect("ident").value;
         this.expect(":");
         const type = this.parseType();
-        this.expect("=");
-        const init = this.parseExpr();
+        let init;
+        if (this.match("=")) {
+          init = this.parseExpr();
+        } else {
+          init = { kind: "int_lit", value: 0 };
+        }
         this.match(";");
         return this.withLoc({ kind: "global", name, type, init, mutable }, token);
       }
@@ -19043,6 +19264,7 @@ var require_parser = __commonJS({
       }
       parseFnDecl(implTypeName) {
         const decorators = this.parseDecorators();
+        const watchObjective = decorators.find((decorator) => decorator.name === "watch")?.args?.objective;
         let isExported;
         const filteredDecorators = decorators.filter((d) => {
           if (d.name === "keep") {
@@ -19070,6 +19292,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,
@@ -19078,8 +19301,11 @@ var require_parser = __commonJS({
           decorators: filteredDecorators,
           body,
           isLibraryFn: this.inLibraryMode || void 0,
-          isExported
+          isExported,
+          watchObjective
         }, fnToken);
+        if (fn.span && closingBraceLine)
+          fn.span.endLine = closingBraceLine;
         return fn;
       }
       /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -19110,7 +19336,7 @@ var require_parser = __commonJS({
         return decorators;
       }
       parseDecoratorValue(value) {
-        const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
+        const match = value.match(/^@(\w+)(?:\((.*)\))?$/s);
         if (!match) {
           this.error(`Invalid decorator: ${value}`);
         }
@@ -19119,6 +19345,9 @@ var require_parser = __commonJS({
         if (!argsStr) {
           return { name };
         }
+        if (name === "profile") {
+          this.error("@profile decorator does not accept arguments");
+        }
         const args = {};
         if (name === "on") {
           const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
@@ -19127,10 +19356,12 @@ var require_parser = __commonJS({
             return { name, args };
           }
         }
-        if (name === "on_trigger" || name === "on_advancement" || name === "on_craft" || name === "on_join_team") {
+        if (name === "watch" || name === "on_trigger" || name === "on_advancement" || name === "on_craft" || name === "on_join_team") {
           const strMatch = argsStr.match(/^"([^"]*)"$/);
           if (strMatch) {
-            if (name === "on_trigger") {
+            if (name === "watch") {
+              args.objective = strMatch[1];
+            } else if (name === "on_trigger") {
               args.trigger = strMatch[1];
             } else if (name === "on_advancement") {
               args.advancement = strMatch[1];
@@ -19142,6 +19373,24 @@ var require_parser = __commonJS({
             return { name, args };
           }
         }
+        if (name === "config") {
+          const configMatch = argsStr.match(/^"([^"]+)"\s*,\s*default\s*:\s*(-?\d+(?:\.\d+)?)$/);
+          if (configMatch) {
+            return { name, args: { configKey: configMatch[1], configDefault: parseFloat(configMatch[2]) } };
+          }
+          const keyOnlyMatch = argsStr.match(/^"([^"]+)"$/);
+          if (keyOnlyMatch) {
+            return { name, args: { configKey: keyOnlyMatch[1] } };
+          }
+          this.error(`Invalid @config syntax. Expected: @config("key", default: value) or @config("key")`);
+        }
+        if (name === "deprecated") {
+          const strMatch = argsStr.match(/^"([^"]*)"$/);
+          if (strMatch) {
+            return { name, args: { message: strMatch[1] } };
+          }
+          return { name, args: {} };
+        }
         if (name === "require_on_load") {
           const rawArgs = [];
           for (const part of argsStr.split(",")) {
@@ -19167,7 +19416,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") {
@@ -19277,7 +19526,16 @@ var require_parser = __commonJS({
         this.expect("{");
         const stmts = [];
         while (!this.check("}") && !this.check("eof")) {
-          stmts.push(this.parseStmt());
+          try {
+            stmts.push(this.parseStmt());
+          } catch (err) {
+            if (err instanceof diagnostics_1.DiagnosticError) {
+              this.parseErrors.push(err);
+              this.syncToNextStmt();
+            } else {
+              throw err;
+            }
+          }
         }
         this.expect("}");
         return stmts;
@@ -19286,6 +19544,9 @@ var require_parser = __commonJS({
         if (this.check("let")) {
           return this.parseLetStmt();
         }
+        if (this.check("const")) {
+          return this.parseLocalConstDecl();
+        }
         if (this.check("return")) {
           return this.parseReturnStmt();
         }
@@ -19305,6 +19566,12 @@ var require_parser = __commonJS({
         if (this.check("while")) {
           return this.parseWhileStmt();
         }
+        if (this.check("do")) {
+          return this.parseDoWhileStmt();
+        }
+        if (this.check("repeat")) {
+          return this.parseRepeatStmt();
+        }
         if (this.check("for")) {
           return this.parseForStmt();
         }
@@ -19359,6 +19626,16 @@ var require_parser = __commonJS({
         this.match(";");
         return this.withLoc({ kind: "let", name, type, init }, letToken);
       }
+      parseLocalConstDecl() {
+        const constToken = this.expect("const");
+        const name = this.expect("ident").value;
+        this.expect(":");
+        const type = this.parseType();
+        this.expect("=");
+        const value = this.parseExpr();
+        this.match(";");
+        return this.withLoc({ kind: "const_decl", name, type, value }, constToken);
+      }
       parseReturnStmt() {
         const returnToken = this.expect("return");
         let value;
@@ -19389,9 +19666,7 @@ var require_parser = __commonJS({
           }
           return this.withLoc({ kind: "if_let_some", binding, init, then: then2, else_: else_2 }, ifToken);
         }
-        this.expect("(");
-        const cond = this.parseExpr();
-        this.expect(")");
+        const cond = this.parseParenOptionalCond();
         const then = this.parseBlock();
         let else_;
         if (this.match("else")) {
@@ -19405,12 +19680,44 @@ var require_parser = __commonJS({
       }
       parseWhileStmt() {
         const whileToken = this.expect("while");
-        this.expect("(");
-        const cond = this.parseExpr();
-        this.expect(")");
+        if (this.check("let") && this.peek(1).kind === "ident" && this.peek(1).value === "Some") {
+          this.advance();
+          this.advance();
+          this.expect("(");
+          const binding = this.expect("ident").value;
+          this.expect(")");
+          this.expect("=");
+          const init = this.parseExpr();
+          const body2 = this.parseBlock();
+          return this.withLoc({ kind: "while_let_some", binding, init, body: body2 }, whileToken);
+        }
+        const cond = this.parseParenOptionalCond();
         const body = this.parseBlock();
         return this.withLoc({ kind: "while", cond, body }, whileToken);
       }
+      parseDoWhileStmt() {
+        const doToken = this.expect("do");
+        const body = this.parseBlock();
+        this.expect("while");
+        const cond = this.parseParenOptionalCond();
+        this.match(";");
+        return this.withLoc({ kind: "do_while", cond, body }, doToken);
+      }
+      parseRepeatStmt() {
+        const repeatToken = this.expect("repeat");
+        const countToken = this.expect("int_lit");
+        const count = parseInt(countToken.value, 10);
+        const body = this.parseBlock();
+        return this.withLoc({ kind: "repeat", count, body }, repeatToken);
+      }
+      parseParenOptionalCond() {
+        if (this.match("(")) {
+          const cond = this.parseExpr();
+          this.expect(")");
+          return cond;
+        }
+        return this.parseExpr();
+      }
       parseForStmt() {
         const forToken = this.expect("for");
         if (this.check("ident") && this.peek(1).kind === "in") {
@@ -19454,9 +19761,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 +19775,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 +19818,67 @@ 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("ident") && this.peek(1).kind === "::") {
+          const enumName = this.advance().value;
+          this.expect("::");
+          const variant = this.expect("ident").value;
+          const bindings = [];
+          if (this.check("(")) {
+            this.advance();
+            while (!this.check(")") && !this.check("eof")) {
+              bindings.push(this.expect("ident").value);
+              if (!this.match(","))
+                break;
+            }
+            this.expect(")");
+          }
+          return { kind: "PatEnum", enumName, variant, bindings };
+        }
+        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("}");
@@ -19810,6 +20182,12 @@ var require_parser = __commonJS({
               continue;
             }
             if (expr.kind === "member") {
+              if (expr.field === "unwrap_or") {
+                const defaultExpr = this.parseExpr();
+                this.expect(")");
+                expr = this.withLoc({ kind: "unwrap_or", opt: expr.obj, default_: defaultExpr }, this.getLocToken(expr) ?? openParenToken);
+                continue;
+              }
               const methodMap = {
                 "tag": "__entity_tag",
                 "untag": "__entity_untag",
@@ -19887,6 +20265,21 @@ var require_parser = __commonJS({
           this.expect("::");
           const memberToken = this.expect("ident");
           if (this.check("(")) {
+            const isNamedArgs = this.peek(1).kind === "ident" && this.peek(2).kind === ":";
+            if (isNamedArgs) {
+              this.advance();
+              const args2 = [];
+              while (!this.check(")") && !this.check("eof")) {
+                const fieldName = this.expect("ident").value;
+                this.expect(":");
+                const value = this.parseExpr();
+                args2.push({ name: fieldName, value });
+                if (!this.match(","))
+                  break;
+              }
+              this.expect(")");
+              return this.withLoc({ kind: "enum_construct", enumName: typeToken.value, variant: memberToken.value, args: args2 }, typeToken);
+            }
             this.advance();
             const args = this.parseArgs();
             this.expect(")");
@@ -19962,6 +20355,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 +20880,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);
@@ -20693,16 +21108,18 @@ var require_lower = __commonJS({
         structs: program.structs.map((s) => ({
           name: s.name,
           fields: s.fields.map((f) => ({ name: f.name, type: f.type })),
+          isSingleton: s.isSingleton,
           span: s.span
         })),
         implBlocks: program.implBlocks.map((ib) => ({
           typeName: ib.typeName,
+          traitName: ib.traitName,
           methods: ib.methods.map(lowerFunction),
           span: ib.span
         })),
         enums: program.enums.map((e) => ({
           name: e.name,
-          variants: e.variants.map((v) => ({ name: v.name, value: v.value })),
+          variants: e.variants.map((v) => ({ name: v.name, value: v.value, fields: v.fields })),
           span: e.span
         })),
         consts: program.consts.map((c) => ({
@@ -20714,6 +21131,22 @@ 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) };
+        case "PatEnum":
+          return { kind: "PatEnum", enumName: pat.enumName, variant: pat.variant, bindings: pat.bindings };
+      }
+    }
     function lowerGlobal(g) {
       return {
         name: g.name,
@@ -20733,7 +21166,8 @@ var require_lower = __commonJS({
         body: lowerBlock(fn.body),
         isLibraryFn: fn.isLibraryFn,
         isExported: fn.isExported,
-        span: fn.span
+        span: fn.span,
+        watchObjective: fn.watchObjective
       };
     }
     function lowerParam(p) {
@@ -20761,6 +21195,8 @@ var require_lower = __commonJS({
           return { kind: "let", name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
         case "let_destruct":
           return { kind: "let_destruct", names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+        case "const_decl":
+          return { kind: "const_decl", name: stmt.name, type: stmt.type, value: lowerExpr(stmt.value), span: stmt.span };
         case "expr":
           return { kind: "expr", expr: lowerExpr(stmt.expr), span: stmt.span };
         case "return":
@@ -20822,7 +21258,7 @@ var require_lower = __commonJS({
             kind: "while",
             cond: {
               kind: "binary",
-              op: "<",
+              op: stmt.inclusive ? "<=" : "<",
               left: { kind: "ident", name: varName },
               right: lowerExpr(stmt.end)
             },
@@ -20883,39 +21319,104 @@ var require_lower = __commonJS({
           };
           return [initStmt, whileStmt];
         }
-        case "foreach":
-          return {
-            kind: "foreach",
-            binding: stmt.binding,
-            iterable: lowerExpr(stmt.iterable),
-            body: lowerBlock(stmt.body),
-            executeContext: stmt.executeContext,
+        // --- 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
           };
-        case "match":
-          return {
-            kind: "match",
-            expr: lowerExpr(stmt.expr),
-            arms: stmt.arms.map((arm) => ({
-              pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
-              body: lowerBlock(arm.body)
-            })),
+          const idxInitStmt = {
+            kind: "let",
+            name: idxName,
+            type: { kind: "named", name: "int" },
+            init: { kind: "int_lit", value: 0 },
             span: stmt.span
           };
-        // --- Desugaring: as_block → execute [as] ---
-        case "as_block":
-          return {
-            kind: "execute",
-            subcommands: [{ kind: "as", selector: stmt.selector }],
-            body: lowerBlock(stmt.body),
+          const bindingInit = {
+            kind: "let",
+            name: stmt.binding,
+            type: void 0,
+            init: {
+              kind: "index",
+              obj: arrExpr,
+              index: { kind: "ident", name: idxName }
+            },
             span: stmt.span
           };
-        // --- Desugaring: at_block → execute [at] ---
-        case "at_block":
-          return {
-            kind: "execute",
-            subcommands: [{ kind: "at", selector: stmt.selector }],
-            body: lowerBlock(stmt.body),
+          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",
+            binding: stmt.binding,
+            iterable: lowerExpr(stmt.iterable),
+            body: lowerBlock(stmt.body),
+            executeContext: stmt.executeContext,
+            span: stmt.span
+          };
+        case "match":
+          return {
+            kind: "match",
+            expr: lowerExpr(stmt.expr),
+            arms: stmt.arms.map((arm) => ({
+              pattern: lowerMatchPattern(arm.pattern),
+              body: lowerBlock(arm.body)
+            })),
+            span: stmt.span
+          };
+        // --- Desugaring: as_block → execute [as] ---
+        case "as_block":
+          return {
+            kind: "execute",
+            subcommands: [{ kind: "as", selector: stmt.selector }],
+            body: lowerBlock(stmt.body),
+            span: stmt.span
+          };
+        // --- Desugaring: at_block → execute [at] ---
+        case "at_block":
+          return {
+            kind: "execute",
+            subcommands: [{ kind: "at", selector: stmt.selector }],
+            body: lowerBlock(stmt.body),
             span: stmt.span
           };
         // --- Desugaring: as_at → execute [as, at] ---
@@ -20947,6 +21448,68 @@ var require_lower = __commonJS({
             else_: stmt.else_ ? lowerBlock(stmt.else_) : void 0,
             span: stmt.span
           };
+        // --- Desugaring: do_while → body + while(cond) { body } ---
+        // Emits the body once unconditionally, then a while loop:
+        //   <body>
+        //   while (cond) { <body> }
+        case "do_while": {
+          const firstBody = lowerBlock(stmt.body);
+          const loopBody = lowerBlock(stmt.body);
+          const whileStmt = {
+            kind: "while",
+            cond: lowerExpr(stmt.cond),
+            body: loopBody,
+            span: stmt.span
+          };
+          return [...firstBody, whileStmt];
+        }
+        // --- Desugaring: repeat N → let __repeat_i = 0; while(__repeat_i < N) { body; __repeat_i = __repeat_i + 1 } ---
+        case "repeat": {
+          const id = repeatCounter++;
+          const idxName = `__repeat_i_${id}`;
+          const initStmt = {
+            kind: "let",
+            name: idxName,
+            type: { kind: "named", name: "int" },
+            init: { kind: "int_lit", value: 0 },
+            span: stmt.span
+          };
+          const body = lowerBlock(stmt.body);
+          const step = [{
+            kind: "expr",
+            expr: {
+              kind: "assign",
+              target: idxName,
+              value: {
+                kind: "binary",
+                op: "+",
+                left: { kind: "ident", name: idxName },
+                right: { kind: "int_lit", value: 1 }
+              }
+            }
+          }];
+          const whileStmt = {
+            kind: "while",
+            cond: {
+              kind: "binary",
+              op: "<",
+              left: { kind: "ident", name: idxName },
+              right: { kind: "int_lit", value: stmt.count }
+            },
+            body,
+            step,
+            span: stmt.span
+          };
+          return [initStmt, whileStmt];
+        }
+        case "while_let_some":
+          return {
+            kind: "while_let_some",
+            binding: stmt.binding,
+            init: lowerExpr(stmt.init),
+            body: lowerBlock(stmt.body),
+            span: stmt.span
+          };
         default: {
           const _exhaustive = stmt;
           throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
@@ -20956,6 +21519,8 @@ var require_lower = __commonJS({
     function lowerExecuteSubcommand(sub) {
       return sub;
     }
+    var forEachCounter = 0;
+    var repeatCounter = 0;
     var COMPOUND_TO_BINOP = {
       "+=": "+",
       "-=": "-",
@@ -20998,8 +21563,10 @@ var require_lower = __commonJS({
             parts: expr.parts.map((p) => typeof p === "string" ? p : lowerExpr(p)),
             span: expr.span
           };
-        case "f_string":
-          return { kind: "f_string", parts: expr.parts, span: expr.span };
+        case "f_string": {
+          const hirParts = expr.parts.map((part) => part.kind === "text" ? { kind: "text", value: part.value } : { kind: "expr", expr: lowerExpr(part.expr) });
+          return { kind: "f_string", parts: hirParts, span: expr.span };
+        }
         // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
         case "binary":
           return {
@@ -21104,12 +21671,22 @@ var require_lower = __commonJS({
           };
         case "path_expr":
           return { kind: "path_expr", enumName: expr.enumName, variant: expr.variant, span: expr.span };
+        case "enum_construct":
+          return {
+            kind: "enum_construct",
+            enumName: expr.enumName,
+            variant: expr.variant,
+            args: expr.args.map((a) => ({ name: a.name, value: lowerExpr(a.value) })),
+            span: expr.span
+          };
         case "tuple_lit":
           return { kind: "tuple_lit", elements: expr.elements.map(lowerExpr), span: expr.span };
         case "some_lit":
           return { kind: "some_lit", value: lowerExpr(expr.value), span: expr.span };
         case "none_lit":
           return { kind: "none_lit", span: expr.span };
+        case "unwrap_or":
+          return { kind: "unwrap_or", opt: lowerExpr(expr.opt), default_: lowerExpr(expr.default_), span: expr.span };
         case "type_cast":
           return { kind: "type_cast", expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span };
         case "lambda": {
@@ -21323,10 +21900,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) };
@@ -21337,6 +21919,14 @@ var require_monomorphize = __commonJS({
               then: this.rewriteBlock(stmt.then, ctx),
               else_: stmt.else_ ? this.rewriteBlock(stmt.else_, ctx) : void 0
             };
+          case "while_let_some":
+            return {
+              ...stmt,
+              init: this.rewriteExpr(stmt.init, ctx),
+              body: this.rewriteBlock(stmt.body, ctx)
+            };
+          case "const_decl":
+            return { ...stmt, value: this.rewriteExpr(stmt.value, ctx) };
           case "break":
           case "continue":
           case "raw":
@@ -21394,11 +21984,16 @@ var require_monomorphize = __commonJS({
           case "str_interp":
             return { ...expr, parts: expr.parts.map((p) => typeof p === "string" ? p : this.rewriteExpr(p, ctx)) };
           case "f_string":
-            return expr;
+            return {
+              ...expr,
+              parts: expr.parts.map((p) => p.kind === "text" ? p : { kind: "expr", expr: this.rewriteExpr(p.expr, ctx) })
+            };
           case "some_lit":
             return { ...expr, value: this.rewriteExpr(expr.value, ctx) };
           case "none_lit":
             return expr;
+          case "unwrap_or":
+            return { ...expr, opt: this.rewriteExpr(expr.opt, ctx), default_: this.rewriteExpr(expr.default_, ctx) };
           // Literals / terminals — pass through unchanged
           default:
             return expr;
@@ -21481,6 +22076,212 @@ var require_monomorphize = __commonJS({
   }
 });
 
+// ../../dist/src/hir/deprecated.js
+var require_deprecated = __commonJS({
+  "../../dist/src/hir/deprecated.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.checkDeprecatedCalls = checkDeprecatedCalls;
+    function buildDeprecatedMap(hir) {
+      const deprecated = /* @__PURE__ */ new Map();
+      for (const fn of hir.functions) {
+        const dep = getDeprecatedDecorator(fn.decorators);
+        if (dep !== null) {
+          deprecated.set(fn.name, dep);
+        }
+      }
+      for (const ib of hir.implBlocks) {
+        for (const m of ib.methods) {
+          const dep = getDeprecatedDecorator(m.decorators);
+          if (dep !== null) {
+            deprecated.set(`${ib.typeName}::${m.name}`, dep);
+          }
+        }
+      }
+      return deprecated;
+    }
+    function getDeprecatedDecorator(decorators) {
+      for (const dec of decorators) {
+        if (dec.name === "deprecated") {
+          return dec.args?.message ?? "";
+        }
+      }
+      return null;
+    }
+    function checkDeprecatedCalls(hir) {
+      const deprecated = buildDeprecatedMap(hir);
+      if (deprecated.size === 0)
+        return [];
+      const warnings = [];
+      for (const fn of hir.functions) {
+        walkBlock(fn.body, fn.name, deprecated, warnings);
+      }
+      for (const ib of hir.implBlocks) {
+        for (const m of ib.methods) {
+          walkBlock(m.body, `${ib.typeName}::${m.name}`, deprecated, warnings);
+        }
+      }
+      return warnings;
+    }
+    function walkBlock(block, caller, deprecated, warnings) {
+      for (const stmt of block) {
+        walkStmt(stmt, caller, deprecated, warnings);
+      }
+    }
+    function walkStmt(stmt, caller, deprecated, warnings) {
+      switch (stmt.kind) {
+        case "let":
+        case "let_destruct":
+          walkExpr(stmt.init, caller, deprecated, warnings);
+          break;
+        case "expr":
+          walkExpr(stmt.expr, caller, deprecated, warnings);
+          break;
+        case "return":
+          if (stmt.value)
+            walkExpr(stmt.value, caller, deprecated, warnings);
+          break;
+        case "if":
+          walkExpr(stmt.cond, caller, deprecated, warnings);
+          walkBlock(stmt.then, caller, deprecated, warnings);
+          if (stmt.else_)
+            walkBlock(stmt.else_, caller, deprecated, warnings);
+          break;
+        case "while":
+          walkExpr(stmt.cond, caller, deprecated, warnings);
+          walkBlock(stmt.body, caller, deprecated, warnings);
+          if (stmt.step)
+            walkBlock(stmt.step, caller, deprecated, warnings);
+          break;
+        case "foreach":
+          walkExpr(stmt.iterable, caller, deprecated, warnings);
+          walkBlock(stmt.body, caller, deprecated, warnings);
+          break;
+        case "match":
+          walkExpr(stmt.expr, caller, deprecated, warnings);
+          for (const arm of stmt.arms) {
+            walkBlock(arm.body, caller, deprecated, warnings);
+          }
+          break;
+        // break/continue/raw/execute: no sub-exprs to walk for deprecation purposes
+        default:
+          break;
+      }
+    }
+    function walkExpr(expr, caller, deprecated, warnings) {
+      switch (expr.kind) {
+        case "call": {
+          if (deprecated.has(expr.fn)) {
+            const msg = deprecated.get(expr.fn);
+            const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : "";
+            const detail = msg ? `: ${msg}` : "";
+            warnings.push(`[DeprecatedUsage] ${location}'${expr.fn}' is deprecated${detail} (called from '${caller}')`);
+          }
+          for (const arg of expr.args)
+            walkExpr(arg, caller, deprecated, warnings);
+          break;
+        }
+        case "static_call": {
+          const qualName = `${expr.type}::${expr.method}`;
+          if (deprecated.has(qualName)) {
+            const msg = deprecated.get(qualName);
+            const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : "";
+            const detail = msg ? `: ${msg}` : "";
+            warnings.push(`[DeprecatedUsage] ${location}'${qualName}' is deprecated${detail} (called from '${caller}')`);
+          }
+          for (const arg of expr.args)
+            walkExpr(arg, caller, deprecated, warnings);
+          break;
+        }
+        case "invoke":
+          walkExpr(expr.callee, caller, deprecated, warnings);
+          for (const arg of expr.args)
+            walkExpr(arg, caller, deprecated, warnings);
+          break;
+        case "binary":
+          walkExpr(expr.left, caller, deprecated, warnings);
+          walkExpr(expr.right, caller, deprecated, warnings);
+          break;
+        case "unary":
+          walkExpr(expr.operand, caller, deprecated, warnings);
+          break;
+        case "is_check":
+          walkExpr(expr.expr, caller, deprecated, warnings);
+          break;
+        case "type_cast":
+          walkExpr(expr.expr, caller, deprecated, warnings);
+          break;
+        case "assign":
+          walkExpr(expr.value, caller, deprecated, warnings);
+          break;
+        case "member_assign":
+          walkExpr(expr.obj, caller, deprecated, warnings);
+          walkExpr(expr.value, caller, deprecated, warnings);
+          break;
+        case "index_assign":
+          walkExpr(expr.obj, caller, deprecated, warnings);
+          walkExpr(expr.index, caller, deprecated, warnings);
+          walkExpr(expr.value, caller, deprecated, warnings);
+          break;
+        case "member":
+          walkExpr(expr.obj, caller, deprecated, warnings);
+          break;
+        case "index":
+          walkExpr(expr.obj, caller, deprecated, warnings);
+          walkExpr(expr.index, caller, deprecated, warnings);
+          break;
+        case "array_lit":
+          for (const el of expr.elements)
+            walkExpr(el, caller, deprecated, warnings);
+          break;
+        case "struct_lit":
+          for (const f of expr.fields)
+            walkExpr(f.value, caller, deprecated, warnings);
+          break;
+        case "str_interp":
+          for (const part of expr.parts) {
+            if (typeof part !== "string")
+              walkExpr(part, caller, deprecated, warnings);
+          }
+          break;
+        case "f_string":
+          for (const part of expr.parts) {
+            if (part.kind === "expr")
+              walkExpr(part.expr, caller, deprecated, warnings);
+          }
+          break;
+        case "some_lit":
+          walkExpr(expr.value, caller, deprecated, warnings);
+          break;
+        case "unwrap_or":
+          walkExpr(expr.opt, caller, deprecated, warnings);
+          walkExpr(expr.default_, caller, deprecated, warnings);
+          break;
+        case "lambda": {
+          const body = expr.body;
+          if (Array.isArray(body)) {
+            walkBlock(body, caller, deprecated, warnings);
+          } else {
+            walkExpr(body, caller, deprecated, warnings);
+          }
+          break;
+        }
+        case "tuple_lit":
+          for (const el of expr.elements)
+            walkExpr(el, caller, deprecated, warnings);
+          break;
+        case "enum_construct":
+          for (const arg of expr.args)
+            walkExpr(arg.value, caller, deprecated, warnings);
+          break;
+        // Terminals: int_lit, float_lit, bool_lit, str_lit, ident, selector, etc.
+        default:
+          break;
+      }
+    }
+  }
+});
+
 // ../../dist/src/mir/macro.js
 var require_macro = __commonJS({
   "../../dist/src/mir/macro.js"(exports2) {
@@ -21667,23 +22468,35 @@ var require_lower2 = __commonJS({
     var macro_1 = require_macro();
     function lowerToMIR(hir, sourceFile) {
       const structDefs = /* @__PURE__ */ new Map();
+      const singletonStructs = /* @__PURE__ */ 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);
       }
       const enumDefs = /* @__PURE__ */ new Map();
+      const enumPayloads = /* @__PURE__ */ new Map();
       for (const e of hir.enums) {
         const variants = /* @__PURE__ */ new Map();
+        const payloads = /* @__PURE__ */ 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);
+        }
       }
       const implMethods = /* @__PURE__ */ new Map();
       for (const ib of hir.implBlocks) {
         const methods = /* @__PURE__ */ 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 : void 0;
+          methods.set(m.name, { hasSelf, returnStructName });
         }
         implMethods.set(ib.typeName, methods);
       }
@@ -21703,14 +22516,23 @@ var require_lower2 = __commonJS({
         hirFnMap.set(f.name, f);
       }
       const specializedFnsRegistry = /* @__PURE__ */ new Map();
+      const constValues = /* @__PURE__ */ 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 * 1e4));
+      }
       const allFunctions = [];
       for (const f of hir.functions) {
-        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, void 0, hirFnMap, specializedFnsRegistry);
+        const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, void 0, hirFnMap, specializedFnsRegistry, void 0, enumPayloads, constValues, singletonStructs);
         allFunctions.push(fn, ...helpers);
       }
       for (const ib of hir.implBlocks) {
         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);
         }
       }
@@ -21724,7 +22546,7 @@ var require_lower2 = __commonJS({
       };
     }
     var FnContext = class {
-      constructor(namespace, fnName, structDefs = /* @__PURE__ */ new Map(), implMethods = /* @__PURE__ */ new Map(), macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), timerCounter = { count: 0, timerId: 0 }) {
+      constructor(namespace, fnName, structDefs = /* @__PURE__ */ new Map(), implMethods = /* @__PURE__ */ new Map(), macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), timerCounter = { count: 0, timerId: 0 }, enumPayloads = /* @__PURE__ */ new Map()) {
         this.tempCounter = 0;
         this.blockCounter = 0;
         this.blocks = [];
@@ -21733,14 +22555,18 @@ var require_lower2 = __commonJS({
         this.structVars = /* @__PURE__ */ new Map();
         this.tupleVars = /* @__PURE__ */ new Map();
         this.arrayVars = /* @__PURE__ */ new Map();
+        this.stringVars = /* @__PURE__ */ new Map();
         this.currentSourceLoc = void 0;
         this.sourceFile = void 0;
         this.constTemps = /* @__PURE__ */ new Map();
         this.floatTemps = /* @__PURE__ */ new Set();
         this.doubleVars = /* @__PURE__ */ new Map();
         this.doubleVarCount = 0;
+        this.stringVarCount = 0;
         this.hirFunctions = /* @__PURE__ */ new Map();
         this.specializedFnsRegistry = /* @__PURE__ */ new Map();
+        this.constValues = /* @__PURE__ */ new Map();
+        this.singletonStructs = /* @__PURE__ */ new Set();
         this.namespace = namespace;
         this.fnName = fnName;
         this.structDefs = structDefs;
@@ -21749,6 +22575,7 @@ var require_lower2 = __commonJS({
         this.fnParamInfo = fnParamInfo;
         this.currentMacroParams = macroInfo.get(fnName)?.macroParams ?? /* @__PURE__ */ new Set();
         this.enumDefs = enumDefs;
+        this.enumPayloads = enumPayloads;
         this.timerCounter = timerCounter;
         const entry = this.makeBlock("entry");
         this.currentBlock = entry;
@@ -21809,11 +22636,17 @@ var require_lower2 = __commonJS({
         this.doubleVars.set(varName, path3);
         return path3;
       }
+      /** Allocate a unique NBT storage path for a string value */
+      freshStringVar(varName) {
+        return `${this.namespace}_${this.fnName}_${varName}_${this.stringVarCount++}`;
+      }
     };
-    function lowerFunction(fn, namespace, structDefs = /* @__PURE__ */ new Map(), implMethods = /* @__PURE__ */ new Map(), macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, arrayArgBindings, hirFnMap, specializedFnsRegistry, overrideName) {
+    function lowerFunction(fn, namespace, structDefs = /* @__PURE__ */ new Map(), implMethods = /* @__PURE__ */ new Map(), macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, arrayArgBindings, hirFnMap, specializedFnsRegistry, overrideName, enumPayloads = /* @__PURE__ */ new Map(), constValues = /* @__PURE__ */ new Map(), singletonStructs = /* @__PURE__ */ new Set()) {
       const mirFnName = overrideName ?? fn.name;
-      const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
+      const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
       ctx.sourceFile = sourceFile;
+      ctx.constValues = constValues;
+      ctx.singletonStructs = singletonStructs;
       if (hirFnMap)
         ctx.hirFunctions = hirFnMap;
       if (specializedFnsRegistry)
@@ -21827,6 +22660,7 @@ var require_lower2 = __commonJS({
       const params = [];
       const scope = /* @__PURE__ */ new Map();
       let doubleParamSlot = 0;
+      let stringParamSlot = 0;
       fn.params.forEach((p) => {
         if (p.type.kind === "array" && arrayArgBindings?.has(p.name)) {
           return;
@@ -21836,6 +22670,10 @@ var require_lower2 = __commonJS({
           ctx.doubleVars.set(p.name, path3);
           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);
@@ -21857,10 +22695,11 @@ var require_lower2 = __commonJS({
       };
       return { fn: result, helpers: ctx.helperFunctions };
     }
-    function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }) {
+    function lowerImplMethod(method, typeName, namespace, structDefs, implMethods, macroInfo = /* @__PURE__ */ new Map(), fnParamInfo = /* @__PURE__ */ new Map(), enumDefs = /* @__PURE__ */ new Map(), sourceFile, timerCounter = { count: 0, timerId: 0 }, enumPayloads = /* @__PURE__ */ new Map(), constValues = /* @__PURE__ */ new Map()) {
       const fnName = `${typeName}::${method.name}`;
-      const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter);
+      const ctx = new FnContext(namespace, fnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter, enumPayloads);
       ctx.sourceFile = sourceFile;
+      ctx.constValues = constValues;
       const fields = structDefs.get(typeName) ?? [];
       const hasSelf = method.params.length > 0 && method.params[0].name === "self";
       const params = [];
@@ -21874,15 +22713,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);
@@ -21959,7 +22823,13 @@ var require_lower2 = __commonJS({
       }
       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 path3 = lowerStringExprToPath(stmt.init, ctx, scope, stmt.name) ?? ctx.freshStringVar(stmt.name);
+            ctx.stringVars.set(stmt.name, path3);
+            const t = ctx.freshTemp();
+            ctx.emit({ kind: "const", dst: t, value: 0 });
+            scope.set(stmt.name, t);
+          } else if (stmt.init.kind === "some_lit") {
             const hasTemp = `__opt_${stmt.name}_has`;
             const valTemp = `__opt_${stmt.name}_val`;
             ctx.emit({ kind: "const", dst: hasTemp, value: 1 });
@@ -21978,10 +22848,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") {
@@ -21992,8 +22878,12 @@ var require_lower2 = __commonJS({
             ctx.emit({ kind: "copy", dst: valTemp, src: { kind: "temp", name: "__rf_val" } });
             const fieldTemps = /* @__PURE__ */ new Map([["has", hasTemp], ["val", valTemp]]);
             ctx.structVars.set(stmt.name, { typeName: "__option", fields: fieldTemps });
-          } else if (stmt.type?.kind === "struct") {
-            const fields = ctx.structDefs.get(stmt.type.name);
+          } 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"
+          ) {
+            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);
               const fieldTemps = /* @__PURE__ */ new Map();
@@ -22007,7 +22897,7 @@ var require_lower2 = __commonJS({
                   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);
               const t = ctx.freshTemp();
@@ -22031,25 +22921,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();
@@ -22102,6 +23000,12 @@ var require_lower2 = __commonJS({
           }
           break;
         }
+        case "const_decl": {
+          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;
@@ -22268,47 +23172,113 @@ var require_lower2 = __commonJS({
           break;
         }
         case "match": {
-          const matchVal = lowerExpr(stmt.expr, ctx, scope);
+          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 mergeBlock2 = 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: mergeBlock2.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: mergeBlock2.id });
+                }
+                ctx.switchTo(nextArm);
+                continue;
+              }
+              throw new Error(`Unsupported string match pattern: ${pat.kind}`);
+            }
+            if (isPlaceholderTerm(ctx.current().term)) {
+              ctx.terminate({ kind: "jump", target: mergeBlock2.id });
+            }
+            ctx.switchTo(mergeBlock2);
+            break;
+          }
           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 +23288,79 @@ var require_lower2 = __commonJS({
                 ctx.terminate({ kind: "jump", target: mergeBlock.id });
               }
               ctx.switchTo(nextArm);
+            } else if (pat.kind === "PatEnum") {
+              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: { 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);
+              const armScope = new Map(scope);
+              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") {
+              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)) {
@@ -22376,6 +23419,47 @@ var require_lower2 = __commonJS({
           ctx.switchTo(mergeBlock);
           break;
         }
+        case "while_let_some": {
+          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 });
+          ctx.switchTo(headerBlock);
+          let hasOp;
+          let valTemp;
+          const sv = (() => {
+            if (stmt.init.kind === "ident")
+              return ctx.structVars.get(stmt.init.name);
+            return void 0;
+          })();
+          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 });
+          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}`);
@@ -22438,6 +23522,9 @@ var require_lower2 = __commonJS({
           const temp = scope.get(expr.name);
           if (temp)
             return { kind: "temp", name: temp };
+          if (ctx.constValues.has(expr.name)) {
+            return { kind: "const", value: ctx.constValues.get(expr.name) };
+          }
           const t = ctx.freshTemp();
           ctx.emit({ kind: "copy", dst: t, src: { kind: "const", value: 0 } });
           scope.set(expr.name, t);
@@ -22556,6 +23643,27 @@ var require_lower2 = __commonJS({
           const value = variants?.get(expr.variant) ?? 0;
           return { kind: "const", value };
         }
+        case "enum_construct": {
+          const variants = ctx.enumDefs.get(expr.enumName);
+          const tagValue = variants?.get(expr.variant) ?? 0;
+          const tagTemp = ctx.freshTemp();
+          ctx.emit({ kind: "const", dst: tagTemp, value: tagValue });
+          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);
+            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": {
           if (expr.obj.kind === "ident") {
             const enumVariants = ctx.enumDefs.get(expr.obj.name);
@@ -22571,6 +23679,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 +23730,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 +23766,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);
@@ -22711,13 +23924,37 @@ var require_lower2 = __commonJS({
             ctx.emit({ kind: "const", dst: t2, value: 0 });
             return { kind: "temp", name: t2 };
           }
+          if (expr.fn === "int_to_str" || expr.fn === "bool_to_str") {
+            if (expr.args.length === 1) {
+              return lowerExpr(expr.args[0], ctx, scope);
+            }
+            const t2 = ctx.freshTemp();
+            ctx.emit({ kind: "const", dst: t2, value: 0 });
+            return { kind: "temp", name: t2 };
+          }
           if (macro_1.BUILTIN_SET.has(expr.fn)) {
-            const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams);
+            const TEXT_BUILTINS_SET = /* @__PURE__ */ 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 t2 = ctx.freshTemp();
             ctx.emit({ kind: "const", dst: t2, value: 0 });
             return { kind: "temp", name: t2 };
           }
+          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) {
@@ -22728,17 +23965,32 @@ var require_lower2 = __commonJS({
                   return lowerTimerMethod(expr.fn, timerId, sv, ctx, scope, expr.args.slice(1));
                 }
               }
-              const methodInfo = ctx.implMethods.get(sv.typeName)?.get(expr.fn);
+              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) {
                 const fields = ctx.structDefs.get(sv.typeName) ?? [];
                 const selfArgs = fields.map((f) => {
                   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 });
+                ctx.emit({ kind: "call", dst: t2, fn: `${sv.typeName}::${originalMethodName}`, args: allArgs });
                 return { kind: "temp", name: t2 };
               }
             }
@@ -22784,7 +24036,7 @@ var require_lower2 = __commonJS({
                 const specializedName = `${expr.fn}__arr_${bindingKey}`;
                 if (!ctx.specializedFnsRegistry.has(specializedName)) {
                   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.specializedFnsRegistry.set(specializedName, [specFn, ...specHelpers]);
                 }
                 const nonArrayArgs = [];
@@ -22803,6 +24055,34 @@ var require_lower2 = __commonJS({
           {
             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 t2 = ctx.freshTemp();
+                ctx.emit({ kind: "call", dst: t2, fn: expr.fn, args: nonStringArgs });
+                return { kind: "temp", name: t2 };
+              }
               const hasDoubleParam = targetParams.some((p) => p.type.kind === "named" && p.type.name === "double");
               if (hasDoubleParam) {
                 const ns = ctx.getNamespace();
@@ -22841,6 +24121,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) {
@@ -22866,6 +24163,31 @@ var require_lower2 = __commonJS({
               }
             }
           }
+          if (expr.callee.kind === "member" && expr.callee.obj.kind !== "ident") {
+            const returnedStructType = inferInvokeReturnStructType(expr.callee.obj, ctx);
+            if (returnedStructType) {
+              lowerExpr(expr.callee.obj, ctx, scope);
+              const chainFields = ctx.structDefs.get(returnedStructType) ?? [];
+              const chainFieldTemps = /* @__PURE__ */ 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 };
+              }
+            }
+          }
           const calleeOp = lowerExpr(expr.callee, ctx, scope);
           const args = expr.args.map((a) => lowerExpr(a, ctx, scope));
           const t = ctx.freshTemp();
@@ -22887,6 +24209,25 @@ var require_lower2 = __commonJS({
             ctx.emit({ kind: "const", dst: t2, value: 0 });
             return { kind: "temp", name: t2 };
           }
+          if (ctx.singletonStructs.has(expr.type)) {
+            if (expr.method === "get") {
+              const t2 = ctx.freshTemp();
+              ctx.emit({ kind: "call", dst: t2, fn: `${expr.type}::${expr.method}`, args: [] });
+              return { kind: "temp", name: t2 };
+            } else if (expr.method === "set" && expr.args.length === 1 && expr.args[0].kind === "ident") {
+              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 t2 = ctx.freshTemp();
+                ctx.emit({ kind: "call", dst: t2, fn: `${expr.type}::${expr.method}`, args: fieldArgs });
+                return { kind: "temp", name: t2 };
+              }
+            }
+          }
           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 });
@@ -22916,6 +24257,41 @@ var require_lower2 = __commonJS({
           ctx.emit({ kind: "const", dst: t, value: 0 });
           return { kind: "temp", name: t };
         }
+        case "unwrap_or": {
+          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 void 0;
+          })();
+          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;
@@ -23017,6 +24393,23 @@ var require_lower2 = __commonJS({
       ctx.switchTo(merge);
       return { kind: "temp", name: result };
     }
+    function inferInvokeReturnStructType(expr, ctx) {
+      if (expr.kind === "invoke" && expr.callee.kind === "member") {
+        let receiverTypeName;
+        if (expr.callee.obj.kind === "ident") {
+          receiverTypeName = ctx.structVars.get(expr.callee.obj.name)?.typeName;
+        } else {
+          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 void 0;
+    }
     function lowerTimerMethod(method, timerId, sv, ctx, scope, extraArgs) {
       const ns = ctx.getNamespace();
       const player = `__timer_${timerId}`;
@@ -23136,6 +24529,39 @@ var require_lower2 = __commonJS({
         }
       }
     }
+    function lowerStringExprToPath(expr, ctx, scope, hint = "str") {
+      switch (expr.kind) {
+        case "str_lit": {
+          const path3 = ctx.freshStringVar(hint);
+          ctx.emit({
+            kind: "call",
+            dst: null,
+            fn: `__raw:data modify storage rs:strings ${path3} set value ${JSON.stringify(expr.value)}`,
+            args: []
+          });
+          return path3;
+        }
+        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) {
       if (!sel.filters || Object.keys(sel.filters).length === 0) {
         return sel.kind;
@@ -23158,7 +24584,82 @@ var require_lower2 = __commonJS({
       return `${sel.kind}[${parts.join(",")}]`;
     }
     var MACRO_SENTINEL = "
";
-    function formatBuiltinCall(fn, args, macroParams) {
+    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;
+        if (inner.kind === "ident" || inner.kind === "int_lit" || inner.kind === "bool_lit") {
+          newParts.push({ kind: "expr", expr: inner });
+          continue;
+        }
+        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;
+          }
+          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;
+        }
+        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 {
+          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 = "") {
+      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 +24713,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 +24779,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 +25784,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":
@@ -24315,6 +25837,219 @@ var require_interprocedural = __commonJS({
   }
 });
 
+// ../../dist/src/optimizer/inline.js
+var require_inline = __commonJS({
+  "../../dist/src/optimizer/inline.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.inlinePass = inlinePass;
+    var _inlineCounter = 0;
+    function freshInlineId() {
+      return `__inline_${_inlineCounter++}`;
+    }
+    function inlinePass(mod) {
+      const inlineSet = mod.inlineFunctions;
+      if (!inlineSet || inlineSet.size === 0)
+        return mod;
+      const fnMap = new Map(mod.functions.map((f) => [f.name, f]));
+      const updatedFunctions = mod.functions.map((fn) => inlineCallsInFunction(fn, fnMap, inlineSet));
+      return { ...mod, functions: updatedFunctions };
+    }
+    function inlineCallsInFunction(fn, fnMap, inlineSet) {
+      let blocks = fn.blocks.map((b) => ({ ...b, instrs: [...b.instrs] }));
+      let changed = true;
+      while (changed) {
+        changed = false;
+        const nextBlocks = [];
+        for (const block of blocks) {
+          const callIdx = block.instrs.findIndex((instr) => {
+            if (instr.kind !== "call")
+              return false;
+            if (!inlineSet.has(instr.fn))
+              return false;
+            const callee2 = fnMap.get(instr.fn);
+            if (!callee2)
+              return false;
+            if (callee2.isMacro)
+              return false;
+            if (callee2.name === fn.name)
+              return false;
+            if (isSelfRecursive(callee2))
+              return false;
+            if (callee2.params.length !== instr.args.length)
+              return false;
+            return true;
+          });
+          if (callIdx === -1) {
+            nextBlocks.push(block);
+            continue;
+          }
+          changed = true;
+          const callInstr = block.instrs[callIdx];
+          const callee = fnMap.get(callInstr.fn);
+          const inlineId = freshInlineId();
+          const priorInstrs = block.instrs.slice(0, callIdx);
+          const afterInstrs = block.instrs.slice(callIdx + 1);
+          const contBlockId = `${block.id}${inlineId}_cont`;
+          const clonedBlocks = cloneCallee(callee, inlineId, callInstr.args, callInstr.dst, contBlockId);
+          const clonedEntryId = `${callee.entry}${inlineId}`;
+          const patchedCurrentBlock = {
+            ...block,
+            instrs: priorInstrs,
+            term: { kind: "jump", target: clonedEntryId }
+          };
+          const contBlock = {
+            id: contBlockId,
+            instrs: afterInstrs,
+            term: block.term,
+            preds: []
+          };
+          nextBlocks.push(patchedCurrentBlock, ...clonedBlocks, contBlock);
+        }
+        blocks = nextBlocks;
+      }
+      return { ...fn, blocks };
+    }
+    function cloneCallee(callee, inlineId, args, dst, contBlockId) {
+      const sub = /* @__PURE__ */ new Map();
+      for (let i = 0; i < callee.params.length; i++) {
+        sub.set(callee.params[i].name, args[i]);
+      }
+      const calleeTemps = /* @__PURE__ */ new Set();
+      for (const block of callee.blocks) {
+        collectDefinedTemps(block, calleeTemps);
+      }
+      const tempRename = /* @__PURE__ */ new Map();
+      for (const tmp of calleeTemps) {
+        if (!sub.has(tmp)) {
+          tempRename.set(tmp, `${tmp}${inlineId}`);
+        }
+      }
+      const fullSub = new Map([...sub]);
+      for (const [old, renamed] of tempRename) {
+        fullSub.set(old, { kind: "temp", name: renamed });
+      }
+      const blockRename = (id) => `${id}${inlineId}`;
+      return callee.blocks.map((block) => cloneBlock(block, inlineId, fullSub, blockRename, dst, contBlockId));
+    }
+    function collectDefinedTemps(block, out) {
+      const collect = (instr) => {
+        if ("dst" in instr && instr.dst !== null && instr.dst !== void 0) {
+          out.add(instr.dst);
+        }
+      };
+      block.instrs.forEach(collect);
+      collect(block.term);
+    }
+    function cloneBlock(block, inlineId, sub, blockRename, callDst, contBlockId) {
+      const newId = blockRename(block.id);
+      const newInstrs = block.instrs.map((instr) => subAndRenameInstr(instr, sub, blockRename));
+      let newTerm;
+      const term = block.term;
+      if (term.kind === "return") {
+        const retInstrs = [];
+        if (term.value !== null && callDst !== null) {
+          const subbed = substituteOp(term.value, sub);
+          retInstrs.push({ kind: "copy", dst: callDst, src: subbed });
+        }
+        return {
+          id: newId,
+          instrs: [...newInstrs, ...retInstrs],
+          term: { kind: "jump", target: contBlockId },
+          preds: block.preds.map(blockRename)
+        };
+      } else {
+        newTerm = subAndRenameInstr(term, sub, blockRename);
+      }
+      return {
+        id: newId,
+        instrs: newInstrs,
+        term: newTerm,
+        preds: block.preds.map(blockRename)
+      };
+    }
+    function substituteOp(op, sub) {
+      if (op.kind === "temp") {
+        const replacement = sub.get(op.name);
+        if (replacement !== void 0)
+          return replacement;
+      }
+      return op;
+    }
+    function renameBlockId(id, blockRename) {
+      return blockRename(id);
+    }
+    function subAndRenameInstr(instr, sub, blockRename) {
+      const renameDst = (dst) => {
+        if (dst === null)
+          return null;
+        const r = sub.get(dst);
+        if (r && r.kind === "temp")
+          return r.name;
+        return dst;
+      };
+      switch (instr.kind) {
+        case "const":
+          return { ...instr, dst: renameDst(instr.dst) };
+        case "copy":
+          return { ...instr, dst: renameDst(instr.dst), src: substituteOp(instr.src, sub) };
+        case "neg":
+        case "not":
+          return { ...instr, dst: renameDst(instr.dst), src: substituteOp(instr.src, sub) };
+        case "add":
+        case "sub":
+        case "mul":
+        case "div":
+        case "mod":
+        case "and":
+        case "or":
+          return { ...instr, dst: renameDst(instr.dst), a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
+        case "cmp":
+          return { ...instr, dst: renameDst(instr.dst), a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) };
+        case "nbt_read":
+          return { ...instr, dst: renameDst(instr.dst) };
+        case "nbt_read_dynamic":
+          return { ...instr, dst: renameDst(instr.dst), indexSrc: substituteOp(instr.indexSrc, sub) };
+        case "nbt_write":
+          return { ...instr, src: substituteOp(instr.src, sub) };
+        case "nbt_write_dynamic":
+          return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) };
+        case "nbt_list_len":
+          return { ...instr, dst: renameDst(instr.dst) };
+        case "score_read":
+          return { ...instr, dst: renameDst(instr.dst) };
+        case "score_write":
+          return { ...instr, src: substituteOp(instr.src, sub) };
+        case "call":
+          return { ...instr, dst: renameDst(instr.dst), args: instr.args.map((a) => substituteOp(a, sub)) };
+        case "call_macro":
+          return { ...instr, dst: renameDst(instr.dst), args: instr.args.map((a) => ({ ...a, value: substituteOp(a.value, sub) })) };
+        case "call_context":
+          return instr;
+        case "jump":
+          return { ...instr, target: renameBlockId(instr.target, blockRename) };
+        case "branch":
+          return { ...instr, cond: substituteOp(instr.cond, sub), then: renameBlockId(instr.then, blockRename), else: renameBlockId(instr.else, blockRename) };
+        case "return":
+          return { ...instr, value: instr.value ? substituteOp(instr.value, sub) : null };
+        default:
+          return instr;
+      }
+    }
+    function isSelfRecursive(fn) {
+      for (const block of fn.blocks) {
+        for (const instr of block.instrs) {
+          if (instr.kind === "call" && instr.fn === fn.name)
+            return true;
+          if (instr.kind === "call_macro" && instr.fn === fn.name)
+            return true;
+        }
+      }
+      return false;
+    }
+  }
+});
+
 // ../../dist/src/optimizer/selector-cache.js
 var require_selector_cache = __commonJS({
   "../../dist/src/optimizer/selector-cache.js"(exports2) {
@@ -24405,6 +26140,7 @@ var require_pipeline = __commonJS({
     var unroll_1 = require_unroll();
     var nbt_batch_1 = require_nbt_batch();
     var interprocedural_1 = require_interprocedural();
+    var inline_1 = require_inline();
     var selector_cache_1 = require_selector_cache();
     Object.defineProperty(exports2, "selectorCache", { enumerable: true, get: function() {
       return selector_cache_1.selectorCache;
@@ -24432,9 +26168,10 @@ var require_pipeline = __commonJS({
       return current;
     }
     function optimizeModule(mod, passes) {
+      const inlined = (0, inline_1.inlinePass)(mod);
       const perFnOptimized = {
-        ...mod,
-        functions: mod.functions.map((fn) => optimizeFunction(fn, passes))
+        ...inlined,
+        functions: inlined.functions.map((fn) => optimizeFunction(fn, passes))
       };
       return (0, interprocedural_1.interproceduralConstProp)(perFnOptimized);
     }
@@ -24691,6 +26428,17 @@ var require_lower3 = __commonJS({
           });
           break;
         }
+        case "string_match": {
+          const dst = ctx.slot(instr.dst);
+          const dstStr = `${dst.player} ${dst.obj}`;
+          const literal = JSON.stringify(instr.value);
+          instrs.push({ kind: "score_set", dst, value: 0 });
+          instrs.push({
+            kind: "raw",
+            cmd: `execute if data storage ${instr.ns} ${instr.path} matches ${literal} run scoreboard players set ${dstStr} 1`
+          });
+          break;
+        }
         case "and": {
           lowerOperandToSlot(instr.dst, instr.a, ctx, instrs);
           lowerBinOp(instr.dst, instr.b, "score_mul", ctx, instrs);
@@ -24722,6 +26470,17 @@ var require_lower3 = __commonJS({
           });
           break;
         }
+        case "nbt_list_len": {
+          const dst = ctx.slot(instr.dst);
+          instrs.push({
+            kind: "store_nbt_to_score",
+            dst,
+            ns: instr.ns,
+            path: instr.path,
+            scale: 1
+          });
+          break;
+        }
         case "nbt_read_dynamic": {
           const dst = ctx.slot(instr.dst);
           const idxSlot = operandToSlot(instr.indexSrc, ctx, instrs);
@@ -25391,6 +27150,9 @@ var require_emit = __commonJS({
       const tickFns = options.tickFunctions ?? [];
       const loadFns = options.loadFunctions ?? [];
       const scheduleFns = options.scheduleFunctions ?? [];
+      const watchFns = options.watchFunctions ?? [];
+      const profiledFns = options.profiledFunctions ?? [];
+      const enableProfiling = options.enableProfiling ?? false;
       const objective = module3.objective;
       const genSourceMap = options.generateSourceMap ?? false;
       const mcVersion = options.mcVersion ?? mc_version_1.DEFAULT_MC_VERSION;
@@ -25401,7 +27163,16 @@ var require_emit = __commonJS({
           pack: { pack_format: 26, description: `RedScript datapack: ${namespace}` }
         }, null, 2) + "\n"
       });
-      const loadCmds = [`scoreboard objectives add ${objective} dummy`];
+      const singletonObjectives = options.singletonObjectives ?? [];
+      const loadCmds = [
+        `scoreboard objectives add ${objective} dummy`,
+        ...watchFns.map((watch) => `scoreboard objectives add ${watchPrevObjective(watch.name)} dummy`),
+        ...singletonObjectives.map((obj) => `scoreboard objectives add ${obj} dummy`),
+        ...enableProfiling && profiledFns.length > 0 ? [
+          "scoreboard objectives add __time dummy",
+          "scoreboard objectives add __profile dummy"
+        ] : []
+      ];
       files.push({
         path: `data/${namespace}/function/load.mcfunction`,
         content: loadCmds.join("\n") + "\n"
@@ -25410,17 +27181,27 @@ var require_emit = __commonJS({
         const fnPath = fnNameToPath(fn.name, namespace);
         if (genSourceMap) {
           const builder = new sourcemap_1.SourceMapBuilder(fnPath);
-          const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion);
+          const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion, enableProfiling && profiledFns.includes(fn.name));
           files.push({ path: fnPath, content: lines.join("\n") + "\n" });
           const map = builder.build();
           if (map) {
             files.push({ path: (0, sourcemap_1.sourceMapPath)(fnPath), content: (0, sourcemap_1.serializeSourceMap)(map) });
           }
         } else {
-          const lines = emitFunction(fn, namespace, objective, mcVersion);
+          const lines = emitFunction(fn, namespace, objective, mcVersion, enableProfiling && profiledFns.includes(fn.name));
           files.push({ path: fnPath, content: lines.join("\n") + "\n" });
         }
       }
+      if (enableProfiling && profiledFns.length > 0) {
+        files.push({
+          path: `data/${namespace}/function/__profiler_reset.mcfunction`,
+          content: emitProfilerReset(profiledFns).join("\n") + "\n"
+        });
+        files.push({
+          path: `data/${namespace}/function/__profiler_report.mcfunction`,
+          content: emitProfilerReport(profiledFns).join("\n") + "\n"
+        });
+      }
       for (const { name, ticks } of scheduleFns) {
         files.push({
           path: `data/${namespace}/function/_schedule_${name}.mcfunction`,
@@ -25428,6 +27209,19 @@ var require_emit = __commonJS({
 `
         });
       }
+      for (const watch of watchFns) {
+        const dispatcher = watchDispatcherName(watch.name);
+        const prevObjective = watchPrevObjective(watch.name);
+        const changedCondition = `unless score @s ${watch.objective} = @s ${prevObjective}`;
+        files.push({
+          path: fnNameToPath(dispatcher, namespace),
+          content: [
+            `execute as @a unless score @s ${prevObjective} = @s ${prevObjective} run scoreboard players operation @s ${prevObjective} = @s ${watch.objective}`,
+            `execute as @a ${changedCondition} run function ${namespace}:${watch.name}`,
+            `execute as @a ${changedCondition} run scoreboard players operation @s ${prevObjective} = @s ${watch.objective}`
+          ].join("\n") + "\n"
+        });
+      }
       if (loadFns.length > 0 || true) {
         const loadValues = [`${namespace}:load`, ...loadFns.map((fn) => `${namespace}:${fn}`)];
         files.push({
@@ -25435,34 +27229,115 @@ var require_emit = __commonJS({
           content: JSON.stringify({ values: loadValues }, null, 2) + "\n"
         });
       }
-      if (tickFns.length > 0) {
-        const tickValues = tickFns.map((fn) => `${namespace}:${fn}`);
+      const allTickFns = [...tickFns, ...watchFns.map((watch) => watchDispatcherName(watch.name))];
+      if (allTickFns.length > 0) {
+        const tickValues = allTickFns.map((fn) => `${namespace}:${fn}`);
         files.push({
           path: "data/minecraft/tags/function/tick.json",
           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) {
-      const lines = [];
+    function emitFunction(fn, namespace, objective, mcVersion, isProfiled = false) {
+      const lines = isProfiled ? profilerStartLines(fn.name) : [];
       for (const instr of fn.instructions) {
         lines.push(emitInstr(instr, namespace, objective, mcVersion));
       }
+      if (isProfiled) {
+        lines.push(...profilerEndLines(fn.name));
+      }
       return lines;
     }
-    function emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion) {
+    function emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion, isProfiled = false) {
       const lines = [];
+      if (isProfiled) {
+        for (const line of profilerStartLines(fn.name)) {
+          lines.push(line);
+          builder.addLine(void 0);
+        }
+      }
       for (const instr of fn.instructions) {
         lines.push(emitInstr(instr, namespace, objective, mcVersion));
         builder.addLine(instr.sourceLoc);
       }
+      if (isProfiled) {
+        for (const line of profilerEndLines(fn.name)) {
+          lines.push(line);
+          builder.addLine(void 0);
+        }
+      }
       return lines;
     }
     function fnNameToPath(name, namespace) {
       const mcName = name.replace(/::/g, "/").toLowerCase();
       return `data/${namespace}/function/${mcName}.mcfunction`;
     }
+    function watchDispatcherName(name) {
+      return `__watch_${name}`;
+    }
+    function watchPrevObjective(name) {
+      return `__watch_${name}_prev`;
+    }
+    function profilerSafeName(name) {
+      return name.replace(/[^A-Za-z0-9_]/g, "_");
+    }
+    function profilerStartPlayer(name) {
+      return `#prof_start_${profilerSafeName(name)}`;
+    }
+    function profilerDeltaPlayer(name) {
+      return `#prof_delta_${profilerSafeName(name)}`;
+    }
+    function profilerTotalPlayer(name) {
+      return `#prof_total_${profilerSafeName(name)}`;
+    }
+    function profilerCountPlayer(name) {
+      return `#prof_count_${profilerSafeName(name)}`;
+    }
+    function profilerStartLines(name) {
+      return [
+        `# __profiler_start_${name}`,
+        `scoreboard players set ${profilerStartPlayer(name)} __time 0`,
+        `execute store result score ${profilerStartPlayer(name)} __time run time query gametime`
+      ];
+    }
+    function profilerEndLines(name) {
+      return [
+        `# __profiler_end_${name}`,
+        `scoreboard players set ${profilerDeltaPlayer(name)} __time 0`,
+        `execute store result score ${profilerDeltaPlayer(name)} __time run time query gametime`,
+        `scoreboard players operation ${profilerDeltaPlayer(name)} __time -= ${profilerStartPlayer(name)} __time`,
+        `scoreboard players operation ${profilerTotalPlayer(name)} __profile += ${profilerDeltaPlayer(name)} __time`,
+        `scoreboard players add ${profilerCountPlayer(name)} __profile 1`
+      ];
+    }
+    function emitProfilerReset(profiledFns) {
+      return profiledFns.flatMap((name) => [
+        `scoreboard players set ${profilerTotalPlayer(name)} __profile 0`,
+        `scoreboard players set ${profilerCountPlayer(name)} __profile 0`
+      ]);
+    }
+    function emitProfilerReport(profiledFns) {
+      return profiledFns.map((name) => `tellraw @a [{"text":"[profile] ${name}: total="},{"score":{"name":"${profilerTotalPlayer(name)}","objective":"__profile"}},{"text":" ticks count="},{"score":{"name":"${profilerCountPlayer(name)}","objective":"__profile"}}]`);
+    }
     function emitInstr(instr, ns, obj, mcVersion) {
       switch (instr.kind) {
         case "score_set":
@@ -25649,15 +27524,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 +27746,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 +27806,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 +27854,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 +27881,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 +27973,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 +27996,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 +28008,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 +28049,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 +28136,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 +28389,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",
@@ -26616,7 +28524,6 @@ var require_typechecker = __commonJS({
     var VOID_TYPE = { kind: "named", name: "void" };
     var INT_TYPE = { kind: "named", name: "int" };
     var STRING_TYPE = { kind: "named", name: "string" };
-    var FORMAT_STRING_TYPE = { kind: "named", name: "format_string" };
     var BUILTIN_SIGNATURES = {
       setTimeout: {
         params: [INT_TYPE, { kind: "function_type", params: [], return: VOID_TYPE }],
@@ -26629,15 +28536,24 @@ var require_typechecker = __commonJS({
       clearInterval: {
         params: [INT_TYPE],
         return: VOID_TYPE
+      },
+      int_to_str: {
+        params: [INT_TYPE],
+        return: STRING_TYPE
+      },
+      bool_to_str: {
+        params: [{ kind: "named", name: "bool" }],
+        return: STRING_TYPE
       }
     };
-    var TypeChecker = class {
+    var TypeChecker = class _TypeChecker {
       constructor(source, filePath) {
         this.lintWarnings = [];
         this.functions = /* @__PURE__ */ new Map();
         this.implMethods = /* @__PURE__ */ new Map();
         this.structs = /* @__PURE__ */ new Map();
         this.enums = /* @__PURE__ */ new Map();
+        this.enumPayloads = /* @__PURE__ */ new Map();
         this.consts = /* @__PURE__ */ new Map();
         this.globals = /* @__PURE__ */ new Map();
         this.currentFn = null;
@@ -26646,6 +28562,7 @@ var require_typechecker = __commonJS({
         this.selfTypeStack = ["entity"];
         this.loopDepth = 0;
         this.condDepth = 0;
+        this.interfaces = /* @__PURE__ */ new Map();
         this.richTextBuiltins = /* @__PURE__ */ new Map([
           ["say", { messageIndex: 0 }],
           ["announce", { messageIndex: 0 }],
@@ -26685,6 +28602,9 @@ var require_typechecker = __commonJS({
         for (const fn of program.declarations) {
           this.functions.set(fn.name, fn);
         }
+        for (const iface of program.interfaces ?? []) {
+          this.interfaces.set(iface.name, iface);
+        }
         for (const global of program.globals ?? []) {
           this.globals.set(global.name, this.normalizeType(global.type));
         }
@@ -26714,13 +28634,47 @@ var require_typechecker = __commonJS({
             fields.set(field.name, field.type);
           }
           this.structs.set(struct.name, fields);
+          if (struct.isSingleton) {
+            const structType = { kind: "struct", name: struct.name };
+            let singletonMethods = this.implMethods.get(struct.name);
+            if (!singletonMethods) {
+              singletonMethods = /* @__PURE__ */ new Map();
+              this.implMethods.set(struct.name, singletonMethods);
+            }
+            const voidType = { kind: "named", name: "void" };
+            singletonMethods.set("get", {
+              name: "get",
+              params: [],
+              returnType: structType,
+              decorators: [],
+              body: [],
+              typeParams: void 0,
+              isLibraryFn: true
+            });
+            singletonMethods.set("set", {
+              name: "set",
+              params: [{ name: "gs", type: structType }],
+              returnType: voidType,
+              decorators: [],
+              body: [],
+              typeParams: void 0,
+              isLibraryFn: true
+            });
+          }
         }
         for (const enumDecl of program.enums ?? []) {
           const variants = /* @__PURE__ */ new Map();
+          const payloads = /* @__PURE__ */ new Map();
           for (const variant of enumDecl.variants) {
             variants.set(variant.name, variant.value ?? 0);
+            if (variant.fields && variant.fields.length > 0) {
+              payloads.set(variant.name, variant.fields);
+            }
           }
           this.enums.set(enumDecl.name, variants);
+          if (payloads.size > 0) {
+            this.enumPayloads.set(enumDecl.name, payloads);
+          }
         }
         for (const constDecl of program.consts ?? []) {
           const constType = this.normalizeType(constDecl.type);
@@ -26730,6 +28684,20 @@ var require_typechecker = __commonJS({
           }
           this.consts.set(constDecl.name, constType);
         }
+        for (const implBlock of program.implBlocks ?? []) {
+          if (!implBlock.traitName)
+            continue;
+          const iface = this.interfaces.get(implBlock.traitName);
+          if (!iface)
+            continue;
+          const implementedMethods = new Set(implBlock.methods.map((m) => m.name));
+          for (const required of iface.methods) {
+            if (!implementedMethods.has(required.name)) {
+              const span = implBlock.span ?? required.span;
+              this.report(`Struct '${implBlock.typeName}' does not implement required method '${required.name}' from interface '${implBlock.traitName}'`, span ?? { line: 1, col: 1 });
+            }
+          }
+        }
         for (const fn of program.declarations) {
           this.checkFunction(fn);
         }
@@ -26773,6 +28741,30 @@ var require_typechecker = __commonJS({
         this.currentReturnType = null;
       }
       checkFunctionDecorators(fn) {
+        const watchDecorators = fn.decorators.filter((decorator) => decorator.name === "watch");
+        if (watchDecorators.length > 1) {
+          this.report(`Function '${fn.name}' cannot have multiple @watch decorators`, fn);
+          return;
+        }
+        if (watchDecorators.length === 1) {
+          const objective = watchDecorators[0].args?.objective;
+          if (!objective) {
+            this.report(`Function '${fn.name}' is missing a scoreboard objective in @watch("...")`, fn);
+            return;
+          }
+          if (fn.params.length > 0) {
+            this.report(`@watch handler '${fn.name}' cannot declare parameters`, fn);
+          }
+        }
+        const profileDecorators = fn.decorators.filter((decorator) => decorator.name === "profile");
+        if (profileDecorators.length > 1) {
+          this.report(`Function '${fn.name}' cannot have multiple @profile decorators`, fn);
+          return;
+        }
+        if (profileDecorators.length === 1 && (profileDecorators[0].rawArgs?.length || profileDecorators[0].args && Object.keys(profileDecorators[0].args).length > 0)) {
+          this.report(`@profile decorator on '${fn.name}' does not accept arguments`, fn);
+          return;
+        }
         const eventDecorators = fn.decorators.filter((decorator) => decorator.name === "on");
         if (eventDecorators.length === 0) {
           return;
@@ -26869,16 +28861,29 @@ 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);
+              } else if (arm.pattern.kind === "PatEnum") {
+                const pat = arm.pattern;
+                const variantPayloads = this.enumPayloads.get(pat.enumName)?.get(pat.variant) ?? [];
+                const savedScope = new Map(this.scope);
+                for (let i = 0; i < pat.bindings.length; i++) {
+                  const fieldDef = variantPayloads[i];
+                  const bindingType = fieldDef ? fieldDef.type : { kind: "named", name: "int" };
+                  this.scope.set(pat.bindings[i], { type: bindingType, mutable: false });
+                }
+                this.checkBlock(arm.body);
+                this.scope = savedScope;
+              } else {
+                this.checkBlock(arm.body);
               }
-              this.checkBlock(arm.body);
             }
             break;
           case "as_block": {
@@ -26917,6 +28922,9 @@ var require_typechecker = __commonJS({
             break;
           case "raw":
             break;
+          case "const_decl":
+            this.scope.set(stmt.name, { type: stmt.type, mutable: false });
+            break;
         }
       }
       checkLetDestructStmt(stmt) {
@@ -27014,6 +29022,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 +29091,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);
               }
             }
@@ -27109,6 +29122,31 @@ var require_typechecker = __commonJS({
               }
             }
             break;
+          case "enum_construct": {
+            if (!this.enums.has(expr.enumName)) {
+              this.report(`Unknown enum '${expr.enumName}'`, expr);
+              break;
+            }
+            const variants = this.enums.get(expr.enumName);
+            if (!variants.has(expr.variant)) {
+              this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr);
+              break;
+            }
+            const variantPayloads = this.enumPayloads.get(expr.enumName)?.get(expr.variant) ?? [];
+            if (variantPayloads.length === 0 && expr.args.length > 0) {
+              this.report(`Enum variant '${expr.enumName}::${expr.variant}' has no payload fields`, expr);
+              break;
+            }
+            for (const arg of expr.args) {
+              const fieldDef = variantPayloads.find((f) => f.name === arg.name);
+              if (!fieldDef) {
+                this.report(`Unknown field '${arg.name}' for enum variant '${expr.enumName}::${expr.variant}'`, expr);
+              } else {
+                this.checkExpr(arg.value, fieldDef.type);
+              }
+            }
+            break;
+          }
           case "blockpos":
             break;
           // Literals don't need checking
@@ -27201,7 +29239,7 @@ var require_typechecker = __commonJS({
           return;
         }
         const messageType = this.inferType(message);
-        if (messageType.kind !== "named" || messageType.name !== "string" && messageType.name !== "format_string") {
+        if (messageType.kind !== "named" || messageType.name !== "string") {
           this.report(`Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`, message);
         }
       }
@@ -27397,7 +29435,7 @@ var require_typechecker = __commonJS({
                 this.checkExpr(part.expr);
               }
             }
-            return FORMAT_STRING_TYPE;
+            return STRING_TYPE;
           case "blockpos":
             return { kind: "named", name: "BlockPos" };
           case "ident":
@@ -27458,6 +29496,11 @@ var require_typechecker = __commonJS({
               return { kind: "enum", name: expr.enumName };
             }
             return { kind: "named", name: "void" };
+          case "enum_construct":
+            if (this.enums.has(expr.enumName)) {
+              return { kind: "enum", name: expr.enumName };
+            }
+            return { kind: "named", name: "void" };
           case "member":
             if (expr.obj.kind === "ident" && this.enums.has(expr.obj.name)) {
               return { kind: "enum", name: expr.obj.name };
@@ -27569,7 +29612,8 @@ var require_typechecker = __commonJS({
         if (receiverType.kind !== "struct") {
           return null;
         }
-        const method = this.implMethods.get(receiverType.name)?.get(expr.fn);
+        const methodName = _TypeChecker.PARSER_METHOD_REMAP[expr.fn] ?? expr.fn;
+        const method = this.implMethods.get(receiverType.name)?.get(expr.fn) ?? this.implMethods.get(receiverType.name)?.get(methodName);
         if (!method || method.params[0]?.name !== "self") {
           return null;
         }
@@ -27740,6 +29784,17 @@ var require_typechecker = __commonJS({
       }
     };
     exports2.TypeChecker = TypeChecker;
+    TypeChecker.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"
+    };
   }
 });
 
@@ -27747,14 +29802,54 @@ var require_typechecker = __commonJS({
 var require_compile2 = __commonJS({
   "../../dist/src/emit/compile.js"(exports2) {
     "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.compile = compile;
+    var fs2 = __importStar(require("fs"));
+    var path3 = __importStar(require("path"));
     var lexer_1 = require_lexer();
     var parser_1 = require_parser();
     var compile_1 = require_compile();
     var diagnostics_1 = require_diagnostics();
     var lower_1 = require_lower();
     var monomorphize_1 = require_monomorphize();
+    var deprecated_1 = require_deprecated();
     var lower_2 = require_lower2();
     var pipeline_1 = require_pipeline();
     var lower_3 = require_lower3();
@@ -27764,35 +29859,137 @@ 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 pruneLibraryFunctionFiles(files, libraryPaths) {
+      if (libraryPaths.size === 0)
+        return files;
+      const fnPathToFilePath = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        const match = file.path.match(/^data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (match) {
+          fnPathToFilePath.set(`${match[1]}:${match[2]}`, file.path);
+        }
+      }
+      const callGraph = /* @__PURE__ */ new Map();
+      const callPattern = /\bfunction\s+([\w\-]+:[\w\-./]+)/g;
+      for (const file of files) {
+        if (!file.path.endsWith(".mcfunction"))
+          continue;
+        const called = /* @__PURE__ */ new Set();
+        let match;
+        callPattern.lastIndex = 0;
+        while ((match = callPattern.exec(file.content)) !== null) {
+          called.add(match[1]);
+        }
+        callGraph.set(file.path, called);
+      }
+      const reachableFiles = /* @__PURE__ */ new Set();
+      const queue = [];
+      for (const file of files) {
+        if (!file.path.endsWith(".mcfunction"))
+          continue;
+        if (libraryPaths.has(file.path))
+          continue;
+        queue.push(file.path);
+        reachableFiles.add(file.path);
+      }
+      while (queue.length > 0) {
+        const current = queue.shift();
+        const called = callGraph.get(current) ?? /* @__PURE__ */ new Set();
+        for (const fnPath of called) {
+          const filePath = fnPathToFilePath.get(fnPath);
+          if (filePath && !reachableFiles.has(filePath)) {
+            reachableFiles.add(filePath);
+            queue.push(filePath);
+          }
+        }
+      }
+      return files.filter((file) => !libraryPaths.has(file.path) || reachableFiles.has(file.path));
+    }
     function compile(source, options = {}) {
-      const { namespace = "redscript", filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false, includeDirs } = options;
+      const { namespace = "redscript", filePath, generateSourceMap = false, mcVersion = mc_version_1.DEFAULT_MC_VERSION, lenient = false, includeDirs, stopAfterCheck = false, debug = false } = options;
       const warnings = [];
       const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath, includeDirs });
       const processedSource = preprocessed.source;
-      const lexer = new lexer_1.Lexer(processedSource);
-      const tokens = lexer.tokenize();
-      const parser = new parser_1.Parser(tokens, processedSource, filePath);
-      const ast = parser.parse(namespace);
-      warnings.push(...parser.warnings);
-      for (const li of preprocessed.libraryImports ?? []) {
-        const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
-        const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
-        const libParser = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath);
-        const libAst = libParser.parse(namespace);
-        warnings.push(...libParser.warnings);
-        for (const fn of libAst.declarations)
-          fn.isLibraryFn = true;
-        ast.declarations.push(...libAst.declarations);
-        ast.structs.push(...libAst.structs);
-        ast.implBlocks.push(...libAst.implBlocks);
-        ast.enums.push(...libAst.enums);
-        ast.consts.push(...libAst.consts);
-        ast.globals.push(...libAst.globals);
-      }
-      if (options.librarySources) {
-        for (const libSrc of options.librarySources) {
-          const libTokens = new lexer_1.Lexer(libSrc).tokenize();
-          const libAst = new parser_1.Parser(libTokens, libSrc).parse(namespace);
+      try {
+        let resolveModuleFilePath = function(modName, fromFile) {
+          const candidates = [`${modName}.mcrs`, modName];
+          const stdlibDir = path3.resolve(__dirname, "..", "src", "stdlib");
+          for (const candidate of candidates) {
+            if (fromFile) {
+              const rel = path3.resolve(path3.dirname(fromFile), candidate);
+              if (fs2.existsSync(rel))
+                return rel;
+            }
+            const stdlib = path3.resolve(stdlibDir, candidate);
+            if (fs2.existsSync(stdlib))
+              return stdlib;
+            for (const dir of includeDirs ?? []) {
+              const extra = path3.resolve(dir, candidate);
+              if (fs2.existsSync(extra))
+                return extra;
+            }
+          }
+          return null;
+        }, mergeWholeModuleImport = function(modFilePath) {
+          if (seenModuleImports.has(modFilePath))
+            return;
+          seenModuleImports.add(modFilePath);
+          const modSource = fs2.readFileSync(modFilePath, "utf-8");
+          const modPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(modSource, { filePath: modFilePath, includeDirs });
+          const modTokens = new lexer_1.Lexer(modPreprocessed.source, modFilePath).tokenize();
+          const modParser = new parser_1.Parser(modTokens, modPreprocessed.source, modFilePath);
+          const modAst = modParser.parse(namespace);
+          warnings.push(...modParser.warnings);
+          if (modParser.parseErrors.length > 0) {
+            throw stopAfterCheck ? new diagnostics_1.DiagnosticBundleError(modParser.parseErrors) : modParser.parseErrors[0];
+          }
+          for (const fn of modAst.declarations)
+            fn.isLibraryFn = true;
+          for (const imp of modAst.imports) {
+            if (imp.symbol !== void 0)
+              continue;
+            const nestedPath = resolveModuleFilePath(imp.moduleName, modFilePath);
+            if (!nestedPath) {
+              warnings.push(`[ImportWarning] Module '${imp.moduleName}' not found (imported in ${modFilePath})`);
+              continue;
+            }
+            mergeWholeModuleImport(nestedPath);
+          }
+          ast.declarations.push(...modAst.declarations);
+          ast.structs.push(...modAst.structs);
+          ast.implBlocks.push(...modAst.implBlocks);
+          ast.enums.push(...modAst.enums);
+          ast.consts.push(...modAst.consts);
+          ast.globals.push(...modAst.globals);
+        };
+        const lexer = new lexer_1.Lexer(processedSource);
+        const tokens = lexer.tokenize();
+        const parser = new parser_1.Parser(tokens, processedSource, filePath);
+        const ast = parser.parse(namespace);
+        warnings.push(...parser.warnings);
+        if (parser.parseErrors.length > 0) {
+          throw stopAfterCheck ? new diagnostics_1.DiagnosticBundleError(parser.parseErrors) : parser.parseErrors[0];
+        }
+        const seenModuleImports = /* @__PURE__ */ new Set();
+        for (const imp of ast.imports) {
+          if (imp.symbol !== void 0)
+            continue;
+          const resolved = resolveModuleFilePath(imp.moduleName, filePath);
+          if (!resolved) {
+            throw new diagnostics_1.DiagnosticError("ParseError", `Module '${imp.moduleName}' not found. Make sure '${imp.moduleName}.mcrs' exists relative to this file or in the stdlib.`, imp.span ?? { line: 1, col: 1 });
+          }
+          mergeWholeModuleImport(resolved);
+        }
+        for (const li of preprocessed.libraryImports ?? []) {
+          const libPreprocessed = (0, compile_1.preprocessSourceWithMetadata)(li.source, { filePath: li.filePath });
+          const libTokens = new lexer_1.Lexer(libPreprocessed.source, li.filePath).tokenize();
+          const libParser = new parser_1.Parser(libTokens, libPreprocessed.source, li.filePath);
+          const libAst = libParser.parse(namespace);
+          warnings.push(...libParser.warnings);
+          if (libParser.parseErrors.length > 0) {
+            throw stopAfterCheck ? new diagnostics_1.DiagnosticBundleError(libParser.parseErrors) : libParser.parseErrors[0];
+          }
           for (const fn of libAst.declarations)
             fn.isLibraryFn = true;
           ast.declarations.push(...libAst.declarations);
@@ -27802,34 +29999,90 @@ var require_compile2 = __commonJS({
           ast.consts.push(...libAst.consts);
           ast.globals.push(...libAst.globals);
         }
-      }
-      {
-        const checker = new typechecker_1.TypeChecker(processedSource, filePath);
-        const typeErrors = checker.check(ast);
-        warnings.push(...checker.getWarnings());
-        if (typeErrors.length > 0) {
-          if (lenient) {
-            for (const e of typeErrors) {
-              warnings.push(`[TypeError] line ${e.location.line}, col ${e.location.col}: ${e.message}`);
+        if (options.librarySources) {
+          for (const libSrc of options.librarySources) {
+            const libTokens = new lexer_1.Lexer(libSrc).tokenize();
+            const libParser = new parser_1.Parser(libTokens, libSrc);
+            const libAst = libParser.parse(namespace);
+            warnings.push(...libParser.warnings);
+            if (libParser.parseErrors.length > 0) {
+              throw stopAfterCheck ? new diagnostics_1.DiagnosticBundleError(libParser.parseErrors) : libParser.parseErrors[0];
+            }
+            for (const fn of libAst.declarations)
+              fn.isLibraryFn = true;
+            ast.declarations.push(...libAst.declarations);
+            ast.structs.push(...libAst.structs);
+            ast.implBlocks.push(...libAst.implBlocks);
+            ast.enums.push(...libAst.enums);
+            ast.consts.push(...libAst.consts);
+            ast.globals.push(...libAst.globals);
+          }
+        }
+        {
+          const configValues = options.config ?? {};
+          const configGlobalNames = /* @__PURE__ */ new Set();
+          for (const g of ast.globals) {
+            if (g.configKey !== void 0) {
+              const resolvedValue = Object.prototype.hasOwnProperty.call(configValues, g.configKey) ? configValues[g.configKey] : g.configDefault ?? 0;
+              const intValue = Math.round(resolvedValue);
+              ast.consts.push({
+                name: g.name,
+                type: { kind: "named", name: "int" },
+                value: { kind: "int_lit", value: intValue },
+                span: g.span
+              });
+              configGlobalNames.add(g.name);
+            }
+          }
+          if (configGlobalNames.size > 0) {
+            ast.globals = ast.globals.filter((g) => !configGlobalNames.has(g.name));
+          }
+        }
+        {
+          const checker = new typechecker_1.TypeChecker(processedSource, filePath);
+          const typeErrors = checker.check(ast);
+          warnings.push(...checker.getWarnings());
+          if (typeErrors.length > 0) {
+            if (lenient) {
+              for (const e of typeErrors) {
+                warnings.push(`[TypeError] line ${e.location.line}, col ${e.location.col}: ${e.message}`);
+              }
+            } else {
+              throw stopAfterCheck ? new diagnostics_1.DiagnosticBundleError(typeErrors) : typeErrors[0];
             }
-          } else {
-            throw typeErrors[0];
           }
         }
-      }
-      try {
         const hirRaw = (0, lower_1.lowerToHIR)(ast);
         const hir = (0, monomorphize_1.monomorphize)(hirRaw);
+        const libraryFilePaths = new Set(hir.functions.filter((fn) => fn.isLibraryFn && fn.decorators.length === 0).map((fn) => `data/${namespace}/function/${fn.name}.mcfunction`));
+        warnings.push(...(0, deprecated_1.checkDeprecatedCalls)(hir));
+        if (stopAfterCheck) {
+          return { files: [], warnings, success: true };
+        }
         const tickFunctions = [];
         const loadFunctions = [];
+        const watchFunctions = [];
+        const inlineFunctions = /* @__PURE__ */ new Set();
         const coroutineInfos = [];
         const scheduleFunctions = [];
+        const profiledFunctions = [];
+        const eventHandlers = /* @__PURE__ */ new Map();
         for (const fn of hir.functions) {
+          if (fn.watchObjective) {
+            watchFunctions.push({ name: fn.name, objective: fn.watchObjective });
+          } else {
+            const watchDec = fn.decorators?.find((d) => d.name === "watch" && d.args?.objective);
+            if (watchDec?.args?.objective) {
+              watchFunctions.push({ name: fn.name, objective: watchDec.args.objective });
+            }
+          }
           for (const dec of fn.decorators) {
             if (dec.name === "tick")
               tickFunctions.push(fn.name);
             if (dec.name === "load")
               loadFunctions.push(fn.name);
+            if (dec.name === "inline")
+              inlineFunctions.add(fn.name);
             if (dec.name === "coroutine") {
               coroutineInfos.push({
                 fnName: fn.name,
@@ -27840,9 +30093,23 @@ var require_compile2 = __commonJS({
             if (dec.name === "schedule") {
               scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 });
             }
+            if (dec.name === "profile") {
+              profiledFunctions.push(fn.name);
+            }
+            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);
+        if (inlineFunctions.size > 0) {
+          mir.inlineFunctions = inlineFunctions;
+        }
         const mirOpt = (0, pipeline_1.optimizeModule)(mir);
         const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
         const mirFinal = coroResult.module;
@@ -27867,15 +30134,90 @@ var require_compile2 = __commonJS({
             }
           }
         }
-        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion });
-        return { files, warnings, success: true };
+        const singletonObjectives = [];
+        for (const s of hir.structs) {
+          if (!s.isSingleton)
+            continue;
+          const structName = s.name;
+          const objective = lirOpt.objective;
+          const getInstrs = [];
+          for (const field of s.fields) {
+            const fieldObj = singletonObjectiveName(structName, field.name);
+            if (!singletonObjectives.includes(fieldObj)) {
+              singletonObjectives.push(fieldObj);
+            }
+            getInstrs.push({
+              kind: "score_copy",
+              dst: { player: `$__rf_${field.name}`, obj: objective },
+              src: { player: `__sng`, obj: fieldObj }
+            });
+          }
+          getInstrs.push({ kind: "score_set", dst: { player: "$ret", obj: objective }, value: 0 });
+          lirOpt.functions.push({
+            name: `${structName}::get`,
+            instructions: getInstrs,
+            isMacro: false,
+            macroParams: []
+          });
+          const setInstrs = [];
+          for (let i = 0; i < s.fields.length; i++) {
+            const field = s.fields[i];
+            const fieldObj = singletonObjectiveName(structName, field.name);
+            setInstrs.push({
+              kind: "score_copy",
+              dst: { player: `__sng`, obj: fieldObj },
+              src: { player: `$p${i}`, obj: objective }
+            });
+          }
+          setInstrs.push({ kind: "score_set", dst: { player: "$ret", obj: objective }, value: 0 });
+          lirOpt.functions.push({
+            name: `${structName}::set`,
+            instructions: setInstrs,
+            isMacro: false,
+            macroParams: []
+          });
+        }
+        const files = (0, index_1.emit)(lirOpt, {
+          namespace,
+          tickFunctions,
+          loadFunctions,
+          watchFunctions,
+          scheduleFunctions,
+          generateSourceMap,
+          mcVersion,
+          eventHandlers,
+          singletonObjectives,
+          profiledFunctions,
+          enableProfiling: debug
+        });
+        const prunedFiles = pruneLibraryFunctionFiles(files, libraryFilePaths);
+        return { files: prunedFiles, warnings, success: true };
       } catch (err) {
+        if (stopAfterCheck) {
+          if (err instanceof diagnostics_1.CheckFailedError)
+            throw err;
+          if (err instanceof diagnostics_1.DiagnosticBundleError) {
+            throw new diagnostics_1.CheckFailedError(err.diagnostics, warnings);
+          }
+          if (err instanceof diagnostics_1.DiagnosticError) {
+            throw new diagnostics_1.CheckFailedError([err], warnings);
+          }
+          const sourceLines2 = processedSource.split("\n");
+          throw new diagnostics_1.CheckFailedError([(0, diagnostics_1.parseErrorMessage)("LoweringError", err.message, sourceLines2, filePath)], warnings);
+        }
         if (err instanceof diagnostics_1.DiagnosticError)
           throw err;
         const sourceLines = processedSource.split("\n");
         throw (0, diagnostics_1.parseErrorMessage)("LoweringError", err.message, sourceLines, filePath);
       }
     }
+    function singletonObjectiveName(structName, fieldName) {
+      const overhead = 5;
+      if (structName.length + fieldName.length <= 12) {
+        return `_s_${structName}_${fieldName}`;
+      }
+      return `_s_${structName.slice(0, 4)}_${fieldName.slice(0, 8)}`;
+    }
   }
 });
 
@@ -27908,6 +30250,9 @@ var require_modules = __commonJS({
         const tokens = lexer.tokenize();
         const parser = new parser_1.Parser(tokens, mod.source, mod.filePath);
         const ast = parser.parse(namespace);
+        if (parser.parseErrors.length > 0) {
+          throw parser.parseErrors[0];
+        }
         const declaredName = ast.moduleName;
         if (declaredName && declaredName !== mod.name) {
           throw new diagnostics_1.DiagnosticError("LoweringError", `Module declares name '${declaredName}' but was registered as '${mod.name}'`, { file: mod.filePath, line: 1, col: 1 });
@@ -27932,7 +30277,9 @@ var require_modules = __commonJS({
           if (!sourceExports) {
             throw new diagnostics_1.DiagnosticError("LoweringError", `Module '${imp.moduleName}' not found (imported in '${modName}')`, { file: ast.namespace, line: 1, col: 1 });
           }
-          if (imp.symbol === "*") {
+          if (imp.symbol === void 0) {
+            continue;
+          } else if (imp.symbol === "*") {
             for (const sym of sourceExports) {
               resolved.set(sym, `${imp.moduleName}/${sym}`);
             }
@@ -27951,6 +30298,8 @@ var require_modules = __commonJS({
       }
       for (const ast of parsedModules.values()) {
         for (const imp of ast.imports) {
+          if (imp.symbol === void 0)
+            continue;
           const used = usedExports.get(imp.moduleName);
           if (!used)
             continue;
@@ -28072,6 +30421,7 @@ var require_modules = __commonJS({
         const hir = (0, monomorphize_1.monomorphize)(hirRaw);
         const tickFunctions = [];
         const loadFunctions = [];
+        const watchFunctions = [];
         const coroutineInfos = [];
         const scheduleFunctions = [];
         for (const fn of hir.functions) {
@@ -28080,6 +30430,9 @@ var require_modules = __commonJS({
               tickFunctions.push(fn.name);
             if (dec.name === "load")
               loadFunctions.push(fn.name);
+            if (dec.name === "watch" && dec.args?.objective) {
+              watchFunctions.push({ name: fn.name, objective: dec.args.objective });
+            }
             if (dec.name === "coroutine") {
               coroutineInfos.push({ fnName: fn.name, batch: dec.args?.batch ?? 10, onDone: dec.args?.onDone });
             }
@@ -28097,7 +30450,7 @@ var require_modules = __commonJS({
         const lir = (0, lower_3.lowerToLIR)(mirFinal);
         lir.objective = objective;
         const lirOpt = (0, pipeline_2.lirOptimizeModule)(lir);
-        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions });
+        const files = (0, index_1.emit)(lirOpt, { namespace, tickFunctions, loadFunctions, watchFunctions, scheduleFunctions });
         if (moduleName) {
           const loadPath = `data/${namespace}/function/load.mcfunction`;
           const newLoadPath = `data/${namespace}/function/${moduleName}/_load.mcfunction`;
@@ -28208,8 +30561,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;
@@ -28733,11 +31086,17 @@ var require_cache = __commonJS({
       save() {
         fs2.mkdirSync(this.cacheDir, { recursive: true });
         const serialized = {
-          version: 1,
+          version: 2,
           entries: {}
         };
         for (const [filePath, entry] of this.entries) {
-          serialized.entries[filePath] = { hash: entry.hash, mtime: entry.mtime };
+          serialized.entries[filePath] = {
+            hash: entry.hash,
+            mtime: entry.mtime,
+            compiledFunctions: entry.compiledFunctions,
+            outputFiles: entry.outputFiles,
+            dependencies: entry.dependencies
+          };
         }
         const cachePath = path3.join(this.cacheDir, "cache.json");
         fs2.writeFileSync(cachePath, JSON.stringify(serialized, null, 2));
@@ -28747,10 +31106,16 @@ var require_cache = __commonJS({
         const cachePath = path3.join(this.cacheDir, "cache.json");
         try {
           const data = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
-          if (data.version !== 1)
+          if (data.version !== 2)
             return;
           for (const [filePath, entry] of Object.entries(data.entries)) {
-            this.entries.set(filePath, { hash: entry.hash, mtime: entry.mtime });
+            this.entries.set(filePath, {
+              hash: entry.hash,
+              mtime: entry.mtime,
+              compiledFunctions: entry.compiledFunctions,
+              outputFiles: entry.outputFiles,
+              dependencies: entry.dependencies
+            });
           }
         } catch {
         }
@@ -28961,101 +31326,137 @@ var require_incremental = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.compileIncremental = compileIncremental;
     exports2.resetCompileCache = resetCompileCache;
+    var fs2 = __importStar(require("fs"));
     var path3 = __importStar(require("path"));
     var compile_1 = require_compile2();
-    var fs2 = __importStar(require("fs"));
-    var compiledCache = /* @__PURE__ */ new Map();
+    var deps_1 = require_deps();
     function compileIncremental(files, cache, depGraph, options) {
+      const start = Date.now();
+      const normalizedEntries = [...new Set(files.map((file) => path3.resolve(file)))];
       const result = {
         recompiled: 0,
         cached: 0,
         errors: /* @__PURE__ */ new Map(),
-        results: /* @__PURE__ */ new Map()
+        results: /* @__PURE__ */ new Map(),
+        skippedFiles: [],
+        rebuiltFiles: [],
+        elapsedMs: 0
       };
-      for (const file of files) {
-        const absFile = path3.resolve(file);
-        try {
-          const source = fs2.readFileSync(absFile, "utf-8");
-          depGraph.addFile(absFile, source);
-        } catch {
-          depGraph.removeFile(absFile);
-        }
-      }
-      const changedSourceFiles = /* @__PURE__ */ new Set();
-      const allSourceFiles = /* @__PURE__ */ new Set();
-      for (const file of files) {
-        const absFile = path3.resolve(file);
-        const allDeps = depGraph.getTransitiveDeps(absFile);
-        allSourceFiles.add(absFile);
-        for (const dep of allDeps)
-          allSourceFiles.add(dep);
-      }
-      for (const sourceFile of allSourceFiles) {
-        if (cache.hasChanged(sourceFile)) {
-          changedSourceFiles.add(sourceFile);
-        }
+      if (normalizedEntries.length === 0) {
+        result.elapsedMs = Date.now() - start;
+        return result;
       }
-      for (const file of files) {
-        const absFile = path3.resolve(file);
-        const allDeps = depGraph.getTransitiveDeps(absFile);
-        const unitFiles = [absFile, ...allDeps];
-        let needsRecompile = false;
-        const prevEntry = compiledCache.get(absFile);
-        if (!prevEntry) {
-          needsRecompile = true;
-        } else {
-          for (const unitFile of unitFiles) {
-            if (changedSourceFiles.has(unitFile)) {
-              needsRecompile = true;
-              break;
-            }
-          }
-          if (!needsRecompile && prevEntry.depHashes.size !== unitFiles.length) {
-            needsRecompile = true;
-          }
-        }
-        if (!needsRecompile) {
-          const cached = compiledCache.get(absFile);
-          writeBuildOutput(cached.result, options.output);
+      depGraph.clear();
+      const discoveredFiles = discoverDependencyGraph(normalizedEntries, depGraph);
+      const changedFiles = /* @__PURE__ */ new Set();
+      for (const file of discoveredFiles) {
+        if (cache.hasChanged(file))
+          changedFiles.add(file);
+      }
+      const dirtyFiles = depGraph.computeDirtySet(changedFiles);
+      for (const entry of normalizedEntries) {
+        if (!discoveredFiles.has(entry))
+          dirtyFiles.add(entry);
+      }
+      for (const entryFile of normalizedEntries) {
+        const entryDeps = depGraph.getTransitiveDeps(entryFile);
+        const entryUnit = /* @__PURE__ */ new Set([entryFile, ...entryDeps]);
+        const cachedEntry = cache.get(entryFile);
+        const cachedDepList = new Set(cachedEntry?.dependencies ?? []);
+        const hasDependencyDrift = cachedDepList.size !== entryUnit.size || [...entryUnit].some((file) => !cachedDepList.has(file));
+        const canUseCache = !dirtyFiles.has(entryFile) && !hasDependencyDrift && !!cachedEntry?.outputFiles && cachedEntry.outputFiles.length > 0;
+        if (canUseCache) {
+          writeBuildOutput(cachedEntry.outputFiles, options.output);
           result.cached++;
+          result.skippedFiles.push(entryFile);
           continue;
         }
         try {
-          const source = fs2.readFileSync(absFile, "utf-8");
-          const ns = options.namespace ?? deriveNamespace(absFile);
-          const compileResult = (0, compile_1.compile)(source, { namespace: ns, filePath: absFile });
-          const depHashes = /* @__PURE__ */ new Map();
-          for (const unitFile of unitFiles) {
-            cache.update(unitFile);
-            const entry = cache.get(unitFile);
-            if (entry)
-              depHashes.set(unitFile, entry.hash);
-          }
-          compiledCache.set(absFile, { result: compileResult, depHashes });
-          writeBuildOutput(compileResult, options.output);
+          const source = fs2.readFileSync(entryFile, "utf-8");
+          const ns = options.namespace ?? deriveNamespace(entryFile);
+          const compileResult = (0, compile_1.compile)(source, {
+            namespace: ns,
+            filePath: entryFile,
+            generateSourceMap: options.generateSourceMap,
+            mcVersion: options.mcVersion,
+            lenient: options.lenient,
+            includeDirs: options.includeDirs
+          });
+          const outputFiles = cloneFiles(compileResult.files);
+          const compiledFunctions = outputFiles.filter((file) => file.path.endsWith(".mcfunction")).map((file) => file.path);
+          removeStaleOutputs(cachedEntry?.outputFiles ?? [], outputFiles, options.output);
+          for (const file of entryUnit) {
+            cache.update(file);
+          }
+          const entryRecord = cache.get(entryFile);
+          if (entryRecord) {
+            entryRecord.compiledFunctions = compiledFunctions;
+            entryRecord.outputFiles = outputFiles;
+            entryRecord.dependencies = [...entryUnit].sort();
+          }
+          writeBuildOutput(outputFiles, options.output);
           result.recompiled++;
-          result.results.set(absFile, compileResult);
+          result.results.set(entryFile, compileResult);
+          result.rebuiltFiles.push(entryFile);
         } catch (err) {
-          result.errors.set(absFile, err.message);
+          result.errors.set(entryFile, err.message);
         }
       }
+      cache.save();
+      result.elapsedMs = Date.now() - start;
       return result;
     }
-    function writeBuildOutput(compileResult, output) {
+    function discoverDependencyGraph(entries, depGraph) {
+      const visited = /* @__PURE__ */ new Set();
+      const queue = [...entries];
+      while (queue.length > 0) {
+        const current = path3.resolve(queue.shift());
+        if (visited.has(current))
+          continue;
+        visited.add(current);
+        try {
+          const source = fs2.readFileSync(current, "utf-8");
+          depGraph.addFile(current, source);
+          const imports = (0, deps_1.parseImports)(current, source);
+          for (const imported of imports) {
+            if (!visited.has(imported))
+              queue.push(imported);
+          }
+        } catch {
+          depGraph.removeFile(current);
+        }
+      }
+      return visited;
+    }
+    function cloneFiles(files) {
+      return files.map((file) => ({ path: file.path, content: file.content }));
+    }
+    function writeBuildOutput(files, output) {
       fs2.mkdirSync(output, { recursive: true });
-      for (const dataFile of compileResult.files) {
+      for (const dataFile of files) {
         const filePath = path3.join(output, dataFile.path);
         const dir = path3.dirname(filePath);
         fs2.mkdirSync(dir, { recursive: true });
         fs2.writeFileSync(filePath, dataFile.content);
       }
     }
+    function removeStaleOutputs(previousFiles, nextFiles, output) {
+      if (previousFiles.length === 0)
+        return;
+      const nextPaths = new Set(nextFiles.map((file) => file.path));
+      for (const oldFile of previousFiles) {
+        if (nextPaths.has(oldFile.path))
+          continue;
+        const targetPath = path3.join(output, oldFile.path);
+        if (fs2.existsSync(targetPath))
+          fs2.rmSync(targetPath, { force: true });
+      }
+    }
     function deriveNamespace(filePath) {
       const basename = path3.basename(filePath, path3.extname(filePath));
       return basename.toLowerCase().replace(/[^a-z0-9]/g, "_");
     }
     function resetCompileCache() {
-      compiledCache.clear();
     }
   }
 });
@@ -29068,8 +31469,10 @@ var require_src = __commonJS({
     exports2.resetCompileCache = exports2.compileIncremental = exports2.parseImports = exports2.DependencyGraph = exports2.hashFile = exports2.FileCache = exports2.MCCommandValidator = exports2.preprocessSourceWithMetadata = exports2.preprocessSource = exports2.Parser = exports2.Lexer = exports2.DEFAULT_MC_VERSION = exports2.compareMcVersion = exports2.parseMcVersion = exports2.McVersion = exports2.compileModules = exports2.compile = exports2.version = void 0;
     exports2.check = check;
     exports2.checkWithWarnings = checkWithWarnings;
+    exports2.checkDetailed = checkDetailed;
     exports2.version = "2.0.0";
     var compile_1 = require_compile2();
+    var diagnostics_1 = require_diagnostics();
     var compile_2 = require_compile2();
     Object.defineProperty(exports2, "compile", { enumerable: true, get: function() {
       return compile_2.compile;
@@ -29135,11 +31538,24 @@ var require_src = __commonJS({
       return checkWithWarnings(source, namespace, filePath).error;
     }
     function checkWithWarnings(source, namespace = "redscript", filePath) {
+      const result = checkDetailed(source, namespace, filePath);
+      return { error: result.errors[0] ?? null, warnings: result.warnings };
+    }
+    function checkDetailed(source, namespace = "redscript", filePath) {
       try {
-        const result = (0, compile_1.compile)(source, { namespace, filePath });
-        return { error: null, warnings: result.warnings };
+        const result = (0, compile_1.compile)(source, { namespace, filePath, stopAfterCheck: true });
+        return { errors: [], warnings: result.warnings };
       } catch (err) {
-        return { error: err, warnings: [] };
+        if (err instanceof diagnostics_1.CheckFailedError) {
+          return { errors: err.diagnostics, warnings: err.warnings };
+        }
+        if (err instanceof diagnostics_1.DiagnosticError) {
+          return { errors: [err], warnings: [] };
+        }
+        return {
+          errors: [(0, diagnostics_1.parseErrorMessage)("LoweringError", err.message, source.split("\n"), filePath)],
+          warnings: []
+        };
       }
     }
   }
@@ -30627,9 +33043,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 +33082,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);