@noya-app/noya-api-client-react 0.1.41 → 0.1.43

package/dist/index.js

@@ -5134,17 +5134,17 @@ var TypeSystemDuplicateFormat = class extends TypeBoxError {
 };
 var TypeSystem;
 (function(TypeSystem2) {
-  function Type2(kind, check) {
+  function Type3(kind, check2) {
     if (type_exports2.Has(kind))
       throw new TypeSystemDuplicateTypeKind(kind);
-    type_exports2.Set(kind, check);
+    type_exports2.Set(kind, check2);
     return (options = {}) => Unsafe({ ...options, [Kind]: kind });
   }
-  TypeSystem2.Type = Type2;
-  function Format(format, check) {
+  TypeSystem2.Type = Type3;
+  function Format(format, check2) {
     if (format_exports.Has(format))
       throw new TypeSystemDuplicateFormat(format);
-    format_exports.Set(format, check);
+    format_exports.Set(format, check2);
     return format;
   }
   TypeSystem2.Format = Format;
@@ -5717,11 +5717,8 @@ function validateUUID(value) {
 format_exports.Set("color", () => true);
 format_exports.Set("uuid", validateUUID);
 
-// ../state-manager/src/ConnectedUsersManager.ts
-var import_observable4 = require("@noya-app/observable");
-
 // ../state-manager/src/ConnectionEventManager.ts
-var import_observable5 = require("@noya-app/observable");
+var import_observable4 = require("@noya-app/observable");
 
 // ../../node_modules/mutative/dist/mutative.esm.mjs
 var PROXY_DRAFT = Symbol.for("__MUTATIVE_PROXY_DRAFT__");
@@ -7314,7 +7311,7 @@ var import_noya_utils4 = require("@noya-app/noya-utils");
 
 // ../state-manager/src/FilePropertyManager.ts
 var import_noya_utils5 = require("@noya-app/noya-utils");
-var import_observable6 = require("@noya-app/observable");
+var import_observable5 = require("@noya-app/observable");
 
 // ../state-manager/src/historyEntries.ts
 var HistoryEntries;
@@ -7384,149 +7381,3163 @@ var HistoryEntries;
         }
       }
     }
-    return result;
-  }
-  HistoryEntries2.compactPatches = compactPatches;
-  function pathsEqual(a, b) {
-    if (a.length !== b.length) {
-      return false;
+    return result;
+  }
+  HistoryEntries2.compactPatches = compactPatches;
+  function pathsEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((path2, index) => {
+      const other = b[index];
+      if (typeof path2 === "object" && "id" in path2 && typeof other === "object" && "id" in other) {
+        return path2.id === other.id;
+      }
+      return path2 === other;
+    });
+  }
+  HistoryEntries2.pathsEqual = pathsEqual;
+})(HistoryEntries || (HistoryEntries = {}));
+
+// ../state-manager/src/IOManager.ts
+var import_observable6 = require("@noya-app/observable");
+
+// ../state-manager/src/jwt.ts
+function base64UrlEncode(str) {
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(str) {
+  str = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (str.length % 4) {
+    case 2:
+      str += "==";
+      break;
+    case 3:
+      str += "=";
+      break;
+  }
+  return atob(str);
+}
+var HEADER = {
+  alg: "HS256",
+  typ: "JWT"
+};
+var JWT_ERROR = {
+  INVALID_JWT_FORMAT: "Invalid JWT format"
+  // INVALID_SIGNATURE: "Invalid signature",
+};
+async function createJwt({
+  payload,
+  secret,
+  header
+}) {
+  const encoder = new TextEncoder();
+  const encodedHeader = base64UrlEncode(
+    JSON.stringify({ ...HEADER, ...header })
+  );
+  const encodedPayload = base64UrlEncode(JSON.stringify(payload));
+  const dataToSign = `${encodedHeader}.${encodedPayload}`;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(dataToSign)
+  );
+  const encodedSignature = base64UrlEncode(
+    String.fromCharCode(...new Uint8Array(signature))
+  );
+  return `${dataToSign}.${encodedSignature}`;
+}
+async function decodeJwt({
+  token,
+  secret
+}) {
+  if (typeof token !== "string") {
+    throw new Error(JWT_ERROR.INVALID_JWT_FORMAT);
+  }
+  const [encodedHeader, encodedPayload, encodedSignature] = token.split(".");
+  if (!encodedHeader || !encodedPayload || !encodedSignature) {
+    throw new Error(JWT_ERROR.INVALID_JWT_FORMAT);
+  }
+  const headerJson = base64UrlDecode(encodedHeader);
+  const payloadJson = base64UrlDecode(encodedPayload);
+  const header = JSON.parse(headerJson);
+  const payload = JSON.parse(payloadJson);
+  const dataToVerify = `${encodedHeader}.${encodedPayload}`;
+  const encoder = new TextEncoder();
+  if (secret !== void 0) {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    const binarySignature = base64UrlDecode(encodedSignature);
+    const signature = new Uint8Array(
+      [...binarySignature].map((char) => char.charCodeAt(0))
+    );
+    const valid = await crypto.subtle.verify(
+      "HMAC",
+      key,
+      signature,
+      encoder.encode(dataToVerify)
+    );
+    return { header, payload, valid };
+  }
+  return { header, payload, valid: false };
+}
+var jwt;
+((jwt2) => {
+  jwt2.encode = createJwt;
+  jwt2.decode = decodeJwt;
+  jwt2.ERROR = JWT_ERROR;
+  jwt2.DEFAULT_HEADER = HEADER;
+})(jwt || (jwt = {}));
+
+// ../state-manager/src/MenuManager.ts
+var import_noya_utils6 = require("@noya-app/noya-utils");
+var import_observable7 = require("@noya-app/observable");
+
+// ../state-manager/src/multiplayer.ts
+var import_noya_utils7 = require("@noya-app/noya-utils");
+var import_observable9 = require("@noya-app/observable");
+
+// ../state-manager/src/stateManager.ts
+var import_observable8 = require("@noya-app/observable");
+
+// ../state-manager/src/multiplayer.ts
+var createHash = (value, options) => (0, import_noya_utils7.hash)(value, { ...options, ignoreUndefinedProperties: true });
+
+// ../../node_modules/@marcbachmann/cel-js/lib/errors.js
+var ParseError = class extends Error {
+  #wasConstructedWithAst = false;
+  #node;
+  constructor(message, node, cause) {
+    super(message, { cause });
+    this.name = "ParseError";
+    this.#node = node;
+    if (!node?.input) return;
+    this.message = formatErrorWithHighlight(this.message, node);
+  }
+  get node() {
+    return this.#node;
+  }
+  withAst(node) {
+    if (this.#node) return this;
+    this.#node = node;
+    if (!node?.input) return this;
+    this.message = formatErrorWithHighlight(this.message, node);
+    return this;
+  }
+};
+var EvaluationError = class extends Error {
+  #node;
+  constructor(message, node, cause) {
+    super(message, { cause });
+    this.name = "EvaluationError";
+    this.#node = node;
+    if (!node?.input) return;
+    this.message = formatErrorWithHighlight(this.message, node);
+  }
+  get node() {
+    return this.#node;
+  }
+  withAst(node) {
+    if (this.#node) return this;
+    this.#node = node;
+    if (!node?.input) return this;
+    this.message = formatErrorWithHighlight(this.message, node);
+    return this;
+  }
+};
+var TypeError2 = class extends Error {
+  #node;
+  constructor(message, node, cause) {
+    super(message, { cause });
+    this.name = "TypeError";
+    this.#node = node;
+    if (!node?.input) return;
+    this.message = formatErrorWithHighlight(this.message, node);
+  }
+  get node() {
+    return this.#node;
+  }
+  withAst(node) {
+    if (this.#node) return this;
+    this.#node = node;
+    if (!node?.input) return this;
+    this.message = formatErrorWithHighlight(this.message, node);
+    return this;
+  }
+};
+function formatErrorWithHighlight(message, node) {
+  if (node?.pos === void 0) return message;
+  const pos = node.pos;
+  const input = node.input;
+  let lineNum = 1;
+  let currentPos = 0;
+  let columnNum = 0;
+  while (currentPos < pos) {
+    if (input[currentPos] === "\n") {
+      lineNum++;
+      columnNum = 0;
+    } else {
+      columnNum++;
+    }
+    currentPos++;
+  }
+  let contextStart = pos;
+  let contextEnd = pos;
+  while (contextStart > 0 && input[contextStart - 1] !== "\n") contextStart--;
+  while (contextEnd < input.length && input[contextEnd] !== "\n") contextEnd++;
+  const line = input.slice(contextStart, contextEnd);
+  const lineNumber = `${lineNum}`.padStart(4, " ");
+  const spaces = " ".repeat(9 + columnNum);
+  return `${message}
+
+> ${lineNumber} | ${line}
+${spaces}^`;
+}
+
+// ../../node_modules/@marcbachmann/cel-js/lib/parser.js
+var TOKEN = {
+  EOF: 0,
+  NUMBER: 1,
+  STRING: 2,
+  BOOLEAN: 3,
+  NULL: 4,
+  IDENTIFIER: 5,
+  PLUS: 6,
+  MINUS: 7,
+  MULTIPLY: 8,
+  DIVIDE: 9,
+  MODULO: 10,
+  EQ: 11,
+  NE: 12,
+  LT: 13,
+  LE: 14,
+  GT: 15,
+  GE: 16,
+  AND: 17,
+  OR: 18,
+  NOT: 19,
+  IN: 20,
+  LPAREN: 21,
+  RPAREN: 22,
+  LBRACKET: 23,
+  RBRACKET: 24,
+  LBRACE: 25,
+  RBRACE: 26,
+  DOT: 27,
+  COMMA: 28,
+  COLON: 29,
+  QUESTION: 30,
+  BYTES: 31
+};
+var ASTNode = class extends Array {
+  #pos;
+  #input;
+  constructor(pos, input, elements) {
+    super();
+    this.#pos = pos;
+    this.#input = input;
+    this.push(...elements);
+  }
+  get input() {
+    return this.#input;
+  }
+  get pos() {
+    return this.#pos;
+  }
+};
+var TOKEN_BY_NUMBER = {};
+for (const key in TOKEN) TOKEN_BY_NUMBER[TOKEN[key]] = key;
+var RESERVED = /* @__PURE__ */ new Set([
+  "as",
+  "break",
+  "const",
+  "continue",
+  "else",
+  "for",
+  "function",
+  "if",
+  "import",
+  "let",
+  "loop",
+  "package",
+  "namespace",
+  "return",
+  "var",
+  "void",
+  "while"
+]);
+var HEX_CODES = new Uint8Array(256);
+for (const ch of "0123456789abcdefABCDEF") HEX_CODES[ch.charCodeAt(0)] = 1;
+var IDENTIFIER_CODES = new Uint8Array(256);
+for (const ch of "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_") {
+  IDENTIFIER_CODES[ch.charCodeAt(0)] = 1;
+}
+var STRING_ESCAPES = {
+  "\\": "\\",
+  "?": "?",
+  '"': '"',
+  "'": "'",
+  "`": "`",
+  a: "\x07",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v"
+};
+var Lexer = class {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.length = input.length;
+  }
+  // Read next token
+  nextToken() {
+    if (this.pos >= this.length) return { type: TOKEN.EOF, value: null, pos: this.pos };
+    const ch = this.input[this.pos];
+    const next = this.input[this.pos + 1];
+    switch (ch) {
+      // Whitespaces
+      case " ":
+      case "	":
+      case "\n":
+      case "\r":
+        this.pos++;
+        return this.nextToken();
+      // Operators
+      case "=":
+        if (next !== "=") break;
+        return { type: TOKEN.EQ, value: "==", pos: (this.pos += 2) - 2 };
+      case "&":
+        if (next !== "&") break;
+        return { type: TOKEN.AND, value: "&&", pos: (this.pos += 2) - 2 };
+      case "|":
+        if (next !== "|") break;
+        return { type: TOKEN.OR, value: "||", pos: (this.pos += 2) - 2 };
+      case "+":
+        return { type: TOKEN.PLUS, value: "+", pos: this.pos++ };
+      case "-":
+        return { type: TOKEN.MINUS, value: "-", pos: this.pos++ };
+      case "*":
+        return { type: TOKEN.MULTIPLY, value: "*", pos: this.pos++ };
+      case "/":
+        if (next === "/") {
+          while (this.pos < this.length && this.input[this.pos] !== "\n") this.pos++;
+          return this.nextToken();
+        }
+        return { type: TOKEN.DIVIDE, value: "/", pos: this.pos++ };
+      case "%":
+        return { type: TOKEN.MODULO, value: "%", pos: this.pos++ };
+      case "<":
+        if (next === "=") return { type: TOKEN.LE, value: "<=", pos: (this.pos += 2) - 2 };
+        return { type: TOKEN.LT, value: "<", pos: this.pos++ };
+      case ">":
+        if (next === "=") return { type: TOKEN.GE, value: ">=", pos: (this.pos += 2) - 2 };
+        return { type: TOKEN.GT, value: ">", pos: this.pos++ };
+      case "!":
+        if (next === "=") return { type: TOKEN.NE, value: "!=", pos: (this.pos += 2) - 2 };
+        return { type: TOKEN.NOT, value: "!", pos: this.pos++ };
+      case "(":
+        return { type: TOKEN.LPAREN, value: "(", pos: this.pos++ };
+      case ")":
+        return { type: TOKEN.RPAREN, value: ")", pos: this.pos++ };
+      case "[":
+        return { type: TOKEN.LBRACKET, value: "[", pos: this.pos++ };
+      case "]":
+        return { type: TOKEN.RBRACKET, value: "]", pos: this.pos++ };
+      case "{":
+        return { type: TOKEN.LBRACE, value: "{", pos: this.pos++ };
+      case "}":
+        return { type: TOKEN.RBRACE, value: "}", pos: this.pos++ };
+      case ".":
+        return { type: TOKEN.DOT, value: ".", pos: this.pos++ };
+      case ",":
+        return { type: TOKEN.COMMA, value: ",", pos: this.pos++ };
+      case ":":
+        return { type: TOKEN.COLON, value: ":", pos: this.pos++ };
+      case "?":
+        return { type: TOKEN.QUESTION, value: "?", pos: this.pos++ };
+      case `"`:
+      case `'`:
+        return this.readString();
+      // Check for string prefixes (b, B, r, R followed by quote)
+      case "b":
+      case "B":
+      case "r":
+      case "R":
+        if (next === '"' || next === "'") {
+          this.pos++;
+          return this.readString(ch.toLowerCase());
+        }
+        return this.readIdentifier();
+      default: {
+        if (ch >= "0" && ch <= "9") return this.readNumber();
+        if (IDENTIFIER_CODES[ch.charCodeAt(0)]) return this.readIdentifier();
+      }
+    }
+    throw new ParseError(`Unexpected character: ${ch}`, { pos: this.pos, input: this.input });
+  }
+  _parseAsBigInt(start, end, isHex, unsigned) {
+    const string = this.input.substring(start, end);
+    if (unsigned === "u" || unsigned === "U") {
+      this.pos++;
+      try {
+        return {
+          type: TOKEN.NUMBER,
+          value: new UnsignedInt(string),
+          pos: start
+        };
+      } catch (_err) {
+      }
+    } else {
+      try {
+        return {
+          type: TOKEN.NUMBER,
+          value: BigInt(string),
+          pos: start
+        };
+      } catch (_err) {
+      }
+    }
+    throw new ParseError(isHex ? `Invalid hex integer: ${string}` : `Invalid integer: ${string}`, {
+      pos: start,
+      input: this.input
+    });
+  }
+  readNumber() {
+    const { input, length, pos: start } = this;
+    if (input[start] === "0" && (input[start + 1] === "x" || input[start + 1] === "X")) {
+      this.pos += 2;
+      while (this.pos < length && HEX_CODES[input[this.pos].charCodeAt(0)]) this.pos++;
+      return this._parseAsBigInt(start, this.pos, true, input[this.pos]);
+    }
+    let ch;
+    while (this.pos < length && (ch = input[this.pos]) >= "0" && ch <= "9") this.pos++;
+    if (ch === "." && (ch = input[this.pos + 1]) >= "0" && ch <= "9") {
+      this.pos++;
+      while (this.pos < length && (ch = input[this.pos]) >= "0" && ch <= "9") this.pos++;
+      const string = input.substring(start, this.pos);
+      const value = Number(string);
+      if (Number.isFinite(value)) return { type: TOKEN.NUMBER, value, pos: start };
+      throw new ParseError(`Invalid number: ${value}`, { pos: start, input: this.input });
+    }
+    return this._parseAsBigInt(start, this.pos, false, input[this.pos]);
+  }
+  readString(prefix) {
+    const delimiter = this.input[this.pos++];
+    if (this.input[this.pos] === delimiter && this.input[this.pos + 1] === delimiter) {
+      this.pos += 2;
+      return this.readTripleQuotedString(delimiter, prefix);
+    }
+    return this.readSingleQuotedString(delimiter, prefix);
+  }
+  _closeQuotedString(rawValue, prefix) {
+    if (prefix === "b") {
+      const processed = this.processEscapes(rawValue, true);
+      const bytes = new Uint8Array(processed.length);
+      for (let i = 0; i < processed.length; i++) {
+        bytes[i] = processed.charCodeAt(i) & 255;
+      }
+      return { type: TOKEN.BYTES, value: bytes, pos: this.pos - rawValue.length - 2 };
+    }
+    const value = prefix === "r" ? rawValue : this.processEscapes(rawValue, false);
+    return { type: TOKEN.STRING, value, pos: this.pos - rawValue.length };
+  }
+  readSingleQuotedString(delimiter, prefix) {
+    const { input, length, pos: start } = this;
+    const needsEscapeHandling = prefix !== "r";
+    while (this.pos < length) {
+      const ch = input[this.pos];
+      if (ch === delimiter) {
+        const rawValue = input.slice(start, this.pos);
+        this.pos++;
+        return this._closeQuotedString(rawValue, prefix);
+      }
+      if (ch === "\n" || ch === "\r") {
+        throw new ParseError("Newlines not allowed in single-quoted strings", {
+          pos: start - 1,
+          input
+        });
+      }
+      if (ch === "\\" && needsEscapeHandling) {
+        this.pos += 2;
+        if (this.pos > length) {
+          throw new ParseError("Unterminated escape sequence", {
+            pos: start - 1,
+            input
+          });
+        }
+        continue;
+      }
+      this.pos++;
+    }
+    throw new ParseError("Unterminated string", { pos: start - 1, input });
+  }
+  readTripleQuotedString(delimiter, prefix) {
+    const start = this.pos;
+    const needsEscapeHandling = prefix !== "r";
+    while (this.pos < this.length) {
+      const ch = this.input[this.pos];
+      if (ch === delimiter && this.input[this.pos + 1] === delimiter && this.input[this.pos + 2] === delimiter) {
+        const rawValue = this.input.slice(start, this.pos);
+        this.pos += 3;
+        return this._closeQuotedString(rawValue, prefix);
+      }
+      if (ch === "\\" && needsEscapeHandling) {
+        this.pos += 2;
+        if (this.pos > this.length) {
+          throw new ParseError("Unterminated escape sequence", {
+            pos: start - 3,
+            input: this.input
+          });
+        }
+        continue;
+      }
+      this.pos++;
+    }
+    throw new ParseError("Unterminated triple-quoted string", { pos: start - 3, input: this.input });
+  }
+  processEscapes(str, isBytes) {
+    let result = "";
+    let i = 0;
+    while (i < str.length) {
+      if (str[i] !== "\\" || i + 1 >= str.length) {
+        result += str[i++];
+        continue;
+      }
+      const next = str[i + 1];
+      if (STRING_ESCAPES[next]) {
+        result += STRING_ESCAPES[next];
+        i += 2;
+      } else if (next === "u") {
+        if (isBytes) throw new ParseError("\\u not allowed in bytes literals");
+        const hex = str.substring(i + 2, i + 6);
+        if (hex.length !== 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) {
+          throw new ParseError(`Invalid Unicode escape: \\u${hex}`);
+        }
+        const code = Number.parseInt(hex, 16);
+        if (code >= 55296 && code <= 57343) {
+          throw new ParseError(`Invalid Unicode surrogate: \\u${hex}`);
+        }
+        result += String.fromCharCode(code);
+        i += 6;
+      } else if (next === "U") {
+        if (isBytes) throw new ParseError("\\U not allowed in bytes literals");
+        const hex = str.substring(i + 2, i + 10);
+        if (hex.length !== 8 || !/^[0-9a-fA-F]{8}$/.test(hex)) {
+          throw new ParseError(`Invalid Unicode escape: \\U${hex}`);
+        }
+        const code = Number.parseInt(hex, 16);
+        if (code > 1114111) throw new ParseError(`Invalid Unicode escape: \\U${hex}`);
+        if (code >= 55296 && code <= 57343) {
+          throw new ParseError(`Invalid Unicode surrogate: \\U${hex}`);
+        }
+        result += String.fromCodePoint(code);
+        i += 10;
+      } else if (next === "x" || next === "X") {
+        const hex = str.substring(i + 2, i + 4);
+        if (hex.length !== 2 || !/^[0-9a-fA-F]{2}$/.test(hex)) {
+          throw new ParseError(`Invalid hex escape: \\${next}${hex}`);
+        }
+        result += String.fromCharCode(Number.parseInt(hex, 16));
+        i += 4;
+      } else if (next >= "0" && next <= "7") {
+        const octal = str.substring(i + 1, i + 4);
+        if (octal.length !== 3 || !/^[0-7]{3}$/.test(octal)) {
+          throw new ParseError("Octal escape must be 3 digits");
+        }
+        const value = Number.parseInt(octal, 8);
+        if (value > 255) {
+          throw new ParseError(`Octal escape out of range: \\${octal}`);
+        }
+        result += String.fromCharCode(value);
+        i += 4;
+      } else {
+        throw new ParseError(`Invalid escape sequence: \\${next}`);
+      }
+    }
+    return result;
+  }
+  readIdentifier() {
+    const start = this.pos;
+    while (this.pos < this.length && IDENTIFIER_CODES[this.input[this.pos].charCodeAt(0)])
+      this.pos++;
+    const text = this.input.substring(start, this.pos);
+    switch (text) {
+      case "true":
+        return { type: TOKEN.BOOLEAN, value: true, pos: start };
+      case "false":
+        return { type: TOKEN.BOOLEAN, value: false, pos: start };
+      case "null":
+        return { type: TOKEN.NULL, value: null, pos: start };
+      case "in":
+        return { type: TOKEN.IN, value: "in", pos: start };
+      default:
+        return { type: TOKEN.IDENTIFIER, value: text, pos: start };
+    }
+  }
+};
+var Parser = class {
+  constructor(input) {
+    this.input = input;
+    this.lexer = new Lexer(input);
+    this.currentToken = this.lexer.nextToken();
+  }
+  consume(expectedType) {
+    const token = this.currentToken;
+    this.currentToken = this.lexer.nextToken();
+    if (token.type === expectedType) return token;
+    throw new ParseError(
+      `Expected ${TOKEN_BY_NUMBER[expectedType]}, got ${TOKEN_BY_NUMBER[token.type]}`,
+      { pos: token.pos, input: this.input }
+    );
+  }
+  match(type) {
+    return this.currentToken.type === type;
+  }
+  // Parse entry point
+  parse() {
+    const result = this.parseExpression();
+    if (!this.match(TOKEN.EOF)) {
+      throw new ParseError(`Unexpected character: '${this.input[this.lexer.pos - 1]}'`, {
+        pos: this.currentToken.pos,
+        input: this.input
+      });
+    }
+    return result;
+  }
+  // Expression ::= LogicalOr ('?' Expression ':' Expression)?  // Made right-associative
+  parseExpression() {
+    const expr = this.parseLogicalOr();
+    if (this.match(TOKEN.QUESTION)) {
+      const token = this.consume(TOKEN.QUESTION);
+      const consequent = this.parseExpression();
+      this.consume(TOKEN.COLON);
+      return new ASTNode(token.pos, this.input, ["?:", expr, consequent, this.parseExpression()]);
+    }
+    return expr;
+  }
+  // LogicalOr ::= LogicalAnd ('||' LogicalAnd)*
+  parseLogicalOr() {
+    let expr = this.parseLogicalAnd();
+    while (this.match(TOKEN.OR)) {
+      const token = this.consume(TOKEN.OR);
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseLogicalAnd()]);
+    }
+    return expr;
+  }
+  // LogicalAnd ::= Equality ('&&' Equality)*
+  parseLogicalAnd() {
+    let expr = this.parseEquality();
+    while (this.match(TOKEN.AND)) {
+      const token = this.consume(TOKEN.AND);
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseEquality()]);
+    }
+    return expr;
+  }
+  // Equality ::= Relational (('==' | '!=') Relational)*
+  parseEquality() {
+    let expr = this.parseRelational();
+    while (this.match(TOKEN.EQ) || this.match(TOKEN.NE)) {
+      const token = this.currentToken;
+      this.currentToken = this.lexer.nextToken();
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseRelational()]);
+    }
+    return expr;
+  }
+  // Relational ::= Additive (('<' | '<=' | '>' | '>=' | 'in') Additive)*
+  parseRelational() {
+    let expr = this.parseAdditive();
+    while (this.match(TOKEN.LT) || this.match(TOKEN.LE) || this.match(TOKEN.GT) || this.match(TOKEN.GE) || this.match(TOKEN.IN)) {
+      const token = this.currentToken;
+      this.currentToken = this.lexer.nextToken();
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseAdditive()]);
+    }
+    return expr;
+  }
+  // Additive ::= Multiplicative (('+' | '-') Multiplicative)*
+  parseAdditive() {
+    let expr = this.parseMultiplicative();
+    while (this.match(TOKEN.PLUS) || this.match(TOKEN.MINUS)) {
+      const token = this.currentToken;
+      this.currentToken = this.lexer.nextToken();
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseMultiplicative()]);
+    }
+    return expr;
+  }
+  // Multiplicative ::= Unary (('*' | '/' | '%') Unary)*
+  parseMultiplicative() {
+    let expr = this.parseUnary();
+    while (this.match(TOKEN.MULTIPLY) || this.match(TOKEN.DIVIDE) || this.match(TOKEN.MODULO)) {
+      const token = this.currentToken;
+      this.currentToken = this.lexer.nextToken();
+      expr = new ASTNode(token.pos, this.input, [token.value, expr, this.parseUnary()]);
+    }
+    return expr;
+  }
+  // Unary ::= ('!' | '-')* Postfix
+  parseUnary() {
+    const token = this.currentToken;
+    if (token.type === TOKEN.NOT) {
+      this.currentToken = this.lexer.nextToken();
+      return new ASTNode(token.pos, this.input, ["!_", this.parseUnary()]);
+    }
+    if (token.type === TOKEN.MINUS) {
+      this.currentToken = this.lexer.nextToken();
+      return new ASTNode(token.pos, this.input, ["-_", this.parseUnary()]);
+    }
+    return this.parsePostfix();
+  }
+  assertReservedIdentifier(property) {
+    if (!RESERVED.has(property.value)) return;
+    throw new ParseError(`Reserved identifier: ${property.value}`, {
+      pos: property.pos,
+      input: this.input
+    });
+  }
+  // Postfix ::= Primary (('.' IDENTIFIER ('(' ArgumentList ')')? | '[' Expression ']'))*
+  parsePostfix() {
+    let expr = this.parsePrimary();
+    while (true) {
+      if (this.match(TOKEN.DOT)) {
+        this.consume(TOKEN.DOT);
+        const property = this.consume(TOKEN.IDENTIFIER);
+        if (this.match(TOKEN.LPAREN)) {
+          this.consume(TOKEN.LPAREN);
+          const args = this.parseArgumentList();
+          this.consume(TOKEN.RPAREN);
+          expr = new ASTNode(property.pos, this.input, ["rcall", property.value, expr, args]);
+        } else {
+          expr = new ASTNode(property.pos, this.input, [".", expr, property.value]);
+        }
+      } else if (this.match(TOKEN.LBRACKET)) {
+        const token = this.consume(TOKEN.LBRACKET);
+        const index = this.parseExpression();
+        this.consume(TOKEN.RBRACKET);
+        expr = new ASTNode(token.pos, this.input, ["[]", expr, index]);
+      } else {
+        break;
+      }
+    }
+    return expr;
+  }
+  // Primary ::= NUMBER | STRING | BOOLEAN | NULL | IDENTIFIER | '(' Expression ')' | Array | Object
+  parsePrimary() {
+    switch (this.currentToken.type) {
+      case TOKEN.NUMBER: {
+        const token = this.consume(TOKEN.NUMBER);
+        return new ASTNode(token.pos, this.input, ["value", token.value]);
+      }
+      case TOKEN.STRING: {
+        const token = this.consume(TOKEN.STRING);
+        return new ASTNode(token.pos, this.input, ["value", token.value]);
+      }
+      case TOKEN.BYTES: {
+        const token = this.consume(TOKEN.BYTES);
+        return new ASTNode(token.pos, this.input, ["value", token.value]);
+      }
+      case TOKEN.BOOLEAN: {
+        const token = this.consume(TOKEN.BOOLEAN);
+        return new ASTNode(token.pos, this.input, ["value", token.value]);
+      }
+      case TOKEN.NULL: {
+        const token = this.consume(TOKEN.NULL);
+        return new ASTNode(token.pos, this.input, ["value", token.value]);
+      }
+      case TOKEN.IDENTIFIER: {
+        const identifier = this.consume(TOKEN.IDENTIFIER);
+        this.assertReservedIdentifier(identifier);
+        if (this.match(TOKEN.LPAREN)) {
+          this.consume(TOKEN.LPAREN);
+          const args = this.parseArgumentList();
+          this.consume(TOKEN.RPAREN);
+          return new ASTNode(identifier.pos, this.input, ["call", identifier.value, args]);
+        }
+        return new ASTNode(identifier.pos, this.input, ["id", identifier.value]);
+      }
+      case TOKEN.LPAREN: {
+        this.consume(TOKEN.LPAREN);
+        const expr = this.parseExpression();
+        this.consume(TOKEN.RPAREN);
+        return expr;
+      }
+      case TOKEN.LBRACKET:
+        return this.parseList();
+      case TOKEN.LBRACE:
+        return this.parseMap();
+    }
+    throw new ParseError(`Unexpected token: ${TOKEN_BY_NUMBER[this.currentToken.type]}`, {
+      pos: this.currentToken.pos,
+      input: this.input
+    });
+  }
+  parseList() {
+    const token = this.consume(TOKEN.LBRACKET);
+    const elements = [];
+    if (!this.match(TOKEN.RBRACKET)) {
+      elements.push(this.parseExpression());
+      while (this.match(TOKEN.COMMA)) {
+        this.consume(TOKEN.COMMA);
+        if (!this.match(TOKEN.RBRACKET)) {
+          elements.push(this.parseExpression());
+        }
+      }
+    }
+    this.consume(TOKEN.RBRACKET);
+    return new ASTNode(token.pos, this.input, ["list", elements]);
+  }
+  parseMap() {
+    const token = this.consume(TOKEN.LBRACE);
+    const properties = [];
+    if (!this.match(TOKEN.RBRACE)) {
+      properties.push(this.parseProperty());
+      while (this.match(TOKEN.COMMA)) {
+        this.consume(TOKEN.COMMA);
+        if (!this.match(TOKEN.RBRACE)) {
+          properties.push(this.parseProperty());
+        }
+      }
+    }
+    this.consume(TOKEN.RBRACE);
+    return new ASTNode(token.pos, this.input, ["map", properties]);
+  }
+  parseProperty() {
+    const key = this.parseExpression();
+    this.consume(TOKEN.COLON);
+    const value = this.parseExpression();
+    return [key, value];
+  }
+  parseArgumentList() {
+    const args = [];
+    if (!this.match(TOKEN.RPAREN)) {
+      args.push(this.parseExpression());
+      while (this.match(TOKEN.COMMA)) {
+        this.consume(TOKEN.COMMA);
+        if (!this.match(TOKEN.RPAREN)) {
+          args.push(this.parseExpression());
+        }
+      }
+    }
+    return args;
+  }
+};
+
+// ../../node_modules/@marcbachmann/cel-js/lib/functions.js
+var UnsignedInt = class {
+  #value;
+  constructor(value) {
+    this.verify(BigInt(value));
+  }
+  get value() {
+    return this.#value;
+  }
+  valueOf() {
+    return this.#value;
+  }
+  verify(v) {
+    if (v < 0n || v > 18446744073709551615n) throw new EvaluationError("Unsigned integer overflow");
+    this.#value = v;
+  }
+  get [Symbol.toStringTag]() {
+    return `value = ${this.#value}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `UnsignedInteger { value: ${this.#value} }`;
+  }
+};
+var UNIT_NANOSECONDS = {
+  h: 3600000000000n,
+  m: 60000000000n,
+  s: 1000000000n,
+  ms: 1000000n,
+  us: 1000n,
+  \u00B5s: 1000n,
+  ns: 1n
+};
+var Duration = class _Duration {
+  #seconds;
+  #nanos;
+  constructor(seconds, nanos = 0) {
+    this.#seconds = BigInt(seconds);
+    this.#nanos = nanos;
+  }
+  get seconds() {
+    return this.#seconds;
+  }
+  get nanos() {
+    return this.#nanos;
+  }
+  valueOf() {
+    return Number(this.#seconds) * 1e3 + this.#nanos / 1e6;
+  }
+  addDuration(other) {
+    const nanos = this.#nanos + other.nanos;
+    return new _Duration(
+      this.#seconds + other.seconds + BigInt(Math.floor(nanos / 1e9)),
+      nanos % 1e9
+    );
+  }
+  subtractDuration(other) {
+    const nanos = this.#nanos - other.nanos;
+    return new _Duration(
+      this.#seconds - other.seconds + BigInt(Math.floor(nanos / 1e9)),
+      (nanos + 1e9) % 1e9
+    );
+  }
+  extendTimestamp(ts) {
+    return new Date(
+      ts.getTime() + Number(this.#seconds) * 1e3 + Math.floor(this.#nanos / 1e6)
+    );
+  }
+  subtractTimestamp(ts) {
+    return new Date(
+      ts.getTime() - Number(this.#seconds) * 1e3 - Math.floor(this.#nanos / 1e6)
+    );
+  }
+  toString() {
+    const nanos = this.#nanos ? (this.#nanos / 1e9).toLocaleString("en-US", { useGrouping: false, maximumFractionDigits: 9 }).slice(1) : "";
+    return `${this.#seconds}${nanos}s`;
+  }
+  getHours() {
+    return this.#seconds / 3600n;
+  }
+  getMinutes() {
+    return this.#seconds / 60n;
+  }
+  getSeconds() {
+    return this.#seconds;
+  }
+  getMilliseconds() {
+    return this.#seconds * 1000n + BigInt(Math.floor(this.#nanos / 1e6));
+  }
+  get [Symbol.toStringTag]() {
+    return "google.protobuf.Duration";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `google.protobuf.Duration { seconds: ${this.#seconds}, nanos: ${this.#nanos} }`;
+  }
+};
+function registerFunctions(registry) {
+  const functionOverload = (sig, handler) => registry.registerFunctionOverload(sig, handler);
+  const identity = (v) => v;
+  functionOverload("has(ast): bool", function(ast) {
+    const selector = ast[2][0];
+    if (selector[0] === ".") return hasNestedField(this, selector, ast) !== void 0;
+    throw new EvaluationError("has() invalid argument", ast);
+  });
+  function hasNestedField(ev, selector, ast) {
+    switch (selector[0]) {
+      case "id":
+        return ev.eval(selector);
+      case ".": {
+        const obj = hasNestedField(ev, selector[1], ast);
+        if (!obj) throw new EvaluationError(`No such key: ${selector[2]}`, selector);
+        const type = ev.debugType(obj);
+        return type.fieldLazy(obj, selector[2], ast, ev);
+      }
+    }
+    throw new EvaluationError("has() invalid argument", ast);
+  }
+  functionOverload("dyn(dyn): dyn", identity);
+  for (const _t in TYPES) {
+    const type = TYPES[_t];
+    if (!(type instanceof Type2)) continue;
+    functionOverload(`type(${type.name}): type`, () => type);
+  }
+  functionOverload("bool(bool): bool", identity);
+  functionOverload("bool(string): bool", (v) => {
+    switch (v) {
+      case "1":
+      case "t":
+      case "true":
+      case "TRUE":
+      case "True":
+        return true;
+      case "0":
+      case "f":
+      case "false":
+      case "FALSE":
+      case "False":
+        return false;
+      default:
+        throw new EvaluationError(`bool() conversion error: invalid string value "${v}"`);
+    }
+  });
+  const objectKeys = Object.keys;
+  functionOverload("size(string): int", (v) => BigInt(stringSize(v)));
+  functionOverload("size(bytes): int", (v) => BigInt(v.length));
+  functionOverload("size(list): int", (v) => BigInt(v.length ?? v.size));
+  functionOverload(
+    "size(map): int",
+    (v) => BigInt(v instanceof Map ? v.size : objectKeys(v).length)
+  );
+  functionOverload("string.size(): int", (v) => BigInt(stringSize(v)));
+  functionOverload("bytes.size(): int", (v) => BigInt(v.length));
+  functionOverload("list.size(): int", (v) => BigInt(v.length ?? v.size));
+  functionOverload(
+    "map.size(): int",
+    (v) => BigInt(v instanceof Map ? v.size : objectKeys(v).length)
+  );
+  functionOverload("bytes(string): bytes", (v) => ByteOpts.fromString(v));
+  functionOverload("bytes(bytes): bytes", identity);
+  functionOverload("double(double): double", identity);
+  functionOverload("double(int): double", (v) => Number(v));
+  functionOverload("double(string): double", (v) => {
+    if (!v || v !== v.trim())
+      throw new EvaluationError("double() type error: cannot convert to double");
+    const s = v.toLowerCase();
+    switch (s) {
+      case "inf":
+      case "+inf":
+      case "infinity":
+      case "+infinity":
+        return Number.POSITIVE_INFINITY;
+      case "-inf":
+      case "-infinity":
+        return Number.NEGATIVE_INFINITY;
+      case "nan":
+        return Number.NaN;
+      default: {
+        const parsed = Number(v);
+        if (!Number.isNaN(parsed)) return parsed;
+        throw new EvaluationError("double() type error: cannot convert to double");
+      }
+    }
+  });
+  functionOverload("int(int): int", identity);
+  functionOverload("int(double): int", (v) => {
+    if (Number.isFinite(v)) return BigInt(Math.trunc(v));
+    throw new EvaluationError("int() type error: integer overflow");
+  });
+  functionOverload("int(string): int", (v) => {
+    if (v !== v.trim() || v.length > 20 || v.includes("0x")) {
+      throw new EvaluationError("int() type error: cannot convert to int");
+    }
+    try {
+      const num = BigInt(v);
+      if (num <= 9223372036854775807n && num >= -9223372036854775808n) return num;
+    } catch (_e) {
+    }
+    throw new EvaluationError("int() type error: cannot convert to int");
+  });
+  functionOverload("uint(uint): uint", identity);
+  functionOverload("uint(double): uint", (v) => {
+    if (Number.isFinite(v)) return BigInt(Math.trunc(v));
+    throw new EvaluationError("int() type error: integer overflow");
+  });
+  functionOverload("uint(string): uint", (v) => {
+    if (v !== v.trim() || v.length > 20 || v.includes("0x")) {
+      throw new EvaluationError("uint() type error: cannot convert to uint");
+    }
+    try {
+      const num = BigInt(v);
+      if (num <= 18446744073709551615n && num >= 0n) return num;
+    } catch (_e) {
+    }
+    throw new EvaluationError("uint() type error: cannot convert to uint");
+  });
+  functionOverload("string(string): string", identity);
+  functionOverload("string(bool): string", (v) => `${v}`);
+  functionOverload("string(int): string", (v) => `${v}`);
+  functionOverload("string(bytes): string", (v) => ByteOpts.toUtf8(v));
+  functionOverload("string(double): string", (v) => {
+    if (v === Infinity) return "+Inf";
+    if (v === -Infinity) return "-Inf";
+    return `${v}`;
+  });
+  functionOverload("string.startsWith(string): bool", (a, b) => a.startsWith(b));
+  functionOverload("string.endsWith(string): bool", (a, b) => a.endsWith(b));
+  functionOverload("string.contains(string): bool", (a, b) => a.includes(b));
+  functionOverload(
+    "string.indexOf(string): bool",
+    (string, search) => BigInt(string.indexOf(search))
+  );
+  functionOverload("string.indexOf(string, int): bool", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    fromIndex = Number(fromIndex);
+    if (fromIndex < 0 || fromIndex >= string.length) {
+      throw new EvaluationError("string.indexOf(search, fromIndex): fromIndex out of range");
+    }
+    return BigInt(string.indexOf(search, fromIndex));
+  });
+  functionOverload(
+    "string.lastIndexOf(string): bool",
+    (string, search) => BigInt(string.lastIndexOf(search))
+  );
+  functionOverload("string.lastIndexOf(string, int): bool", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    fromIndex = Number(fromIndex);
+    if (fromIndex < 0 || fromIndex >= string.length) {
+      throw new EvaluationError("string.lastIndexOf(search, fromIndex): fromIndex out of range");
+    }
+    return BigInt(string.lastIndexOf(search, fromIndex));
+  });
+  functionOverload("string.substring(int): string", (string, start) => {
+    start = Number(start);
+    if (start < 0 || start > string.length) {
+      throw new EvaluationError("string.substring(start, end): start index out of range");
+    }
+    return string.substring(start);
+  });
+  functionOverload("string.substring(int, int): string", (string, start, end) => {
+    start = Number(start);
+    if (start < 0 || start > string.length) {
+      throw new EvaluationError("string.substring(start, end): start index out of range");
+    }
+    end = Number(end);
+    if (end < start || end > string.length) {
+      throw new EvaluationError("string.substring(start, end): end index out of range");
+    }
+    return string.substring(start, end);
+  });
+  functionOverload("string.matches(string): bool", (a, b) => {
+    try {
+      return new RegExp(b).test(a);
+    } catch (_err) {
+      throw new EvaluationError(`Invalid regular expression: ${b}`);
+    }
+  });
+  functionOverload("string.split(string): list", (s, sep) => s.split(sep));
+  functionOverload("string.split(string, int): list", (s, sep, l) => s.split(sep, l));
+  functionOverload("list.join(): string", (v) => {
+    for (let i = 0; i < v.length; i++) {
+      if (typeof v[i] !== "string") {
+        throw new EvaluationError("string.join(): list must contain only strings");
+      }
+    }
+    return v.join("");
+  });
+  functionOverload("list.join(string): string", (v, sep) => {
+    for (let i = 0; i < v.length; i++) {
+      if (typeof v[i] !== "string") {
+        throw new EvaluationError("string.join(separator): list must contain only strings");
+      }
+    }
+    return v.join(sep);
+  });
+  const textEncoder = new TextEncoder("utf8");
+  const textDecoder = new TextDecoder("utf8");
+  const ByteOpts = typeof Buffer !== "undefined" ? {
+    byteLength: (v) => Buffer.byteLength(v),
+    fromString: (str) => Buffer.from(str, "utf8"),
+    toHex: (b) => Buffer.prototype.hexSlice.call(b, 0, b.length),
+    toBase64: (b) => Buffer.prototype.base64Slice.call(b, 0, b.length),
+    toUtf8: (b) => Buffer.prototype.utf8Slice.call(b, 0, b.length),
+    jsonParse: (b) => JSON.parse(b)
+  } : {
+    textEncoder: new TextEncoder("utf8"),
+    byteLength: (v) => textEncoder.encode(v).length,
+    fromString: (str) => textEncoder.encode(str),
+    toHex: Uint8Array.prototype.toHex ? (b) => b.toHex() : (b) => Array.from(b, (i) => i.toString(16).padStart(2, "0")).join(""),
+    toBase64: Uint8Array.prototype.toBase64 ? (b) => b.toBase64() : (b) => btoa(Array.from(b, (i) => String.fromCodePoint(i)).join("")),
+    toUtf8: (b) => textDecoder.decode(b),
+    jsonParse: (b) => JSON.parse(textEncoder.decode(b))
+  };
+  functionOverload("bytes.json(): map", ByteOpts.jsonParse);
+  functionOverload("bytes.hex(): string", ByteOpts.toHex);
+  functionOverload("bytes.string(): string", ByteOpts.toUtf8);
+  functionOverload("bytes.base64(): string", ByteOpts.toBase64);
+  functionOverload("bytes.at(int): int", (b, index) => {
+    if (index < 0 || index >= b.length) throw new EvaluationError("Bytes index out of range");
+    return BigInt(b[index]);
+  });
+  const TS = "google.protobuf.Timestamp";
+  function tzDate(d, timeZone) {
+    return new Date(d.toLocaleString("en-US", { timeZone }));
+  }
+  function getDayOfYear(d, tz) {
+    const workingDate = tz ? tzDate(d, tz) : new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    const start = new Date(workingDate.getFullYear(), 0, 0);
+    return BigInt(Math.floor((workingDate - start) / 864e5) - 1);
+  }
+  functionOverload(`timestamp(string): ${TS}`, (v) => {
+    if (v.length < 20 || v.length > 30) {
+      throw new EvaluationError("timestamp() requires a string in ISO 8601 format");
+    }
+    const d = new Date(v);
+    if (d <= 253402300799999 && d >= -621355968e5) return d;
+    throw new EvaluationError("timestamp() requires a string in ISO 8601 format");
+  });
+  functionOverload(`timestamp(int): ${TS}`, (i) => {
+    i = Number(i) * 1e3;
+    if (i <= 253402300799999 && i >= -621355968e5) return new Date(i);
+    throw new EvaluationError("timestamp() requires a valid integer unix timestamp");
+  });
+  functionOverload(`${TS}.getDate(): int`, (d) => BigInt(d.getUTCDate()));
+  functionOverload(`${TS}.getDate(string): int`, (d, tz) => BigInt(tzDate(d, tz).getDate()));
+  functionOverload(`${TS}.getDayOfMonth(): int`, (d) => BigInt(d.getUTCDate() - 1));
+  functionOverload(
+    `${TS}.getDayOfMonth(string): int`,
+    (d, tz) => BigInt(tzDate(d, tz).getDate() - 1)
+  );
+  functionOverload(`${TS}.getDayOfWeek(): int`, (d) => BigInt(d.getUTCDay()));
+  functionOverload(`${TS}.getDayOfWeek(string): int`, (d, tz) => BigInt(tzDate(d, tz).getDay()));
+  functionOverload(`${TS}.getDayOfYear(): int`, getDayOfYear);
+  functionOverload(`${TS}.getDayOfYear(string): int`, getDayOfYear);
+  functionOverload(`${TS}.getFullYear(): int`, (d) => BigInt(d.getUTCFullYear()));
+  functionOverload(`${TS}.getFullYear(string): int`, (d, tz) => BigInt(tzDate(d, tz).getFullYear()));
+  functionOverload(`${TS}.getHours(): int`, (d) => BigInt(d.getUTCHours()));
+  functionOverload(`${TS}.getHours(string): int`, (d, tz) => BigInt(tzDate(d, tz).getHours()));
+  functionOverload(`${TS}.getMilliseconds(): int`, (d) => BigInt(d.getUTCMilliseconds()));
+  functionOverload(`${TS}.getMilliseconds(string): int`, (d) => BigInt(d.getUTCMilliseconds()));
+  functionOverload(`${TS}.getMinutes(): int`, (d) => BigInt(d.getUTCMinutes()));
+  functionOverload(`${TS}.getMinutes(string): int`, (d, tz) => BigInt(tzDate(d, tz).getMinutes()));
+  functionOverload(`${TS}.getMonth(): int`, (d) => BigInt(d.getUTCMonth()));
+  functionOverload(`${TS}.getMonth(string): int`, (d, tz) => BigInt(tzDate(d, tz).getMonth()));
+  functionOverload(`${TS}.getSeconds(): int`, (d) => BigInt(d.getUTCSeconds()));
+  functionOverload(`${TS}.getSeconds(string): int`, (d, tz) => BigInt(tzDate(d, tz).getSeconds()));
+  const parseDurationPattern = /(\d*\.?\d*)(ns|us|µs|ms|s|m|h)/;
+  function parseDuration(string) {
+    if (!string) throw new EvaluationError(`Invalid duration string: ''`);
+    const isNegative = string[0] === "-";
+    if (string[0] === "-" || string[0] === "+") string = string.slice(1);
+    let nanoseconds = BigInt(0);
+    while (true) {
+      const match = parseDurationPattern.exec(string);
+      if (!match) throw new EvaluationError(`Invalid duration string: ${string}`);
+      if (match.index !== 0) throw new EvaluationError(`Invalid duration string: ${string}`);
+      string = string.slice(match[0].length);
+      const unitNanos = UNIT_NANOSECONDS[match[2]];
+      const [intPart = "0", fracPart = ""] = match[1].split(".");
+      const intVal = BigInt(intPart) * unitNanos;
+      const fracNanos = fracPart ? BigInt(fracPart.slice(0, 13).padEnd(13, "0")) * unitNanos / 10000000000000n : 0n;
+      nanoseconds += intVal + fracNanos;
+      if (string === "") break;
+    }
+    const seconds = nanoseconds >= 1000000000n ? nanoseconds / 1000000000n : 0n;
+    const nanos = Number(nanoseconds % 1000000000n);
+    if (isNegative) return new Duration(-seconds, -nanos);
+    return new Duration(seconds, nanos);
+  }
+  functionOverload(`duration(string): google.protobuf.Duration`, (s) => parseDuration(s));
+  functionOverload(`google.protobuf.Duration.getHours(): int`, (d) => d.getHours());
+  functionOverload(`google.protobuf.Duration.getMinutes(): int`, (d) => d.getMinutes());
+  functionOverload(`google.protobuf.Duration.getSeconds(): int`, (d) => d.getSeconds());
+  functionOverload(`google.protobuf.Duration.getMilliseconds(): int`, (d) => d.getMilliseconds());
+  function getIterableElementType(receiverType, checker) {
+    if (receiverType.type === "list") return receiverType.valueType;
+    if (receiverType.type === "map") return receiverType.keyType;
+    return checker.getType("dyn");
+  }
+  function validateIdentifierArg(args, functionDesc) {
+    const identArg = args[0];
+    if (identArg instanceof ASTNode && identArg[0] === "id") return identArg[1];
+    throw new TypeError2(`${functionDesc} requires first argument to be an identifier`, identArg);
+  }
+  function predicateTypeCheck(methodName) {
+    return (checker, receiverType, args) => {
+      const varName = validateIdentifierArg(args, `${methodName}(var, predicate)`);
+      const elementType = getIterableElementType(receiverType, checker);
+      const scopedChecker = checker.createOverlay(varName, elementType);
+      const predicateType = scopedChecker.check(args[1]);
+      if (predicateType.isDynOrBool()) return predicateType;
+      throw new TypeError2(`predicate must return bool, got '${predicateType}'`, args[1]);
+    };
+  }
+  function mapTypeCheck(checker, receiverType, args) {
+    const funcDesc = `map(var, ${args.length === 3 ? "filter, " : ""}transform)`;
+    const varName = validateIdentifierArg(args, funcDesc);
+    const elementType = getIterableElementType(receiverType, checker);
+    const scopedChecker = checker.createOverlay(varName, elementType);
+    if (args.length === 3) {
+      const filterType = scopedChecker.check(args[1]);
+      if (!filterType.isDynOrBool()) {
+        throw new TypeError2(
+          `${funcDesc} filter predicate must return bool, got '${filterType}'`,
+          args[1]
+        );
+      }
+    }
+    return checker.getType(`list<${scopedChecker.check(args[args.length - 1])}>`);
+  }
+  function filterTypeCheck(checker, receiverType, args) {
+    const funcDesc = `filter(var, filter)`;
+    const varName = validateIdentifierArg(args, funcDesc);
+    const elementType = getIterableElementType(receiverType, checker);
+    const scopedChecker = checker.createOverlay(varName, elementType);
+    const filterType = scopedChecker.check(args[1]);
+    if (filterType.isDynOrBool()) return checker.getType(`list<${elementType}>`);
+    throw new TypeError2(`${funcDesc} predicate must return bool, got '${filterType}'`, args[1]);
+  }
+  functionOverload("list.all(ast, ast): bool", {
+    handler: allMacro,
+    typeCheck: predicateTypeCheck("all")
+  });
+  functionOverload("map.all(ast, ast): bool", {
+    handler: allMacro,
+    typeCheck: predicateTypeCheck("all")
+  });
+  functionOverload("list.exists(ast, ast): bool", {
+    handler: existsMacro,
+    typeCheck: predicateTypeCheck("exists")
+  });
+  functionOverload("map.exists(ast, ast): bool", {
+    handler: existsMacro,
+    typeCheck: predicateTypeCheck("exists")
+  });
+  functionOverload("list.exists_one(ast, ast): bool", {
+    handler: existsOneMacro,
+    typeCheck: predicateTypeCheck("exists_one")
+  });
+  functionOverload("map.exists_one(ast, ast): bool", {
+    handler: existsOneMacro,
+    typeCheck: predicateTypeCheck("exists_one")
+  });
+  functionOverload("list.map(ast, ast): list", { handler: mapMacro, typeCheck: mapTypeCheck });
+  functionOverload("list.map(ast, ast, ast): list", {
+    handler: filterMapMacro,
+    typeCheck: mapTypeCheck
+  });
+  functionOverload("map.map(ast, ast): list", { handler: mapMacro, typeCheck: mapTypeCheck });
+  functionOverload("map.map(ast, ast, ast): list", {
+    handler: filterMapMacro,
+    typeCheck: mapTypeCheck
+  });
+  functionOverload("list.filter(ast, ast): list", {
+    handler: filterMacro,
+    typeCheck: filterTypeCheck
+  });
+  functionOverload("map.filter(ast, ast): list", { handler: filterMacro, typeCheck: filterTypeCheck });
+}
+var kPredicateEvaluator = Symbol("predicateEvaluator");
+function allMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "all(var, predicate)",
+    ast
+  );
+  const items = evaluator.getIterableItems(receiver);
+  let error = null;
+  for (let i = 0; i < items.length; i++) {
+    try {
+      if (evaluator.childEvaluateBool(items[i])) continue;
+      return false;
+    } catch (e) {
+      if (e.message.includes("Unknown variable")) throw e;
+      if (e.message.includes("predicate result is not a boolean")) throw e;
+      error ??= e;
+    }
+  }
+  if (error) throw error;
+  return true;
+}
+function existsMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "exists(var, predicate)",
+    ast
+  );
+  const items = evaluator.getIterableItems(receiver);
+  let error;
+  for (let i = 0; i < items.length; i++) {
+    try {
+      if (evaluator.childEvaluateBool(items[i])) return true;
+    } catch (e) {
+      if (e.message.includes("Unknown variable")) throw e;
+      if (e.message.includes("predicate result is not a boolean")) throw e;
+      error ??= e;
+    }
+  }
+  if (error) throw error;
+  return false;
+}
+function existsOneMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "exists_one(var, predicate)",
+    ast
+  );
+  const items = evaluator.getIterableItems(receiver);
+  let count = 0;
+  for (let i = 0; i < items.length; i++) {
+    if (evaluator.childEvaluateBool(items[i]) === false) continue;
+    if (++count > 1) return false;
+  }
+  return count === 1;
+}
+function mapMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "map(var, transform)",
+    ast
+  );
+  const items = evaluator.getIterableItems(receiver);
+  const results = [];
+  for (let i = 0; i < items.length; i++) results[i] = evaluator.childEvaluate(items[i]);
+  return results;
+}
+function filterMapMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "map(var, filter, transform)",
+    ast
+  );
+  const transform = ast[3][2];
+  const items = evaluator.getIterableItems(receiver);
+  const results = [];
+  for (let i = 0; i < items.length; i++) {
+    switch (evaluator.childEvaluateBool(items[i])) {
+      case false:
+        continue;
+      case true:
+        results.push(evaluator.eval(transform));
+        continue;
+    }
+  }
+  return results;
+}
+function filterMacro(receiver, ast) {
+  const evaluator = ast[kPredicateEvaluator] ??= this.predicateEvaluator(
+    "filter(var, predicate)",
+    ast
+  );
+  const items = evaluator.getIterableItems(receiver);
+  const results = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (evaluator.childEvaluateBool(item) === false) continue;
+    results.push(item);
+  }
+  return results;
+}
+function stringSize(str) {
+  let count = 0;
+  for (const c of str) count++;
+  return count;
+}
+
+// ../../node_modules/@marcbachmann/cel-js/lib/registry.js
+var Type2 = class {
+  #name;
+  constructor(name) {
+    this.#name = name;
+    Object.freeze(this);
+  }
+  get name() {
+    return this.#name;
+  }
+  get [Symbol.toStringTag]() {
+    return `Type<${this.#name}>`;
+  }
+  toString() {
+    return `Type<${this.#name}>`;
+  }
+};
+var TYPES = {
+  string: new Type2("string"),
+  bool: new Type2("bool"),
+  int: new Type2("int"),
+  uint: new Type2("uint"),
+  double: new Type2("double"),
+  map: new Type2("map"),
+  list: new Type2("list"),
+  bytes: new Type2("bytes"),
+  null_type: new Type2("null"),
+  type: new Type2("type"),
+  google: {
+    protobuf: {
+      Timestamp: new Type2("google.protobuf.Timestamp"),
+      Duration: new Type2("google.protobuf.Duration")
+    }
+  }
+};
+TYPES["google.protobuf.Timestamp"] = TYPES.google.protobuf.Timestamp;
+TYPES["google.protobuf.Duration"] = TYPES.google.protobuf.Duration;
+var LayeredMap = class _LayeredMap {
+  #parent = null;
+  #entries = null;
+  constructor(source) {
+    if (source instanceof _LayeredMap) {
+      this.#parent = source;
+      this.#entries = /* @__PURE__ */ new Map();
+    } else {
+      this.#entries = new Map(source);
+    }
+  }
+  fork(lock = true) {
+    if (lock) this.set = this.#throwLocked;
+    return new this.constructor(this);
+  }
+  #throwLocked() {
+    throw new Error("Cannot modify frozen registry");
+  }
+  set(key, value) {
+    this.#entries.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this.#entries.has(key) || (this.#parent ? this.#parent.has(key) : false);
+  }
+  get(key) {
+    return this.#entries.get(key) || this.#parent?.get(key);
+  }
+  *#entryIterator() {
+    if (this.#parent) yield* this.#parent;
+    yield* this.#entries;
+  }
+  [Symbol.iterator]() {
+    return this.#entryIterator();
+  }
+  get size() {
+    return this.#entries.size + (this.#parent ? this.#parent.size : 0);
+  }
+};
+var DynVariableRegistry = class extends LayeredMap {
+  constructor(source = null, marker = null) {
+    super(source, marker);
+  }
+  get(name) {
+    const value = super.get(name);
+    return value === void 0 ? dynType : value;
+  }
+};
+function createLayeredMap(source, MapCtor = LayeredMap, lock = true) {
+  if (source instanceof MapCtor) return source.fork(lock);
+  return new MapCtor(source);
+}
+var TypeDeclaration = class {
+  #matchesCache = /* @__PURE__ */ new WeakMap();
+  constructor({ kind, type, name, keyType, valueType, values }) {
+    this.kind = kind;
+    this.type = type;
+    this.name = name;
+    if (keyType) this.keyType = keyType;
+    if (valueType) this.valueType = valueType;
+    if (values) this.values = values;
+    if (kind === "list") this.fieldLazy = this.#getListField;
+    else if (kind === "map") this.fieldLazy = this.#getMapField;
+    else if (kind === "message") this.fieldLazy = this.#getMessageField;
+    else if (kind === "dyn") this.fieldLazy = this.#getMapField;
+    Object.freeze(this);
+  }
+  isDynOrBool() {
+    return this.type === "bool" || this.kind === "dyn";
+  }
+  toString() {
+    return this.name;
+  }
+  #getMessageField(obj, key, ast, ev) {
+    const type = ev.objectTypesByConstructor.get(obj.constructor);
+    if (!type) return;
+    if (!type.fields) return Object.hasOwn(obj, key) ? obj[key] : void 0;
+    const valueType = type.fields[key];
+    if (!valueType) return;
+    const value = obj[key];
+    if (valueType.kind === "dyn") return value;
+    const actualType = ev.debugType(value);
+    if (valueType.matches(actualType)) return value;
+    throw new EvaluationError(
+      `Field '${key}' is not of type '${valueType}', got '${actualType}'`,
+      ast
+    );
+  }
+  #getMapField(obj, key, ast, ev) {
+    let value;
+    if (obj instanceof Map) value = obj.get(key);
+    else value = Object.hasOwn(obj, key) ? obj[key] : void 0;
+    if (value === void 0) return;
+    if (this.valueType.kind === "dyn") return value;
+    const type = ev.debugType(value);
+    if (this.valueType.matches(type)) return value;
+    throw new EvaluationError(
+      `Field '${key}' is not of type '${this.valueType}', got '${type}'`,
+      ast
+    );
+  }
+  #getListField(obj, key, ast, ev) {
+    if (!(typeof key === "number" || typeof key === "bigint")) return;
+    const value = obj[key];
+    if (value === void 0) {
+      throw new EvaluationError(
+        `No such key: index out of bounds, index ${key} ${key < 0 ? "< 0" : `>= size ${obj.length}`}`,
+        ast
+      );
+    }
+    const type = ev.debugType(value);
+    if (this.valueType.matches(type)) return value;
+    throw new EvaluationError(
+      `List item with index '${key}' is not of type '${this.valueType}', got '${type}'`,
+      ast
+    );
+  }
+  fieldLazy() {
+  }
+  field(obj, key, ast, ev) {
+    const v = this.fieldLazy(obj, key, ast, ev);
+    if (v !== void 0) return v;
+    throw new EvaluationError(`No such key: ${key}`, ast);
+  }
+  matchesBoth(other) {
+    return this.matches(other) && other.matches(this);
+  }
+  matches(other) {
+    return this.#matchesCache.get(other) ?? this.#matchesCache.set(other, this.#matches(other)).get(other);
+  }
+  #matches(other) {
+    if (this === other) return true;
+    if (other.kind === "dyn") return other.valueType ? this.matches(other.valueType) : true;
+    switch (this.kind) {
+      case "dyn":
+        return true;
+      case "list":
+        return other.kind === "list" && this.valueType.matches(other.valueType);
+      case "map":
+        return other.kind === "map" && this.keyType.matches(other.keyType) && this.valueType.matches(other.valueType);
+      default:
+        return this.name === other.name;
+    }
+  }
+};
+var FunctionDeclaration = class {
+  constructor({ name, receiverType, argTypes, returnType, handler, typeCheck }) {
+    this.name = name;
+    this.macro = argTypes.includes(astType);
+    this.receiverType = receiverType || null;
+    this.argTypes = argTypes;
+    this.returnType = returnType;
+    const receiverString = receiverType ? `${receiverType}.` : "";
+    this.signature = `${receiverString}${name}(${argTypes.join(", ")}): ${returnType}`;
+    this.handler = handler;
+    this.typeCheck = typeCheck;
+    Object.freeze(this);
+  }
+  matchesArgs(argTypes) {
+    if (argTypes.length !== this.argTypes.length) return false;
+    return this.argTypes.every((t, i) => t.matches(argTypes[i]));
+  }
+};
+var OperatorDeclaration = class {
+  constructor({ operator, leftType, rightType, handler, returnType }) {
+    this.operator = operator;
+    this.leftType = leftType;
+    this.rightType = rightType || null;
+    this.handler = handler;
+    this.returnType = returnType;
+    if (rightType) this.signature = `${leftType} ${operator} ${rightType}: ${returnType}`;
+    else this.signature = `${operator}${leftType}: ${returnType}`;
+    Object.freeze(this);
+  }
+  get isUnary() {
+    return this.rightType === null;
+  }
+  get isBinary() {
+    return this.rightType !== null;
+  }
+  equals(other) {
+    return this.operator === other.operator && this.leftType === other.leftType && this.rightType === other.rightType;
+  }
+};
+function _createListType(valueType) {
+  return new TypeDeclaration({
+    kind: "list",
+    name: `list<${valueType}>`,
+    type: "list",
+    valueType
+  });
+}
+function _createPrimitiveType(name) {
+  return new TypeDeclaration({
+    kind: "primitive",
+    name,
+    type: name
+  });
+}
+function _createMessageType(name) {
+  return new TypeDeclaration({
+    kind: "message",
+    name,
+    type: name
+  });
+}
+function _createDynType(valueType) {
+  const name = valueType ? `dyn<${valueType}>` : "dyn";
+  return new TypeDeclaration({
+    kind: "dyn",
+    name,
+    type: name,
+    valueType
+  });
+}
+function _createMapType(keyType, valueType) {
+  return new TypeDeclaration({
+    kind: "map",
+    name: `map<${keyType}, ${valueType}>`,
+    type: "map",
+    keyType,
+    valueType
+  });
+}
+var dynType = _createDynType();
+var astType = _createPrimitiveType("ast");
+var listType = _createListType(dynType);
+var mapType = _createMapType(dynType, dynType);
+var celTypes = Object.freeze({
+  string: _createPrimitiveType("string"),
+  bool: _createPrimitiveType("bool"),
+  int: _createPrimitiveType("int"),
+  uint: _createPrimitiveType("uint"),
+  double: _createPrimitiveType("double"),
+  bytes: _createPrimitiveType("bytes"),
+  dyn: dynType,
+  null: _createPrimitiveType("null"),
+  type: _createPrimitiveType("type"),
+  "google.protobuf.Timestamp": _createPrimitiveType("google.protobuf.Timestamp"),
+  "google.protobuf.Duration": _createPrimitiveType("google.protobuf.Duration"),
+  list: listType,
+  "list<dyn>": listType,
+  map: mapType,
+  "map<dyn, dyn>": mapType
+});
+var FunctionsByReceiver = class {
+  /** @type {Array<FunctionDeclaration>} */
+  functions = [];
+  exists = false;
+  hasMacro = false;
+  add(decl) {
+    this.exists = true;
+    if (decl.macro) this.hasMacro = true;
+    this.functions.push(decl);
+  }
+  findMatch(argTypes) {
+    if (!this.exists) return null;
+    for (const fn of this.functions) {
+      if (fn.matchesArgs(argTypes)) return fn;
+    }
+    return null;
+  }
+};
+var NO_RECEIVER = new FunctionsByReceiver();
+var FunctionCandidates = class {
+  exists = false;
+  hasMacro = false;
+  returnType = null;
+  /** @type {Map<string|null, FunctionsByReceiver>} */
+  #byReceiverType = /* @__PURE__ */ new Map();
+  add(declaration) {
+    this.exists = true;
+    if (declaration.macro) this.hasMacro = true;
+    if (!this.returnType) this.returnType = declaration.returnType;
+    else if (declaration.typeCheck) this.returnType = dynType;
+    else if (this.returnType !== declaration.returnType) this.returnType = dynType;
+    const receiverType = declaration.receiverType;
+    const coll = this.#byReceiverType.get(receiverType) || this.#byReceiverType.set(receiverType, new FunctionsByReceiver()).get(receiverType);
+    coll.add(declaration);
+  }
+  filterByReceiverType(receiverType) {
+    if (receiverType === null) return this.#byReceiverType.get(null) || NO_RECEIVER;
+    return (
+      // First try exact match
+      this.#byReceiverType.get(receiverType) || // For generic types, also try matching with the base type
+      // e.g., if looking for list<string>, also check list<dyn>
+      (receiverType.type === "list" || receiverType.type === "map" ? this.#byReceiverType.get(celTypes[receiverType.type]) : null) || NO_RECEIVER
+    );
+  }
+};
+function splitByComma(str) {
+  const parts = [];
+  let current2 = "";
+  let depth = 0;
+  for (const char of str) {
+    if (char === "<") depth++;
+    else if (char === ">") depth--;
+    else if (char === "," && depth === 0) {
+      parts.push(current2);
+      current2 = "";
+      continue;
+    }
+    current2 += char;
+  }
+  if (current2) parts.push(current2);
+  return parts;
+}
+var builtinObjectTypes = [
+  [void 0, "map"],
+  [Object, "map"],
+  [Map, "map"],
+  [Array, "list"],
+  [Uint8Array, "bytes"],
+  [Date, "google.protobuf.Timestamp"],
+  [Duration, "google.protobuf.Duration"],
+  [UnsignedInt, "uint"],
+  [Type2, "type"]
+];
+if (typeof Buffer !== "undefined") builtinObjectTypes.push([Buffer, "bytes"]);
+var Registry = class _Registry {
+  #overloadResolutionCache = {};
+  #overloadCheckCache = {};
+  #typeDeclarations;
+  #operatorDeclarations;
+  #functionDeclarations;
+  #dynTypes = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.objectTypes = createLayeredMap(opts.objectTypes);
+    this.objectTypesByConstructor = createLayeredMap(opts.objectTypesByConstructor);
+    this.objectTypeInstances = createLayeredMap(opts.objectTypeInstances);
+    this.#functionDeclarations = createLayeredMap(opts.functionDeclarations);
+    this.#operatorDeclarations = createLayeredMap(opts.operatorDeclarations);
+    this.#typeDeclarations = createLayeredMap(
+      opts.typeDeclarations || Object.entries(celTypes),
+      void 0,
+      false
+    );
+    this.variables = opts.unlistedVariablesAreDyn ? createLayeredMap(opts.variables, DynVariableRegistry) : createLayeredMap(opts.variables);
+    if (!this.variables.size) {
+      for (const [instance, name] of builtinObjectTypes) {
+        this.registerType(name, instance, true);
+      }
+      const globalValues2 = new Map(Object.entries(TYPES));
+      for (const [name, type] of globalValues2) {
+        if (!(type instanceof Type2)) continue;
+        this.registerVariable(name, "type");
+      }
+    }
+  }
+  #invalidateOverloadsCache() {
+    this.#overloadResolutionCache = {};
+    this.#overloadCheckCache = {};
+  }
+  registerVariable(name, type) {
+    if (this.variables.has(name)) throw new Error(`Variable already registered: ${name}`);
+    this.variables.set(name, type instanceof TypeDeclaration ? type : this.getType(type));
+    return this;
+  }
+  getFunctionCandidates(receiverType, functionName, argCount) {
+    const candidates = new FunctionCandidates();
+    for (const [, dec] of this.#functionDeclarations) {
+      if (functionName !== dec.name) continue;
+      if (receiverType === null && dec.receiverType) continue;
+      if (receiverType && dec.receiverType === null) continue;
+      candidates.exists = true;
+      if (dec.macro) candidates.hasMacro = true;
+      if (receiverType && !receiverType.matches(dec.receiverType)) continue;
+      if (dec.argTypes.length !== argCount) continue;
+      candidates.add(dec);
+    }
+    return candidates;
+  }
+  getType(typename) {
+    return this.#parseTypeString(typename, true);
+  }
+  getDynType(type) {
+    return this.#dynTypes.get(type) || this.#dynTypes.set(type, this.#parseTypeString(`dyn<${type}>`, true)).get(type);
+  }
+  assertType(typename, type, signature) {
+    try {
+      return this.#parseTypeString(typename, true);
+    } catch (e) {
+      e.message = `Invalid ${type} '${e.unknownType || typename}' in '${signature}'`;
+      throw e;
+    }
+  }
+  getFunctionType(typename) {
+    if (typename === "ast") return astType;
+    return this.#parseTypeString(typename, true);
+  }
+  registerType(typename, _d, withoutDynRegistration) {
+    const decl = {
+      name: typename,
+      type: this.#parseTypeString(typename, false),
+      ctor: typeof _d === "function" ? _d : _d?.ctor,
+      fields: this.#normalizeFields(typename, _d?.fields)
+    };
+    if (!withoutDynRegistration) {
+      if (this.objectTypes.has(typename)) throw new Error(`Type already registered: ${typename}`);
+      if (typeof decl.ctor !== "function") {
+        throw new Error(`Constructor function missing for type '${typename}'`);
+      }
+    }
+    this.objectTypes.set(typename, decl);
+    this.objectTypesByConstructor.set(decl.ctor, decl);
+    if (withoutDynRegistration) return;
+    const type = new Type2(typename);
+    this.objectTypeInstances.set(typename, type);
+    this.registerFunctionOverload(`type(${typename}): type`, () => type);
+  }
+  /** @returns {TypeDeclaration} */
+  #parseTypeString(typeStr, requireKnownTypes = false) {
+    const existing = this.#typeDeclarations.get(typeStr);
+    if (existing) return existing;
+    const dynMatch = typeStr.match(/^dyn<(.+)>$/);
+    if (dynMatch) {
+      const type = this.#parseTypeString(dynMatch[1].trim(), requireKnownTypes);
+      return this.#createDeclaration(_createDynType, `dyn<${type}>`, type);
+    }
+    const listMatch = typeStr.match(/^list<(.+)>$/);
+    if (listMatch) {
+      const vType = this.#parseTypeString(listMatch[1].trim(), requireKnownTypes);
+      return this.#createDeclaration(_createListType, `list<${vType}>`, vType);
+    }
+    const mapMatch = typeStr.match(/^map<(.+)>$/);
+    if (mapMatch) {
+      const parts = splitByComma(mapMatch[1]);
+      if (parts.length !== 2) throw new Error(`Invalid map type: ${typeStr}`);
+      const kType = this.#parseTypeString(parts[0].trim(), requireKnownTypes);
+      const vType = this.#parseTypeString(parts[1].trim(), requireKnownTypes);
+      return this.#createDeclaration(_createMapType, `map<${kType}, ${vType}>`, kType, vType);
+    }
+    if (requireKnownTypes) {
+      const err = new Error(`Unknown type: ${typeStr}`);
+      err.unknownType = typeStr;
+      throw err;
+    }
+    return this.#createDeclaration(_createMessageType, typeStr, typeStr);
+  }
+  #createDeclaration(creator, key, ...args) {
+    return this.#typeDeclarations.get(key) || this.#typeDeclarations.set(key, creator(...args)).get(key);
+  }
+  #findBinaryOverloads(operator, leftType, rightType) {
+    const nonexactMatches = [];
+    for (const [, decl] of this.#operatorDeclarations) {
+      if (decl.operator !== operator) continue;
+      if (this.#exactMatch(decl, leftType, rightType)) return [decl];
+      if (this.#matchesOverload(decl, leftType, rightType)) nonexactMatches.push(decl);
+    }
+    if (nonexactMatches.length === 0 && (operator === "==" || operator === "!=") && this.#hasDynOperand(leftType, rightType)) {
+      const handler = operator === "==" ? (a, b) => a === b : (a, b) => a !== b;
+      return [{ handler, returnType: this.getType("bool") }];
+    }
+    return nonexactMatches;
+  }
+  findUnaryOverload(op, left) {
+    const cached = this.#overloadResolutionCache[op]?.get(left);
+    if (cached !== void 0) return cached;
+    let value = false;
+    for (const [, decl] of this.#operatorDeclarations) {
+      if (decl.operator !== op || decl.leftType !== left) continue;
+      value = decl;
+      break;
+    }
+    return (this.#overloadResolutionCache[op] ??= /* @__PURE__ */ new Map()).set(left, value).get(left);
+  }
+  findBinaryOverload(op, left, right) {
+    return this.#overloadResolutionCache[op]?.get(left)?.get(right) ?? this.#cacheOverloadResult(
+      this.#overloadResolutionCache,
+      op,
+      left,
+      right,
+      this.#findBinaryOverloadUncached(op, left, right)
+    );
+  }
+  checkBinaryOverload(op, left, right) {
+    return this.#overloadCheckCache[op]?.get(left)?.get(right) ?? this.#cacheOverloadResult(
+      this.#overloadCheckCache,
+      op,
+      left,
+      right,
+      this.#checkBinaryOverloadUncached(op, left, right)
+    );
+  }
+  #findBinaryOverloadUncached(operator, leftType, rightType) {
+    const ops = this.#findBinaryOverloads(operator, leftType, rightType);
+    if (ops.length === 0) return false;
+    if (ops.length === 1) return ops[0];
+    throw new Error(`Operator overload '${ops[0].signature}' overlaps with '${ops[1].signature}'.`);
+  }
+  #checkBinaryOverloadUncached(op, left, right) {
+    const ops = this.#findBinaryOverloads(op, left, right);
+    if (ops.length === 0) return false;
+    const firstType = ops[0].returnType;
+    if (ops.every((d) => d.returnType === firstType)) return firstType;
+    if ((firstType.kind === "list" || firstType.kind === "map") && ops.every((d) => d.returnType.kind === firstType.kind)) {
+      return firstType.kind === "list" ? celTypes.list : celTypes.map;
+    }
+    return celTypes.dyn;
+  }
+  #cacheOverloadResult(cache, op, left, right, result) {
+    const opMap = cache[op] ??= /* @__PURE__ */ new Map();
+    const leftMap = opMap.get(left) || opMap.set(left, /* @__PURE__ */ new Map()).get(left);
+    leftMap.set(right, result);
+    return result;
+  }
+  #exactMatch(decl, actualLeft, actualRight) {
+    return actualLeft === decl.leftType && actualRight === decl.rightType || actualLeft.name === `dyn<${decl.leftType}>` && actualRight === decl.rightType || actualLeft === decl.leftType && actualRight.name === `dyn<${decl.rightType}>` || actualLeft.name === `dyn<${decl.leftType}>` && actualRight.name === `dyn<${decl.rightType}>`;
+  }
+  #matchesOverload(decl, actualLeft, actualRight) {
+    if (!this.#isAssignable(actualLeft, decl.leftType)) return false;
+    if (!this.#isAssignable(actualRight, decl.rightType)) return false;
+    return this.#validateParameters(decl.operator, actualLeft, actualRight);
+  }
+  #isAssignable(actual, declared) {
+    if (actual === declared) return true;
+    if (actual.kind === "dyn") {
+      return actual.valueType ? this.#isAssignable(actual.valueType, declared) : true;
+    }
+    if (actual.type !== declared.type) return false;
+    if (declared === celTypes.list) return true;
+    if (declared === celTypes.map) return true;
+    return false;
+  }
+  #validateParameters(operator, leftType, rightType) {
+    if (operator === "in") {
+      if (leftType.kind === "dyn") return true;
+      if (rightType.kind === "list") return rightType.valueType.matchesBoth(leftType);
+      if (rightType.kind === "map") return rightType.keyType.matchesBoth(leftType);
+      return true;
+    }
+    if (operator === "+" || operator === "==" || operator === "!=") {
+      if (leftType.kind === "list" && rightType.kind === "list") {
+        return leftType.matchesBoth(rightType);
+      }
+      if (leftType.kind === "map" && rightType.kind === "map") {
+        return leftType.matchesBoth(rightType);
+      }
+    }
+    return true;
+  }
+  #hasDynOperand(leftType, rightType) {
+    if (leftType.kind === "dyn" || rightType.kind === "dyn") return true;
+    return false;
+  }
+  #toCelFieldDeclaration(typename, fields, k, requireKnownTypes = false) {
+    try {
+      const field = typeof fields[k] === "string" ? { type: fields[k] } : { ...fields[k] };
+      if (typeof field?.type !== "string") throw new Error(`unsupported declaration`);
+      return this.#parseTypeString(field.type, requireKnownTypes);
+    } catch (e) {
+      e.message = `Field '${k}' in type '${typename}' has unsupported declaration: ${JSON.stringify(fields[k])}`;
+      throw e;
+    }
+  }
+  #normalizeFields(typename, fields) {
+    if (!fields) return;
+    const all = {};
+    for (const k of Object.keys(fields)) all[k] = this.#toCelFieldDeclaration(typename, fields, k);
+    return all;
+  }
+  clone(opts = {}) {
+    return new _Registry({
+      objectTypes: this.objectTypes,
+      objectTypesByConstructor: this.objectTypesByConstructor,
+      objectTypeInstances: this.objectTypeInstances,
+      typeDeclarations: this.#typeDeclarations,
+      operatorDeclarations: this.#operatorDeclarations,
+      functionDeclarations: this.#functionDeclarations,
+      variables: this.variables,
+      unlistedVariablesAreDyn: opts.unlistedVariablesAreDyn
+    });
+  }
+  /** @param {string} signature */
+  #parseFunctionDeclaration(signature, handler, typeCheck) {
+    const match = signature.match(/^(?:([a-zA-Z0-9.]+)\.)?(\w+)\((.*?)\):\s*(.+)$/);
+    if (!match) throw new Error(`Invalid signature: ${signature}`);
+    const [, receiverType, name, argsStr, _returnType] = match;
+    try {
+      return new FunctionDeclaration({
+        name,
+        receiverType: receiverType ? this.getType(receiverType.trim()) : null,
+        returnType: this.getType(_returnType.trim() || "dyn"),
+        argTypes: splitByComma(argsStr).map((s) => this.getFunctionType(s.trim())),
+        handler,
+        typeCheck
+      });
+    } catch (e) {
+      throw new Error(`Invalid function declaration: ${signature}`);
+    }
+  }
+  /**
+   * @param {FunctionDeclaration} a
+   * @param {FunctionDeclaration} b
+   */
+  #functionSignatureOverlaps(a, b) {
+    if (a.name !== b.name) return false;
+    if (a.argTypes.length !== b.argTypes.length) return false;
+    if ((a.receiverType || b.receiverType) && (!a.receiverType || !b.receiverType)) return false;
+    const isDifferentReceiver = a.receiverType !== b.receiverType && a.receiverType !== dynType && b.receiverType !== dynType;
+    return !isDifferentReceiver && (b.macro || a.macro || b.argTypes.every((type1, i) => {
+      const type2 = a.argTypes[i];
+      if (type1 === type2) return true;
+      if (type1 === astType || type2 === astType) return true;
+      if (type1 === dynType || type2 === dynType) return true;
+      return false;
+    }));
+  }
+  /** @param {FunctionDeclaration} newDec */
+  #checkOverlappingSignatures(newDec) {
+    for (const [, decl] of this.#functionDeclarations) {
+      if (!this.#functionSignatureOverlaps(decl, newDec)) continue;
+      throw new Error(
+        `Function signature '${newDec.signature}' overlaps with existing overload '${decl.signature}'.`
+      );
+    }
+  }
+  registerFunctionOverload(s, handlerOrOptions) {
+    const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrOptions.handler;
+    const options = typeof handlerOrOptions === "function" ? {} : handlerOrOptions;
+    const dec = this.#parseFunctionDeclaration(s, handler, options.typeCheck);
+    this.#checkOverlappingSignatures(dec);
+    this.#functionDeclarations.set(dec.signature, dec);
+  }
+  registerOperatorOverload(string, handler) {
+    const unaryParts = string.match(/^([-!])([\w.<>]+)(?::\s*([\w.<>]+))?$/);
+    if (unaryParts) {
+      const [, op2, operandType, returnType2] = unaryParts;
+      return this.unaryOverload(op2, operandType, handler, returnType2);
+    }
+    const parts = string.match(
+      /^([\w.<>]+) ([-+*%/]|==|!=|<|<=|>|>=|in) ([\w.<>]+)(?::\s*([\w.<>]+))?$/
+    );
+    if (!parts) throw new Error(`Operator overload invalid: ${string}`);
+    const [, leftType, op, rightType, returnType] = parts;
+    return this.binaryOverload(leftType, op, rightType, handler, returnType);
+  }
+  unaryOverload(op, typeStr, handler, returnTypeStr) {
+    const leftType = this.assertType(typeStr, "type", `${op}${typeStr}`);
+    const returnType = this.assertType(
+      returnTypeStr || typeStr,
+      "return type",
+      `${op}${typeStr}: ${returnTypeStr || typeStr}`
+    );
+    const decl = new OperatorDeclaration({ operator: `${op}_`, leftType, returnType, handler });
+    if (this.#hasOverload(decl)) {
+      throw new Error(`Operator overload already registered: ${op}${typeStr}`);
+    }
+    this.#operatorDeclarations.set(decl.signature, decl);
+    this.#invalidateOverloadsCache();
+  }
+  #hasOverload(decl) {
+    for (const [, other] of this.#operatorDeclarations) if (decl.equals(other)) return true;
+    return false;
+  }
+  binaryOverload(leftTypeStr, op, rightTypeStr, handler, returnTypeStr) {
+    returnTypeStr ??= isRelational(op) ? "bool" : leftTypeStr;
+    const sig = `${leftTypeStr} ${op} ${rightTypeStr}: ${returnTypeStr}`;
+    const leftType = this.assertType(leftTypeStr, "left type", sig);
+    const rightType = this.assertType(rightTypeStr, "right type", sig);
+    const returnType = this.assertType(returnTypeStr, "return type", sig);
+    if (isRelational(op) && returnType.type !== "bool") {
+      throw new Error(`Comparison operator '${op}' must return 'bool', got '${returnType.type}'`);
+    }
+    const dec = new OperatorDeclaration({ operator: op, leftType, rightType, returnType, handler });
+    if (this.#hasOverload(dec)) {
+      throw new Error(`Operator overload already registered: ${dec.signature}`);
+    }
+    if (op === "==") {
+      const declarations = [
+        new OperatorDeclaration({
+          operator: "!=",
+          leftType,
+          rightType,
+          handler(a, b, ast, ev) {
+            return !handler(a, b, ast, ev);
+          },
+          returnType
+        })
+      ];
+      if (leftType !== rightType) {
+        declarations.push(
+          new OperatorDeclaration({
+            operator: "==",
+            leftType: rightType,
+            rightType: leftType,
+            handler(a, b, ast, ev) {
+              return handler(b, a, ast, ev);
+            },
+            returnType
+          }),
+          new OperatorDeclaration({
+            operator: "!=",
+            leftType: rightType,
+            rightType: leftType,
+            handler(a, b, ast, ev) {
+              return !handler(b, a, ast, ev);
+            },
+            returnType
+          })
+        );
+      }
+      for (const decl of declarations) {
+        if (!this.#hasOverload(decl)) continue;
+        throw new Error(`Operator overload already registered: ${decl.signature}`);
+      }
+      for (const decl of declarations) this.#operatorDeclarations.set(decl.signature, decl);
+    }
+    this.#operatorDeclarations.set(dec.signature, dec);
+    this.#invalidateOverloadsCache();
+  }
+};
+function isRelational(op) {
+  return op === "<" || op === "<=" || op === ">" || op === ">=" || op === "==" || op === "!=" || op === "in";
+}
+function createRegistry(opts) {
+  return new Registry(opts);
+}
+
+// ../../node_modules/@marcbachmann/cel-js/lib/overloads.js
+function registerOverloads(registry) {
+  const unaryOverload2 = registry.unaryOverload.bind(registry);
+  const binaryOverload2 = registry.binaryOverload.bind(registry);
+  function verifyInteger(v, ast) {
+    if (v <= 9223372036854775807n && v >= -9223372036854775808n) return v;
+    throw new EvaluationError(`integer overflow: ${v}`, ast);
+  }
+  unaryOverload2("!", "bool", (a) => !a);
+  unaryOverload2("-", "int", (a) => -a);
+  binaryOverload2("int", "*", "int", (a, b, ast) => verifyInteger(a * b, ast));
+  binaryOverload2("int", "+", "int", (a, b, ast) => verifyInteger(a + b, ast));
+  binaryOverload2("int", "-", "int", (a, b, ast) => verifyInteger(a - b, ast));
+  binaryOverload2("int", "/", "int", (a, b, ast) => {
+    if (b === 0n) throw new EvaluationError("division by zero", ast);
+    return a / b;
+  });
+  binaryOverload2("int", "%", "int", (a, b, ast) => {
+    if (b === 0n) throw new EvaluationError("modulo by zero", ast);
+    return a % b;
+  });
+  unaryOverload2("-", "double", (a) => -a);
+  binaryOverload2("double", "*", "double", (a, b) => a * b);
+  binaryOverload2("double", "+", "double", (a, b) => a + b);
+  binaryOverload2("double", "-", "double", (a, b) => a - b);
+  binaryOverload2("double", "/", "double", (a, b, ast) => {
+    if (b === 0) throw new EvaluationError("division by zero", ast);
+    return a / b;
+  });
+  binaryOverload2("string", "+", "string", (a, b) => a + b);
+  binaryOverload2("list", "+", "list", (a, b) => [...a, ...b]);
+  binaryOverload2("bytes", "+", "bytes", (a, b) => {
+    const result = new Uint8Array(a.length + b.length);
+    result.set(a, 0);
+    result.set(b, a.length);
+    return result;
+  });
+  const GPD = "google.protobuf.Duration";
+  binaryOverload2(GPD, "+", GPD, (a, b) => a.addDuration(b));
+  binaryOverload2(GPD, "-", GPD, (a, b) => a.subtractDuration(b));
+  binaryOverload2(GPD, "==", GPD, (a, b) => a.seconds === b.seconds && a.nanos === b.nanos);
+  const GPT = "google.protobuf.Timestamp";
+  binaryOverload2(GPT, "==", GPT, (a, b) => a.getTime() === b.getTime());
+  binaryOverload2(GPT, "-", GPD, (a, b) => b.subtractTimestamp(a));
+  binaryOverload2(GPT, "+", GPD, (a, b) => b.extendTimestamp(a));
+  binaryOverload2(GPD, "+", GPT, (a, b) => a.extendTimestamp(b));
+  function listIncludes(value, list, ast, ev) {
+    if (list instanceof Set && list.has(value)) return true;
+    for (const v of list) if (isEqual2(value, v, ev)) return true;
+    return false;
+  }
+  function listStrictIncludes(value, list) {
+    return Array.isArray(list) ? list.includes(value) : list.has(value);
+  }
+  for (const t of ["string", "bool", "null", "type"])
+    binaryOverload2(t, "in", `list`, listStrictIncludes);
+  for (const t of ["int", "double", "list", "map"]) binaryOverload2(t, "in", `list`, listIncludes);
+  for (const t of ["string", "int", "double", "bool", "null"]) {
+    binaryOverload2(t, "in", "map", (a, b) => {
+      if (b instanceof Map) return b.get(a) !== void 0;
+      return Object.hasOwn(b, a) ? b[a] !== void 0 : false;
+    });
+  }
+  for (const t of ["type", "null", "bool", "string", "int", "uint", "double"]) {
+    binaryOverload2(t, "==", t, (a, b) => a === b);
+  }
+  binaryOverload2("int", `==`, `dyn<double>`, (a, b) => a == b);
+  binaryOverload2("int", `==`, `dyn<uint>`, (a, b) => a == b.valueOf());
+  binaryOverload2("uint", `==`, `dyn<double>`, (a, b) => a.valueOf() == b);
+  binaryOverload2("uint", `==`, `dyn<int>`, (a, b) => a.valueOf() == b);
+  binaryOverload2("double", `==`, `dyn<int>`, (a, b) => a == b);
+  binaryOverload2("double", `==`, `dyn<uint>`, (a, b) => a == b.valueOf());
+  binaryOverload2("bytes", `==`, "bytes", (a, b) => {
+    let i = a.length;
+    if (i !== b.length) return false;
+    while (i--) if (a[i] !== b[i]) return false;
+    return true;
+  });
+  binaryOverload2("list", `==`, "list", (a, b, ast, ev) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      const length = a.length;
+      if (length !== b.length) return false;
+      for (let i = 0; i < length; i++) {
+        if (!isEqual2(a[i], b[i], ev)) return false;
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) return false;
+      for (const value of a) if (!b.has(value)) return false;
+      return true;
+    }
+    const arr = a instanceof Set ? b : a;
+    const set4 = a instanceof Set ? a : b;
+    if (!Array.isArray(arr)) return false;
+    if (arr.length !== set4?.size) return false;
+    for (let i = 0; i < arr.length; i++) if (!set4.has(arr[i])) return false;
+    return true;
+  });
+  binaryOverload2("map", `==`, "map", (a, b, ast, ev) => {
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) return false;
+      for (const [key, value] of a)
+        if (!(b.has(key) && isEqual2(value, b.get(key), ev))) return false;
+      return true;
+    }
+    if (a instanceof Map || b instanceof Map) {
+      const obj = a instanceof Map ? b : a;
+      const map3 = a instanceof Map ? a : b;
+      const keysObj = Object.keys(obj);
+      if (map3.size !== keysObj.length) return false;
+      for (const [key, value] of map3) {
+        if (!(key in obj && isEqual2(value, obj[key], ev))) return false;
+      }
+      return true;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i];
+      if (!(key in b && isEqual2(a[key], b[key], ev))) return false;
+    }
+    return true;
+  });
+  binaryOverload2("uint", "+", "uint", (a, b) => new UnsignedInt(a.valueOf() + b.valueOf()));
+  binaryOverload2("uint", "-", "uint", (a, b) => new UnsignedInt(a.valueOf() - b.valueOf()));
+  binaryOverload2("uint", "*", "uint", (a, b) => new UnsignedInt(a.valueOf() * b.valueOf()));
+  binaryOverload2("uint", "/", "uint", (a, b, ast) => {
+    if (b.valueOf() === 0n) throw new EvaluationError("division by zero", ast);
+    return new UnsignedInt(a.valueOf() / b.valueOf());
+  });
+  binaryOverload2("uint", "%", "uint", (a, b, ast) => {
+    if (b.valueOf() === 0n) throw new EvaluationError("modulo by zero", ast);
+    return new UnsignedInt(a.valueOf() % b.valueOf());
+  });
+  for (const [left, right] of [
+    ["int", "int"],
+    ["uint", "uint"],
+    ["double", "double"],
+    ["string", "string"],
+    ["google.protobuf.Timestamp", "google.protobuf.Timestamp"],
+    ["google.protobuf.Duration", "google.protobuf.Duration"],
+    ["int", "uint"],
+    ["int", "double"],
+    ["double", "int"],
+    ["double", "uint"],
+    ["uint", "int"],
+    ["uint", "double"]
+  ]) {
+    binaryOverload2(left, "<", right, (a, b) => a < b);
+    binaryOverload2(left, "<=", right, (a, b) => a <= b);
+    binaryOverload2(left, ">", right, (a, b) => a > b);
+    binaryOverload2(left, ">=", right, (a, b) => a >= b);
+  }
+}
+function isEqual2(a, b, ev) {
+  if (a === b) return true;
+  switch (typeof a) {
+    case "string":
+      return false;
+    case "bigint":
+      if (typeof b === "number") return a == b;
+      return false;
+    case "number":
+      if (typeof b === "bigint") return a == b;
+      return false;
+    case "boolean":
+      return false;
+    case "object":
+      if (typeof b !== "object" || a === null || b === null) return false;
+      const leftType = ev.objectTypesByConstructor.get(a.constructor)?.type;
+      const rightType = ev.objectTypesByConstructor.get(b.constructor)?.type;
+      if (!leftType || leftType !== rightType) return false;
+      const handler = ev.registry.findBinaryOverload("==", leftType, rightType)?.handler;
+      if (!handler) return false;
+      return handler(a, b, null, ev);
+  }
+  throw new EvaluationError(`Cannot compare values of type ${typeof a}`);
+}
+
+// ../../node_modules/@marcbachmann/cel-js/lib/type-checker.js
+var TypeChecker = class {
+  constructor({ ctx, objectTypes, objectTypesByConstructor, registry }) {
+    this.ctx = ctx;
+    this.objectTypes = objectTypes;
+    this.objectTypesByConstructor = objectTypesByConstructor;
+    this.registry = registry;
+  }
+  /**
+   * Get a TypeDeclaration instance for a type name
+   * @param {string} typeName - The type name (e.g., 'string', 'int', 'dyn')
+   * @returns {TypeDeclaration} The type declaration instance
+   */
+  getType(typeName) {
+    return this.registry.getType(typeName);
+  }
+  createOverlay(varName, varType) {
+    return new this.constructor({
+      ctx: this.ctx.createOverlay(varName, varType),
+      objectTypes: this.objectTypes,
+      objectTypesByConstructor: this.objectTypesByConstructor,
+      registry: this.registry
+    });
+  }
+  /**
+   * Check an expression and return its inferred type
+   * @param {Array|any} ast - The AST node to check
+   * @returns {Object} The inferred type declaration
+   * @throws {TypeError} If type checking fails
+   */
+  check(ast) {
+    if (ast.checkedType) return ast.checkedType;
+    switch (ast[0]) {
+      case "value":
+        return ast.checkedType ??= this.inferLiteralType(ast[1]);
+      case "id":
+        return ast.checkedType ??= this.checkVariable(ast);
+      case ".":
+      case "[]":
+        return ast.checkedType ??= this.checkAccess(ast);
+      case "call":
+        return ast.checkedType ??= this.checkCall(ast);
+      case "rcall":
+        return ast.checkedType ??= this.checkReceiverCall(ast);
+      case "list":
+        return ast.checkedType ??= this.checkList(ast);
+      case "map":
+        return ast.checkedType ??= this.checkMap(ast);
+      case "?:":
+        return ast.checkedType ??= this.checkTernary(ast);
+      case "||":
+      case "&&":
+        return ast.checkedType ??= this.checkLogicalOp(ast);
+      case "!_":
+      case "-_":
+        return ast.checkedType ??= this.checkUnaryOperator(ast);
+      case "==":
+      case "!=":
+      case "<":
+      case "<=":
+      case ">":
+      case ">=":
+      case "+":
+      case "-":
+      case "*":
+      case "/":
+      case "%":
+      case "in":
+        return ast.checkedType ??= this.checkBinaryOperator(ast);
+      default:
+        throw new TypeError2(`Unknown operation: ${ast[0]}`, ast);
+    }
+  }
+  inferLiteralType(value) {
+    switch (typeof value) {
+      case "string":
+        return this.getType("string");
+      case "bigint":
+        return this.getType("int");
+      case "number":
+        return this.getType("double");
+      case "boolean":
+        return this.getType("bool");
+      case "object":
+        if (value === null) return this.getType("null");
+        const type = this.objectTypesByConstructor.get(value.constructor)?.type;
+        if (type) return type;
+        throw new TypeError2(`Unsupported type: ${value.constructor?.name || typeof value}`);
+      default:
+        throw new TypeError2(`Unsupported type: ${typeof value}`);
+    }
+  }
+  checkVariable(ast) {
+    const varName = ast[1];
+    const varType = this.ctx.getType(varName);
+    if (varType !== void 0) return varType;
+    throw new TypeError2(`Unknown variable: ${varName}`, ast);
+  }
+  checkAccess(ast) {
+    const leftType = this.check(ast[1]);
+    if (leftType.kind === "dyn") return leftType;
+    const indexType = ast[0] === "[]" ? this.check(ast[2]) : this.getType("string");
+    const indexTypeName = indexType.type;
+    if (leftType.kind === "list") {
+      if (indexTypeName !== "int" && indexTypeName !== "dyn") {
+        throw new TypeError2(`List index must be int, got '${indexTypeName}'`, ast);
+      }
+      return leftType.valueType;
+    }
+    if (leftType.kind === "map") return leftType.valueType;
+    const customType = this.objectTypes.get(leftType.name);
+    if (customType) {
+      if (!(indexTypeName === "string" || indexTypeName === "dyn")) {
+        throw new TypeError2(
+          `Cannot index type '${leftType.name}' with type '${indexTypeName}'`,
+          ast
+        );
+      }
+      if (customType.fields) {
+        const keyName2 = ast[0] === "." ? ast[2] : void 0;
+        if (keyName2) {
+          const fieldType = customType.fields[keyName2];
+          if (fieldType) return fieldType;
+          throw new TypeError2(`No such key: ${keyName2}`, ast);
+        }
+      }
+      return this.getType("dyn");
+    }
+    throw new TypeError2(`Cannot index type '${leftType}'`, ast);
+  }
+  checkCall(ast) {
+    const functionName = ast[1];
+    const args = ast[2];
+    const byReceiver = (ast.functionCandidates ??= this.registry.getFunctionCandidates(
+      null,
+      functionName,
+      args.length
+    )).filterByReceiverType(null);
+    if (!byReceiver.exists) throw new TypeError2(`Function not found: '${functionName}'`, ast);
+    if (byReceiver.hasMacro) return this.#returnMacroType(null, byReceiver, args, ast);
+    const argTypes = args.map(this.check, this);
+    const decl = byReceiver.findMatch(argTypes);
+    if (!decl) {
+      throw new TypeError2(
+        `found no matching overload for '${functionName}(${argTypes.join(", ")})'`,
+        ast
+      );
+    }
+    return decl.returnType;
+  }
+  #returnMacroType(receiverType, byReceiver, args, ast) {
+    const candidate = byReceiver.functions[0];
+    if (candidate.typeCheck) return candidate.typeCheck(this, receiverType, args, ast);
+    return candidate.returnType;
+  }
+  checkReceiverCall(ast) {
+    const methodName = ast[1];
+    const args = ast[3];
+    const receiverType = this.check(ast[2]);
+    const functionCandidates = ast.functionCandidates ??= this.registry.getFunctionCandidates(
+      receiverType,
+      methodName,
+      args.length
+    );
+    if (!functionCandidates.exists) {
+      throw new TypeError2(
+        `Function not found: '${methodName}' for value of type '${receiverType}'`,
+        ast
+      );
     }
-    return a.every((path2, index) => {
-      const other = b[index];
-      if (typeof path2 === "object" && "id" in path2 && typeof other === "object" && "id" in other) {
-        return path2.id === other.id;
+    if (receiverType.kind === "dyn") return functionCandidates.returnType || receiverType;
+    const byReceiver = functionCandidates.filterByReceiverType(receiverType);
+    if (byReceiver.hasMacro) return this.#returnMacroType(receiverType, byReceiver, args, ast);
+    const argTypes = args.map(this.check, this);
+    const decl = byReceiver.findMatch(argTypes);
+    if (!decl) {
+      throw new TypeError2(
+        `found no matching overload for '${receiverType.type}.${methodName}(${argTypes.join(
+          ", "
+        )})'`,
+        ast
+      );
+    }
+    return decl.returnType;
+  }
+  checkList(ast) {
+    const elements = ast[1];
+    if (elements.length === 0) return this.getType(`list`);
+    const firstType = this.check(elements[0]);
+    const allSameType = elements.every((e) => firstType === this.check(e));
+    if (allSameType) return this.getType(`list<${firstType}>`);
+    return this.getType(`list`);
+  }
+  checkMap(ast) {
+    const entries = ast[1];
+    if (entries.length === 0) return this.getType("map");
+    const firstKeyType = this.check(entries[0][0]);
+    const firstValueType = this.check(entries[0][1]);
+    let allSameKeyType = true;
+    let allSameValueType = true;
+    for (let i = 1; i < entries.length; i++) {
+      const [key, value] = entries[i];
+      if (firstKeyType !== this.check(key)) allSameKeyType = false;
+      if (firstValueType !== this.check(value)) allSameValueType = false;
+    }
+    const inferredKeyType = allSameKeyType ? firstKeyType : "dyn";
+    const inferredValueType = allSameValueType ? firstValueType : "dyn";
+    return this.getType(`map<${inferredKeyType}, ${inferredValueType}>`);
+  }
+  checkTernary(ast) {
+    const condType = this.check(ast[1]);
+    if (!condType.isDynOrBool()) {
+      throw new TypeError2(`Ternary condition must be bool, got '${condType}'`, ast);
+    }
+    const trueType = this.check(ast[2]);
+    const falseType = this.check(ast[3]);
+    if (trueType === falseType) return trueType;
+    if (trueType.name === "dyn") return trueType;
+    if (falseType.name === "dyn") return falseType;
+    throw new TypeError2(
+      `Ternary branches must have the same type, got '${trueType}' and '${falseType}'`,
+      ast
+    );
+  }
+  checkLogicalOp(ast) {
+    const leftType = this.check(ast[1]);
+    const rightType = this.check(ast[2]);
+    if (!leftType.isDynOrBool()) {
+      throw new TypeError2(`Logical operator requires bool operands, got '${leftType}'`, ast);
+    }
+    if (!rightType.isDynOrBool()) {
+      throw new TypeError2(`Logical operator requires bool operands, got '${rightType}'`, ast);
+    }
+    return this.getType("bool");
+  }
+  checkUnaryOperator(ast) {
+    const op = ast[0];
+    const operandType = this.check(ast[1]);
+    if (operandType.kind === "dyn") return op === "!_" ? this.getType("bool") : operandType;
+    const overload = this.registry.findUnaryOverload(op, operandType);
+    if (overload) return overload.returnType;
+    throw new TypeError2(`no such overload: ${op[0]}${operandType.type}`, ast);
+  }
+  checkBinaryOperator(ast) {
+    const op = ast[0];
+    const leftType = this.check(ast[1]);
+    const rightType = this.check(ast[2]);
+    const type = this.registry.checkBinaryOverload(op, leftType, rightType);
+    if (type) return type;
+    throw new TypeError2(`no such overload: ${leftType} ${op} ${rightType}`, ast);
+  }
+};
+
+// ../../node_modules/@marcbachmann/cel-js/lib/evaluator.js
+var globalRegistry = createRegistry();
+registerOverloads(globalRegistry);
+registerFunctions(globalRegistry);
+var handlers = new Map(
+  Object.entries({
+    value(ast) {
+      return ast[1];
+    },
+    id(ast, ev) {
+      return ev.value(ast[1], ast).value;
+    },
+    "||"(ast, ev) {
+      try {
+        const left = ev.eval(ast[1]);
+        if (left === true) return true;
+        if (left !== false) {
+          throw new EvaluationError("Left operand of || is not a boolean", ast[1]);
+        }
+      } catch (err) {
+        if (err.message.includes("Unknown variable")) throw err;
+        if (err.message.includes("is not a boolean")) throw err;
+        const right2 = ev.eval(ast[2]);
+        if (right2 === true) return true;
+        if (right2 === false) throw err;
+        throw new EvaluationError("Right operand of || is not a boolean", ast[2]);
+      }
+      const right = ev.eval(ast[2]);
+      if (typeof right === "boolean") return right;
+      throw new EvaluationError("Right operand of || is not a boolean", ast[2]);
+    },
+    "&&"(ast, ev) {
+      try {
+        const left = ev.eval(ast[1]);
+        if (left === false) return false;
+        if (left !== true) {
+          throw new EvaluationError("Left operand of && is not a boolean", ast[1]);
+        }
+      } catch (err) {
+        if (err.message.includes("Unknown variable")) throw err;
+        if (err.message.includes("is not a boolean")) throw err;
+        const right2 = ev.eval(ast[2]);
+        if (right2 === false) return false;
+        if (right2 === true) throw err;
+        throw new EvaluationError("Right operand of && is not a boolean", ast[2]);
+      }
+      const right = ev.eval(ast[2]);
+      if (typeof right === "boolean") return right;
+      throw new EvaluationError("Right operand of && is not a boolean", ast[2]);
+    },
+    "."(ast, ev) {
+      const left = ev.eval(ast[1]);
+      return ev.debugType(left).field(left, ast[2], ast, ev);
+    },
+    "[]"(ast, ev) {
+      const left = ev.eval(ast[1]);
+      return ev.debugType(left).field(left, ev.eval(ast[2]), ast, ev);
+    },
+    rcall(ast, ev) {
+      const functionName = ast[1];
+      const receiver = ev.eval(ast[2]);
+      const checkedType = ast[2].checkedType || ev.celTypes.dyn;
+      const argAst = ast[3];
+      const argLen = argAst.length;
+      const functionCandidates = ast.functionCandidates ??= ev.registry.getFunctionCandidates(
+        checkedType,
+        functionName,
+        argLen
+      );
+      const receiverType = checkedType.kind !== "dyn" ? checkedType : ev.debugType(receiver);
+      if (!functionCandidates.exists) {
+        throw new EvaluationError(
+          `Function not found: '${functionName}' for value of type '${receiverType}'`,
+          ast
+        );
       }
-      return path2 === other;
+      const byReceiver = functionCandidates.filterByReceiverType(receiverType);
+      let args;
+      let argTypes;
+      if (byReceiver.hasMacro) {
+        args = argAst;
+        argTypes = ast.argMacroTypes ??= new Array(argLen).fill(ev.registry.getFunctionType("ast"));
+      } else {
+        args = ast.argValues ??= new Array(argLen);
+        argTypes = ast.argTypes ??= new Array(argLen);
+        for (let i = 0; i < argLen; i++) {
+          const arg = argAst[i];
+          args[i] = ev.eval(arg);
+          argTypes[i] = getFunctionArgType(arg.checkedType, ev.debugType(args[i]), ev);
+        }
+      }
+      const decl = byReceiver.findMatch(argTypes);
+      if (!decl) {
+        throw new EvaluationError(
+          `found no matching overload for '${receiverType.type}.${functionName}(${argTypes.join(
+            ", "
+          )})'`,
+          ast
+        );
+      }
+      try {
+        if (decl.macro) return decl.handler.call(ev, receiver, ast);
+        return decl.handler.call(ev, receiver, ...args);
+      } catch (err) {
+        if (err instanceof EvaluationError) throw err.withAst(ast);
+        throw err;
+      }
+    },
+    call(ast, ev) {
+      const functionName = ast[1];
+      const argAst = ast[2];
+      const argLen = argAst.length;
+      const functionCandidates = ast.functionCandidates ??= ev.registry.getFunctionCandidates(
+        null,
+        functionName,
+        argLen
+      );
+      if (functionCandidates.exists === false) {
+        throw new EvaluationError(`Function not found: '${functionName}'`, ast);
+      }
+      const byReceiver = functionCandidates.filterByReceiverType(null);
+      let args;
+      let argTypes;
+      if (functionCandidates.hasMacro) {
+        args = argAst;
+        argTypes = ast.argMacroTypes ??= new Array(argLen).fill(ev.registry.getFunctionType("ast"));
+      } else {
+        args = ast.argValues ??= new Array(argLen);
+        argTypes = ast.argTypes ??= new Array(argLen);
+        for (let i = 0; i < argLen; i++) {
+          const arg = argAst[i];
+          args[i] = ev.eval(arg);
+          argTypes[i] = getFunctionArgType(arg.checkedType, ev.debugType(args[i]), ev);
+        }
+      }
+      const decl = byReceiver.findMatch(argTypes);
+      if (!decl) {
+        throw new EvaluationError(
+          `found no matching overload for '${functionName}(${argTypes.join(", ")})'`,
+          ast
+        );
+      }
+      try {
+        if (decl.macro) return decl.handler.call(ev, ast);
+        return decl.handler.apply(ev, args);
+      } catch (err) {
+        if (err instanceof EvaluationError) throw err.withAst(ast);
+        throw err;
+      }
+    },
+    list(ast, ev) {
+      const elements = ast[1];
+      const result = new Array(elements.length);
+      for (let i = 0; i < elements.length; i++) result[i] = ev.eval(elements[i]);
+      return result;
+    },
+    map(ast, ev) {
+      const result = {};
+      const props = ast[1];
+      for (let i = 0; i < props.length; i++) {
+        const e = props[i];
+        result[ev.eval(e[0])] = ev.eval(e[1]);
+      }
+      return result;
+    },
+    "?:"(ast, ev) {
+      const condition = ev.eval(ast[1]);
+      if (condition === true) return ev.eval(ast[2]);
+      else if (condition === false) return ev.eval(ast[3]);
+      throw new EvaluationError("Ternary condition must be a boolean");
+    },
+    "!_": unaryOverload,
+    "-_": unaryOverload,
+    "!=": binaryOverload,
+    "==": binaryOverload,
+    in: binaryOverload,
+    "+": binaryOverload,
+    "-": binaryOverload,
+    "*": binaryOverload,
+    "/": binaryOverload,
+    "%": binaryOverload,
+    "<": binaryOverload,
+    "<=": binaryOverload,
+    ">": binaryOverload,
+    ">=": binaryOverload
+  })
+);
+function unaryOverload(ast, ev) {
+  const left = ev.eval(ast[1]);
+  const leftType = ev.debugType(left);
+  const overload = ev.registry.findUnaryOverload(ast[0], leftType);
+  if (overload) return overload.handler(left);
+  throw new EvaluationError(`no such overload: ${ast[0][0]}${leftType}`, ast);
+}
+function binaryOverload(ast, ev) {
+  const left = ev.eval(ast[1]);
+  const right = ev.eval(ast[2]);
+  const leftType = getOperandType(ast[1].checkedType, ev.debugType(left), ev);
+  const rightType = getOperandType(ast[2].checkedType, ev.debugType(right), ev);
+  const overload = ev.registry.findBinaryOverload(ast[0], leftType, rightType);
+  if (overload) return overload.handler(left, right, ast, ev);
+  throw new EvaluationError(`no such overload: ${leftType} ${ast[0]} ${rightType}`, ast);
+}
+function getOperandType(checkedType, runtimeType, ev) {
+  if (checkedType === runtimeType || !checkedType) return runtimeType;
+  if (checkedType.kind === "dyn") return ev.registry.getDynType(runtimeType);
+  if (checkedType.kind !== runtimeType.kind) {
+    throw new EvaluationError(`Type mismatch: expected ${checkedType}, got ${runtimeType}`);
+  }
+  return checkedType;
+}
+function getFunctionArgType(checkedType, runtimeType) {
+  if (checkedType === runtimeType || !checkedType || checkedType.kind === "dyn") return runtimeType;
+  if (checkedType.kind !== runtimeType.kind) {
+    throw new EvaluationError(`Type mismatch: expected ${checkedType}, got ${runtimeType}`);
+  }
+  return checkedType;
+}
+var Context = class {
+  createOverlay(name, type) {
+    return new OverlayContext({
+      parent: this,
+      variableName: name,
+      variableType: type
     });
   }
-  HistoryEntries2.pathsEqual = pathsEqual;
-})(HistoryEntries || (HistoryEntries = {}));
-
-// ../state-manager/src/IOManager.ts
-var import_observable7 = require("@noya-app/observable");
-
-// ../state-manager/src/jwt.ts
-function base64UrlEncode(str) {
-  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function base64UrlDecode(str) {
-  str = str.replace(/-/g, "+").replace(/_/g, "/");
-  switch (str.length % 4) {
-    case 2:
-      str += "==";
-      break;
-    case 3:
-      str += "=";
-      break;
+  getVariable(name) {
+    const type = this.getType(name);
+    if (!type) return;
+    const value = this.getValue(name);
+    if (value === void 0) return;
+    return { type, value };
   }
-  return atob(str);
-}
-var HEADER = {
-  alg: "HS256",
-  typ: "JWT"
 };
-var JWT_ERROR = {
-  INVALID_JWT_FORMAT: "Invalid JWT format"
-  // INVALID_SIGNATURE: "Invalid signature",
+var RootContext = class extends Context {
+  constructor({ variables, fallbackValues }) {
+    super();
+    this.variables = variables;
+    this.fallbackValues = fallbackValues;
+    this.primary = null;
+    this.primaryGetter = this.#getFromSecondary;
+  }
+  getType(name) {
+    return this.variables.get(name);
+  }
+  getValue() {
+  }
+  setPrimaryContext(primary) {
+    if (typeof primary !== "object") throw new EvaluationError("Context must be an object");
+    this.primary = primary;
+    if (!primary) this.getValue = this.#getFromSecondary;
+    else if (primary instanceof Map) this.getValue = this.#getFromMap;
+    else this.getValue = this.#getFromObject;
+  }
+  #getFromSecondary(key) {
+    return this.fallbackValues.get(key);
+  }
+  #getFromObject(key) {
+    const v = Object.hasOwn(this.primary, key) ? this.primary[key] : void 0;
+    if (v !== void 0) return v;
+    return this.fallbackValues.get(key);
+  }
+  #getFromMap(key) {
+    const v = this.primary.get(key);
+    if (v !== void 0) return v;
+    return this.fallbackValues.get(key);
+  }
 };
-async function createJwt({
-  payload,
-  secret,
-  header
-}) {
-  const encoder = new TextEncoder();
-  const encodedHeader = base64UrlEncode(
-    JSON.stringify({ ...HEADER, ...header })
-  );
-  const encodedPayload = base64UrlEncode(JSON.stringify(payload));
-  const dataToSign = `${encodedHeader}.${encodedPayload}`;
-  const key = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const signature = await crypto.subtle.sign(
-    "HMAC",
-    key,
-    encoder.encode(dataToSign)
-  );
-  const encodedSignature = base64UrlEncode(
-    String.fromCharCode(...new Uint8Array(signature))
-  );
-  return `${dataToSign}.${encodedSignature}`;
-}
-async function decodeJwt({
-  token,
-  secret
-}) {
-  if (typeof token !== "string") {
-    throw new Error(JWT_ERROR.INVALID_JWT_FORMAT);
+var OverlayContext = class extends Context {
+  constructor({ parent, variableName, variableType }) {
+    super();
+    this.parent = parent;
+    this.variableName = variableName;
+    this.variableType = variableType;
+    this.variableValue = void 0;
   }
-  const [encodedHeader, encodedPayload, encodedSignature] = token.split(".");
-  if (!encodedHeader || !encodedPayload || !encodedSignature) {
-    throw new Error(JWT_ERROR.INVALID_JWT_FORMAT);
+  getType(name) {
+    if (this.variableName === name) return this.variableType;
+    return this.parent.getType(name);
   }
-  const headerJson = base64UrlDecode(encodedHeader);
-  const payloadJson = base64UrlDecode(encodedPayload);
-  const header = JSON.parse(headerJson);
-  const payload = JSON.parse(payloadJson);
-  const dataToVerify = `${encodedHeader}.${encodedPayload}`;
-  const encoder = new TextEncoder();
-  if (secret !== void 0) {
-    const key = await crypto.subtle.importKey(
-      "raw",
-      encoder.encode(secret),
-      { name: "HMAC", hash: "SHA-256" },
-      false,
-      ["verify"]
-    );
-    const binarySignature = base64UrlDecode(encodedSignature);
-    const signature = new Uint8Array(
-      [...binarySignature].map((char) => char.charCodeAt(0))
+  getValue(name) {
+    if (this.variableName === name) return this.variableValue;
+    return this.parent.getValue(name);
+  }
+  setVariableValue(value) {
+    this.variableValue = value;
+  }
+};
+var registryByEnvironment = /* @__PURE__ */ new WeakMap();
+var globalValues = new Map(Object.entries(TYPES));
+var Environment = class _Environment {
+  #variables;
+  #registry;
+  #evaluator;
+  #typeChecker;
+  #opts;
+  constructor(opts) {
+    this.#opts = opts;
+    this.#registry = (opts?.inherit instanceof _Environment ? registryByEnvironment.get(opts.inherit) : globalRegistry).clone({
+      unlistedVariablesAreDyn: opts?.unlistedVariablesAreDyn ?? false
+    });
+    this.#variables = this.#registry.variables;
+    const childOpts = {
+      registry: this.#registry,
+      variables: this.#variables,
+      objectTypes: this.#registry.objectTypes,
+      objectTypesByConstructor: this.#registry.objectTypesByConstructor,
+      ctx: new RootContext({
+        variables: this.#variables,
+        fallbackValues: globalValues
+      })
+    };
+    this.#typeChecker = new TypeChecker(childOpts);
+    this.#evaluator = new Evaluator({ ...childOpts, typeChecker: this.#typeChecker });
+    registryByEnvironment.set(this, this.#registry);
+    Object.freeze(this);
+  }
+  clone(opts) {
+    return new _Environment({
+      inherit: this,
+      unlistedVariablesAreDyn: this.#opts?.unlistedVariablesAreDyn ?? false
+    });
+  }
+  registerFunction(string, handler) {
+    this.#registry.registerFunctionOverload(string, handler);
+    return this;
+  }
+  registerOperator(string, handler) {
+    this.#registry.registerOperatorOverload(string, handler);
+    return this;
+  }
+  registerType(typename, constructor) {
+    this.#registry.registerType(typename, constructor);
+    return this;
+  }
+  registerVariable(name, type) {
+    this.#registry.registerVariable(name, type);
+    return this;
+  }
+  hasVariable(name) {
+    return this.#registry.variables.has(name);
+  }
+  check(expression) {
+    try {
+      const typeDecl = this.#typeChecker.check(new Parser(expression).parse());
+      return { valid: true, type: this.#formatTypeForCheck(typeDecl) };
+    } catch (e) {
+      return { valid: false, error: e };
+    }
+  }
+  #checkAST(ast) {
+    try {
+      const typeDecl = this.#typeChecker.check(ast);
+      return { valid: true, type: this.#formatTypeForCheck(typeDecl) };
+    } catch (e) {
+      return { valid: false, error: e };
+    }
+  }
+  #formatTypeForCheck(typeDecl) {
+    if (typeDecl.name === `list<dyn>`) return "list";
+    if (typeDecl.name === `map<dyn, dyn>`) return "map";
+    return `${typeDecl.name}`;
+  }
+  parse(expression) {
+    const ast = new Parser(expression).parse();
+    const evaluateParsed = this.#evaluateAST.bind(this, ast);
+    evaluateParsed.check = this.#checkAST.bind(this, ast);
+    evaluateParsed.ast = ast;
+    return evaluateParsed;
+  }
+  evaluate(expression, context) {
+    return this.#evaluateAST(new Parser(expression).parse(), context);
+  }
+  #evaluateAST(ast, context = null) {
+    const evaluator = this.#evaluator;
+    evaluator.ctx.setPrimaryContext(context);
+    evaluator.tryCheck(ast);
+    return evaluator.eval(ast);
+  }
+};
+function unsupportedType(type) {
+  throw new EvaluationError(`Unsupported type: ${type}`);
+}
+var Evaluator = class {
+  handlers = handlers;
+  celTypes = celTypes;
+  constructor({ registry, objectTypes, objectTypesByConstructor, typeChecker, ctx }) {
+    this.objectTypes = objectTypes;
+    this.objectTypesByConstructor = objectTypesByConstructor;
+    this.registry = registry;
+    this.typeChecker = typeChecker;
+    this.ctx = ctx;
+  }
+  value(name, ast) {
+    const dec = this.ctx.getVariable(name);
+    if (!dec) throw new EvaluationError(`Unknown variable: ${name}`, ast);
+    const valueType = this.debugType(dec.value);
+    if (dec.type.matches(valueType)) return dec;
+    throw new EvaluationError(
+      `Variable '${name}' is not of type '${dec.type}', got '${valueType}'`,
+      ast
     );
-    const valid = await crypto.subtle.verify(
-      "HMAC",
-      key,
-      signature,
-      encoder.encode(dataToVerify)
+  }
+  predicateEvaluator(functionName, ast) {
+    return new PredicateEvaluator(this, functionName, ast);
+  }
+  debugType(v) {
+    switch (typeof v) {
+      case "string":
+        return this.celTypes.string;
+      case "bigint":
+        return this.celTypes.int;
+      case "number":
+        return this.celTypes.double;
+      case "boolean":
+        return this.celTypes.bool;
+      case "object":
+        if (v === null) return this.celTypes.null;
+        return this.objectTypesByConstructor.get(v.constructor)?.type || unsupportedType(v.constructor?.name || typeof v);
+      default:
+        unsupportedType(typeof v);
+    }
+  }
+  tryCheck(ast) {
+    try {
+      return ast.checkedType || this.typeChecker.check(ast);
+    } catch (_e) {
+    }
+  }
+  eval(ast) {
+    const handler = this.handlers.get(ast[0]);
+    if (handler) return handler(ast, this);
+    throw new EvaluationError(`Unknown operation: ${ast[0]}`, ast);
+  }
+};
+var PredicateEvaluator = class extends Evaluator {
+  constructor(e, functionName, ast) {
+    super(e);
+    const [identifier, predicate] = ast[3];
+    if (identifier?.[0] !== "id") {
+      throw new EvaluationError(`${functionName} invalid predicate iteration variable`, ast);
+    }
+    this.ast = ast;
+    this.functionName = functionName;
+    this.predicateVariable = identifier[1];
+    this.predicateExpression = predicate;
+    const receiverType = ast[2].checkedType || this.celTypes.dyn;
+    let predicateType = this.celTypes.dyn;
+    if (receiverType.type === "list") predicateType = receiverType.valueType;
+    if (receiverType.type === "map") predicateType = receiverType.keyType;
+    this.ctx = this.ctx.createOverlay(this.predicateVariable, predicateType);
+    this.tryCheck(predicate);
+  }
+  getIterableItems(collection) {
+    if (Array.isArray(collection)) return collection;
+    if (collection instanceof Set) return [...collection];
+    if (collection instanceof Map) return [...collection.keys()];
+    if (typeof collection === "object") return Object.keys(collection);
+    throw new EvaluationError(
+      `${this.functionName} cannot iterate over non-collection type. argument must be a list, map, or object`,
+      this.ast
     );
-    return { header, payload, valid };
   }
-  return { header, payload, valid: false };
-}
-var jwt;
-((jwt2) => {
-  jwt2.encode = createJwt;
-  jwt2.decode = decodeJwt;
-  jwt2.ERROR = JWT_ERROR;
-  jwt2.DEFAULT_HEADER = HEADER;
-})(jwt || (jwt = {}));
-
-// ../state-manager/src/MenuManager.ts
-var import_noya_utils6 = require("@noya-app/noya-utils");
-var import_observable8 = require("@noya-app/observable");
-
-// ../state-manager/src/multiplayer.ts
-var import_noya_utils7 = require("@noya-app/noya-utils");
-var import_observable10 = require("@noya-app/observable");
-
-// ../state-manager/src/stateManager.ts
-var import_observable9 = require("@noya-app/observable");
+  childEvaluateBool(item) {
+    this.ctx.setVariableValue(item);
+    switch (this.eval(this.predicateExpression)) {
+      case true:
+        return true;
+      case false:
+        return false;
+      default:
+        throw new EvaluationError(
+          `${this.functionName} predicate result is not a boolean`,
+          Array.isArray(this.predicateExpression) ? this.predicateExpression : this.ast
+        );
+    }
+  }
+  childEvaluate(item) {
+    this.ctx.setVariableValue(item);
+    return this.eval(this.predicateExpression);
+  }
+};
+var globalEnvironment = new Environment({
+  unlistedVariablesAreDyn: true
+});
 
-// ../state-manager/src/multiplayer.ts
-var createHash = (value, options) => (0, import_noya_utils7.hash)(value, { ...options, ignoreUndefinedProperties: true });
+// ../state-manager/src/multiplayerPolicies.ts
+var import_noya_utils8 = require("@noya-app/noya-utils");
+var celEnvironment = new Environment({
+  unlistedVariablesAreDyn: true
+});
+var MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+celEnvironment.registerFunction("random(): double", () => Math.random()).registerFunction("randomInt(int, int): int", (min, max) => {
+  if (max < min) {
+    throw new Error(
+      "randomInt requires the second argument to be greater than or equal to the first"
+    );
+  }
+  if (max === min) {
+    return min;
+  }
+  const span = max - min + 1n;
+  if (span > MAX_SAFE_INTEGER_BIGINT) {
+    throw new Error("randomInt range is too large to generate safely");
+  }
+  const spanNumber = Number(span);
+  const offset = BigInt(Math.floor(Math.random() * spanNumber));
+  return min + offset;
+}).registerFunction(
+  "now(): double",
+  function() {
+    const nowVariable = this.ctx.getVariable("now");
+    const nowValue = nowVariable?.value ?? Date.now();
+    return typeof nowValue === "number" ? nowValue : Number(nowValue);
+  }
+).registerFunction(
+  "timestamp(): string",
+  function() {
+    const nowVariable = this.ctx.getVariable("now");
+    const nowValue = typeof nowVariable?.value === "number" ? nowVariable.value : typeof nowVariable?.value === "string" ? Number(nowVariable.value) : Date.now();
+    return new Date(nowValue).toISOString();
+  }
+).registerFunction("uuid(): string", () => (0, import_noya_utils8.uuid)());
+var READ_DENIED = Symbol("readDenied");
 
 // ../state-manager/src/NoyaManager.ts
-var import_noya_utils11 = require("@noya-app/noya-utils");
+var import_noya_utils12 = require("@noya-app/noya-utils");
 var import_observable18 = require("@noya-app/observable");
 
 // ../noya-pipeline/src/graphToTasks.ts
-var import_observable11 = require("@noya-app/observable");
+var import_observable10 = require("@noya-app/observable");
 
 // ../noya-pipeline/src/state.ts
-var import_noya_utils8 = require("@noya-app/noya-utils");
+var import_noya_utils9 = require("@noya-app/noya-utils");
 var rectSchema = Type.Object({
   x: Type.Number(),
   y: Type.Number(),
@@ -7625,23 +10636,26 @@ var pipelineSchema = Type.Object(
 );
 
 // ../state-manager/src/PipelineManager.ts
-var import_observable12 = require("@noya-app/observable");
+var import_observable11 = require("@noya-app/observable");
 
 // ../state-manager/src/PublishingManager.ts
-var import_observable13 = require("@noya-app/observable");
+var import_observable12 = require("@noya-app/observable");
 
 // ../state-manager/src/ResourceManager.ts
-var import_noya_utils9 = require("@noya-app/noya-utils");
-var import_observable14 = require("@noya-app/observable");
+var import_noya_utils10 = require("@noya-app/noya-utils");
+var import_observable13 = require("@noya-app/observable");
 
 // ../state-manager/src/rpcManager.ts
-var import_noya_utils10 = require("@noya-app/noya-utils");
-var import_observable15 = require("@noya-app/observable");
+var import_noya_utils11 = require("@noya-app/noya-utils");
+var import_observable14 = require("@noya-app/observable");
 
 // ../state-manager/src/SecretManager.ts
-var import_observable16 = require("@noya-app/observable");
+var import_observable15 = require("@noya-app/observable");
 
 // ../state-manager/src/TaskManager.ts
+var import_observable16 = require("@noya-app/observable");
+
+// ../state-manager/src/UserManager.ts
 var import_observable17 = require("@noya-app/observable");
 
 // ../state-manager/src/NoyaManager.ts
@@ -7655,7 +10669,7 @@ var createMutatorParametersSchema = Type.Object({
 });
 
 // ../state-manager/src/sync/localRpcHelpers.ts
-var import_noya_utils12 = require("@noya-app/noya-utils");
+var import_noya_utils13 = require("@noya-app/noya-utils");
 
 // ../noya-keymap/src/hooks.ts
 var import_react4 = require("react");
@@ -7953,7 +10967,7 @@ var FileDropTarget = memoGeneric(function FileDropTarget2({ children, onDropFile
 var import_react8 = require("react");
 
 // ../noya-react-utils/src/hooks/useDeepArray.ts
-var import_noya_utils13 = require("@noya-app/noya-utils");
+var import_noya_utils14 = require("@noya-app/noya-utils");
 var import_react9 = require("react");
 function useJsonMemo(value) {
   const stringified = (0, import_react9.useMemo)(
@@ -7968,7 +10982,7 @@ function useJsonMemo(value) {
 }
 
 // ../noya-react-utils/src/hooks/useDeepState.ts
-var import_noya_utils14 = require("@noya-app/noya-utils");
+var import_noya_utils15 = require("@noya-app/noya-utils");
 var import_react10 = require("react");
 
 // ../noya-react-utils/src/hooks/useFetch.ts
@@ -7999,7 +11013,7 @@ var import_react17 = require("react");
 var import_react18 = require("react");
 
 // ../noya-react-utils/src/hooks/useShallowArray.ts
-var import_noya_utils15 = require("@noya-app/noya-utils");
+var import_noya_utils16 = require("@noya-app/noya-utils");
 var import_react19 = require("react");
 
 // ../noya-react-utils/src/hooks/useStableCallback.ts
@@ -8009,7 +11023,7 @@ var import_react20 = require("react");
 var import_react21 = require("react");
 
 // ../noya-react-utils/src/hooks/useUrlHashParameters.ts
-var import_noya_utils16 = require("@noya-app/noya-utils");
+var import_noya_utils17 = require("@noya-app/noya-utils");
 var import_react22 = require("react");
 
 // ../noya-react-utils/src/hooks/useWindowSize.ts
@@ -8160,7 +11174,7 @@ var import_react55 = __toESM(require("react"));
 var import_client = require("react-dom/client");
 
 // ../noya-multiplayer-react/src/inspector/StateInspector.tsx
-var import_noya_utils17 = require("@noya-app/noya-utils");
+var import_noya_utils18 = require("@noya-app/noya-utils");
 var import_react54 = __toESM(require("react"));
 
 // ../../node_modules/react-inspector/dist/index.mjs
@@ -9564,14 +12578,15 @@ function StateInspectorRow({
   colorScheme,
   selected,
   style: style2,
-  variant
+  variant,
+  bordered = true
 }) {
   const solidBorderColor = colorScheme === "light" ? "rgb(223 223 223)" : "rgb(29 29 29)";
   return /* @__PURE__ */ import_react46.default.createElement(
     "div",
     {
       style: {
-        borderBottom: `1px solid ${solidBorderColor}`,
+        borderBottom: bordered ? `1px solid ${solidBorderColor}` : void 0,
         fontSize: "12px",
         fontFamily: "Menlo, monospace",
         padding: "2px 12px 1px",
@@ -10646,12 +13661,13 @@ var StateInspector = memoGeneric(function StateInspector2({
   colorScheme = "light",
   anchor = "right",
   unstyled = false,
+  advanced = false,
   ...props
 }) {
   const {
     multiplayerStateManager,
     assetManager,
-    connectedUsersManager,
+    userManager,
     secretManager,
     ephemeralUserDataManager,
     connectionEventManager,
@@ -10738,8 +13754,8 @@ var StateInspector = memoGeneric(function StateInspector2({
   const assetsInitialized = useObservable2(assetManager.isInitialized$);
   const secrets = useObservable2(secretManager.secrets$);
   const secretsInitialized = useObservable2(secretManager.isInitialized$);
-  const connectedUsers = useObservable2(connectedUsersManager.connectedUsers$);
-  const userId = useObservable2(connectedUsersManager.currentUserId$);
+  const connectedUsers = useObservable2(userManager.connectedUsers$);
+  const userId = useObservable2(userManager.currentUserId$);
   const state = useObservable2(multiplayerStateManager.optimisticState$);
   const inputsInitialized = useObservable2(ioManager.inputsInitialized$);
   const outputTransformsInitialized = useObservable2(
@@ -10837,12 +13853,13 @@ var StateInspector = memoGeneric(function StateInspector2({
           }
         )
       },
-      /* @__PURE__ */ import_react54.default.createElement(StateInspectorDisclosureRowInner, { style: { flex: "0 0 auto" } }, connectedUsers?.map((user) => /* @__PURE__ */ import_react54.default.createElement(
+      /* @__PURE__ */ import_react54.default.createElement(StateInspectorDisclosureRowInner, { style: { flex: "0 0 auto" } }, connectedUsers?.map((user, index, array) => /* @__PURE__ */ import_react54.default.createElement(
         StateInspectorRow,
         {
           key: user.id,
           colorScheme,
-          variant: user.id === userId ? "up" : void 0
+          variant: user.id === userId ? "up" : void 0,
+          bordered: index !== array.length - 1
         },
         user.image && /* @__PURE__ */ import_react54.default.createElement(
           "img",
@@ -11014,7 +14031,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         "Delete"
       ))))
     ),
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       StateInspectorDisclosureSection,
       {
         title: /* @__PURE__ */ import_react54.default.createElement(StateInspectorTitleLabel, null, "Resources (", resources.length, ")", /* @__PURE__ */ import_react54.default.createElement(ColoredDot, { type: resourcesInitialized ? "success" : "error" })),
@@ -11041,7 +14058,7 @@ var StateInspector = memoGeneric(function StateInspector2({
           {
             theme: theme3,
             onClick: async () => {
-              const path2 = prompt("Enter directory path") || (0, import_noya_utils17.uuid)();
+              const path2 = prompt("Enter directory path") || (0, import_noya_utils18.uuid)();
               await resourceManager.createResource({
                 type: "directory",
                 path: path2
@@ -11057,9 +14074,9 @@ var StateInspector = memoGeneric(function StateInspector2({
               const file = await uploadFile();
               resourceManager.createResource({
                 type: "asset",
-                path: file.name || (0, import_noya_utils17.uuid)(),
+                path: file.name || (0, import_noya_utils18.uuid)(),
                 asset: {
-                  content: import_noya_utils17.Base64.encode(await file.arrayBuffer()),
+                  content: import_noya_utils18.Base64.encode(await file.arrayBuffer()),
                   contentType: file.type,
                   encoding: "base64"
                 }
@@ -11096,7 +14113,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         "Rename"
       )))))
     ),
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       StateInspectorDisclosureSection,
       {
         title: /* @__PURE__ */ import_react54.default.createElement(StateInspectorTitleLabel, null, "Secrets", /* @__PURE__ */ import_react54.default.createElement(ColoredDot, { type: secretsInitialized ? "success" : "error" })),
@@ -11127,8 +14144,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         "Delete"
       ))))
     ),
-    " ",
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       StateInspectorDisclosureSection,
       {
         open: showInputs,
@@ -11150,7 +14166,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         /* @__PURE__ */ import_react54.default.createElement("span", null, "No inputs")
       ))
     ),
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       StateInspectorDisclosureSection,
       {
         open: showOutputTransforms,
@@ -11177,7 +14193,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         /* @__PURE__ */ import_react54.default.createElement("span", null, "No output transforms")
       ))
     ),
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       StateInspectorDisclosureSection,
       {
         title: "Tasks",
@@ -11222,7 +14238,7 @@ var StateInspector = memoGeneric(function StateInspector2({
         }
       ))))
     ),
-    /* @__PURE__ */ import_react54.default.createElement(
+    advanced && /* @__PURE__ */ import_react54.default.createElement(
       ActivityEventsSection,
       {
         colorScheme,
@@ -11244,7 +14260,7 @@ var StateInspector = memoGeneric(function StateInspector2({
     )
   );
 });
-var truncateAsset = (0, import_noya_utils17.memoize)((asset) => {
+var truncateAsset = (0, import_noya_utils18.memoize)((asset) => {
   if (asset.url.startsWith("data:") || asset.url.startsWith("blob:")) {
     return { ...asset, url: ellipsis(asset.url, 40) };
   }
@@ -11321,12 +14337,12 @@ var UserPointerInternal = memoGeneric(function UserPointerInternal2({
   });
 });
 var UserPointersOverlay = memoGeneric(function UserPointers({
-  connectedUsersManager,
+  userManager,
   ephemeralUserDataManager,
   renderUserPointer
 }) {
   const currentUserId = useObservable2(ephemeralUserDataManager.currentUserId$);
-  const connectedUsers = useObservable2(connectedUsersManager.connectedUsers$);
+  const connectedUsers = useObservable2(userManager.connectedUsers$);
   return /* @__PURE__ */ import_react61.default.createElement(import_react61.default.Fragment, null, connectedUsers.map((user) => {
     if (user.id === currentUserId) return null;
     return /* @__PURE__ */ import_react61.default.createElement(