redscript-mc 2.6.2 → 3.0.0

package/editors/vscode/out/lsp-server.js

@@ -9207,6 +9207,8 @@ var KEYWORDS = {
   while: "while",
   for: "for",
   foreach: "foreach",
+  do: "do",
+  repeat: "repeat",
   match: "match",
   return: "return",
   break: "break",
@@ -9226,6 +9228,8 @@ var KEYWORDS = {
   unless: "unless",
   declare: "declare",
   export: "export",
+  import: "import",
+  interface: "interface",
   int: "int",
   bool: "bool",
   float: "float",
@@ -9471,7 +9475,13 @@ var Lexer = class {
       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 === "#") {
@@ -9539,6 +9549,26 @@ var Lexer = class {
     }
     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;
@@ -9782,6 +9812,8 @@ var Parser = class _Parser {
     this.inLibraryMode = false;
     /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
     this.warnings = [];
+    /** Parse errors collected during error-recovery mode. */
+    this.parseErrors = [];
     this.tokens = tokens;
     this.sourceLines = source?.split("\n") ?? [];
     this.filePath = filePath;
@@ -9852,6 +9884,60 @@ var Parser = class _Parser {
     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") {
@@ -9863,6 +9949,7 @@ var Parser = class _Parser {
     const enums = [];
     const consts = [];
     const imports = [];
+    const interfaces = [];
     let isLibrary = false;
     let moduleName;
     if (this.check("namespace")) {
@@ -9883,40 +9970,74 @@ var Parser = class _Parser {
       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();
-          symbol = "*";
+          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();
+          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 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
@@ -9945,6 +10066,19 @@ var Parser = class _Parser {
     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);
@@ -9962,14 +10096,72 @@ var Parser = class _Parser {
   }
   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");
@@ -9989,8 +10181,12 @@ var Parser = class _Parser {
     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);
   }
@@ -10006,6 +10202,7 @@ var Parser = class _Parser {
   }
   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") {
@@ -10043,7 +10240,8 @@ var Parser = class _Parser {
         decorators: filteredDecorators,
         body,
         isLibraryFn: this.inLibraryMode || void 0,
-        isExported
+        isExported,
+        watchObjective
       },
       fnToken
     );
@@ -10076,7 +10274,7 @@ var Parser = class _Parser {
     return decorators;
   }
   parseDecoratorValue(value) {
-    const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
+    const match = value.match(/^@(\w+)(?:\((.*)\))?$/s);
     if (!match) {
       this.error(`Invalid decorator: ${value}`);
     }
@@ -10085,6 +10283,9 @@ var Parser = class _Parser {
     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_]*)$/);
@@ -10093,10 +10294,12 @@ var Parser = class _Parser {
         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];
@@ -10108,6 +10311,24 @@ var Parser = class _Parser {
         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(",")) {
@@ -10245,7 +10466,16 @@ var Parser = class _Parser {
     this.expect("{");
     const stmts = [];
     while (!this.check("}") && !this.check("eof")) {
-      stmts.push(this.parseStmt());
+      try {
+        stmts.push(this.parseStmt());
+      } catch (err) {
+        if (err instanceof DiagnosticError) {
+          this.parseErrors.push(err);
+          this.syncToNextStmt();
+        } else {
+          throw err;
+        }
+      }
     }
     this.expect("}");
     return stmts;
@@ -10254,6 +10484,9 @@ var Parser = class _Parser {
     if (this.check("let")) {
       return this.parseLetStmt();
     }
+    if (this.check("const")) {
+      return this.parseLocalConstDecl();
+    }
     if (this.check("return")) {
       return this.parseReturnStmt();
     }
@@ -10273,6 +10506,12 @@ var Parser = class _Parser {
     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();
     }
@@ -10327,6 +10566,16 @@ var Parser = class _Parser {
     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;
@@ -10357,9 +10606,7 @@ var Parser = class _Parser {
       }
       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")) {
@@ -10373,12 +10620,44 @@ var Parser = class _Parser {
   }
   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") {
@@ -10495,6 +10774,21 @@ var Parser = class _Parser {
       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) };
@@ -10838,6 +11132,15 @@ var Parser = class _Parser {
           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",
@@ -10930,6 +11233,20 @@ var Parser = class _Parser {
       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(")");
@@ -11693,7 +12010,6 @@ var MC_TYPE_TO_ENTITY = {
 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 }],
@@ -11706,15 +12022,25 @@ var BUILTIN_SIGNATURES = {
   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();
+    // enumName → variantName → field list (for payload variants)
+    this.enumPayloads = /* @__PURE__ */ new Map();
     this.consts = /* @__PURE__ */ new Map();
     this.globals = /* @__PURE__ */ new Map();
     this.currentFn = null;
@@ -11725,6 +12051,8 @@ var TypeChecker = class {
     // Depth of loop/conditional nesting (for static-allocation enforcement)
     this.loopDepth = 0;
     this.condDepth = 0;
+    // interface name → InterfaceDecl
+    this.interfaces = /* @__PURE__ */ new Map();
     this.richTextBuiltins = /* @__PURE__ */ new Map([
       ["say", { messageIndex: 0 }],
       ["announce", { messageIndex: 0 }],
@@ -11766,6 +12094,9 @@ var TypeChecker = class {
     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));
     }
@@ -11795,13 +12126,47 @@ var TypeChecker = class {
         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);
@@ -11814,6 +12179,21 @@ var TypeChecker = class {
       }
       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);
     }
@@ -11859,6 +12239,30 @@ var TypeChecker = class {
     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;
@@ -11968,8 +12372,21 @@ var TypeChecker = class {
             if (!isUnknown(subjectType) && !isUnknown(patternType) && !this.typesMatch(subjectType, patternType)) {
               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": {
@@ -12008,6 +12425,9 @@ var TypeChecker = class {
         break;
       case "raw":
         break;
+      case "const_decl":
+        this.scope.set(stmt.name, { type: stmt.type, mutable: false });
+        break;
     }
   }
   checkLetDestructStmt(stmt) {
@@ -12234,6 +12654,31 @@ var TypeChecker = class {
           }
         }
         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
@@ -12345,7 +12790,7 @@ var TypeChecker = class {
       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
@@ -12570,7 +13015,7 @@ var TypeChecker = class {
             this.checkExpr(part.expr);
           }
         }
-        return FORMAT_STRING_TYPE;
+        return STRING_TYPE;
       case "blockpos":
         return { kind: "named", name: "BlockPos" };
       case "ident":
@@ -12630,6 +13075,11 @@ var TypeChecker = class {
           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 };
@@ -12735,6 +13185,21 @@ var TypeChecker = class {
     }
     return "entity";
   }
+  static {
+    // Reverse map: parser sometimes remaps method names (e.g. add→set_add) for builtins.
+    // When the receiver is a struct with an impl method matching the original name, use that.
+    this.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"
+    };
+  }
   resolveInstanceMethod(expr) {
     const receiver = expr.args[0];
     if (!receiver) {
@@ -12744,7 +13209,8 @@ var TypeChecker = class {
     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;
     }
@@ -13961,6 +14427,7 @@ function toDiagnostic(err) {
 var DECORATOR_DOCS = {
   tick: "Runs every game tick.\n\n**Optional args:** `rate=N` (every N ticks, e.g. `@tick(rate=20)` = once per second)\n\nExample: `@tick fn every_tick() {}` or `@tick(rate=20) fn every_second() {}`",
   load: "Runs once on `/reload`. Use for initialization.\n\nExample: `@load fn init() { scoreboard_create(...) }`",
+  watch: 'Runs when a scoreboard objective changes for a player.\n\n**Required arg:** objective name.\n\nExample: `@watch("rs.kills") fn on_kill_change() {}`',
   coroutine: "Wraps a loop to spread execution across multiple ticks.\n\n**Required arg:** `batch=N` \u2014 iterations per tick.\n\nExample: `@coroutine(batch=10) fn scan_blocks() { for i in 0..1000 { ... } }`",
   schedule: "Schedules the function to run after a delay.\n\n**Required arg:** `ticks=N`\n\nExample: `@schedule(ticks=100) fn delayed() {}`",
   on_trigger: 'Runs when a player executes `/trigger <name>`.\n\n**Required arg:** trigger objective name.\n\nExample: `@on_trigger("shop") fn open_shop() {}`',
@@ -14107,6 +14574,7 @@ var TYPE_COMPLETIONS = [
 }));
 var DECORATOR_COMPLETIONS = [
   { label: "@tick", detail: "Run every game tick (~20 Hz)", insertText: "tick" },
+  { label: "@watch", detail: "Run when a scoreboard objective changes", insertText: "watch" },
   { label: "@load", detail: "Run on /reload (initialization)", insertText: "load" },
   { label: "@on_trigger", detail: "Run when a player uses /trigger", insertText: "on_trigger" },
   { label: "@schedule", detail: "Schedule function after N ticks", insertText: "schedule" },