rei-lang 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1729 @@
+// src/lang/lexer.ts
+var TokenType = {
+  // Literals
+  NUMBER: "NUMBER",
+  STRING: "STRING",
+  EXT_LIT: "EXT_LIT",
+  SYMBOL_0_0: "SYMBOL_0_0",
+  SYMBOL_DOT_PRIM: "SYMBOL_DOT_PRIM",
+  BOOL_TRUE: "BOOL_TRUE",
+  BOOL_FALSE: "BOOL_FALSE",
+  // Math constants
+  CONST_PI: "CONST_PI",
+  CONST_E: "CONST_E",
+  CONST_PHI: "CONST_PHI",
+  CONST_I: "CONST_I",
+  CONST_PHI_UP: "CONST_PHI_UP",
+  CONST_PSI_UP: "CONST_PSI_UP",
+  CONST_OMEGA_UP: "CONST_OMEGA_UP",
+  CONST_EMPTY: "CONST_EMPTY",
+  // Quad literals (v0.2)
+  QUAD_TOP: "QUAD_TOP",
+  QUAD_BOT: "QUAD_BOT",
+  QUAD_TOP_PI: "QUAD_TOP_PI",
+  QUAD_BOT_PI: "QUAD_BOT_PI",
+  // Keywords
+  LET: "LET",
+  MUT: "MUT",
+  COMPRESS: "COMPRESS",
+  WEIGHT: "WEIGHT",
+  GENESIS: "GENESIS",
+  IF: "IF",
+  THEN: "THEN",
+  ELSE: "ELSE",
+  MATCH: "MATCH",
+  CASE: "CASE",
+  WITNESSED: "WITNESSED",
+  BY: "BY",
+  TRUE: "TRUE",
+  FALSE: "FALSE",
+  NULL: "NULL",
+  TEMPORAL: "TEMPORAL",
+  TIMELESS: "TIMELESS",
+  // Identifiers
+  IDENT: "IDENT",
+  // Operators
+  PLUS: "PLUS",
+  MINUS: "MINUS",
+  STAR: "STAR",
+  SLASH: "SLASH",
+  OPLUS: "OPLUS",
+  OTIMES: "OTIMES",
+  CDOT: "CDOT",
+  PIPE_OP: "PIPE_OP",
+  EXTEND: "EXTEND",
+  REDUCE: "REDUCE",
+  ASSIGN: "ASSIGN",
+  DOT: "DOT",
+  ARROW: "ARROW",
+  SEMICOLON: "SEMICOLON",
+  COMMA: "COMMA",
+  COLON: "COLON",
+  LPAREN: "LPAREN",
+  RPAREN: "RPAREN",
+  LBRACE: "LBRACE",
+  RBRACE: "RBRACE",
+  LBRACKET: "LBRACKET",
+  RBRACKET: "RBRACKET",
+  CONVERGE: "CONVERGE",
+  DIVERGE: "DIVERGE",
+  REFLECT: "REFLECT",
+  AND: "AND",
+  OR: "OR",
+  NOT: "NOT",
+  GT_K: "GT_K",
+  LT_K: "LT_K",
+  EQ_K: "EQ_K",
+  GT: "GT",
+  LT: "LT",
+  EQ: "EQ",
+  NEQ: "NEQ",
+  GTE: "GTE",
+  LTE: "LTE",
+  MDIM_OPEN: "MDIM_OPEN",
+  // Special
+  NEWLINE: "NEWLINE",
+  EOF: "EOF"
+};
+var KEYWORDS = {
+  "let": TokenType.LET,
+  "mut": TokenType.MUT,
+  "compress": TokenType.COMPRESS,
+  "weight": TokenType.WEIGHT,
+  "genesis": TokenType.GENESIS,
+  "if": TokenType.IF,
+  "then": TokenType.THEN,
+  "else": TokenType.ELSE,
+  "match": TokenType.MATCH,
+  "case": TokenType.CASE,
+  "witnessed": TokenType.WITNESSED,
+  "by": TokenType.BY,
+  "true": TokenType.TRUE,
+  "false": TokenType.FALSE,
+  "null": TokenType.NULL,
+  "Temporal": TokenType.TEMPORAL,
+  "Timeless": TokenType.TIMELESS
+};
+var SUBSCRIPT_CHARS = new Set("oxzwensbua".split(""));
+var Lexer = class {
+  constructor(source) {
+    this.source = source;
+    this.chars = Array.from(source);
+  }
+  chars;
+  pos = 0;
+  line = 1;
+  col = 1;
+  tokens = [];
+  tokenize() {
+    this.tokens = [];
+    while (this.pos < this.chars.length) {
+      this.skipWhitespaceAndComments();
+      if (this.pos >= this.chars.length) break;
+      const ch = this.chars[this.pos];
+      if (ch === "\n") {
+        this.emit(TokenType.NEWLINE, "\n");
+        this.advance();
+        this.line++;
+        this.col = 1;
+        continue;
+      }
+      if (ch === '"') {
+        this.readString();
+        continue;
+      }
+      if (ch === "0" && this.peek(1) === "\u2080") {
+        this.emit(TokenType.SYMBOL_0_0, "0\u2080");
+        this.advance();
+        this.advance();
+        continue;
+      }
+      if (ch === "\u{1D544}" && this.peek(1) === "{") {
+        this.emit(TokenType.MDIM_OPEN, "\u{1D544}{");
+        this.advance();
+        this.advance();
+        continue;
+      }
+      if (this.isExtStart(ch)) {
+        const ext = this.readExtLit();
+        if (ext) continue;
+      }
+      if (this.isDigit(ch) || ch === "-" && this.isDigit(this.peek(1) ?? "") && this.shouldNegateBePrefix()) {
+        this.readNumber();
+        continue;
+      }
+      if (this.readUnicodeToken(ch)) continue;
+      if (this.readMultiCharOp(ch)) continue;
+      if (this.readSingleCharOp(ch)) continue;
+      if (this.isIdentStart(ch)) {
+        this.readIdentOrKeyword();
+        continue;
+      }
+      this.advance();
+    }
+    this.emit(TokenType.EOF, "");
+    return this.tokens.filter((t) => t.type !== TokenType.NEWLINE || false);
+  }
+  skipWhitespaceAndComments() {
+    while (this.pos < this.chars.length) {
+      const ch = this.chars[this.pos];
+      if (ch === " " || ch === "	" || ch === "\r") {
+        this.advance();
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "/") {
+        while (this.pos < this.chars.length && this.chars[this.pos] !== "\n") this.advance();
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "*") {
+        this.advance();
+        this.advance();
+        while (this.pos < this.chars.length) {
+          if (this.chars[this.pos] === "*" && this.peek(1) === "/") {
+            this.advance();
+            this.advance();
+            break;
+          }
+          if (this.chars[this.pos] === "\n") {
+            this.line++;
+            this.col = 0;
+          }
+          this.advance();
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  readString() {
+    const startCol = this.col;
+    this.advance();
+    let str = "";
+    while (this.pos < this.chars.length && this.chars[this.pos] !== '"') {
+      if (this.chars[this.pos] === "\\" && this.pos + 1 < this.chars.length) {
+        this.advance();
+        const esc = this.chars[this.pos];
+        if (esc === "n") str += "\n";
+        else if (esc === "t") str += "	";
+        else if (esc === "\\") str += "\\";
+        else if (esc === '"') str += '"';
+        else str += esc;
+      } else {
+        str += this.chars[this.pos];
+      }
+      this.advance();
+    }
+    if (this.pos < this.chars.length) this.advance();
+    this.tokens.push({ type: TokenType.STRING, value: str, line: this.line, col: startCol });
+  }
+  isExtStart(ch) {
+    if (ch === "0" && SUBSCRIPT_CHARS.has(this.peek(1) ?? "")) return true;
+    if (ch === "\u03C0" || ch === "\u03C6") {
+      const next = this.peek(1);
+      if (next && SUBSCRIPT_CHARS.has(next)) return true;
+    }
+    if (ch === "e" || ch === "i") {
+      const next = this.peek(1);
+      if (!next || !SUBSCRIPT_CHARS.has(next)) return false;
+      let offset = 1;
+      while (this.peek(offset) && SUBSCRIPT_CHARS.has(this.peek(offset))) offset++;
+      const afterSubs = this.peek(offset);
+      if (afterSubs && /[a-zA-Z0-9_]/.test(afterSubs)) return false;
+      return true;
+    }
+    return false;
+  }
+  readExtLit() {
+    const startCol = this.col;
+    const base = this.chars[this.pos];
+    this.advance();
+    let subs = "";
+    while (this.pos < this.chars.length && SUBSCRIPT_CHARS.has(this.chars[this.pos])) {
+      subs += this.chars[this.pos];
+      this.advance();
+    }
+    if (subs.length > 0) {
+      this.tokens.push({
+        type: TokenType.EXT_LIT,
+        value: base + subs,
+        line: this.line,
+        col: startCol
+      });
+      return true;
+    }
+    this.pos--;
+    this.col--;
+    return false;
+  }
+  readNumber() {
+    const startCol = this.col;
+    let num = "";
+    if (this.chars[this.pos] === "-") {
+      num += "-";
+      this.advance();
+    }
+    while (this.pos < this.chars.length && this.isDigit(this.chars[this.pos])) {
+      num += this.chars[this.pos];
+      this.advance();
+    }
+    if (this.pos < this.chars.length && this.chars[this.pos] === "." && this.isDigit(this.peek(1) ?? "")) {
+      num += ".";
+      this.advance();
+      while (this.pos < this.chars.length && this.isDigit(this.chars[this.pos])) {
+        num += this.chars[this.pos];
+        this.advance();
+      }
+    }
+    this.tokens.push({ type: TokenType.NUMBER, value: num, line: this.line, col: startCol });
+  }
+  readUnicodeToken(ch) {
+    this.col;
+    const map = [
+      ["\u2295", TokenType.OPLUS],
+      ["\u2297", TokenType.OTIMES],
+      ["\xB7", TokenType.CDOT],
+      ["\u03C0", TokenType.CONST_PI],
+      ["\u03C6", TokenType.CONST_PHI],
+      ["\u03A6", TokenType.CONST_PHI_UP],
+      ["\u03A8", TokenType.CONST_PSI_UP],
+      ["\u03A9", TokenType.CONST_OMEGA_UP],
+      ["\u2205", TokenType.CONST_EMPTY],
+      ["\u22A4", TokenType.QUAD_TOP],
+      ["\u22A5", TokenType.QUAD_BOT],
+      ["\u290A", TokenType.CONVERGE],
+      ["\u290B", TokenType.DIVERGE],
+      ["\u25C1", TokenType.REFLECT],
+      ["\u2227", TokenType.AND],
+      ["\u2228", TokenType.OR],
+      ["\xAC", TokenType.NOT],
+      ["\u30FB", TokenType.SYMBOL_DOT_PRIM]
+    ];
+    if (ch === "\u22A4" && this.peek(1) === "\u03C0") {
+      this.emit(TokenType.QUAD_TOP_PI, "\u22A4\u03C0");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "\u22A5" && this.peek(1) === "\u03C0") {
+      this.emit(TokenType.QUAD_BOT_PI, "\u22A5\u03C0");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    for (const [sym, type] of map) {
+      if (ch === sym) {
+        this.emit(type, sym);
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  readMultiCharOp(ch) {
+    const next = this.peek(1);
+    if (ch === "|" && next === ">") {
+      this.emit(TokenType.PIPE_OP, "|>");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === ">" && next === ">") {
+      this.emit(TokenType.EXTEND, ">>");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "<" && next === "<") {
+      this.emit(TokenType.REDUCE, "<<");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "-" && next === ">") {
+      this.emit(TokenType.ARROW, "->");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "=" && next === "=") {
+      this.emit(TokenType.EQ, "==");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "!" && next === "=") {
+      this.emit(TokenType.NEQ, "!=");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === ">" && next === "=") {
+      this.emit(TokenType.GTE, ">=");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "<" && next === "=") {
+      this.emit(TokenType.LTE, "<=");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === ">" && next === "\u03BA") {
+      this.emit(TokenType.GT_K, ">\u03BA");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "<" && next === "\u03BA") {
+      this.emit(TokenType.LT_K, "<\u03BA");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    if (ch === "=" && next === "\u03BA") {
+      this.emit(TokenType.EQ_K, "=\u03BA");
+      this.advance();
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  readSingleCharOp(ch) {
+    const map = {
+      "+": TokenType.PLUS,
+      "-": TokenType.MINUS,
+      "*": TokenType.STAR,
+      "/": TokenType.SLASH,
+      "=": TokenType.ASSIGN,
+      ".": TokenType.DOT,
+      ",": TokenType.COMMA,
+      ":": TokenType.COLON,
+      ";": TokenType.SEMICOLON,
+      "(": TokenType.LPAREN,
+      ")": TokenType.RPAREN,
+      "{": TokenType.LBRACE,
+      "}": TokenType.RBRACE,
+      "[": TokenType.LBRACKET,
+      "]": TokenType.RBRACKET,
+      "|": TokenType.PIPE_OP,
+      ">": TokenType.GT,
+      "<": TokenType.LT
+    };
+    const type = map[ch];
+    if (type) {
+      this.emit(type, ch);
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  readIdentOrKeyword() {
+    const startCol = this.col;
+    let name = "";
+    while (this.pos < this.chars.length && this.isIdentPart(this.chars[this.pos])) {
+      name += this.chars[this.pos];
+      this.advance();
+    }
+    if (name.startsWith("compress") && name.length > 8) {
+      const suffix = name.slice(8);
+      if (["\u2070", "\xB9", "\xB2", "\xB3", "\u221E"].includes(suffix)) {
+        this.tokens.push({ type: TokenType.COMPRESS, value: name, line: this.line, col: startCol });
+        return;
+      }
+    }
+    const kw = KEYWORDS[name];
+    if (kw) {
+      this.tokens.push({ type: kw, value: name, line: this.line, col: startCol });
+    } else {
+      this.tokens.push({ type: TokenType.IDENT, value: name, line: this.line, col: startCol });
+    }
+  }
+  // --- Helpers ---
+  advance() {
+    this.pos++;
+    this.col++;
+  }
+  peek(offset) {
+    return this.chars[this.pos + offset];
+  }
+  emit(type, value) {
+    this.tokens.push({ type, value, line: this.line, col: this.col });
+  }
+  isDigit(ch) {
+    return ch >= "0" && ch <= "9";
+  }
+  isIdentStart(ch) {
+    return /[a-zA-Z_α-ωΑ-Ω𝕄𝕌]/.test(ch);
+  }
+  isIdentPart(ch) {
+    return /[a-zA-Z0-9_α-ωΑ-Ω⁰¹²³∞𝕄𝕌]/.test(ch);
+  }
+  shouldNegateBePrefix() {
+    if (this.tokens.length === 0) return true;
+    const last = this.tokens[this.tokens.length - 1];
+    return [
+      TokenType.LPAREN,
+      TokenType.COMMA,
+      TokenType.ASSIGN,
+      TokenType.PLUS,
+      TokenType.MINUS,
+      TokenType.STAR,
+      TokenType.SLASH,
+      TokenType.OPLUS,
+      TokenType.OTIMES,
+      TokenType.PIPE_OP,
+      TokenType.SEMICOLON,
+      TokenType.LBRACKET,
+      TokenType.COLON
+    ].includes(last.type);
+  }
+};
+
+// src/lang/parser.ts
+function node(type, props = {}) {
+  return { type, ...props };
+}
+var Parser = class {
+  pos = 0;
+  tokens;
+  constructor(tokens) {
+    this.tokens = tokens.filter((t) => t.type !== TokenType.NEWLINE);
+  }
+  parseProgram() {
+    const stmts = [];
+    while (!this.isAtEnd()) {
+      while (this.check(TokenType.SEMICOLON)) this.advance();
+      if (this.isAtEnd()) break;
+      stmts.push(this.parseStatement());
+      while (this.check(TokenType.SEMICOLON)) this.advance();
+    }
+    return node("Program", { body: stmts });
+  }
+  parseStatement() {
+    if (this.check(TokenType.LET)) return this.parseLetStmt();
+    if (this.check(TokenType.COMPRESS)) return this.parseCompressDef();
+    return this.parseExpression();
+  }
+  // --- let [mut] name [: type] = expr [witnessed by "..."] ---
+  parseLetStmt() {
+    this.expect(TokenType.LET);
+    const mutable = this.match(TokenType.MUT);
+    const name = this.expect(TokenType.IDENT).value;
+    let typeAnnotation = null;
+    let phaseGuard = null;
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.expect(TokenType.IDENT).value;
+      if (this.check(TokenType.IDENT) && this.peek().value.startsWith("@")) {
+        phaseGuard = this.advance().value.slice(1);
+      }
+    }
+    this.expect(TokenType.ASSIGN);
+    const init = this.parseExpression();
+    let witness = null;
+    if (this.match(TokenType.WITNESSED)) {
+      this.expect(TokenType.BY);
+      witness = this.expect(TokenType.STRING).value;
+    }
+    return node(mutable ? "MutStmt" : "LetStmt", {
+      name,
+      init,
+      typeAnnotation,
+      phaseGuard,
+      witness
+    });
+  }
+  // --- compress [level] name(params) [-> type] = body ---
+  parseCompressDef() {
+    const compressToken = this.expect(TokenType.COMPRESS);
+    const level = this.parseCompressLevel(compressToken.value);
+    const name = this.expect(TokenType.IDENT).value;
+    this.expect(TokenType.LPAREN);
+    const params = [];
+    if (!this.check(TokenType.RPAREN)) {
+      params.push(this.parseParamDecl());
+      while (this.match(TokenType.COMMA)) {
+        params.push(this.parseParamDecl());
+      }
+    }
+    this.expect(TokenType.RPAREN);
+    let returnType = null;
+    if (this.match(TokenType.ARROW)) {
+      returnType = this.expect(TokenType.IDENT).value;
+    }
+    this.expect(TokenType.ASSIGN);
+    const body = this.parseExpression();
+    return node("CompressDef", { name, params, body, level, returnType });
+  }
+  parseCompressLevel(value) {
+    if (value === "compress") return -1;
+    const suffixMap = {
+      "compress\u2070": 0,
+      "compress\xB9": 1,
+      "compress\xB2": 2,
+      "compress\xB3": 3,
+      "compress\u221E": Infinity
+    };
+    return suffixMap[value] ?? -1;
+  }
+  parseParamDecl() {
+    let name;
+    if (this.check(TokenType.IDENT)) {
+      name = this.advance().value;
+    } else if (this.check(TokenType.CONST_E)) {
+      name = this.advance().value;
+    } else if (this.check(TokenType.CONST_I)) {
+      name = this.advance().value;
+    } else {
+      name = this.expect(TokenType.IDENT).value;
+    }
+    if (this.match(TokenType.COLON)) {
+      this.expect(TokenType.IDENT);
+    }
+    return name;
+  }
+  // --- Expression hierarchy (low → high precedence) ---
+  parseExpression() {
+    return this.parsePipe();
+  }
+  // Level 1: |> pipe, ◁ reflect
+  parsePipe() {
+    let left = this.parseLogicOr();
+    while (this.check(TokenType.PIPE_OP) || this.check(TokenType.REFLECT)) {
+      if (this.match(TokenType.PIPE_OP)) {
+        const cmd = this.parsePipeCommand();
+        left = node("Pipe", { input: left, command: cmd });
+      } else if (this.match(TokenType.REFLECT)) {
+        const right = this.parseLogicOr();
+        left = node("ReflectOp", { left, right });
+      }
+    }
+    return left;
+  }
+  parsePipeCommand() {
+    if (this.check(TokenType.IDENT) || this.check(TokenType.GENESIS)) {
+      const cmd = this.advance().value;
+      let mode = null;
+      let args = [];
+      if (this.match(TokenType.COLON)) {
+        mode = this.expect(TokenType.IDENT).value;
+      }
+      if (this.match(TokenType.LPAREN)) {
+        if (!this.check(TokenType.RPAREN)) {
+          args.push(this.parseExpression());
+          while (this.match(TokenType.COMMA)) args.push(this.parseExpression());
+        }
+        this.expect(TokenType.RPAREN);
+      }
+      return node("PipeCmd", { cmd, mode, args });
+    }
+    if (this.match(TokenType.CONVERGE)) return node("PipeCmd", { cmd: "\u290A", mode: null, args: [] });
+    if (this.match(TokenType.DIVERGE)) return node("PipeCmd", { cmd: "\u290B", mode: null, args: [] });
+    throw this.error("\u30D1\u30A4\u30D7\u30B3\u30DE\u30F3\u30C9\u304C\u5FC5\u8981");
+  }
+  // Level 2: ∧ ∨ (logic)
+  parseLogicOr() {
+    let left = this.parseLogicAnd();
+    while (this.match(TokenType.OR)) {
+      const right = this.parseLogicAnd();
+      left = node("BinOp", { op: "\u2228", left, right });
+    }
+    return left;
+  }
+  parseLogicAnd() {
+    let left = this.parseComparison();
+    while (this.match(TokenType.AND)) {
+      const right = this.parseComparison();
+      left = node("BinOp", { op: "\u2227", left, right });
+    }
+    return left;
+  }
+  // Level 3: >κ <κ =κ == != > < >= <=
+  parseComparison() {
+    let left = this.parseAddition();
+    const compOps = [
+      TokenType.GT_K,
+      TokenType.LT_K,
+      TokenType.EQ_K,
+      TokenType.EQ,
+      TokenType.NEQ,
+      TokenType.GT,
+      TokenType.LT,
+      TokenType.GTE,
+      TokenType.LTE
+    ];
+    while (compOps.some((op) => this.check(op))) {
+      const opToken = this.advance();
+      const right = this.parseAddition();
+      left = node("BinOp", { op: opToken.value, left, right });
+    }
+    return left;
+  }
+  // Level 4: + - ⊕
+  parseAddition() {
+    let left = this.parseMultiplication();
+    while (this.check(TokenType.PLUS) || this.check(TokenType.MINUS) || this.check(TokenType.OPLUS)) {
+      const op = this.advance().value;
+      const right = this.parseMultiplication();
+      left = node("BinOp", { op, left, right });
+    }
+    return left;
+  }
+  // Level 5: * / ⊗ ·
+  parseMultiplication() {
+    let left = this.parseExtendReduce();
+    while (this.check(TokenType.STAR) || this.check(TokenType.SLASH) || this.check(TokenType.OTIMES) || this.check(TokenType.CDOT)) {
+      const op = this.advance().value;
+      const right = this.parseExtendReduce();
+      left = node("BinOp", { op, left, right });
+    }
+    return left;
+  }
+  // Level 6: >> << ⤊ ⤋
+  parseExtendReduce() {
+    let left = this.parseUnary();
+    while (true) {
+      if (this.match(TokenType.EXTEND)) {
+        if (this.match(TokenType.COLON)) {
+          const sub = this.expect(TokenType.IDENT).value;
+          left = node("Extend", { target: left, subscript: sub });
+        } else {
+          const right = this.parseUnary();
+          left = node("Extend", { target: left, expr: right });
+        }
+      } else if (this.match(TokenType.REDUCE)) {
+        left = node("Reduce", { target: left });
+      } else if (this.match(TokenType.CONVERGE)) {
+        const right = this.parseUnary();
+        left = node("ConvergeOp", { left, right });
+      } else if (this.match(TokenType.DIVERGE)) {
+        const right = this.parseUnary();
+        left = node("DivergeOp", { left, right });
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  // Level 7: unary ¬ -
+  parseUnary() {
+    if (this.match(TokenType.NOT)) {
+      const operand = this.parseUnary();
+      return node("UnaryOp", { op: "\xAC", operand });
+    }
+    if (this.check(TokenType.MINUS) && this.shouldNegateBePrefix()) {
+      this.advance();
+      const operand = this.parseUnary();
+      return node("UnaryOp", { op: "-", operand });
+    }
+    return this.parsePostfix();
+  }
+  // Level 8: . member access, [index], (call)
+  parsePostfix() {
+    let left = this.parsePrimary();
+    while (true) {
+      if (this.match(TokenType.DOT)) {
+        if (this.check(TokenType.IDENT)) {
+          const member = this.advance().value;
+          if (this.match(TokenType.DOT) && this.check(TokenType.IDENT) && this.peek().value === "\u03BA") {
+            this.advance();
+            left = node("MemberAccess", { object: left, member, kappa: true });
+          } else {
+            left = node("MemberAccess", { object: left, member, kappa: false });
+          }
+        }
+      } else if (this.match(TokenType.LPAREN)) {
+        const args = [];
+        if (!this.check(TokenType.RPAREN)) {
+          args.push(this.parseExpression());
+          while (this.match(TokenType.COMMA)) args.push(this.parseExpression());
+        }
+        this.expect(TokenType.RPAREN);
+        left = node("FnCall", { callee: left, args });
+      } else if (this.match(TokenType.LBRACKET)) {
+        const index = this.parseExpression();
+        this.expect(TokenType.RBRACKET);
+        left = node("IndexAccess", { object: left, index });
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  // --- Primary expressions ---
+  parsePrimary() {
+    if (this.check(TokenType.NUMBER)) {
+      const val = this.advance().value;
+      return node("NumLit", { value: parseFloat(val) });
+    }
+    if (this.check(TokenType.STRING)) {
+      return node("StrLit", { value: this.advance().value });
+    }
+    if (this.match(TokenType.TRUE)) return node("BoolLit", { value: true });
+    if (this.match(TokenType.FALSE)) return node("BoolLit", { value: false });
+    if (this.match(TokenType.NULL)) return node("NullLit", {});
+    if (this.check(TokenType.EXT_LIT)) {
+      const val = this.advance().value;
+      return node("ExtLit", { raw: val });
+    }
+    if (this.match(TokenType.SYMBOL_0_0)) {
+      return node("ExtLit", { raw: "0\u2080" });
+    }
+    if (this.match(TokenType.SYMBOL_DOT_PRIM)) {
+      return node("ConstLit", { value: "\u30FB" });
+    }
+    if (this.match(TokenType.CONST_PI)) return node("NumLit", { value: Math.PI });
+    if (this.match(TokenType.CONST_E)) return node("NumLit", { value: Math.E });
+    if (this.match(TokenType.CONST_PHI)) return node("NumLit", { value: (1 + Math.sqrt(5)) / 2 });
+    if (this.match(TokenType.CONST_I)) return node("ConstLit", { value: "i" });
+    if (this.match(TokenType.CONST_EMPTY)) return node("ConstLit", { value: "\u2205" });
+    if (this.match(TokenType.CONST_PHI_UP)) return node("ConstLit", { value: "\u03A6" });
+    if (this.match(TokenType.CONST_PSI_UP)) return node("ConstLit", { value: "\u03A8" });
+    if (this.match(TokenType.CONST_OMEGA_UP)) return node("ConstLit", { value: "\u03A9" });
+    if (this.match(TokenType.QUAD_TOP)) return node("QuadLit", { value: "top" });
+    if (this.match(TokenType.QUAD_BOT)) return node("QuadLit", { value: "bottom" });
+    if (this.match(TokenType.QUAD_TOP_PI)) return node("QuadLit", { value: "topPi" });
+    if (this.match(TokenType.QUAD_BOT_PI)) return node("QuadLit", { value: "bottomPi" });
+    if (this.match(TokenType.MDIM_OPEN)) {
+      return this.parseMDimLit();
+    }
+    if (this.match(TokenType.LBRACKET)) {
+      const elems = [];
+      if (!this.check(TokenType.RBRACKET)) {
+        elems.push(this.parseExpression());
+        while (this.match(TokenType.COMMA)) elems.push(this.parseExpression());
+      }
+      this.expect(TokenType.RBRACKET);
+      return node("ArrayLit", { elements: elems });
+    }
+    if (this.match(TokenType.LPAREN)) {
+      const expr = this.parseExpression();
+      this.expect(TokenType.RPAREN);
+      return expr;
+    }
+    if (this.check(TokenType.IF)) return this.parseIfExpr();
+    if (this.check(TokenType.MATCH)) return this.parseMatchExpr();
+    if (this.check(TokenType.GENESIS)) {
+      this.advance();
+      if (this.match(TokenType.LPAREN)) {
+        this.expect(TokenType.RPAREN);
+      }
+      return node("FnCall", { callee: node("Ident", { name: "genesis" }), args: [] });
+    }
+    if (this.check(TokenType.IDENT)) {
+      const name = this.advance().value;
+      return node("Ident", { name });
+    }
+    throw this.error(`\u4E88\u671F\u3057\u306A\u3044\u30C8\u30FC\u30AF\u30F3: ${this.peek().value} (${this.peek().type})`);
+  }
+  // --- MDim literal: 𝕄{center; n1, n2, ... [weight w] [mode]} ---
+  parseMDimLit() {
+    const center = this.parseExpression();
+    this.expect(TokenType.SEMICOLON);
+    const neighbors = [];
+    neighbors.push(this.parseExpression());
+    while (this.match(TokenType.COMMA)) {
+      if (this.check(TokenType.RBRACE)) break;
+      if (this.check(TokenType.WEIGHT)) break;
+      neighbors.push(this.parseExpression());
+    }
+    let weight = null;
+    if (this.match(TokenType.WEIGHT)) {
+      weight = this.parseExpression();
+    }
+    let mode = "weighted";
+    if (this.match(TokenType.COLON)) {
+      if (this.check(TokenType.IDENT)) {
+        mode = this.advance().value;
+      }
+    }
+    this.expect(TokenType.RBRACE);
+    return node("MDimLit", { center, neighbors, weight, mode });
+  }
+  // --- if expr then expr else expr ---
+  parseIfExpr() {
+    this.expect(TokenType.IF);
+    const cond = this.parseExpression();
+    this.expect(TokenType.THEN);
+    const then = this.parseExpression();
+    this.expect(TokenType.ELSE);
+    const elseExpr = this.parseExpression();
+    return node("IfExpr", { cond, then, else: elseExpr });
+  }
+  // --- match expr { case pat -> expr, ... } ---
+  parseMatchExpr() {
+    this.expect(TokenType.MATCH);
+    const target = this.parseExpression();
+    this.expect(TokenType.LBRACE);
+    const cases = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      this.expect(TokenType.CASE);
+      const pattern = this.parsePrimary();
+      this.expect(TokenType.ARROW);
+      const body = this.parseExpression();
+      cases.push({ pattern, body });
+      this.match(TokenType.COMMA);
+    }
+    this.expect(TokenType.RBRACE);
+    return node("MatchExpr", { target, cases });
+  }
+  // --- Helpers ---
+  peek() {
+    return this.tokens[this.pos] || { type: TokenType.EOF, value: "", line: 0, col: 0 };
+  }
+  isAtEnd() {
+    return this.peek().type === TokenType.EOF;
+  }
+  check(type) {
+    return this.peek().type === type;
+  }
+  checkAhead(type, offset) {
+    const idx = this.pos + offset;
+    return idx < this.tokens.length && this.tokens[idx].type === type;
+  }
+  advance() {
+    const t = this.tokens[this.pos];
+    this.pos++;
+    return t;
+  }
+  match(type) {
+    if (this.check(type)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  expect(type) {
+    if (this.check(type)) return this.advance();
+    const t = this.peek();
+    throw this.error(`\u671F\u5F85: ${type}, \u5B9F\u969B: ${t.type} ("${t.value}")`);
+  }
+  error(msg) {
+    const t = this.peek();
+    return new Error(`[\u884C ${t.line}:${t.col}] \u69CB\u6587\u30A8\u30E9\u30FC: ${msg}`);
+  }
+  shouldNegateBePrefix() {
+    if (this.pos === 0) return true;
+    const prev = this.tokens[this.pos - 1];
+    return [
+      TokenType.LPAREN,
+      TokenType.COMMA,
+      TokenType.ASSIGN,
+      TokenType.PLUS,
+      TokenType.MINUS,
+      TokenType.STAR,
+      TokenType.SLASH,
+      TokenType.OPLUS,
+      TokenType.OTIMES,
+      TokenType.PIPE_OP,
+      TokenType.SEMICOLON,
+      TokenType.LBRACKET,
+      TokenType.COLON
+    ].includes(prev.type);
+  }
+};
+
+// src/core/types.ts
+var Environment = class {
+  constructor(parent = null) {
+    this.parent = parent;
+  }
+  bindings = /* @__PURE__ */ new Map();
+  define(name, value, mutable = false) {
+    this.bindings.set(name, { value, mutable });
+  }
+  get(name) {
+    const b = this.bindings.get(name);
+    if (b) return b.value;
+    if (this.parent) return this.parent.get(name);
+    throw new Error(`\u672A\u5B9A\u7FA9\u306E\u5909\u6570: ${name}`);
+  }
+  set(name, value) {
+    const b = this.bindings.get(name);
+    if (b) {
+      if (!b.mutable) throw new Error(`\u4E0D\u5909\u306E\u5909\u6570\u306B\u4EE3\u5165: ${name}`);
+      b.value = value;
+      return;
+    }
+    if (this.parent) {
+      this.parent.set(name, value);
+      return;
+    }
+    throw new Error(`\u672A\u5B9A\u7FA9\u306E\u5909\u6570: ${name}`);
+  }
+  has(name) {
+    if (this.bindings.has(name)) return true;
+    if (this.parent) return this.parent.has(name);
+    return false;
+  }
+  getBinding(name) {
+    const b = this.bindings.get(name);
+    if (b) return b;
+    if (this.parent) return this.parent.getBinding(name);
+    return null;
+  }
+  allBindings() {
+    const all = /* @__PURE__ */ new Map();
+    if (this.parent) {
+      for (const [k, v] of this.parent.allBindings()) all.set(k, v);
+    }
+    for (const [k, v] of this.bindings) all.set(k, v);
+    return all;
+  }
+};
+
+// src/lang/evaluator.ts
+function createExtended(base, subscripts) {
+  const order = subscripts.length;
+  return {
+    reiType: "Ext",
+    base,
+    order,
+    subscripts,
+    valStar() {
+      if (base === 0) return Math.pow(0.1, order);
+      return base * Math.pow(0.1, order);
+    }
+  };
+}
+function parseExtLit(raw) {
+  if (raw === "0\u2080") return createExtended(0, "o");
+  const baseChar = raw[0];
+  const subs = raw.slice(1);
+  const baseMap = {
+    "0": 0,
+    "\u03C0": Math.PI,
+    "e": Math.E,
+    "\u03C6": (1 + Math.sqrt(5)) / 2,
+    "i": NaN
+  };
+  return createExtended(baseMap[baseChar] ?? 0, subs);
+}
+function computeMDim(md) {
+  const { center, neighbors, mode } = md;
+  const weights = md.weights ?? neighbors.map(() => 1);
+  const n = neighbors.length;
+  if (n === 0) return center;
+  switch (mode) {
+    case "weighted": {
+      const wSum = weights.reduce((a, b) => a + b, 0);
+      const wAvg = neighbors.reduce((sum, v, i) => sum + weights[i] * v, 0) / (wSum || 1);
+      return center + wAvg;
+    }
+    case "multiplicative": {
+      const prod = neighbors.reduce((p, v) => p * (1 + v), 1);
+      return center * prod;
+    }
+    case "harmonic": {
+      const harmSum = neighbors.reduce((s, v) => s + 1 / (Math.abs(v) || 1), 0);
+      return center + n / harmSum;
+    }
+    case "exponential": {
+      const expSum = neighbors.reduce((s, v) => s + Math.exp(v), 0);
+      return center * (expSum / n);
+    }
+    default:
+      return center;
+  }
+}
+function quadNot(v) {
+  const map = {
+    "top": "bottom",
+    "bottom": "top",
+    "topPi": "bottomPi",
+    "bottomPi": "topPi"
+  };
+  return map[v];
+}
+function quadAnd(a, b) {
+  if (a === "bottom" || b === "bottom") return "bottom";
+  if (a === "bottomPi" || b === "bottomPi") return "bottomPi";
+  if (a === "top" && b === "top") return "top";
+  if (a === "topPi" || b === "topPi") return "topPi";
+  return "top";
+}
+function quadOr(a, b) {
+  if (a === "top" || b === "top") return "top";
+  if (a === "topPi" || b === "topPi") return "topPi";
+  if (a === "bottom" && b === "bottom") return "bottom";
+  return "bottomPi";
+}
+function createGenesis() {
+  return { reiType: "State", state: "void", omega: 0, history: ["void"] };
+}
+var PHASE_ORDER = ["void", "dot", "line", "surface", "solid", "omega"];
+function genesisForward(g) {
+  const idx = PHASE_ORDER.indexOf(g.state);
+  if (idx < PHASE_ORDER.length - 1) {
+    g.state = PHASE_ORDER[idx + 1];
+    g.history.push(g.state);
+    if (g.state === "omega") g.omega = 1;
+  }
+}
+var Evaluator = class {
+  env;
+  constructor(parent) {
+    this.env = new Environment(parent ?? null);
+    this.registerBuiltins();
+  }
+  registerBuiltins() {
+    this.env.define("e", Math.E);
+    this.env.define("PI", Math.PI);
+    this.env.define("genesis", {
+      reiType: "Function",
+      name: "genesis",
+      params: [],
+      body: null,
+      closure: this.env
+    });
+    const mathFns = ["abs", "sqrt", "sin", "cos", "log", "exp", "floor", "ceil", "round", "min", "max", "len", "print"];
+    for (const name of mathFns) {
+      this.env.define(name, {
+        reiType: "Function",
+        name,
+        params: ["x"],
+        body: null,
+        closure: this.env
+      });
+    }
+  }
+  eval(ast) {
+    switch (ast.type) {
+      case "Program":
+        return this.evalProgram(ast);
+      case "NumLit":
+        return ast.value;
+      case "StrLit":
+        return ast.value;
+      case "BoolLit":
+        return ast.value;
+      case "NullLit":
+        return null;
+      case "ExtLit":
+        return parseExtLit(ast.raw);
+      case "ConstLit":
+        return this.evalConstLit(ast);
+      case "QuadLit":
+        return { reiType: "Quad", value: ast.value };
+      case "MDimLit":
+        return this.evalMDimLit(ast);
+      case "ArrayLit":
+        return ast.elements.map((e) => this.eval(e));
+      case "Ident":
+        return this.env.get(ast.name);
+      case "LetStmt":
+        return this.evalLetStmt(ast);
+      case "MutStmt":
+        return this.evalMutStmt(ast);
+      case "CompressDef":
+        return this.evalCompressDef(ast);
+      case "BinOp":
+        return this.evalBinOp(ast);
+      case "UnaryOp":
+        return this.evalUnaryOp(ast);
+      case "Pipe":
+        return this.evalPipe(ast);
+      case "FnCall":
+        return this.evalFnCall(ast);
+      case "MemberAccess":
+        return this.evalMemberAccess(ast);
+      case "IndexAccess":
+        return this.evalIndexAccess(ast);
+      case "Extend":
+        return this.evalExtend(ast);
+      case "Reduce":
+        return this.evalReduce(ast);
+      case "ConvergeOp":
+        return this.evalConverge(ast);
+      case "DivergeOp":
+        return this.evalDiverge(ast);
+      case "ReflectOp":
+        return this.evalReflect(ast);
+      case "IfExpr":
+        return this.evalIfExpr(ast);
+      case "MatchExpr":
+        return this.evalMatchExpr(ast);
+      default:
+        throw new Error(`\u672A\u5B9F\u88C5\u306E\u30CE\u30FC\u30C9\u578B: ${ast.type}`);
+    }
+  }
+  evalProgram(ast) {
+    let result = null;
+    for (const stmt of ast.body) {
+      result = this.eval(stmt);
+    }
+    return result;
+  }
+  evalConstLit(ast) {
+    switch (ast.value) {
+      case "\u30FB":
+        return createGenesis();
+      // 原初点
+      case "\u2205":
+        return null;
+      case "i":
+        return { reiType: "Ext", base: NaN, order: 0, subscripts: "", valStar: () => NaN };
+      case "\u03A6":
+        return "\u03A6";
+      // phase constants
+      case "\u03A8":
+        return "\u03A8";
+      case "\u03A9":
+        return "\u03A9";
+      default:
+        return null;
+    }
+  }
+  evalMDimLit(ast) {
+    const center = this.toNumber(this.eval(ast.center));
+    const neighbors = ast.neighbors.map((n) => this.toNumber(this.eval(n)));
+    const weights = ast.weight ? [this.toNumber(this.eval(ast.weight))] : void 0;
+    const mode = ast.mode || "weighted";
+    return { reiType: "MDim", center, neighbors, mode, weights };
+  }
+  evalLetStmt(ast) {
+    const val = this.eval(ast.init);
+    this.env.define(ast.name, val, false);
+    return val;
+  }
+  evalMutStmt(ast) {
+    const val = this.eval(ast.init);
+    this.env.define(ast.name, val, true);
+    return val;
+  }
+  evalCompressDef(ast) {
+    const fn = {
+      reiType: "Function",
+      name: ast.name,
+      params: ast.params,
+      body: ast.body,
+      closure: this.env
+    };
+    this.env.define(ast.name, fn);
+    return fn;
+  }
+  evalBinOp(ast) {
+    const left = this.eval(ast.left);
+    const right = this.eval(ast.right);
+    if (this.isQuad(left) && this.isQuad(right)) {
+      const lq = left.value;
+      const rq = right.value;
+      switch (ast.op) {
+        case "\u2227":
+          return { reiType: "Quad", value: quadAnd(lq, rq) };
+        case "\u2228":
+          return { reiType: "Quad", value: quadOr(lq, rq) };
+      }
+    }
+    if (this.isExt(left) && this.isExt(right) && ast.op === "\u2295") {
+      const le = left;
+      const re = right;
+      return createExtended(le.base + re.base, le.subscripts + re.subscripts);
+    }
+    if (typeof left === "number" && this.isExt(right) && ast.op === "\xB7") {
+      const re = right;
+      return createExtended(left * re.base, re.subscripts);
+    }
+    if (this.isMDim(left) && this.isMDim(right) && ast.op === "\u2295") {
+      const lm = left;
+      const rm = right;
+      const maxLen = Math.max(lm.neighbors.length, rm.neighbors.length);
+      const neighbors = [];
+      for (let i = 0; i < maxLen; i++) {
+        neighbors.push((lm.neighbors[i] ?? 0) + (rm.neighbors[i] ?? 0));
+      }
+      return { reiType: "MDim", center: lm.center + rm.center, neighbors, mode: lm.mode };
+    }
+    if (typeof left === "string" && typeof right === "string" && ast.op === "+") {
+      return left + right;
+    }
+    const l = this.toNumber(left);
+    const r = this.toNumber(right);
+    switch (ast.op) {
+      case "+":
+        return l + r;
+      case "-":
+        return l - r;
+      case "*":
+        return l * r;
+      case "/":
+        return r === 0 ? NaN : l / r;
+      case "\u2295":
+        return l + r;
+      case "\u2297":
+        return l * r;
+      case "\xB7":
+        return l * r;
+      case "==":
+        return l === r;
+      case "!=":
+        return l !== r;
+      case ">":
+        return l > r;
+      case "<":
+        return l < r;
+      case ">=":
+        return l >= r;
+      case "<=":
+        return l <= r;
+      case ">\u03BA":
+        return l > r;
+      case "<\u03BA":
+        return l < r;
+      case "=\u03BA":
+        return l === r;
+      case "\u2227":
+        return !!left && !!right;
+      case "\u2228":
+        return !!left || !!right;
+      default:
+        throw new Error(`\u672A\u77E5\u306E\u6F14\u7B97\u5B50: ${ast.op}`);
+    }
+  }
+  evalUnaryOp(ast) {
+    const operand = this.eval(ast.operand);
+    switch (ast.op) {
+      case "-":
+        return -this.toNumber(operand);
+      case "\xAC":
+        if (this.isQuad(operand)) {
+          return { reiType: "Quad", value: quadNot(operand.value) };
+        }
+        return !operand;
+      default:
+        throw new Error(`\u672A\u77E5\u306E\u5358\u9805\u6F14\u7B97\u5B50: ${ast.op}`);
+    }
+  }
+  evalPipe(ast) {
+    const input = this.eval(ast.input);
+    const cmd = ast.command;
+    if (cmd.type === "PipeCmd") {
+      return this.execPipeCmd(input, cmd);
+    }
+    throw new Error("\u7121\u52B9\u306A\u30D1\u30A4\u30D7\u30B3\u30DE\u30F3\u30C9");
+  }
+  execPipeCmd(input, cmd) {
+    const { cmd: cmdName, mode, args: argNodes } = cmd;
+    const args = argNodes.map((a) => this.eval(a));
+    if (this.isMDim(input)) {
+      const md = input;
+      switch (cmdName) {
+        case "compute": {
+          const m = mode || md.mode;
+          return computeMDim({ ...md, mode: m });
+        }
+        case "center":
+          return md.center;
+        case "neighbors":
+          return md.neighbors;
+        case "dim":
+          return md.neighbors.length;
+        case "normalize": {
+          const sum = md.neighbors.reduce((a, b) => a + Math.abs(b), 0) || 1;
+          return {
+            reiType: "MDim",
+            center: md.center,
+            neighbors: md.neighbors.map((n) => n / sum),
+            mode: md.mode
+          };
+        }
+        case "flatten":
+          return computeMDim(md);
+        case "map": {
+          if (args.length > 0 && this.isFunction(args[0])) {
+            const fn = args[0];
+            const newNeighbors = md.neighbors.map((n) => this.toNumber(this.callFunction(fn, [n])));
+            return { ...md, neighbors: newNeighbors };
+          }
+          return md;
+        }
+      }
+    }
+    if (this.isExt(input)) {
+      const ext = input;
+      switch (cmdName) {
+        case "order":
+          return ext.order;
+        case "base":
+          return ext.base;
+        case "valStar":
+        case "val":
+          return ext.valStar();
+        case "subscripts":
+          return ext.subscripts;
+      }
+    }
+    if (this.isGenesis(input)) {
+      const g = input;
+      switch (cmdName) {
+        case "forward":
+          genesisForward(g);
+          return g;
+        case "phase":
+          return g.state;
+        case "history":
+          return g.history;
+        case "omega":
+          return g.omega;
+      }
+    }
+    if (Array.isArray(input)) {
+      switch (cmdName) {
+        case "len":
+          return input.length;
+        case "sum":
+          return input.reduce((a, b) => a + this.toNumber(b), 0);
+        case "avg":
+          return input.length === 0 ? 0 : input.reduce((a, b) => a + this.toNumber(b), 0) / input.length;
+        case "first":
+          return input[0] ?? null;
+        case "last":
+          return input[input.length - 1] ?? null;
+        case "reverse":
+          return [...input].reverse();
+        case "sort":
+          return [...input].sort((a, b) => this.toNumber(a) - this.toNumber(b));
+        case "map": {
+          if (args.length > 0 && this.isFunction(args[0])) {
+            return input.map((v) => this.callFunction(args[0], [v]));
+          }
+          return input;
+        }
+        case "filter": {
+          if (args.length > 0 && this.isFunction(args[0])) {
+            return input.filter((v) => !!this.callFunction(args[0], [v]));
+          }
+          return input;
+        }
+        case "reduce": {
+          if (args.length >= 2 && this.isFunction(args[0])) {
+            return input.reduce((acc, v) => this.callFunction(args[0], [acc, v]), args[1]);
+          }
+          return input;
+        }
+      }
+    }
+    if (typeof input === "number") {
+      switch (cmdName) {
+        case "abs":
+          return Math.abs(input);
+        case "sqrt":
+          return Math.sqrt(input);
+        case "round":
+          return Math.round(input);
+        case "floor":
+          return Math.floor(input);
+        case "ceil":
+          return Math.ceil(input);
+        case "negate":
+          return -input;
+      }
+    }
+    if (typeof input === "string") {
+      switch (cmdName) {
+        case "len":
+          return input.length;
+        case "upper":
+          return input.toUpperCase();
+        case "lower":
+          return input.toLowerCase();
+        case "trim":
+          return input.trim();
+        case "split":
+          return input.split(args[0] ?? "");
+        case "reverse":
+          return Array.from(input).reverse().join("");
+      }
+    }
+    if (cmdName === "\u290A" || cmdName === "converge") {
+      if (this.isMDim(input)) {
+        return computeMDim(input);
+      }
+      return input;
+    }
+    if (cmdName === "\u290B" || cmdName === "diverge") {
+      if (typeof input === "number") {
+        return { reiType: "MDim", center: input, neighbors: [input, input, input, input], mode: "weighted" };
+      }
+      return input;
+    }
+    if (this.env.has(cmdName)) {
+      const fn = this.env.get(cmdName);
+      if (this.isFunction(fn)) {
+        return this.callFunction(fn, [input, ...args]);
+      }
+    }
+    throw new Error(`\u672A\u77E5\u306E\u30D1\u30A4\u30D7\u30B3\u30DE\u30F3\u30C9: ${cmdName}`);
+  }
+  evalFnCall(ast) {
+    const callee = this.eval(ast.callee);
+    const args = ast.args.map((a) => this.eval(a));
+    if (ast.callee.type === "Ident" && ast.callee.name === "genesis") {
+      return createGenesis();
+    }
+    if (this.isFunction(callee)) {
+      const fn = callee;
+      return this.callFunction(fn, args);
+    }
+    throw new Error(`\u547C\u3073\u51FA\u3057\u4E0D\u53EF\u80FD: ${JSON.stringify(callee)}`);
+  }
+  callFunction(fn, args) {
+    if (fn.body === null || fn.body === void 0) {
+      return this.callBuiltin(fn.name, args);
+    }
+    const callEnv = new Environment(fn.closure);
+    for (let i = 0; i < fn.params.length; i++) {
+      callEnv.define(fn.params[i], args[i] ?? null);
+    }
+    const savedEnv = this.env;
+    this.env = callEnv;
+    const result = this.eval(fn.body);
+    this.env = savedEnv;
+    return result;
+  }
+  callBuiltin(name, args) {
+    if (name === "genesis") return createGenesis();
+    const a = args[0] !== void 0 ? this.toNumber(args[0]) : 0;
+    const b = args[1] !== void 0 ? this.toNumber(args[1]) : 0;
+    switch (name) {
+      case "abs":
+        return Math.abs(a);
+      case "sqrt":
+        return Math.sqrt(a);
+      case "sin":
+        return Math.sin(a);
+      case "cos":
+        return Math.cos(a);
+      case "log":
+        return Math.log(a);
+      case "exp":
+        return Math.exp(a);
+      case "floor":
+        return Math.floor(a);
+      case "ceil":
+        return Math.ceil(a);
+      case "round":
+        return Math.round(a);
+      case "min":
+        return Math.min(a, b);
+      case "max":
+        return Math.max(a, b);
+      case "len":
+        if (Array.isArray(args[0])) return args[0].length;
+        if (typeof args[0] === "string") return args[0].length;
+        return 0;
+      case "print":
+        return args[0] ?? null;
+      default:
+        throw new Error(`\u672A\u77E5\u306E\u7D44\u8FBC\u307F\u95A2\u6570: ${name}`);
+    }
+  }
+  evalMemberAccess(ast) {
+    const obj = this.eval(ast.object);
+    if (this.isMDim(obj)) {
+      const md = obj;
+      switch (ast.member) {
+        case "center":
+          return md.center;
+        case "neighbors":
+          return md.neighbors;
+        case "mode":
+          return md.mode;
+        case "dim":
+          return md.neighbors.length;
+      }
+    }
+    if (this.isExt(obj)) {
+      const ext = obj;
+      switch (ast.member) {
+        case "order":
+          return ext.order;
+        case "base":
+          return ext.base;
+        case "subscripts":
+          return ext.subscripts;
+        case "valStar":
+          return ext.valStar();
+      }
+    }
+    if (this.isGenesis(obj)) {
+      const g = obj;
+      switch (ast.member) {
+        case "state":
+        case "phase":
+          return g.state;
+        case "omega":
+          return g.omega;
+        case "history":
+          return g.history;
+      }
+    }
+    if (Array.isArray(obj)) {
+      switch (ast.member) {
+        case "length":
+          return obj.length;
+        case "first":
+          return obj[0] ?? null;
+        case "last":
+          return obj[obj.length - 1] ?? null;
+      }
+    }
+    throw new Error(`\u30E1\u30F3\u30D0\u30FC ${ast.member} \u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093`);
+  }
+  evalIndexAccess(ast) {
+    const obj = this.eval(ast.object);
+    const idx = this.toNumber(this.eval(ast.index));
+    if (Array.isArray(obj)) return obj[idx] ?? null;
+    if (typeof obj === "string") return obj[idx] ?? null;
+    if (this.isMDim(obj)) return obj.neighbors[idx] ?? null;
+    throw new Error("\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u30A2\u30AF\u30BB\u30B9\u4E0D\u53EF");
+  }
+  evalExtend(ast) {
+    const target = this.eval(ast.target);
+    if (this.isExt(target)) {
+      const ext = target;
+      if (ast.subscript) {
+        return createExtended(ext.base, ext.subscripts + ast.subscript);
+      }
+      return createExtended(ext.base, ext.subscripts + "o");
+    }
+    throw new Error("\u62E1\u5F35\u306F\u62E1\u5F35\u6570\u306B\u306E\u307F\u9069\u7528\u53EF\u80FD");
+  }
+  evalReduce(ast) {
+    const target = this.eval(ast.target);
+    if (this.isExt(target)) {
+      const ext = target;
+      if (ext.order <= 1) return ext.base;
+      return createExtended(ext.base, ext.subscripts.slice(0, -1));
+    }
+    throw new Error("\u7E2E\u7D04\u306F\u62E1\u5F35\u6570\u306B\u306E\u307F\u9069\u7528\u53EF\u80FD");
+  }
+  evalConverge(ast) {
+    const left = this.eval(ast.left);
+    const right = this.eval(ast.right);
+    if (this.isMDim(left) && this.isMDim(right)) {
+      const lm = left;
+      const rm = right;
+      return {
+        reiType: "MDim",
+        center: (lm.center + rm.center) / 2,
+        neighbors: [...lm.neighbors, ...rm.neighbors],
+        mode: lm.mode
+      };
+    }
+    return this.toNumber(left) + this.toNumber(right);
+  }
+  evalDiverge(ast) {
+    const left = this.eval(ast.left);
+    const right = this.eval(ast.right);
+    if (this.isMDim(left)) {
+      const md = left;
+      this.toNumber(right);
+      const half = Math.floor(md.neighbors.length / 2);
+      return [
+        { reiType: "MDim", center: md.center, neighbors: md.neighbors.slice(0, half), mode: md.mode },
+        { reiType: "MDim", center: md.center, neighbors: md.neighbors.slice(half), mode: md.mode }
+      ];
+    }
+    return this.toNumber(left) - this.toNumber(right);
+  }
+  evalReflect(ast) {
+    const left = this.eval(ast.left);
+    this.eval(ast.right);
+    if (this.isMDim(left)) {
+      const md = left;
+      return {
+        reiType: "MDim",
+        center: md.center,
+        neighbors: [...md.neighbors].reverse(),
+        mode: md.mode
+      };
+    }
+    return this.toNumber(left);
+  }
+  evalIfExpr(ast) {
+    const cond = this.eval(ast.cond);
+    return this.isTruthy(cond) ? this.eval(ast.then) : this.eval(ast.else);
+  }
+  evalMatchExpr(ast) {
+    const target = this.eval(ast.target);
+    for (const { pattern, body } of ast.cases) {
+      const patVal = this.eval(pattern);
+      if (this.matches(target, patVal)) {
+        return this.eval(body);
+      }
+    }
+    throw new Error("\u30DE\u30C3\u30C1\u3059\u308B\u5206\u5C90\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093");
+  }
+  // --- Helpers ---
+  toNumber(val) {
+    if (typeof val === "number") return val;
+    if (typeof val === "boolean") return val ? 1 : 0;
+    if (val === null) return 0;
+    if (this.isExt(val)) return val.valStar();
+    if (this.isMDim(val)) return computeMDim(val);
+    if (typeof val === "string") return parseFloat(val) || 0;
+    return 0;
+  }
+  isTruthy(val) {
+    if (val === null || val === false || val === 0) return false;
+    if (this.isQuad(val)) return val.value === "top" || val.value === "topPi";
+    return true;
+  }
+  matches(target, pattern) {
+    if (typeof target === typeof pattern && target === pattern) return true;
+    if (this.isQuad(target) && this.isQuad(pattern)) {
+      return target.value === pattern.value;
+    }
+    return false;
+  }
+  isObj(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+  }
+  isMDim(v) {
+    return this.isObj(v) && v.reiType === "MDim";
+  }
+  isExt(v) {
+    return this.isObj(v) && v.reiType === "Ext";
+  }
+  isGenesis(v) {
+    return this.isObj(v) && v.reiType === "State";
+  }
+  isFunction(v) {
+    return this.isObj(v) && v.reiType === "Function";
+  }
+  isQuad(v) {
+    return this.isObj(v) && v.reiType === "Quad";
+  }
+};
+
+// src/index.ts
+var _evaluator = new Evaluator();
+function rei(code) {
+  const lexer = new Lexer(code);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parseProgram();
+  return _evaluator.eval(ast);
+}
+rei.reset = function reset() {
+  _evaluator = new Evaluator();
+};
+rei.evaluator = function evaluator() {
+  return _evaluator;
+};
+rei.parse = function parse(code) {
+  const lexer = new Lexer(code);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  return parser.parseProgram();
+};
+rei.tokenize = function tokenize(code) {
+  const lexer = new Lexer(code);
+  return lexer.tokenize();
+};
+var index_default = rei;
+
+export { Environment, Evaluator, Lexer, Parser, TokenType, index_default as default, rei };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map