@tokens-studio/tokenscript-interpreter 0.36.3 → 0.37.0

package/dist/{chunk-33CDF4L4.js → chunk-P4VLJQEI.js}

@@ -1,5 +1,5 @@
-import { SupportedFormats, ReservedKeyword, UNINTERPRETED_KEYWORDS } from './chunk-AXH5N7KV.js';
-import { Color, Fn, Unit, Token, ZodError } from '@tokens-studio/schema-validation';
+import { SupportedFormats, ReservedKeyword, UNINTERPRETED_KEYWORDS } from './chunk-BNLQ6GCU.js';
+import { type } from 'arktype';
 
 // src/interpreter/errors/messages/en.ts
 var messages = {
@@ -17,7 +17,6 @@ var messages = {
   ["PARSER_CONDITION_MUST_BE_BOOLEAN" /* CONDITION_MUST_BE_BOOLEAN */]: "If/elif condition must be a boolean",
   ["PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */]: (data) => data?.message ? String(data.message) : "Invalid syntax",
   ["PARSER_UNEXPECTED_END" /* UNEXPECTED_END */]: "Unexpected end of input",
-  ["PARSER_TOLERANT_REQUIRES_INLINE" /* TOLERANT_REQUIRES_INLINE */]: "Tolerant mode only supports inline expressions. Use parse(true) for tolerant parsing.",
   // Interpreter errors
   ["INT_UNKNOWN_NODE_TYPE" /* UNKNOWN_NODE_TYPE */]: (data) => `No visit method for AST node type: ${data.nodeType}`,
   ["INT_ARITHMETIC_REQUIRES_NUMBER" /* ARITHMETIC_REQUIRES_NUMBER */]: (data) => `Arithmetic operator ${data.operator} requires Number or NumberWithUnit operands, got ${data.leftType} and ${data.rightType}.`,
@@ -44,9 +43,6 @@ var messages = {
   ["INT_MAX_ITERATIONS_EXCEEDED" /* MAX_ITERATIONS_EXCEEDED */]: "Max iterations exceeded in while loop.",
   ["INT_WHILE_CONDITION_NOT_BOOLEAN" /* WHILE_CONDITION_NOT_BOOLEAN */]: "While loop condition must be a boolean.",
   ["INT_IF_CONDITION_NOT_BOOLEAN" /* IF_CONDITION_NOT_BOOLEAN */]: "If/elif condition must be a boolean.",
-  ["INT_FOR_EACH_NOT_LIST" /* FOR_EACH_NOT_LIST */]: (data) => `for...in requires a List, got ${data.actualType}.`,
-  ["INT_FOR_EACH_VARIABLE_SHADOW" /* FOR_EACH_VARIABLE_SHADOW */]: (data) => `for...in variable '${data.name}' shadows an existing variable in this scope.`,
-  ["INT_FOR_EACH_DUPLICATE_VARS" /* FOR_EACH_DUPLICATE_VARS */]: (data) => `for...in item and index variables must have different names, both are '${data.name}'.`,
   ["INT_UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: "An unknown error occurred during interpretation.",
   // Operations errors
   ["OP_UNSUPPORTED_OPERAND_TYPE" /* UNSUPPORTED_OPERAND_TYPE */]: (data) => `Unsupported operand type for unit decomposition: ${data.type}`,
@@ -1830,59 +1826,6 @@ function stringifyInterpreterResult(value) {
   return String(value);
 }
 
-// src/interpreter/tolerant/partial-nodes.ts
-var PartialReferenceNode = class {
-  constructor(partialValue, token) {
-    this.partialValue = partialValue;
-    this.token = token;
-    this.nodeType = "PartialReferenceNode";
-  }
-};
-var PartialStringNode = class {
-  constructor(partialValue, quoteType, token) {
-    this.partialValue = partialValue;
-    this.quoteType = quoteType;
-    this.token = token;
-    this.nodeType = "PartialStringNode";
-  }
-};
-var PartialFunctionCallNode = class {
-  constructor(name, args, token) {
-    this.name = name;
-    this.args = args;
-    this.token = token;
-    this.nodeType = "PartialFunctionCallNode";
-  }
-};
-var PartialBinOpNode = class {
-  constructor(left, opToken) {
-    this.left = left;
-    this.opToken = opToken;
-    this.nodeType = "PartialBinOpNode";
-    this.token = opToken;
-  }
-  get op() {
-    return this.opToken.value;
-  }
-};
-var PartialUnaryOpNode = class {
-  constructor(opToken) {
-    this.opToken = opToken;
-    this.nodeType = "PartialUnaryOpNode";
-    this.token = opToken;
-  }
-  get op() {
-    return this.opToken.value;
-  }
-};
-var PartialParenNode = class {
-  constructor(expr, token) {
-    this.expr = expr;
-    this.token = token;
-    this.nodeType = "PartialParenNode";
-  }
-};
-
 // src/interpreter/ast.ts
 var BinOpNode = class {
   constructor(left, opToken, right, token) {
@@ -1915,13 +1858,6 @@ var StringNode = class {
     this.value = token.value;
   }
 };
-var TemplateStringNode = class {
-  constructor(parts, token) {
-    this.parts = parts;
-    this.token = token;
-    this.nodeType = "TemplateStringNode";
-  }
-};
 var UnaryOpNode = class {
   constructor(opToken, expr, token) {
     this.opToken = opToken;
@@ -2071,16 +2007,6 @@ var WhileNode = class {
     this.nodeType = "WhileNode";
   }
 };
-var ForEachNode = class {
-  constructor(itemVar, indexVar, collection, body, token) {
-    this.itemVar = itemVar;
-    this.indexVar = indexVar;
-    this.collection = collection;
-    this.body = body;
-    this.token = token;
-    this.nodeType = "ForEachNode";
-  }
-};
 var IfConditionNode = class {
   constructor(condition, body, token) {
     this.condition = condition;
@@ -2114,7 +2040,6 @@ var StatementListNode = class {
 };
 var AttributeAccessNode = class {
   // 'left' is the object, 'right' is the attribute (IdentifierNode) or method (FunctionCallNode)
-  // In tolerant mode, 'right' may also be a PartialFunctionCallNode
   constructor(left, right, token) {
     this.left = left;
     this.right = right;
@@ -2150,9 +2075,6 @@ function walkAST(node, onVisit) {
   } else if (node instanceof WhileNode) {
     walkAST(node.condition, onVisit);
     walkAST(node.body, onVisit);
-  } else if (node instanceof ForEachNode) {
-    walkAST(node.collection, onVisit);
-    walkAST(node.body, onVisit);
   } else if (node instanceof IfConditionNode) {
     walkAST(node.condition, onVisit);
     walkAST(node.body, onVisit);
@@ -2169,23 +2091,11 @@ function walkAST(node, onVisit) {
     for (const statement of node.statements) {
       walkAST(statement, onVisit);
     }
-  } else if (node instanceof TemplateStringNode) {
-    for (const part of node.parts) {
-      walkAST(part, onVisit);
-    }
   } else if (node instanceof AttributeAccessNode) {
     walkAST(node.left, onVisit);
-    if (node.right instanceof FunctionCallNode || node.right instanceof PartialFunctionCallNode) {
+    if (node.right instanceof FunctionCallNode) {
       walkAST(node.right, onVisit);
     }
-  } else if (node instanceof PartialBinOpNode) {
-    walkAST(node.left, onVisit);
-  } else if (node instanceof PartialUnaryOpNode) ; else if (node instanceof PartialFunctionCallNode) {
-    for (const arg of node.args) {
-      walkAST(arg, onVisit);
-    }
-  } else if (node instanceof PartialParenNode) {
-    walkAST(node.expr, onVisit);
   }
 }
 function filterAST(ast, predicate) {
@@ -2245,7 +2155,7 @@ for (const val of Object.values(ReservedKeyword)) {
   RESERVED_KEYWORD_STRINGS[val.toLowerCase()] = val;
 }
 var Lexer = class {
-  constructor(text, options) {
+  constructor(text) {
     this.pos = 0;
     this.line = 1;
     this.column = 1;
@@ -2258,10 +2168,8 @@ var Lexer = class {
      * @see docs/tokenscript/edge-cases/format-unit-parsing.md
      */
     this._lastUnitableToken = null;
-    this.collectedTokens = [];
     this.text = text;
-    this.currentChar = this.pos < this.text.length ? this.text[this.pos] : null;
-    this.tolerant = options?.tolerant ?? false;
+    this.currentChar = this.text[this.pos];
   }
   /**
    * Check if a FORMAT token (unit suffix) is valid at the given position.
@@ -2297,7 +2205,7 @@ var Lexer = class {
     }
   }
   peek(n = 1) {
-    return this.text[this.pos + n] ?? null;
+    return this.text[this.pos + n];
   }
   skipWhitespace() {
     while (isSpace(this.currentChar)) {
@@ -2405,9 +2313,6 @@ var Lexer = class {
     let result = "";
     while (this.currentChar !== null && this.currentChar !== "}") {
       if (this.currentChar === "{") {
-        if (this.tolerant) {
-          break;
-        }
         this.error("LEXER_UNTERMINATED_REFERENCE" /* UNTERMINATED_REFERENCE */, {});
       }
       if (isSpace(this.currentChar)) {
@@ -2418,27 +2323,9 @@ var Lexer = class {
       this.advance();
     }
     if (this.currentChar === null) {
-      if (this.tolerant) {
-        return {
-          type: "PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */,
-          value: result,
-          line: this.line,
-          pos: refStartPos,
-          endPos: this.pos
-        };
-      }
       this.error("LEXER_UNTERMINATED_REFERENCE" /* UNTERMINATED_REFERENCE */, {});
     }
     if (result === "") {
-      if (this.tolerant) {
-        return {
-          type: "PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */,
-          value: "",
-          line: this.line,
-          pos: refStartPos,
-          endPos: this.pos
-        };
-      }
       this.error("LEXER_EMPTY_VARIABLE_NAME" /* EMPTY_VARIABLE_NAME */, {});
     }
     const refEndPos = this.pos;
@@ -2462,15 +2349,6 @@ var Lexer = class {
       this.advance();
     }
     if (this.currentChar === null) {
-      if (this.tolerant) {
-        return {
-          type: "PARTIAL_STRING" /* PARTIAL_STRING */,
-          value: result,
-          line: this.line,
-          pos: startPos,
-          endPos: this.pos
-        };
-      }
       this.error("LEXER_UNTERMINATED_STRING" /* UNTERMINATED_STRING */, { quoteType });
     }
     this.eat(quoteType);
@@ -2482,51 +2360,6 @@ var Lexer = class {
       endPos: this.pos
     };
   }
-  /**
-   * Read a backtick-delimited template string.
-   * Supports escape sequences: \{ \$ \` \\
-   * The raw content (with escapes preserved) is stored as the token value.
-   * The parser handles splitting into segments.
-   */
-  templateString() {
-    const startPos = this.pos;
-    this.eat("`");
-    let result = "";
-    while (this.currentChar !== null && this.currentChar !== "`") {
-      if (this.currentChar === "\\") {
-        const next = this.peek();
-        if (next === "{" || next === "$" || next === "`" || next === "\\") {
-          result += "\\";
-          result += next;
-          this.advance();
-          this.advance();
-          continue;
-        }
-      }
-      result += this.currentChar;
-      this.advance();
-    }
-    if (this.currentChar === null) {
-      if (this.tolerant) {
-        return {
-          type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
-          value: result,
-          line: this.line,
-          pos: startPos,
-          endPos: this.pos
-        };
-      }
-      this.error("LEXER_UNTERMINATED_TEMPLATE_STRING" /* UNTERMINATED_TEMPLATE_STRING */, {});
-    }
-    this.eat("`");
-    return {
-      type: "TEMPLATE_STRING" /* TEMPLATE_STRING */,
-      value: result,
-      line: this.line,
-      pos: startPos,
-      endPos: this.pos
-    };
-  }
   hexColor() {
     const startPos = this.pos;
     let result = "";
@@ -2535,15 +2368,6 @@ var Lexer = class {
       this.advance();
     }
     if (result.length !== 4 && result.length !== 5 && result.length !== 7 && result.length !== 9) {
-      if (this.tolerant) {
-        return {
-          type: "HEX_COLOR" /* HEX_COLOR */,
-          value: result,
-          line: this.line,
-          pos: startPos,
-          endPos: this.pos
-        };
-      }
       this.error("LEXER_INVALID_HEX_COLOR_FORMAT" /* INVALID_HEX_COLOR_FORMAT */, {
         value: result,
         expectedLength: "#RGB, #RGBA, #RRGGBB, or #RRGGBBAA"
@@ -2557,12 +2381,6 @@ var Lexer = class {
       endPos: this.pos
     };
   }
-  collectToken(token) {
-    if (this.tolerant) {
-      this.collectedTokens.push(token);
-    }
-    return token;
-  }
   nextToken() {
     while (this.currentChar !== null) {
       this.skipWhitespace();
@@ -2572,130 +2390,127 @@ var Lexer = class {
         continue;
       }
       if (this.isDigit()) {
-        return this.collectToken(this.number());
+        return this.number();
       }
       if (this.currentChar === "'" || this.currentChar === '"') {
-        return this.collectToken(this.explicitString(this.currentChar));
-      }
-      if (this.currentChar === "`") {
-        return this.collectToken(this.templateString());
+        return this.explicitString(this.currentChar);
       }
       if (this.isValidIdentifierStart(this.currentChar)) {
-        return this.collectToken(this.stringElement());
+        return this.stringElement();
       }
       if (this.currentChar === "{") {
-        return this.collectToken(this.reference());
+        return this.reference();
       }
       if (this.currentChar === "[") {
         const startPos = this.pos;
         this.eat("[");
-        return this.collectToken({
+        return {
           type: "LBLOCK" /* LBLOCK */,
           value: "[",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "]") {
         const startPos = this.pos;
         this.eat("]");
-        return this.collectToken({
+        return {
           type: "RBLOCK" /* RBLOCK */,
           value: "]",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "!" && this.peek() === "=") {
         const startPos = this.pos;
         this.eat("!");
         this.eat("=");
-        return this.collectToken({
+        return {
           type: "IS_NOT_EQ" /* IS_NOT_EQ */,
           value: "!=",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "+") {
         const startPos = this.pos;
         this.eat("+");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "+" /* ADD */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "-") {
         const startPos = this.pos;
         this.eat("-");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "-" /* SUBTRACT */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "*") {
         const startPos = this.pos;
         this.eat("*");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "*" /* MULTIPLY */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "/") {
         const startPos = this.pos;
         this.eat("/");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "/" /* DIVIDE */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "^") {
         const startPos = this.pos;
         this.eat("^");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "^" /* POWER */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "!") {
         const startPos = this.pos;
         this.eat("!");
-        return this.collectToken({
+        return {
           type: "OPERATION" /* OPERATION */,
           value: "!" /* LOGIC_NOT */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "(") {
         const startPos = this.pos;
         this.eat("(");
-        return this.collectToken({
+        return {
           type: "LPAREN" /* LPAREN */,
           value: "(",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === ")") {
         const startPos = this.pos;
@@ -2708,162 +2523,158 @@ var Lexer = class {
           endPos: this.pos
         };
         this._lastUnitableToken = token;
-        return this.collectToken(token);
+        return token;
       }
       if (this.currentChar === ",") {
         const startPos = this.pos;
         this.eat(",");
-        return this.collectToken({
+        return {
           type: "COMMA" /* COMMA */,
           value: ",",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === ".") {
         if (this.peek() !== null && isNumber2(this.peek())) {
-          return this.collectToken(this.number());
+          return this.number();
         }
         const startPos = this.pos;
         this.eat(".");
-        return this.collectToken({
+        return {
           type: "DOT" /* DOT */,
           value: ".",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "#") {
-        return this.collectToken(this.hexColor());
+        return this.hexColor();
       }
       if (this.currentChar === "%") {
         const startPos = this.pos;
         this.eat("%");
-        return this.collectToken({
+        return {
           type: "FORMAT" /* FORMAT */,
           value: "%" /* PERCENTAGE */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "=") {
         const startPos = this.pos;
         if (this.peek() === "=") {
           this.eat("=");
           this.eat("=");
-          return this.collectToken({
+          return {
             type: "IS_EQ" /* IS_EQ */,
             value: "==",
             line: this.line,
             pos: startPos,
             endPos: this.pos
-          });
+          };
         }
         this.eat("=");
-        return this.collectToken({
+        return {
           type: "ASSIGN" /* ASSIGN */,
           value: "=",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === ">") {
         const startPos = this.pos;
         if (this.peek() === "=") {
           this.eat(">");
           this.eat("=");
-          return this.collectToken({
+          return {
             type: "IS_GT_EQ" /* IS_GT_EQ */,
             value: ">=",
             line: this.line,
             pos: startPos,
             endPos: this.pos
-          });
+          };
         }
         this.eat(">");
-        return this.collectToken({
+        return {
           type: "GT" /* IS_GT */,
           value: ">",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "<") {
         const startPos = this.pos;
         if (this.peek() === "=") {
           this.eat("<");
           this.eat("=");
-          return this.collectToken({
+          return {
             type: "IS_LT_EQ" /* IS_LT_EQ */,
             value: "<=",
             line: this.line,
             pos: startPos,
             endPos: this.pos
-          });
+          };
         }
         this.eat("<");
-        return this.collectToken({
+        return {
           type: "LT" /* IS_LT */,
           value: "<",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === ";") {
         const startPos = this.pos;
         this.eat(";");
-        return this.collectToken({
+        return {
           type: "SEMICOLON" /* SEMICOLON */,
           value: ";",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "&" && this.peek() === "&") {
         const startPos = this.pos;
         this.eat("&");
         this.eat("&");
-        return this.collectToken({
+        return {
           type: "LOGIC_AND" /* LOGIC_AND */,
           value: "&&" /* LOGIC_AND */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === "|" && this.peek() === "|") {
         const startPos = this.pos;
         this.eat("|");
         this.eat("|");
-        return this.collectToken({
+        return {
           type: "LOGIC_OR" /* LOGIC_OR */,
           value: "||" /* LOGIC_OR */,
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
+        };
       }
       if (this.currentChar === ":") {
         const startPos = this.pos;
         this.eat(":");
-        return this.collectToken({
+        return {
           type: "COLON" /* COLON */,
           value: ":",
           line: this.line,
           pos: startPos,
           endPos: this.pos
-        });
-      }
-      if (this.tolerant) {
-        this.advance();
-        continue;
+        };
       }
       const char = this.currentChar === null ? "end of input" : this.currentChar;
       this.error("LEXER_INVALID_CHARACTER" /* INVALID_CHARACTER */, {
@@ -2871,48 +2682,18 @@ var Lexer = class {
         position: this.pos
       });
     }
-    const eofToken = {
-      type: "EOF" /* EOF */,
-      value: null,
-      line: this.line,
-      pos: this.pos,
-      endPos: this.pos
-    };
-    return this.collectToken(eofToken);
-  }
-  /**
-   * Get all tokens that have been collected during tokenization.
-   * This is useful for tolerant parsing to get all tokens including partial ones.
-   */
-  getAllTokens() {
-    return [...this.collectedTokens];
-  }
-  /**
-   * Tokenize the entire input and return all tokens.
-   * This is a convenience method for tolerant parsing.
-   */
-  tokenizeAll() {
-    const tokens = [];
-    let token = this.nextToken();
-    while (token.type !== "EOF" /* EOF */) {
-      tokens.push(token);
-      token = this.nextToken();
-    }
-    tokens.push(token);
-    return tokens;
+    return { type: "EOF" /* EOF */, value: null, line: this.line, pos: this.pos, endPos: this.pos };
   }
   peekToken() {
     const savedPos = this.pos;
     const savedChar = this.currentChar;
     const savedLine = this.line;
     const savedColumn = this.column;
-    const savedCollectedLength = this.collectedTokens.length;
     const nextToken = this.nextToken();
     this.pos = savedPos;
     this.currentChar = savedChar;
     this.line = savedLine;
     this.column = savedColumn;
-    this.collectedTokens.length = savedCollectedLength;
     return nextToken.type === "EOF" /* EOF */ ? null : nextToken;
   }
   peekTokens(n) {
@@ -2920,7 +2701,6 @@ var Lexer = class {
     const savedChar = this.currentChar;
     const savedLine = this.line;
     const savedColumn = this.column;
-    const savedCollectedLength = this.collectedTokens.length;
     const tokens = [];
     for (let i = 0; i < n; i++) {
       const token = this.nextToken();
@@ -2933,7 +2713,6 @@ var Lexer = class {
     this.currentChar = savedChar;
     this.line = savedLine;
     this.column = savedColumn;
-    this.collectedTokens.length = savedCollectedLength;
     return tokens.length > 0 ? tokens : null;
   }
   isEOF() {
@@ -2956,41 +2735,11 @@ var Lexer = class {
 };
 
 // src/interpreter/parser.ts
-var Parser = class _Parser {
-  constructor(lexer, options) {
+var Parser = class {
+  constructor(lexer) {
     this.requiredReferences = /* @__PURE__ */ new Set();
-    this.incompleteInfo = [];
     this.lexer = lexer;
     this.currentToken = this.lexer.nextToken();
-    this.tolerant = options?.tolerant ?? false;
-  }
-  /**
-   * In tolerant mode, check if the current token is EOF after consuming an operator.
-   * If so, record the incomplete info and return a PartialBinOpNode.
-   * Returns null if not at EOF or not in tolerant mode.
-   */
-  tryRecoverMissingOperand(left, opToken) {
-    if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-      this.incompleteInfo.push({
-        type: "missing_operand" /* MISSING_OPERAND */,
-        startPos: opToken.pos,
-        endPos: opToken.endPos
-      });
-      return new PartialBinOpNode(left, opToken);
-    }
-    return null;
-  }
-  /**
-   * Check if the parser encountered any incomplete constructs
-   */
-  hasIncomplete() {
-    return this.incompleteInfo.length > 0;
-  }
-  /**
-   * Get information about incomplete constructs
-   */
-  getIncomplete() {
-    return [...this.incompleteInfo];
   }
   formatError(message, token = this.currentToken) {
     const {
@@ -3114,8 +2863,6 @@ ${contextText}`;
           return this.returnStatement();
         case "while" /* WHILE */:
           return this.whileStatement();
-        case "for" /* FOR */:
-          return this.forStatement();
         case "if" /* IF */:
           return this.ifStatement();
         case "variable" /* VARIABLE */:
@@ -3171,18 +2918,7 @@ ${contextText}`;
     return new ReassignNode(name, assignmentExpr, varNameToken);
   }
   reference() {
-    const token = this.currentToken;
-    if (token.type === "PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */) {
-      this.eat("PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */);
-      this.incompleteInfo.push({
-        type: "unclosed_reference" /* UNCLOSED_REFERENCE */,
-        startPos: token.pos,
-        endPos: token.endPos,
-        partialValue: token.value
-      });
-      return new PartialReferenceNode(token.value, token);
-    }
-    const node = new ReferenceNode(token);
+    const node = new ReferenceNode(this.currentToken);
     this.eat("REFERENCE" /* REFERENCE */);
     this.requiredReferences.add(node.value);
     if (this.currentToken.type === "FORMAT" /* FORMAT */) {
@@ -3195,8 +2931,6 @@ ${contextText}`;
     let node = this.logicTerm();
     while (this.currentToken.type === "LOGIC_AND" /* LOGIC_AND */ || this.currentToken.type === "LOGIC_OR" /* LOGIC_OR */) {
       const token = this.eat(this.currentToken.type);
-      const partial = this.tryRecoverMissingOperand(node, token);
-      if (partial) return partial;
       node = new BinOpNode(node, token, this.logicTerm());
     }
     return node;
@@ -3225,48 +2959,6 @@ ${contextText}`;
     const body = this.block();
     return new WhileNode(condition, body.statements, whileToken);
   }
-  forStatement() {
-    const forToken = this.eat("RESERVED_KEYWORD" /* RESERVED_KEYWORD */);
-    if (!this.isIdentifierToken()) {
-      throw new ParserError("PARSER_EXPECTED_TOKEN_TYPE" /* EXPECTED_TOKEN_TYPE */, {
-        token: this.currentToken,
-        data: { expectedType: "identifier", actualType: this.currentToken.type }
-      });
-    }
-    const firstVar = this.currentToken.value;
-    this.eat(this.currentToken.type);
-    let indexVar = null;
-    if (this.currentToken.type === "COMMA" /* COMMA */) {
-      this.eat("COMMA" /* COMMA */);
-      if (!this.isIdentifierToken()) {
-        throw new ParserError("PARSER_EXPECTED_TOKEN_TYPE" /* EXPECTED_TOKEN_TYPE */, {
-          token: this.currentToken,
-          data: { expectedType: "identifier", actualType: this.currentToken.type }
-        });
-      }
-      indexVar = this.currentToken.value;
-      this.eat(this.currentToken.type);
-    }
-    if (!this.isIdentifierToken() || this.currentToken.value !== "in") {
-      throw new ParserError("PARSER_EXPECTED_TOKEN_TYPE" /* EXPECTED_TOKEN_TYPE */, {
-        token: this.currentToken,
-        data: { expectedType: "'in'", actualType: this.currentToken.value }
-      });
-    }
-    this.eat(this.currentToken.type);
-    const collection = this.expr();
-    const body = this.block();
-    if (this.currentToken.type === "SEMICOLON" /* SEMICOLON */) {
-      this.eat("SEMICOLON" /* SEMICOLON */);
-    }
-    return new ForEachNode(
-      firstVar,
-      indexVar,
-      collection,
-      body.statements,
-      forToken
-    );
-  }
   ifStatement() {
     const ifToken = this.eat("RESERVED_KEYWORD" /* RESERVED_KEYWORD */);
     this.eat("LPAREN" /* LPAREN */);
@@ -3295,21 +2987,6 @@ ${contextText}`;
     this.eat("RBLOCK" /* RBLOCK */);
     return new BlockNode(statements);
   }
-  // Explicit list literal: [expr, expr, ...]
-  explicitList() {
-    const token = this.currentToken;
-    this.eat("LBLOCK" /* LBLOCK */);
-    const elements = [];
-    if (this.currentToken.type !== "RBLOCK" /* RBLOCK */) {
-      elements.push(this.expr());
-      while (this.currentToken.type === "COMMA" /* COMMA */) {
-        this.eat("COMMA" /* COMMA */);
-        elements.push(this.expr());
-      }
-    }
-    this.eat("RBLOCK" /* RBLOCK */);
-    return new ListNode(elements, token);
-  }
   // implicit_list_expr : factor ((COMMA) factor)*
   implicitListExpr() {
     const token = this.currentToken;
@@ -3338,8 +3015,6 @@ ${contextText}`;
     let node = this.comparison();
     while (this.currentToken.type === "OPERATION" /* OPERATION */ && (this.currentToken.value === "+" /* ADD */ || this.currentToken.value === "-" /* SUBTRACT */)) {
       const token = this.eat("OPERATION" /* OPERATION */);
-      const partial = this.tryRecoverMissingOperand(node, token);
-      if (partial) return partial;
       node = new BinOpNode(node, token, this.comparison());
     }
     return node;
@@ -3349,8 +3024,6 @@ ${contextText}`;
     let node = this.term();
     while (this.currentToken.type === "IS_EQ" /* IS_EQ */ || this.currentToken.type === "IS_NOT_EQ" /* IS_NOT_EQ */ || this.currentToken.type === "GT" /* IS_GT */ || this.currentToken.type === "LT" /* IS_LT */ || this.currentToken.type === "IS_GT_EQ" /* IS_GT_EQ */ || this.currentToken.type === "IS_LT_EQ" /* IS_LT_EQ */) {
       const token = this.eat(this.currentToken.type);
-      const partial = this.tryRecoverMissingOperand(node, token);
-      if (partial) return partial;
       node = new BinOpNode(node, token, this.term());
     }
     return node;
@@ -3360,8 +3033,6 @@ ${contextText}`;
     let node = this.power();
     while (this.currentToken.type === "OPERATION" /* OPERATION */ && (this.currentToken.value === "*" /* MULTIPLY */ || this.currentToken.value === "/" /* DIVIDE */)) {
       const token = this.eat("OPERATION" /* OPERATION */);
-      const partial = this.tryRecoverMissingOperand(node, token);
-      if (partial) return partial;
       node = new BinOpNode(node, token, this.power());
     }
     return node;
@@ -3371,8 +3042,6 @@ ${contextText}`;
     let node = this.factor();
     while (this.currentToken.type === "OPERATION" /* OPERATION */ && this.currentToken.value === "^" /* POWER */) {
       const token = this.eat("OPERATION" /* OPERATION */);
-      const partial = this.tryRecoverMissingOperand(node, token);
-      if (partial) return partial;
       node = new BinOpNode(node, token, this.factor());
     }
     return node;
@@ -3401,19 +3070,8 @@ ${contextText}`;
   //        | HEX_COLOR
   factor() {
     const token = this.currentToken;
-    if (token.type === "LBLOCK" /* LBLOCK */) {
-      return this.explicitList();
-    }
     if (token.type === "OPERATION" /* OPERATION */ && (token.value === "+" /* ADD */ || token.value === "-" /* SUBTRACT */ || token.value === "!" /* LOGIC_NOT */)) {
       this.eat("OPERATION" /* OPERATION */);
-      if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-        this.incompleteInfo.push({
-          type: "missing_operand" /* MISSING_OPERAND */,
-          startPos: token.pos,
-          endPos: token.endPos
-        });
-        return new PartialUnaryOpNode(token);
-      }
       return new UnaryOpNode(token, this.factor());
     }
     if (token.type === "RESERVED_KEYWORD" /* RESERVED_KEYWORD */ && (token.value === "true" /* TRUE */ || token.value === "false" /* FALSE */)) {
@@ -3428,34 +3086,14 @@ ${contextText}`;
       return this.number();
     }
     if (token.type === "LPAREN" /* LPAREN */) {
-      const lparenToken = token;
       this.eat("LPAREN" /* LPAREN */);
-      if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-        this.incompleteInfo.push({
-          type: "unclosed_paren" /* UNCLOSED_PAREN */,
-          startPos: lparenToken.pos
-        });
-        return new PartialParenNode(new NullNode(lparenToken), lparenToken);
-      }
       const node = this.expr();
-      if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-        this.incompleteInfo.push({
-          type: "unclosed_paren" /* UNCLOSED_PAREN */,
-          startPos: lparenToken.pos
-        });
-        return new PartialParenNode(node, lparenToken);
-      }
       this.eat("RPAREN" /* RPAREN */);
       if (this.currentToken.type === "FORMAT" /* FORMAT */) {
         return this.format(node);
       }
       return node;
     }
-    if (token.type === "PARTIAL_REFERENCE" /* PARTIAL_REFERENCE */) {
-      let node = this.reference();
-      node = this.attributeAccess(node);
-      return node;
-    }
     if (token.type === "REFERENCE" /* REFERENCE */) {
       let node = this.reference();
       node = this.attributeAccess(node);
@@ -3465,18 +3103,6 @@ ${contextText}`;
       this.eat("HEX_COLOR" /* HEX_COLOR */);
       return new HexColorNode(token);
     }
-    if (token.type === "PARTIAL_STRING" /* PARTIAL_STRING */) {
-      this.eat("PARTIAL_STRING" /* PARTIAL_STRING */);
-      const sourceText = this.lexer.getSourceInfo().text;
-      const quoteType = sourceText[token.pos] ?? '"';
-      this.incompleteInfo.push({
-        type: "unclosed_string" /* UNCLOSED_STRING */,
-        startPos: token.pos,
-        endPos: token.endPos,
-        partialValue: token.value
-      });
-      return new PartialStringNode(token.value, quoteType, token);
-    }
     if (this.isIdentifierToken(token)) {
       this.eat(token.type);
       let node;
@@ -3488,39 +3114,27 @@ ${contextText}`;
       node = this.attributeAccess(node);
       return node;
     }
-    if (token.type === "TEMPLATE_STRING" /* TEMPLATE_STRING */) {
-      return this.templateString();
-    }
     if (token.type === "EXPLICIT_STRING" /* EXPLICIT_STRING */) {
       this.eat("EXPLICIT_STRING" /* EXPLICIT_STRING */);
       let node = new StringNode(token);
       node = this.attributeAccess(node);
       return node;
     }
-    if (this.tolerant && token.type === "EOF" /* EOF */) {
-      return new NullNode(token);
-    }
     this.error("PARSER_UNEXPECTED_TOKEN" /* UNEXPECTED_TOKEN */, { token: String(token.value) });
   }
   attributeAccess(leftNode) {
     let node = leftNode;
     while (this.currentToken.type === "DOT" /* DOT */) {
-      const dotToken = this.eat("DOT" /* DOT */);
-      if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-        this.incompleteInfo.push({
-          type: "trailing_dot" /* TRAILING_DOT */,
-          startPos: dotToken.pos,
-          endPos: dotToken.endPos
-        });
-        break;
-      }
+      this.eat("DOT" /* DOT */);
       if (this.isIdentifierToken()) {
         const nextToken = this.lexer.peekToken();
         if (nextToken && nextToken.type === "LPAREN" /* LPAREN */) {
           const methodName = this.currentToken.value;
           this.eat(this.currentToken.type);
-          const funcCall = this.functionCall({ ...this.currentToken, value: methodName });
-          node = new AttributeAccessNode(node, funcCall);
+          node = new AttributeAccessNode(
+            node,
+            this.functionCall({ ...this.currentToken, value: methodName })
+          );
         } else {
           const attrToken = this.currentToken;
           this.eat(this.currentToken.type);
@@ -3534,14 +3148,6 @@ ${contextText}`;
     this.eat("LPAREN" /* LPAREN */);
     const args = [];
     while (this.currentToken.type !== "RPAREN" /* RPAREN */) {
-      if (this.tolerant && this.currentToken.type === "EOF" /* EOF */) {
-        this.incompleteInfo.push({
-          type: "unclosed_function" /* UNCLOSED_FUNCTION */,
-          startPos: functionName.pos,
-          partialValue: functionName.value
-        });
-        return new PartialFunctionCallNode(functionName.value, args, functionName);
-      }
       if (this.currentToken.type === "COMMA" /* COMMA */) {
         this.eat("COMMA" /* COMMA */);
       }
@@ -3550,126 +3156,7 @@ ${contextText}`;
     this.eat("RPAREN" /* RPAREN */);
     return new FunctionCallNode(functionName.value, args, functionName);
   }
-  /**
-   * Parse a TEMPLATE_STRING token into a TemplateStringNode.
-   * Scans the raw content for:
-   *   - {ref.path} → ReferenceNode
-   *   - ${expression} → parsed sub-expression
-   *   - \{ \${ \` \\ → escaped literals (backslash removed)
-   *   - everything else → literal StringNode segments
-   */
-  templateString() {
-    const token = this.currentToken;
-    const raw = token.value;
-    this.eat("TEMPLATE_STRING" /* TEMPLATE_STRING */);
-    const parts = [];
-    let literal = "";
-    let i = 0;
-    const flushLiteral = () => {
-      if (literal.length > 0) {
-        parts.push(new StringNode({ ...token, value: literal }));
-        literal = "";
-      }
-    };
-    while (i < raw.length) {
-      const ch = raw[i];
-      if (ch === "\\" && i + 1 < raw.length) {
-        const next = raw[i + 1];
-        if (next === "{" || next === "`" || next === "\\") {
-          literal += next;
-          i += 2;
-          continue;
-        }
-        if (next === "$") {
-          if (i + 2 < raw.length && raw[i + 2] === "{") {
-            literal += "${";
-            i += 3;
-          } else {
-            literal += "$";
-            i += 2;
-          }
-          continue;
-        }
-      }
-      if (ch === "$" && i + 1 < raw.length && raw[i + 1] === "{") {
-        flushLiteral();
-        const start = i + 2;
-        let depth = 1;
-        let j = start;
-        while (j < raw.length && depth > 0) {
-          if (raw[j] === "`") {
-            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
-              message: "Nested template strings are not allowed inside ${...}"
-            });
-          }
-          if (raw[j] === "{") depth++;
-          else if (raw[j] === "}") depth--;
-          if (depth > 0) j++;
-        }
-        if (depth !== 0) {
-          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
-            message: "Unterminated ${...} in template string"
-          });
-        }
-        const exprStr = raw.slice(start, j);
-        const subLexer = new Lexer(exprStr);
-        const subParser = new _Parser(subLexer);
-        const exprNode = subParser.expr();
-        for (const ref of subParser.requiredReferences) {
-          this.requiredReferences.add(ref);
-        }
-        parts.push(exprNode);
-        i = j + 1;
-        continue;
-      }
-      if (ch === "{") {
-        flushLiteral();
-        const start = i + 1;
-        let j = start;
-        while (j < raw.length && raw[j] !== "}") {
-          if (raw[j] === "{") {
-            this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
-              message: "Nested braces in template reference"
-            });
-          }
-          j++;
-        }
-        if (j >= raw.length) {
-          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
-            message: "Unterminated {ref} in template string"
-          });
-        }
-        let refPath = raw.slice(start, j);
-        refPath = refPath.replace(/[ \t]/g, "");
-        if (refPath.length === 0) {
-          this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
-            message: "Empty reference in template string"
-          });
-        }
-        this.requiredReferences.add(refPath);
-        parts.push(
-          new ReferenceNode({
-            ...token,
-            type: "REFERENCE" /* REFERENCE */,
-            value: refPath
-          })
-        );
-        i = j + 1;
-        continue;
-      }
-      literal += ch;
-      i++;
-    }
-    flushLiteral();
-    if (parts.length === 1 && parts[0] instanceof StringNode) {
-      return parts[0];
-    }
-    return new TemplateStringNode(parts, token);
-  }
   parse(inlineMode = false) {
-    if (this.tolerant && !inlineMode) {
-      this.error("PARSER_TOLERANT_REQUIRES_INLINE" /* TOLERANT_REQUIRES_INLINE */);
-    }
     if (this.currentToken.type === "EOF" /* EOF */) return null;
     if (inlineMode) return this.listExpr();
     const node = this.statementsList();
@@ -3715,11 +3202,49 @@ function renameReferences(originalValue, ast, renameMap) {
   }
   return result;
 }
-var parseColorSpec = Color.parseColorSpec;
-Color.safeParseColorSpec;
-Color.parseColorSpec;
+var ScriptBlockSchema = type({
+  type: "string",
+  script: "string"
+});
+var InitializerSchema = type({
+  "title?": "string",
+  keyword: "string",
+  "description?": "string",
+  // schema: type({ "...": "unknown" }),
+  script: ScriptBlockSchema
+});
+var ConversionSchema = type({
+  source: "string",
+  target: "string",
+  "description?": "string",
+  lossless: "boolean",
+  script: ScriptBlockSchema
+});
 var validSchemaTypes = ["number", "string", "color"];
-var specName = Color.specName;
+type({
+  type: "'number' | 'string' | 'color'"
+});
+var SpecSchemaSchema = type({
+  type: "'object'",
+  properties: type("Record<string, unknown>").narrow((v) => {
+    if (!isObject(v)) return false;
+    return Object.values(v).every(
+      (prop) => ["number", "string", "color"].includes(prop?.type)
+    );
+  }),
+  "required?": "string[]",
+  "order?": "string[]",
+  "additionalProperties?": "boolean"
+});
+var ColorSpecificationSchema = type({
+  name: "string",
+  type: "'color'",
+  "description?": "string",
+  "schema?": SpecSchemaSchema,
+  initializers: InitializerSchema.array(),
+  conversions: ConversionSchema.array()
+});
+var specName = (spec) => spec.name.toLowerCase();
 
 // src/utils/schema-uri.ts
 var DEFAULT_REGISTRY_URL = "https://schema.tokenscript.dev.gcp.tokens.studio";
@@ -4139,11 +3664,6 @@ var BaseManager = class {
 
 // src/interpreter/config/managers/functions/builtin/math.ts
 function extractNumber(arg, functionName) {
-  if (arg === void 0 || arg === null) {
-    throw new InterpreterError("FN_EXPECTS_NUMBER_ARGUMENTS" /* EXPECTS_NUMBER_ARGUMENTS */, {
-      data: { functionName }
-    });
-  }
   if (arg instanceof NumberSymbol) return arg.value;
   if (arg instanceof NumberWithUnitSymbol) return arg.value;
   if (typeof arg.value === "number") return arg.value;
@@ -4398,10 +3918,21 @@ var mathFunctions = {
   // Constants
   pi: () => new NumberSymbol(Math.PI)
 };
-var parseFunctionSpec = Fn.parseFunctionSpec;
-Fn.safeParseFunctionSpec;
-Fn.parseFunctionSpec;
-Fn.specName;
+var FunctionSpecificationSchema = type({
+  name: "string",
+  type: "'function'",
+  "input?": {
+    type: "'object'",
+    "properties?": "Record<string, unknown>"
+  },
+  script: {
+    type: "string",
+    script: "string"
+  },
+  keyword: "string",
+  "description?": "string",
+  "requirements?": "string[]"
+});
 
 // src/interpreter/config/managers/functions/manager.ts
 var FunctionsManager = class _FunctionsManager extends BaseManager {
@@ -4423,12 +3954,18 @@ var FunctionsManager = class _FunctionsManager extends BaseManager {
   }
   register(name, spec) {
     let parsedSpec;
-    try {
-      const input = typeof spec === "string" ? JSON.parse(spec) : spec;
-      parsedSpec = parseFunctionSpec(input);
-    } catch (err) {
-      const summary = err instanceof ZodError ? err.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ") : err instanceof Error ? err.message : String(err);
-      throw new Error(`Invalid function specification for ${name}: ${summary}`);
+    if (typeof spec === "string") {
+      const parseResult = FunctionSpecificationSchema(JSON.parse(spec));
+      if (parseResult instanceof type.errors) {
+        throw new Error(`Invalid function specification for ${name}: ${parseResult.summary}`);
+      }
+      parsedSpec = parseResult;
+    } else {
+      const parseResult = FunctionSpecificationSchema(spec);
+      if (parseResult instanceof type.errors) {
+        throw new Error(`Invalid function specification for ${name}: ${parseResult.summary}`);
+      }
+      parsedSpec = parseResult;
     }
     const functionName = parsedSpec.keyword.toLowerCase();
     this.specs.set(functionName, parsedSpec);
@@ -4499,72 +4036,6 @@ var FunctionsManager = class _FunctionsManager extends BaseManager {
     this.registerFunction("is_color", (arg) => {
       return new BooleanSymbol(arg.type === "Color");
     });
-    this.registerFunction("range", (...args) => {
-      if (args.length < 1 || args.length > 2) {
-        throw new InterpreterError("FN_REQUIRES_MIN_ARGUMENTS" /* REQUIRES_MIN_ARGUMENTS */, {
-          data: { functionName: "range", minArgs: 1 }
-        });
-      }
-      let start;
-      let end;
-      if (args.length === 1) {
-        if (!(args[0] instanceof NumberSymbol)) {
-          throw new InterpreterError("FN_EXPECTS_TYPE_ARGUMENT" /* EXPECTS_TYPE_ARGUMENT */, {
-            data: { functionName: "range", expectedType: "Number", argumentPosition: "first" }
-          });
-        }
-        const v = args[0].value;
-        if (v !== Math.trunc(v) || Number.isNaN(v) || !Number.isFinite(v) || v < 0 || v > 1e6) {
-          throw new InterpreterError("FN_ARGUMENT_OUT_OF_RANGE" /* ARGUMENT_OUT_OF_RANGE */, {
-            data: {
-              functionName: "range",
-              constraint: `count must be a non-negative integer <= 1000000, got ${v}`
-            }
-          });
-        }
-        start = 0;
-        end = v;
-      } else {
-        if (!(args[0] instanceof NumberSymbol)) {
-          throw new InterpreterError("FN_EXPECTS_TYPE_ARGUMENT" /* EXPECTS_TYPE_ARGUMENT */, {
-            data: { functionName: "range", expectedType: "Number", argumentPosition: "first" }
-          });
-        }
-        if (!(args[1] instanceof NumberSymbol)) {
-          throw new InterpreterError("FN_EXPECTS_TYPE_ARGUMENT" /* EXPECTS_TYPE_ARGUMENT */, {
-            data: { functionName: "range", expectedType: "Number", argumentPosition: "second" }
-          });
-        }
-        const sv = args[0].value;
-        const ev = args[1].value;
-        if (sv !== Math.trunc(sv) || ev !== Math.trunc(ev) || Number.isNaN(sv) || Number.isNaN(ev) || !Number.isFinite(sv) || !Number.isFinite(ev)) {
-          throw new InterpreterError("FN_ARGUMENT_OUT_OF_RANGE" /* ARGUMENT_OUT_OF_RANGE */, {
-            data: {
-              functionName: "range",
-              constraint: `arguments must be integers, got ${sv} and ${ev}`
-            }
-          });
-        }
-        if (ev - sv > 1e6) {
-          throw new InterpreterError("FN_ARGUMENT_OUT_OF_RANGE" /* ARGUMENT_OUT_OF_RANGE */, {
-            data: {
-              functionName: "range",
-              constraint: `size exceeds limit (1000000), got ${ev - sv}`
-            }
-          });
-        }
-        start = sv;
-        end = ev;
-      }
-      if (end < start) {
-        return new ListSymbol([], false);
-      }
-      const elements = [];
-      for (let i = start; i < end; i++) {
-        elements.push(new NumberSymbol(i));
-      }
-      return new ListSymbol(elements, false);
-    });
   }
   registerFunction(name, impl) {
     this.functionMap.set(name.toLowerCase(), impl);
@@ -4616,33 +4087,26 @@ var FunctionsManager = class _FunctionsManager extends BaseManager {
   getFunctionNames() {
     return Array.from(this.functionMap.keys());
   }
-  getFunctionSchemas() {
-    return this.specs;
-  }
-  /**
-   * Validate that a function call has the correct number of arguments
-   * based on its schema spec. Only validates schema-registered functions
-   * (not builtins which handle their own argument validation).
-   */
-  validateFunctionArgs(name, args, token) {
-    const fnName = name.toLowerCase();
-    const spec = this.specs.get(fnName);
-    if (!spec?.input?.properties) return;
-    const requiredCount = Object.values(spec.input.properties).filter(
-      (prop) => !prop?.optional
-    ).length;
-    if (args.length < requiredCount) {
-      throw new InterpreterError("FN_REQUIRES_MIN_ARGUMENTS" /* REQUIRES_MIN_ARGUMENTS */, {
-        token,
-        data: { functionName: name, minArgs: requiredCount }
-      });
-    }
-  }
 };
-var parseUnitSpec = Unit.parseUnitSpec;
-Unit.safeParseUnitSpec;
-Unit.parseUnitSpec;
-var specName3 = Unit.specName;
+var ScriptBlockSchema2 = type({
+  "type?": "string",
+  script: "string"
+});
+var ConversionSchema2 = type({
+  source: "string",
+  target: "string",
+  script: ScriptBlockSchema2,
+  "description?": "string"
+});
+var UnitSpecificationSchema = type({
+  name: "string",
+  type: "'absolute' | 'relative'",
+  keyword: "string",
+  "description?": "string",
+  "conversions?": ConversionSchema2.array(),
+  "to_absolute?": ScriptBlockSchema2
+});
+var specName2 = (spec) => spec.name.toLowerCase();
 
 // src/interpreter/config/managers/unit/manager.ts
 var PIXEL_UNIT = buildSchemaUri({
@@ -4721,7 +4185,7 @@ var UnitManager = class _UnitManager extends BaseManager {
     }
   }
   getSpecName(spec) {
-    return specName3(spec);
+    return specName2(spec);
   }
   /**
    * Creates a clone of this class to be passed down to initializers and conversion functions
@@ -4755,19 +4219,26 @@ var UnitManager = class _UnitManager extends BaseManager {
   }
   register(uri, spec) {
     let parsedSpec;
-    try {
-      const input = typeof spec === "string" ? JSON.parse(spec) : spec;
-      parsedSpec = parseUnitSpec(input);
-    } catch (err) {
-      const summary = err instanceof ZodError ? err.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ") : err instanceof Error ? err.message : String(err);
-      const jsonSuffix = typeof spec === "string" ? `
+    if (typeof spec === "string") {
+      const parseResult = UnitSpecificationSchema(JSON.parse(spec));
+      if (parseResult instanceof type.errors) {
+        throw new Error(
+          `Invalid unit specification for URI ${uri}: ${parseResult.summary}
 
 Json:
-${spec}` : "";
-      throw new Error(`Invalid unit specification for URI ${uri}: ${summary}${jsonSuffix}`);
+${spec}`
+        );
+      }
+      parsedSpec = parseResult;
+    } else {
+      const parseResult = UnitSpecificationSchema(spec);
+      if (parseResult instanceof type.errors) {
+        throw new Error(`Invalid unit specification for URI ${uri}: ${parseResult.summary}`);
+      }
+      parsedSpec = parseResult;
     }
     this.specs.set(uri, parsedSpec);
-    this.specTypes.set(specName3(parsedSpec), uri);
+    this.specTypes.set(specName2(parsedSpec), uri);
     this.unitKeywords.set(parsedSpec.keyword.toUpperCase(), uri);
     this.registerConversions(uri, parsedSpec);
     return parsedSpec;
@@ -5038,16 +4509,23 @@ var ColorManager = class _ColorManager extends BaseManager {
   }
   register(uri, spec) {
     let parsedSpec;
-    try {
-      const input = typeof spec === "string" ? JSON.parse(spec) : spec;
-      parsedSpec = parseColorSpec(input);
-    } catch (err) {
-      const summary = err instanceof ZodError ? err.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ") : err instanceof Error ? err.message : String(err);
-      const jsonSuffix = typeof spec === "string" ? `
+    if (typeof spec === "string") {
+      const parseResult = ColorSpecificationSchema(JSON.parse(spec));
+      if (parseResult instanceof type.errors) {
+        throw new Error(
+          `Invalid color specification for URI ${uri}: ${parseResult.summary}
 
 Json:
-${spec}` : "";
-      throw new Error(`Invalid color specification for URI ${uri}: ${summary}${jsonSuffix}`);
+${spec}`
+        );
+      }
+      parsedSpec = parseResult;
+    } else {
+      const parseResult = ColorSpecificationSchema(spec);
+      if (parseResult instanceof type.errors) {
+        throw new Error(`Invalid color specification for URI ${uri}: ${parseResult.summary}`);
+      }
+      parsedSpec = parseResult;
     }
     this.specs.set(uri, parsedSpec);
     this.specTypes.set(specName(parsedSpec), uri);
@@ -5055,8 +4533,8 @@ ${spec}` : "";
     this.registerConversions(uri, parsedSpec);
     return parsedSpec;
   }
-  getSpecByType(type) {
-    const uri = this.specTypes.get(type.toLowerCase());
+  getSpecByType(type9) {
+    const uri = this.specTypes.get(type9.toLowerCase());
     if (!uri) return;
     return this.getSpec(uri);
   }
@@ -5269,14 +4747,28 @@ ${spec}` : "";
     }
     return "";
   }
-  getColorSchemas() {
-    return this.specs;
-  }
 };
-var parseTokenSpec = Token.parseTokenSpec;
-Token.safeParseTokenSpec;
-Token.parseTokenSpec;
-var specName4 = Token.specName;
+var SpecSchemaSchema2 = type({
+  type: "'object' | 'number' | 'string' | 'list'",
+  "properties?": "Record<string, unknown>",
+  // Simplified validation
+  "validations?": "Record<string, string>",
+  "required?": "string[]",
+  "order?": "string[]",
+  "additionalProperties?": "boolean",
+  "items?": "unknown"
+  // For list types - validated at runtime
+});
+var TokenSpecificationSchema = type({
+  name: "string",
+  type: "'token'",
+  "description?": "string",
+  "url?": "string",
+  "schema?": SpecSchemaSchema2,
+  "validation?": "string | unknown"
+  // Allow string or object, validated at runtime in manager
+});
+var specName3 = (spec) => spec.name.toLowerCase();
 
 // src/interpreter/config/managers/token/manager.ts
 var MAX_VALIDATION_DEPTH = 10;
@@ -5301,10 +4793,10 @@ var TokenManager = class _TokenManager extends BaseManager {
     this.validationInterpreterCache = /* @__PURE__ */ new Map();
   }
   getSpecName(spec) {
-    return specName4(spec);
+    return specName3(spec);
   }
-  getSpecByType(type) {
-    const uri = this.specTypes.get(type.toLowerCase());
+  getSpecByType(type9) {
+    const uri = this.specTypes.get(type9.toLowerCase());
     if (!uri) return;
     return this.getSpec(uri);
   }
@@ -5320,18 +4812,25 @@ var TokenManager = class _TokenManager extends BaseManager {
   }
   register(uri, spec) {
     let parsedSpec;
-    try {
-      const input = typeof spec === "string" ? JSON.parse(spec) : spec;
-      parsedSpec = parseTokenSpec(input);
-    } catch (err) {
-      const summary = err instanceof ZodError ? err.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ") : err instanceof Error ? err.message : String(err);
-      const jsonSuffix = typeof spec === "string" ? `
+    if (typeof spec === "string") {
+      const parseResult = TokenSpecificationSchema(JSON.parse(spec));
+      if (parseResult instanceof type.errors) {
+        throw new Error(
+          `Invalid token specification for URI ${uri}: ${parseResult.summary}
 Json:
-${spec}` : "";
-      throw new Error(`Invalid token specification for URI ${uri}: ${summary}${jsonSuffix}`);
+${spec}`
+        );
+      }
+      parsedSpec = parseResult;
+    } else {
+      const parseResult = TokenSpecificationSchema(spec);
+      if (parseResult instanceof type.errors) {
+        throw new Error(`Invalid token specification for URI ${uri}: ${parseResult.summary}`);
+      }
+      parsedSpec = parseResult;
     }
     this.specs.set(uri, parsedSpec);
-    this.specTypes.set(specName4(parsedSpec), uri);
+    this.specTypes.set(specName3(parsedSpec), uri);
     if (parsedSpec.validation) {
       this.registerValidation(parsedSpec.name, parsedSpec.validation);
     }
@@ -5367,8 +4866,8 @@ ${spec}` : "";
       return this.extractErrorTypesFromAST(tokenType);
     }
     const allErrors = /* @__PURE__ */ new Set();
-    for (const type of this.validationScripts.keys()) {
-      for (const error of this.extractErrorTypesFromAST(type)) {
+    for (const type9 of this.validationScripts.keys()) {
+      for (const error of this.extractErrorTypesFromAST(type9)) {
         allErrors.add(error);
       }
     }
@@ -5921,9 +5420,6 @@ var SymbolTable = class {
   isDefined(name) {
     return !!this.symbols[name.toLowerCase()];
   }
-  delete(name) {
-    delete this.symbols[name.toLowerCase()];
-  }
   reset() {
     this.symbols = {};
   }
@@ -6033,47 +5529,6 @@ var Interpreter = class {
   visitStringNode(node) {
     return new StringSymbol(node.value, this.config);
   }
-  visitTemplateStringNode(node) {
-    if (node.parts.length === 0) {
-      return new StringSymbol("", this.config);
-    }
-    if (node.parts.length === 1) {
-      const val = this.visit(node.parts[0]);
-      this.validateTemplateValue(val, node);
-      return val;
-    }
-    let result = "";
-    for (const part of node.parts) {
-      const val = this.visit(part);
-      this.validateTemplateValue(val, node);
-      result += val.toString();
-    }
-    return new StringSymbol(result, this.config);
-  }
-  /**
-   * Validate that a value is a primitive type allowed in template string interpolation.
-   * Lists, Dictionaries, and non-hex Colors are rejected.
-   */
-  validateTemplateValue(val, node) {
-    if (val instanceof ListSymbol) {
-      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
-        token: node.token,
-        data: { valueType: "List" }
-      });
-    }
-    if (val instanceof DictionarySymbol) {
-      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
-        token: node.token,
-        data: { valueType: "Dictionary" }
-      });
-    }
-    if (val instanceof ColorSymbol && !val.isHex()) {
-      throw new InterpreterError("INT_TEMPLATE_INVALID_TYPE" /* TEMPLATE_INVALID_TYPE */, {
-        token: node.token,
-        data: { valueType: `Color.${val.subType}` }
-      });
-    }
-  }
   /**
    * Bare identifiers are treated as string literals if not found as variables
    * Check symbol table first (variables override references), then references
@@ -6168,7 +5623,6 @@ var Interpreter = class {
     const fnName = node.name.toLowerCase();
     const args = node.args.map((arg) => this.visit(arg));
     if (this.config.functionsManager.hasFunction(fnName)) {
-      this.config.functionsManager.validateFunctionArgs(fnName, args, node.token);
       const fn = this.config.functionsManager.getFunction(fnName);
       if (fn) {
         return fn(...args);
@@ -6346,63 +5800,6 @@ var Interpreter = class {
       this.visit(node.body);
     }
   }
-  visitForEachNode(node) {
-    if (this.symbolTable.isDefined(node.itemVar)) {
-      throw new InterpreterError("INT_FOR_EACH_VARIABLE_SHADOW" /* FOR_EACH_VARIABLE_SHADOW */, {
-        token: node.token,
-        data: { name: node.itemVar }
-      });
-    }
-    if (node.indexVar !== null) {
-      if (node.indexVar === node.itemVar) {
-        throw new InterpreterError("INT_FOR_EACH_DUPLICATE_VARS" /* FOR_EACH_DUPLICATE_VARS */, {
-          token: node.token,
-          data: { name: node.itemVar }
-        });
-      }
-      if (this.symbolTable.isDefined(node.indexVar)) {
-        throw new InterpreterError("INT_FOR_EACH_VARIABLE_SHADOW" /* FOR_EACH_VARIABLE_SHADOW */, {
-          token: node.token,
-          data: { name: node.indexVar }
-        });
-      }
-    }
-    const collectionVal = this.visit(node.collection);
-    if (!(collectionVal instanceof ListSymbol)) {
-      throw new InterpreterError("INT_FOR_EACH_NOT_LIST" /* FOR_EACH_NOT_LIST */, {
-        token: node.token,
-        data: { actualType: collectionVal?.type ?? "null" }
-      });
-    }
-    const elements = collectionVal.value;
-    const results = [];
-    for (let idx = 0; idx < elements.length; idx++) {
-      const item = elements[idx];
-      this.symbolTable.set(node.itemVar, item);
-      if (node.indexVar !== null) {
-        this.symbolTable.set(node.indexVar, new NumberSymbol(idx, this.config));
-      }
-      let bodyResult = null;
-      try {
-        bodyResult = this.visit(node.body);
-      } catch (e) {
-        if (e instanceof ReturnSignal) {
-          this.symbolTable.delete(node.itemVar);
-          if (node.indexVar !== null) {
-            this.symbolTable.delete(node.indexVar);
-          }
-          throw e;
-        }
-        throw e;
-      }
-      results.push(bodyResult ?? new NullSymbol(this.config));
-    }
-    this.symbolTable.delete(node.itemVar);
-    if (node.indexVar !== null) {
-      this.symbolTable.delete(node.indexVar);
-    }
-    return new ListSymbol(results, false, this.config);
-  }
   visitIfNode(node) {
     for (const conditionNode of node.conditions) {
       const condition = this.visit(conditionNode.condition);
@@ -6439,6 +5836,6 @@ var Interpreter = class {
   }
 };
 
-export { BaseSymbolType, BooleanSymbol, ColorManager, ColorSymbol, Config, DictionarySymbol, Interpreter, InterpreterError, Lexer, LexerError, ListSymbol, NullSymbol, NumberSymbol, NumberWithUnitSymbol, Parser, ParserError, ProcessorError, StringSymbol, TokenSymbol, getAssignmentInfo, getKeyAlt, getReassignmentInfo, isArray, isBoolean, isLanguageError, isNone, isNull, isNumber, isObject, isString, isTokenscriptSymbol, jsValueToSymbolType, parseColorSpec, parseExpression, parseFunctionSpec, renameReferences, serializeInterpreterResult, stringifyInterpreterResult };
-//# sourceMappingURL=chunk-33CDF4L4.js.map
-//# sourceMappingURL=chunk-33CDF4L4.js.map
+export { BaseSymbolType, BooleanSymbol, ColorManager, ColorSpecificationSchema, ColorSymbol, Config, DictionarySymbol, FunctionSpecificationSchema, Interpreter, InterpreterError, Lexer, LexerError, ListSymbol, NullSymbol, NumberSymbol, NumberWithUnitSymbol, Parser, ParserError, ProcessorError, StringSymbol, TokenSymbol, getAssignmentInfo, getKeyAlt, getReassignmentInfo, isArray, isBoolean, isLanguageError, isNone, isNull, isNumber, isObject, isString, isTokenscriptSymbol, jsValueToSymbolType, parseExpression, renameReferences, serializeInterpreterResult, stringifyInterpreterResult };
+//# sourceMappingURL=chunk-P4VLJQEI.js.map
+//# sourceMappingURL=chunk-P4VLJQEI.js.map