wield-mcp 0.0.0-stage → 0.1.2

package/dist/extension/content.js

@@ -0,0 +1,4228 @@
+"use strict";
+(() => {
+  // packages/recipe/src/errors.ts
+  var RecipeError = class extends Error {
+    code;
+    step;
+    constructor(code, message, step) {
+      super(message);
+      this.name = "RecipeError";
+      this.code = code;
+      this.step = step;
+    }
+  };
+  var TemplateError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "TemplateError";
+    }
+  };
+
+  // node_modules/.pnpm/@jmespath-community+jmespath@1.5.0/node_modules/@jmespath-community/jmespath/dist/index.esm.js
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var CHILD_PROPS = ["left", "right", "condition", "child", "operand", "trueExpr", "falseExpr", "expression"];
+  function pushChildren(node, stack) {
+    const n = node;
+    for (const prop of CHILD_PROPS) {
+      const val = n[prop];
+      if (val && typeof val === "object" && "type" in val) {
+        stack.push(val);
+      }
+    }
+    if (Array.isArray(n.children)) {
+      for (const item of n.children) {
+        if (!item) {
+          continue;
+        }
+        stack.push(item);
+        if (item.type === "KeyValuePair" && item.value) {
+          stack.push(item.value);
+        }
+      }
+    }
+    if (Array.isArray(n.bindings)) {
+      for (const item of n.bindings) {
+        if (!item) {
+          continue;
+        }
+        stack.push(item);
+        if (item.reference) {
+          stack.push(item.reference);
+        }
+      }
+    }
+  }
+  function forEachNode(root, visitor) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) {
+        break;
+      }
+      if (visitor(current) === false) {
+        return;
+      }
+      pushChildren(current, stack);
+    }
+  }
+  function countNodes(root) {
+    let count = 0;
+    forEachNode(root, () => {
+      count += 1;
+      return true;
+    });
+    return count;
+  }
+  var isObject = (obj) => {
+    return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
+  };
+  var strictDeepEqual = (first, second) => {
+    if (first === second) {
+      return true;
+    }
+    if (typeof first !== typeof second) {
+      return false;
+    }
+    if (Array.isArray(first) && Array.isArray(second)) {
+      if (first.length !== second.length) {
+        return false;
+      }
+      for (let i = 0; i < first.length; i += 1) {
+        if (!strictDeepEqual(first[i], second[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (isObject(first) && isObject(second)) {
+      const keys = Object.keys(first);
+      if (keys.length !== Object.keys(second).length) {
+        return false;
+      }
+      return keys.every(
+        (key) => Object.prototype.hasOwnProperty.call(second, key) && strictDeepEqual(first[key], second[key])
+      );
+    }
+    return false;
+  };
+  var isFalse = (obj) => {
+    if (obj == null || obj === false) {
+      return true;
+    }
+    if (typeof obj === "string") {
+      return obj === "";
+    }
+    if (typeof obj === "object") {
+      return Array.isArray(obj) ? obj.length === 0 : Object.keys(obj).length === 0;
+    }
+    return false;
+  };
+  var isAlpha = (ch) => {
+    return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+  };
+  var isNum = (ch) => {
+    return ch >= "0" && ch <= "9" || ch === "-";
+  };
+  var isAlphaNum = (ch) => {
+    return isAlpha(ch) || ch >= "0" && ch <= "9";
+  };
+  var ensureInteger = (value) => {
+    if (!(typeof value === "number") || Math.floor(value) !== value) {
+      throw new Error("invalid-value: expecting an integer.");
+    }
+    return value;
+  };
+  var ensurePositiveInteger = (value) => {
+    if (!(typeof value === "number") || value < 0 || Math.floor(value) !== value) {
+      throw new Error("invalid-value: expecting a non-negative integer.");
+    }
+    return value;
+  };
+  var ensureNumbers = (...operands) => {
+    for (let i = 0; i < operands.length; i++) {
+      if (operands[i] === null || operands[i] === void 0) {
+        throw new Error("not-a-number: undefined");
+      }
+      if (typeof operands[i] !== "number") {
+        throw new Error("not-a-number");
+      }
+    }
+  };
+  var notZero = (n) => {
+    n = +n;
+    if (!n) {
+      throw new Error("not-a-number: divide by zero");
+    }
+    return n;
+  };
+  var binOp = (fn) => (left, right) => {
+    ensureNumbers(left, right);
+    return fn(left, right);
+  };
+  var add = binOp((a, b) => a + b);
+  var sub = binOp((a, b) => a - b);
+  var mul = binOp((a, b) => a * b);
+  var divide = binOp((a, b) => a / notZero(b));
+  var div = binOp((a, b) => Math.floor(a / notZero(b)));
+  var mod = binOp((a, b) => a % notZero(b));
+  var basicTokens = {
+    "(": "Lparen",
+    ")": "Rparen",
+    "*": "Star",
+    ",": "Comma",
+    ".": "Dot",
+    ":": "Colon",
+    "@": "Current",
+    "]": "Rbracket",
+    "{": "Lbrace",
+    "}": "Rbrace",
+    "+": "Plus",
+    "%": "Modulo",
+    "?": "Question",
+    "\u2212": "Minus",
+    "\xD7": "Multiply",
+    "\xF7": "Divide"
+    /* TOK_DIVIDE */
+  };
+  var operatorStartToken = {
+    "!": true,
+    "<": true,
+    "=": true,
+    ">": true,
+    "&": true,
+    "|": true,
+    "/": true
+  };
+  var skipChars = {
+    "	": true,
+    "\n": true,
+    "\r": true,
+    " ": true
+  };
+  var StreamLexer = class {
+    constructor() {
+      __publicField(this, "_current", 0);
+      __publicField(this, "_enable_legacy_literals", false);
+    }
+    tokenize(stream, options) {
+      const tokens = [];
+      this._current = 0;
+      this._enable_legacy_literals = options?.enable_legacy_literals || false;
+      let start;
+      let identifier;
+      let token;
+      while (this._current < stream.length) {
+        if (isAlpha(stream[this._current])) {
+          start = this._current;
+          identifier = this.consumeUnquotedIdentifier(stream);
+          tokens.push({
+            start,
+            type: "UnquotedIdentifier",
+            value: identifier
+          });
+        } else if (basicTokens[stream[this._current]] !== void 0) {
+          tokens.push({
+            start: this._current,
+            type: basicTokens[stream[this._current]],
+            value: stream[this._current]
+          });
+          this._current += 1;
+        } else if (stream[this._current] === "$") {
+          start = this._current;
+          if (this._current + 1 < stream.length && isAlpha(stream[this._current + 1])) {
+            this._current += 1;
+            identifier = this.consumeUnquotedIdentifier(stream);
+            tokens.push({
+              start,
+              type: "Variable",
+              value: identifier
+            });
+          } else {
+            tokens.push({
+              start,
+              type: "Root",
+              value: stream[this._current]
+            });
+            this._current += 1;
+          }
+        } else if (stream[this._current] === "-") {
+          if (this._current + 1 < stream.length && isNum(stream[this._current + 1])) {
+            const token2 = this.consumeNumber(stream);
+            token2 && tokens.push(token2);
+          } else {
+            const token2 = {
+              start: this._current,
+              type: "Minus",
+              value: "-"
+            };
+            tokens.push(token2);
+            this._current += 1;
+          }
+        } else if (isNum(stream[this._current])) {
+          token = this.consumeNumber(stream);
+          tokens.push(token);
+        } else if (stream[this._current] === "[") {
+          token = this.consumeLBracket(stream);
+          tokens.push(token);
+        } else if (stream[this._current] === '"') {
+          start = this._current;
+          identifier = this.consumeQuotedIdentifier(stream);
+          tokens.push({
+            start,
+            type: "QuotedIdentifier",
+            value: identifier
+          });
+        } else if (stream[this._current] === `'`) {
+          start = this._current;
+          identifier = this.consumeRawStringLiteral(stream);
+          tokens.push({
+            start,
+            type: "Literal",
+            value: identifier
+          });
+        } else if (stream[this._current] === "`") {
+          start = this._current;
+          const literal = this.consumeLiteral(stream);
+          tokens.push({
+            start,
+            type: "Literal",
+            value: literal
+          });
+        } else if (operatorStartToken[stream[this._current]] !== void 0) {
+          token = this.consumeOperator(stream);
+          token && tokens.push(token);
+        } else if (skipChars[stream[this._current]] !== void 0) {
+          this._current += 1;
+        } else {
+          const error = new Error(`Syntax error: unknown character: ${stream[this._current]}`);
+          error.name = "LexerError";
+          throw error;
+        }
+      }
+      return tokens;
+    }
+    consumeUnquotedIdentifier(stream) {
+      const start = this._current;
+      this._current += 1;
+      while (this._current < stream.length && isAlphaNum(stream[this._current])) {
+        this._current += 1;
+      }
+      return stream.slice(start, this._current);
+    }
+    consumeUntil(stream, delimiter) {
+      const start = this._current;
+      this._current += 1;
+      const len = stream.length;
+      while (this._current < len && stream[this._current] !== delimiter) {
+        if (stream[this._current] === "\\" && (stream[this._current + 1] === "\\" || stream[this._current + 1] === delimiter)) {
+          this._current += 2;
+        } else {
+          this._current += 1;
+        }
+      }
+      if (this._current < len) {
+        this._current += 1;
+      }
+      return stream.slice(start, this._current);
+    }
+    consumeQuotedIdentifier(stream) {
+      const raw = this.consumeUntil(stream, '"');
+      const [value, ok] = this.parseJSON(raw);
+      if (!ok) {
+        const error = new Error("syntax: unexpected end of JSON input");
+        error.name = "LexerError";
+        throw error;
+      }
+      return value;
+    }
+    consumeRawStringLiteral(stream) {
+      const raw = this.consumeUntil(stream, "'");
+      if (!raw.endsWith("'") || raw.length < 2) {
+        const error = new Error("Syntax error: unclosed single quote");
+        error.name = "LexerError";
+        throw error;
+      }
+      const content = raw.slice(1, -1);
+      return content.replace(/\\(['\\])/g, "$1");
+    }
+    consumeNumber(stream) {
+      const start = this._current;
+      this._current += 1;
+      const maxLength = stream.length;
+      while (isNum(stream[this._current]) && this._current < maxLength) {
+        this._current += 1;
+      }
+      const value = parseInt(stream.slice(start, this._current), 10);
+      return {
+        start,
+        value,
+        type: "Number"
+        /* TOK_NUMBER */
+      };
+    }
+    consumeLBracket(stream) {
+      const start = this._current;
+      this._current += 1;
+      if (stream[this._current] === "?") {
+        this._current += 1;
+        return { start, type: "Filter", value: "[?" };
+      }
+      if (stream[this._current] === "]") {
+        this._current += 1;
+        return { start, type: "Flatten", value: "[]" };
+      }
+      return { start, type: "Lbracket", value: "[" };
+    }
+    consumeOrElse(stream, peek, token, orElse) {
+      const start = this._current;
+      this._current += 1;
+      if (this._current < stream.length && stream[this._current] === peek) {
+        this._current += 1;
+        return {
+          start,
+          type: orElse,
+          value: stream.slice(start, this._current)
+        };
+      }
+      return { start, type: token, value: stream[start] };
+    }
+    consumeOperator(stream) {
+      const start = this._current;
+      const startingChar = stream[start];
+      switch (startingChar) {
+        case "!":
+          return this.consumeOrElse(
+            stream,
+            "=",
+            "Not",
+            "NE"
+            /* TOK_NE */
+          );
+        case "<":
+          return this.consumeOrElse(
+            stream,
+            "=",
+            "LT",
+            "LTE"
+            /* TOK_LTE */
+          );
+        case ">":
+          return this.consumeOrElse(
+            stream,
+            "=",
+            "GT",
+            "GTE"
+            /* TOK_GTE */
+          );
+        case "=":
+          return this.consumeOrElse(
+            stream,
+            "=",
+            "Assign",
+            "EQ"
+            /* TOK_EQ */
+          );
+        case "&":
+          return this.consumeOrElse(
+            stream,
+            "&",
+            "Expref",
+            "And"
+            /* TOK_AND */
+          );
+        case "|":
+          return this.consumeOrElse(
+            stream,
+            "|",
+            "Pipe",
+            "Or"
+            /* TOK_OR */
+          );
+        case "/":
+          return this.consumeOrElse(
+            stream,
+            "/",
+            "Divide",
+            "Div"
+            /* TOK_DIV */
+          );
+      }
+    }
+    consumeLiteral(stream) {
+      const raw = this.consumeUntil(stream, "`");
+      const inner = raw.endsWith("`") && raw.length > 1 ? raw.slice(1, -1) : raw.slice(1);
+      const literalString = inner.trimStart().replace("\\`", "`");
+      let [literal, ok] = this.parseJSON(literalString);
+      if (!ok && this._enable_legacy_literals) {
+        [literal, ok] = this.parseJSON(`"${literalString}"`);
+      }
+      if (!ok) {
+        const error = new Error(
+          `Syntax error: unexpected end of JSON input or invalid format for a JSON literal: ${stream[this._current - 1] ?? ""}`
+        );
+        error.name = "LexerError";
+        throw error;
+      }
+      return literal;
+    }
+    parseJSON(text) {
+      try {
+        const json = JSON.parse(text);
+        return [json, true];
+      } catch {
+        return [null, false];
+      }
+    }
+  };
+  var Lexer = new StreamLexer();
+  var Lexer_default = Lexer;
+  var bindingPower = {
+    [
+      "EOF"
+      /* TOK_EOF */
+    ]: 0,
+    [
+      "Variable"
+      /* TOK_VARIABLE */
+    ]: 0,
+    [
+      "UnquotedIdentifier"
+      /* TOK_UNQUOTEDIDENTIFIER */
+    ]: 0,
+    [
+      "QuotedIdentifier"
+      /* TOK_QUOTEDIDENTIFIER */
+    ]: 0,
+    [
+      "Rbracket"
+      /* TOK_RBRACKET */
+    ]: 0,
+    [
+      "Rparen"
+      /* TOK_RPAREN */
+    ]: 0,
+    [
+      "Comma"
+      /* TOK_COMMA */
+    ]: 0,
+    [
+      "Rbrace"
+      /* TOK_RBRACE */
+    ]: 0,
+    [
+      "Number"
+      /* TOK_NUMBER */
+    ]: 0,
+    [
+      "Current"
+      /* TOK_CURRENT */
+    ]: 0,
+    [
+      "Expref"
+      /* TOK_EXPREF */
+    ]: 0,
+    [
+      "Root"
+      /* TOK_ROOT */
+    ]: 0,
+    [
+      "Assign"
+      /* TOK_ASSIGN */
+    ]: 1,
+    [
+      "Pipe"
+      /* TOK_PIPE */
+    ]: 1,
+    [
+      "Question"
+      /* TOK_QUESTION */
+    ]: 2,
+    [
+      "Or"
+      /* TOK_OR */
+    ]: 3,
+    [
+      "And"
+      /* TOK_AND */
+    ]: 4,
+    [
+      "EQ"
+      /* TOK_EQ */
+    ]: 5,
+    [
+      "GT"
+      /* TOK_GT */
+    ]: 5,
+    [
+      "LT"
+      /* TOK_LT */
+    ]: 5,
+    [
+      "GTE"
+      /* TOK_GTE */
+    ]: 5,
+    [
+      "LTE"
+      /* TOK_LTE */
+    ]: 5,
+    [
+      "NE"
+      /* TOK_NE */
+    ]: 5,
+    [
+      "Minus"
+      /* TOK_MINUS */
+    ]: 6,
+    [
+      "Plus"
+      /* TOK_PLUS */
+    ]: 6,
+    [
+      "Div"
+      /* TOK_DIV */
+    ]: 7,
+    [
+      "Divide"
+      /* TOK_DIVIDE */
+    ]: 7,
+    [
+      "Modulo"
+      /* TOK_MODULO */
+    ]: 7,
+    [
+      "Multiply"
+      /* TOK_MULTIPLY */
+    ]: 7,
+    [
+      "Flatten"
+      /* TOK_FLATTEN */
+    ]: 9,
+    [
+      "Star"
+      /* TOK_STAR */
+    ]: 20,
+    [
+      "Filter"
+      /* TOK_FILTER */
+    ]: 21,
+    [
+      "Dot"
+      /* TOK_DOT */
+    ]: 40,
+    [
+      "Not"
+      /* TOK_NOT */
+    ]: 45,
+    [
+      "Lbrace"
+      /* TOK_LBRACE */
+    ]: 50,
+    [
+      "Lbracket"
+      /* TOK_LBRACKET */
+    ]: 55,
+    [
+      "Lparen"
+      /* TOK_LPAREN */
+    ]: 60
+  };
+  var DEFAULT_MAX_DEPTH = 1e3;
+  var TokenParser = class _TokenParser {
+    constructor() {
+      __publicField(this, "index", 0);
+      __publicField(this, "tokens", []);
+      __publicField(this, "depth", 0);
+      __publicField(this, "maxDepth", DEFAULT_MAX_DEPTH);
+      __publicField(this, "nodeCount", 0);
+      __publicField(this, "maxNodes");
+    }
+    parse(expression, options) {
+      this.loadTokens(expression, options || { enable_legacy_literals: false });
+      this.index = 0;
+      this.depth = 0;
+      this.nodeCount = 0;
+      this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+      this.maxNodes = options?.maxNodes;
+      const ast = this.expression(0);
+      if (this.lookahead(0) !== "EOF") {
+        const token = this.lookaheadToken(0);
+        this.errorToken(token, `Syntax error: unexpected token type: ${token.type}, value: ${token.value}`);
+      }
+      if (this.maxNodes !== void 0 && countNodes(ast) > this.maxNodes) {
+        throw new Error(`Expression exceeds maximum allowed node count of ${this.maxNodes}`);
+      }
+      return ast;
+    }
+    loadTokens(expression, options) {
+      this.tokens = Lexer_default.tokenize(expression, options);
+      this.tokens.push({ type: "EOF", value: "", start: expression.length });
+    }
+    expression(rbp) {
+      if (this.depth >= this.maxDepth) {
+        throw new Error(`Expression exceeds maximum allowed depth of ${this.maxDepth}`);
+      }
+      this.depth += 1;
+      this.trackNode();
+      try {
+        const leftToken = this.lookaheadToken(0);
+        this.advance();
+        let left = this.nud(leftToken);
+        let currentTokenType = this.lookahead(0);
+        while (rbp < bindingPower[currentTokenType]) {
+          this.trackNode();
+          this.advance();
+          left = this.led(currentTokenType, left);
+          currentTokenType = this.lookahead(0);
+        }
+        return left;
+      } finally {
+        this.depth -= 1;
+      }
+    }
+    trackNode() {
+      this.nodeCount += 1;
+      if (this.maxNodes !== void 0 && this.nodeCount > this.maxNodes) {
+        throw new Error(`Expression exceeds maximum allowed node count of ${this.maxNodes}`);
+      }
+    }
+    lookahead(offset) {
+      return this.tokens[this.index + offset].type;
+    }
+    lookaheadToken(offset) {
+      return this.tokens[this.index + offset];
+    }
+    advance() {
+      this.index += 1;
+    }
+    nud(token) {
+      switch (token.type) {
+        case "Variable":
+          return { type: "Variable", name: token.value };
+        case "Literal":
+          return { type: "Literal", value: token.value };
+        case "UnquotedIdentifier": {
+          if (_TokenParser.isKeyword(token, "let") && this.lookahead(0) === "Variable") {
+            return this.parseLetExpression();
+          } else {
+            return { type: "Field", name: token.value };
+          }
+        }
+        case "QuotedIdentifier":
+          if (this.lookahead(0) === "Lparen") {
+            throw new Error("Syntax error: quoted identifier not allowed for function names.");
+          } else {
+            return { type: "Field", name: token.value };
+          }
+        case "Not": {
+          const child = this.expression(bindingPower.Not);
+          return { type: "NotExpression", child };
+        }
+        case "Minus": {
+          const child = this.expression(bindingPower.Minus);
+          return {
+            type: "Unary",
+            operator: token.type,
+            operand: child
+          };
+        }
+        case "Plus": {
+          const child = this.expression(bindingPower.Plus);
+          return {
+            type: "Unary",
+            operator: token.type,
+            operand: child
+          };
+        }
+        case "Star": {
+          const left = { type: "Identity" };
+          return { type: "ValueProjection", left, right: this.parseProjectionRHS(bindingPower.Star) };
+        }
+        case "Filter":
+          return this.led(token.type, { type: "Identity" });
+        case "Lbrace":
+          return this.parseMultiselectHash();
+        case "Flatten": {
+          const left = {
+            type: "Flatten",
+            child: { type: "Identity" }
+          };
+          const right = this.parseProjectionRHS(bindingPower.Flatten);
+          return { type: "Projection", left, right };
+        }
+        case "Lbracket": {
+          if (this.lookahead(0) === "Number" || this.lookahead(0) === "Colon") {
+            const right = this.parseIndexExpression();
+            return this.projectIfSlice({ type: "Identity" }, right);
+          }
+          if (this.lookahead(0) === "Star" && this.lookahead(1) === "Rbracket") {
+            this.advance();
+            this.advance();
+            const right = this.parseProjectionRHS(bindingPower.Star);
+            return {
+              left: { type: "Identity" },
+              right,
+              type: "Projection"
+            };
+          }
+          return this.parseMultiselectList();
+        }
+        case "Current":
+          return {
+            type: "Current"
+            /* TOK_CURRENT */
+          };
+        case "Root":
+          return {
+            type: "Root"
+            /* TOK_ROOT */
+          };
+        case "Expref": {
+          const child = this.expression(bindingPower.Expref);
+          return { type: "ExpressionReference", child };
+        }
+        case "Lparen": {
+          const expression = this.expression(0);
+          this.match(
+            "Rparen"
+            /* TOK_RPAREN */
+          );
+          return expression;
+        }
+        default:
+          this.errorToken(token);
+      }
+    }
+    led(tokenName, left) {
+      switch (tokenName) {
+        case "Question": {
+          const trueExpr = this.expression(0);
+          this.match(
+            "Colon"
+            /* TOK_COLON */
+          );
+          const falseExpr = this.expression(0);
+          return {
+            type: "Ternary",
+            condition: left,
+            trueExpr,
+            falseExpr
+          };
+        }
+        case "Dot": {
+          const rbp = bindingPower.Dot;
+          if (this.lookahead(0) !== "Star") {
+            const right2 = this.parseDotRHS(rbp);
+            return { type: "Subexpression", left, right: right2 };
+          }
+          this.advance();
+          const right = this.parseProjectionRHS(rbp);
+          return { type: "ValueProjection", left, right };
+        }
+        case "Pipe": {
+          const right = this.expression(bindingPower.Pipe);
+          return { type: "Pipe", left, right };
+        }
+        case "Or": {
+          const right = this.expression(bindingPower.Or);
+          return { type: "OrExpression", left, right };
+        }
+        case "And": {
+          const right = this.expression(bindingPower.And);
+          return { type: "AndExpression", left, right };
+        }
+        case "Lparen": {
+          if (left.type !== "Field") {
+            throw new Error("Syntax error: expected a Field node");
+          }
+          const name = left.name;
+          const args = this.parseCommaSeparatedExpressionsUntilToken(
+            "Rparen"
+            /* TOK_RPAREN */
+          );
+          const node = { name, type: "Function", children: args };
+          return node;
+        }
+        case "Filter": {
+          const condition = this.expression(0);
+          this.match(
+            "Rbracket"
+            /* TOK_RBRACKET */
+          );
+          const right = this.lookahead(0) === "Flatten" ? { type: "Identity" } : this.parseProjectionRHS(bindingPower.Filter);
+          return { type: "FilterProjection", left, right, condition };
+        }
+        case "Flatten": {
+          const leftNode = { type: "Flatten", child: left };
+          const right = this.parseProjectionRHS(bindingPower.Flatten);
+          return { type: "Projection", left: leftNode, right };
+        }
+        case "Assign": {
+          const leftNode = left;
+          const right = this.expression(0);
+          return {
+            type: "Binding",
+            variable: leftNode.name,
+            reference: right
+          };
+        }
+        case "EQ":
+        case "NE":
+        case "GT":
+        case "GTE":
+        case "LT":
+        case "LTE":
+          return this.parseComparator(left, tokenName);
+        case "Plus":
+        case "Minus":
+        case "Multiply":
+        case "Star":
+        case "Divide":
+        case "Modulo":
+        case "Div":
+          return this.parseArithmetic(left, tokenName);
+        case "Lbracket": {
+          const token = this.lookaheadToken(0);
+          if (token.type === "Number" || token.type === "Colon") {
+            const right2 = this.parseIndexExpression();
+            return this.projectIfSlice(left, right2);
+          }
+          this.match(
+            "Star"
+            /* TOK_STAR */
+          );
+          this.match(
+            "Rbracket"
+            /* TOK_RBRACKET */
+          );
+          const right = this.parseProjectionRHS(bindingPower.Star);
+          return { type: "Projection", left, right };
+        }
+        default:
+          return this.errorToken(this.lookaheadToken(0));
+      }
+    }
+    static isKeyword(token, keyword) {
+      return token.type === "UnquotedIdentifier" && token.value === keyword;
+    }
+    match(tokenType) {
+      if (this.lookahead(0) === tokenType) {
+        this.advance();
+        return;
+      } else {
+        const token = this.lookaheadToken(0);
+        this.errorToken(token, `Syntax error: expected ${tokenType}, got: ${token.type}`);
+      }
+    }
+    errorToken(token, message = "") {
+      const error = new Error(message || `Syntax error: invalid token (${token.type}): "${token.value}"`);
+      error.name = "ParserError";
+      throw error;
+    }
+    parseIndexExpression() {
+      if (this.lookahead(0) === "Colon" || this.lookahead(1) === "Colon") {
+        return this.parseSliceExpression();
+      }
+      const value = Number(this.lookaheadToken(0).value);
+      this.advance();
+      this.match(
+        "Rbracket"
+        /* TOK_RBRACKET */
+      );
+      return { type: "Index", value };
+    }
+    projectIfSlice(left, right) {
+      const indexExpr = {
+        type: "IndexExpression",
+        left,
+        right
+      };
+      if (right.type === "Slice") {
+        const rhs = this.parseProjectionRHS(bindingPower.Star);
+        if (rhs.type === "Identity") {
+          return indexExpr;
+        }
+        return {
+          left: indexExpr,
+          right: rhs,
+          type: "Projection"
+        };
+      }
+      return indexExpr;
+    }
+    parseSliceExpression() {
+      const parts = [null, null, null];
+      let index = 0;
+      let current = this.lookaheadToken(0);
+      while (current.type != "Rbracket" && index < 3) {
+        if (current.type === "Colon") {
+          index++;
+          if (index === 3) {
+            this.errorToken(this.lookaheadToken(0), "Syntax error, too many colons in slice expression");
+          }
+          this.advance();
+        } else if (current.type === "Number" && parts[index] === null) {
+          const part = this.lookaheadToken(0).value;
+          parts[index] = part;
+          this.advance();
+        } else {
+          const next = this.lookaheadToken(0);
+          this.errorToken(next, `Syntax error, unexpected token: ${next.value}(${next.type})`);
+        }
+        current = this.lookaheadToken(0);
+      }
+      this.match(
+        "Rbracket"
+        /* TOK_RBRACKET */
+      );
+      const [start, stop, step] = parts;
+      return { type: "Slice", start, stop, step };
+    }
+    parseLetExpression() {
+      const separated = this.parseCommaSeparatedExpressionsUntilKeyword("in");
+      const expression = this.expression(0);
+      const bindings = separated.map((binding) => binding);
+      return {
+        type: "LetExpression",
+        bindings,
+        expression
+      };
+    }
+    parseCommaSeparatedExpressionsUntilKeyword(keyword) {
+      return this.parseCommaSeparatedExpressionsUntil(
+        () => {
+          return _TokenParser.isKeyword(this.lookaheadToken(0), keyword);
+        },
+        () => {
+          this.advance();
+        }
+      );
+    }
+    parseCommaSeparatedExpressionsUntilToken(token) {
+      return this.parseCommaSeparatedExpressionsUntil(
+        () => {
+          return this.lookahead(0) === token;
+        },
+        () => {
+          return this.match(token);
+        }
+      );
+    }
+    parseCommaSeparatedExpressionsUntil(isEndToken, matchEndToken) {
+      const args = [];
+      let expression;
+      while (!isEndToken()) {
+        expression = this.expression(0);
+        if (this.lookahead(0) === "Comma") {
+          this.match(
+            "Comma"
+            /* TOK_COMMA */
+          );
+        }
+        args.push(expression);
+      }
+      matchEndToken();
+      return args;
+    }
+    parseComparator(left, comparator) {
+      const right = this.expression(bindingPower[comparator]);
+      return { type: "Comparator", name: comparator, left, right };
+    }
+    parseArithmetic(left, operator) {
+      const right = this.expression(bindingPower[operator]);
+      return { type: "Arithmetic", operator, left, right };
+    }
+    parseDotRHS(rbp) {
+      const lookahead = this.lookahead(0);
+      const exprTokens = [
+        "UnquotedIdentifier",
+        "QuotedIdentifier",
+        "Star"
+        /* TOK_STAR */
+      ];
+      if (exprTokens.includes(lookahead)) {
+        return this.expression(rbp);
+      }
+      if (lookahead === "Lbracket") {
+        this.match(
+          "Lbracket"
+          /* TOK_LBRACKET */
+        );
+        return this.parseMultiselectList();
+      }
+      if (lookahead === "Lbrace") {
+        this.match(
+          "Lbrace"
+          /* TOK_LBRACE */
+        );
+        return this.parseMultiselectHash();
+      }
+      const token = this.lookaheadToken(0);
+      this.errorToken(token, `Syntax error, unexpected token: ${token.value}(${token.type})`);
+    }
+    parseProjectionRHS(rbp) {
+      if (bindingPower[this.lookahead(0)] < 10) {
+        return { type: "Identity" };
+      }
+      if (this.lookahead(0) === "Lbracket") {
+        return this.expression(rbp);
+      }
+      if (this.lookahead(0) === "Filter") {
+        return this.expression(rbp);
+      }
+      if (this.lookahead(0) === "Dot") {
+        this.match(
+          "Dot"
+          /* TOK_DOT */
+        );
+        return this.parseDotRHS(rbp);
+      }
+      const token = this.lookaheadToken(0);
+      this.errorToken(token, `Syntax error, unexpected token: ${token.value}(${token.type})`);
+    }
+    parseMultiselectList() {
+      const expressions = [];
+      while (this.lookahead(0) !== "Rbracket") {
+        const expression = this.expression(0);
+        expressions.push(expression);
+        if (this.lookahead(0) === "Comma") {
+          this.match(
+            "Comma"
+            /* TOK_COMMA */
+          );
+          if (this.lookahead(0) === "Rbracket") {
+            throw new Error("Syntax error: unexpected token Rbracket");
+          }
+        } else if (this.lookahead(0) !== "Rbracket") {
+          const token = this.lookaheadToken(0);
+          this.errorToken(token, `Syntax error: unexpected token: ${token.value}(${token.type})`);
+        }
+      }
+      this.match(
+        "Rbracket"
+        /* TOK_RBRACKET */
+      );
+      return { type: "MultiSelectList", children: expressions };
+    }
+    parseMultiselectHash() {
+      const pairs = [];
+      const identifierTypes = [
+        "UnquotedIdentifier",
+        "QuotedIdentifier"
+        /* TOK_QUOTEDIDENTIFIER */
+      ];
+      let keyToken;
+      let keyName;
+      let value;
+      for (; ; ) {
+        keyToken = this.lookaheadToken(0);
+        if (!identifierTypes.includes(keyToken.type)) {
+          throw new Error(`Syntax error: expecting an identifier token, got: ${keyToken.type}`);
+        }
+        keyName = keyToken.value;
+        this.advance();
+        this.match(
+          "Colon"
+          /* TOK_COLON */
+        );
+        value = this.expression(0);
+        pairs.push({ value, type: "KeyValuePair", name: keyName });
+        if (this.lookahead(0) === "Comma") {
+          this.match(
+            "Comma"
+            /* TOK_COMMA */
+          );
+        } else if (this.lookahead(0) === "Rbrace") {
+          this.match(
+            "Rbrace"
+            /* TOK_RBRACE */
+          );
+          break;
+        } else {
+          const token = this.lookaheadToken(0);
+          this.errorToken(token, `Syntax error: unexpected token: ${token.value}(${token.type})`);
+        }
+      }
+      return { type: "MultiSelectHash", children: pairs };
+    }
+  };
+  var Parser = new TokenParser();
+  var Parser_default = Parser;
+  var normalizeBounds = (len, start, end) => {
+    let s2 = ensureInteger(start ?? 0);
+    if (s2 < 0) {
+      s2 = Math.max(0, len + s2);
+    }
+    let e = ensureInteger(end ?? len);
+    if (e < 0) {
+      e = Math.max(0, len + e);
+    }
+    return [s2, Math.min(len, e)];
+  };
+  var findFirst = (subject, sub2, start, end) => {
+    if (!subject || !sub2) {
+      return null;
+    }
+    const chars = [...subject];
+    const [s2, e] = normalizeBounds(chars.length, start, end);
+    const target = chars.slice(s2, e).join("");
+    const idx = target.indexOf(sub2);
+    return idx === -1 ? null : [...target.slice(0, idx)].length + s2;
+  };
+  var findLast = (subject, sub2, start, end) => {
+    if (!subject || !sub2) {
+      return null;
+    }
+    const chars = [...subject];
+    const [s2, e] = normalizeBounds(chars.length, start, end);
+    const target = chars.slice(s2, e).join("");
+    const idx = target.lastIndexOf(sub2);
+    return idx === -1 ? null : [...target.slice(0, idx)].length + s2;
+  };
+  var createPad = (isLeft, name) => (subject, width, padding = " ") => {
+    if ([...padding].length !== 1) {
+      throw new Error(
+        `invalid value, ${name} expects its 'pad' parameter to be a valid string with a single codepoint`
+      );
+    }
+    ensurePositiveInteger(width);
+    if (!subject) {
+      return "";
+    }
+    const padLen = width - [...subject].length;
+    if (padLen <= 0) {
+      return subject;
+    }
+    const pad2 = padding.repeat(padLen);
+    return isLeft ? pad2 + subject : subject + pad2;
+  };
+  var padLeft = createPad(true, "pad_left");
+  var padRight = createPad(false, "pad_right");
+  var replace = (subject, string, by, count) => {
+    if (count === 0) {
+      return subject;
+    }
+    const parts = subject.split(string);
+    if (count === null || count === void 0) {
+      return parts.join(by);
+    }
+    ensurePositiveInteger(count);
+    const head = parts.slice(0, count + 1).join(by);
+    const tail = parts.slice(count + 1).join(string);
+    return tail.length > 0 ? head + string + tail : head;
+  };
+  var split = (subject, search2, count) => {
+    if (subject.length === 0 && search2.length === 0) {
+      return [];
+    }
+    if (count !== null && count !== void 0) {
+      ensurePositiveInteger(count);
+      if (count === 0) {
+        return [subject];
+      }
+    }
+    const parts = search2 === "" ? [...subject] : subject.split(search2);
+    if (count === null || count === void 0) {
+      return parts;
+    }
+    return [...parts.slice(0, count), parts.slice(count).join(search2)];
+  };
+  var trimImpl = (subject, pattern, chars) => {
+    const charClass = chars ? chars.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") : "\\s\x85";
+    return subject.replace(new RegExp(pattern.replace("%s", charClass), "u"), "");
+  };
+  var trimLeft = (subject, chars) => trimImpl(subject, "^[%s]+", chars);
+  var trimRight = (subject, chars) => trimImpl(subject, "[%s]+$", chars);
+  var trim = (subject, chars) => trimLeft(trimRight(subject, chars), chars);
+  var compareStrings = (a, b) => {
+    if (a === b) {
+      return 0;
+    }
+    const itA = a[Symbol.iterator]();
+    const itB = b[Symbol.iterator]();
+    while (true) {
+      const nextA = itA.next();
+      const nextB = itB.next();
+      if (nextA.done || nextB.done) {
+        return nextA.done && nextB.done ? 0 : nextA.done ? -1 : 1;
+      }
+      if (nextA.value !== nextB.value) {
+        return nextA.value.codePointAt(0) > nextB.value.codePointAt(0) ? 1 : -1;
+      }
+    }
+  };
+  var Text = class {
+    constructor(string) {
+      this.string = string;
+    }
+    get length() {
+      return [...this.string].length;
+    }
+    compareTo(other) {
+      return compareStrings(this.string, other);
+    }
+  };
+  __publicField(Text, "comparer", compareStrings);
+  __publicField(Text, "compareStrings", compareStrings);
+  var InputArgument = /* @__PURE__ */ ((InputArgument2) => {
+    InputArgument2[InputArgument2["TYPE_NUMBER"] = 0] = "TYPE_NUMBER";
+    InputArgument2[InputArgument2["TYPE_ANY"] = 1] = "TYPE_ANY";
+    InputArgument2[InputArgument2["TYPE_STRING"] = 2] = "TYPE_STRING";
+    InputArgument2[InputArgument2["TYPE_ARRAY"] = 3] = "TYPE_ARRAY";
+    InputArgument2[InputArgument2["TYPE_OBJECT"] = 4] = "TYPE_OBJECT";
+    InputArgument2[InputArgument2["TYPE_BOOLEAN"] = 5] = "TYPE_BOOLEAN";
+    InputArgument2[InputArgument2["TYPE_EXPREF"] = 6] = "TYPE_EXPREF";
+    InputArgument2[InputArgument2["TYPE_NULL"] = 7] = "TYPE_NULL";
+    InputArgument2[InputArgument2["TYPE_ARRAY_NUMBER"] = 8] = "TYPE_ARRAY_NUMBER";
+    InputArgument2[InputArgument2["TYPE_ARRAY_STRING"] = 9] = "TYPE_ARRAY_STRING";
+    InputArgument2[InputArgument2["TYPE_ARRAY_OBJECT"] = 10] = "TYPE_ARRAY_OBJECT";
+    InputArgument2[InputArgument2["TYPE_ARRAY_ARRAY"] = 11] = "TYPE_ARRAY_ARRAY";
+    return InputArgument2;
+  })(InputArgument || {});
+  var ARRAY_SUBTYPES = {
+    [
+      8
+      /* TYPE_ARRAY_NUMBER */
+    ]: 0,
+    [
+      10
+      /* TYPE_ARRAY_OBJECT */
+    ]: 4,
+    [
+      9
+      /* TYPE_ARRAY_STRING */
+    ]: 2,
+    [
+      11
+      /* TYPE_ARRAY_ARRAY */
+    ]: 3
+    /* TYPE_ARRAY */
+  };
+  var JSON_NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  var s = (...types) => types.map((t) => ({ types: Array.isArray(t) ? t : [t] }));
+  var opt = (...types) => types.map((t) => ({ types: Array.isArray(t) ? t : [t], optional: true }));
+  var variadic = (...types) => types.map((t) => ({ types: Array.isArray(t) ? t : [t], variadic: true }));
+  var optVariadic = (...types) => types.map((t) => ({ types: Array.isArray(t) ? t : [t], variadic: true, optional: true }));
+  var {
+    TYPE_NUMBER: NUM,
+    TYPE_ANY: ANY,
+    TYPE_STRING: STR,
+    TYPE_ARRAY: ARR,
+    TYPE_OBJECT: OBJ,
+    TYPE_EXPREF: EXP,
+    TYPE_ARRAY_NUMBER: ARR_NUM,
+    TYPE_ARRAY_STRING: ARR_STR,
+    TYPE_ARRAY_ARRAY: ARR_ARR
+  } = InputArgument;
+  var Runtime = class {
+    constructor(interpreter) {
+      __publicField(this, "_interpreter");
+      __publicField(this, "_functionTable");
+      __publicField(this, "_customFunctions", /* @__PURE__ */ new Set());
+      __publicField(this, "TYPE_NAME_TABLE", Object.freeze([
+        "number",
+        "any",
+        "string",
+        "array",
+        "object",
+        "boolean",
+        "expression",
+        "null",
+        "Array<number>",
+        "Array<string>",
+        "Array<object>",
+        "Array<Array<any>>"
+      ]));
+      __publicField(this, "functionContains", ([
+        searchable,
+        searchValue
+      ]) => {
+        if (Array.isArray(searchable)) {
+          const array = searchable;
+          return array.includes(searchValue);
+        }
+        if (typeof searchable === "string") {
+          const text = searchable;
+          if (typeof searchValue === "string") {
+            return text.includes(searchValue);
+          }
+          return false;
+        }
+        return null;
+      });
+      __publicField(this, "functionFromItems", ([array]) => {
+        for (const pair of array) {
+          if (pair.length !== 2 || typeof pair[0] !== "string") {
+            throw new Error("invalid value, each array must contain two elements, a pair of string and value");
+          }
+        }
+        return Object.fromEntries(array);
+      });
+      __publicField(this, "functionGroupBy", ([array, exprefNode]) => {
+        const interpreter2 = this._interpreter;
+        if (!interpreter2) {
+          return {};
+        }
+        const groups = /* @__PURE__ */ new Map();
+        for (const item of array) {
+          const raw = interpreter2.visit(exprefNode, item);
+          if (raw === null || raw === void 0) {
+            continue;
+          }
+          if (typeof raw !== "string") {
+            const type = this.getTypeName(raw);
+            throw new Error(
+              `Invalid type: expected one of (${this.TYPE_NAME_TABLE[
+                2
+                /* TYPE_STRING */
+              ]}), received ${this.TYPE_NAME_TABLE[type]}`
+            );
+          }
+          let group = groups.get(raw);
+          if (!group) {
+            group = [];
+            groups.set(raw, group);
+          }
+          group.push(item);
+        }
+        return Object.fromEntries(groups);
+      });
+      __publicField(this, "functionMap", ([exprefNode, elements]) => {
+        if (!this._interpreter) {
+          return [];
+        }
+        const mapped = [];
+        const interpreter2 = this._interpreter;
+        for (let i = 0; i < elements.length; i += 1) {
+          mapped.push(interpreter2.visit(exprefNode, elements[i]));
+        }
+        return mapped;
+      });
+      __publicField(this, "functionSort", ([inputValue]) => inputValue.length <= 1 ? inputValue : typeof inputValue[0] === "string" ? [...inputValue].sort(Text.comparer) : [...inputValue].sort((a, b) => a - b));
+      __publicField(this, "functionSortBy", (resolvedArgs) => {
+        const sortedArray = [...resolvedArgs[0]];
+        if (sortedArray.length === 0) {
+          return sortedArray;
+        }
+        const interpreter2 = this._interpreter;
+        const exprefNode = resolvedArgs[1];
+        const requiredType = this.getTypeName(interpreter2.visit(exprefNode, sortedArray[0]));
+        if (requiredType === void 0 || ![
+          0,
+          2
+          /* TYPE_STRING */
+        ].includes(requiredType)) {
+          const typeName = requiredType !== void 0 ? this.TYPE_NAME_TABLE[requiredType] : "undefined";
+          throw new Error(`Invalid type: unexpected type (${typeName})`);
+        }
+        if (sortedArray.length === 1) {
+          return sortedArray;
+        }
+        function throwInvalidTypeError(rt, item) {
+          throw new Error(
+            `Invalid type: expected (${rt.TYPE_NAME_TABLE[requiredType]}), received ${rt.TYPE_NAME_TABLE[rt.getTypeName(item)]}`
+          );
+        }
+        return sortedArray.sort((a, b) => {
+          const exprA = interpreter2.visit(exprefNode, a);
+          const exprB = interpreter2.visit(exprefNode, b);
+          if (this.getTypeName(exprA) !== requiredType) {
+            throwInvalidTypeError(this, exprA);
+          } else if (this.getTypeName(exprB) !== requiredType) {
+            throwInvalidTypeError(this, exprB);
+          }
+          if (requiredType === 2) {
+            return Text.comparer(exprA, exprB);
+          }
+          return exprA - exprB;
+        });
+      });
+      __publicField(this, "functionToNumber", ([inputValue]) => {
+        const typeName = this.getTypeName(inputValue);
+        if (typeName === 0) {
+          return inputValue;
+        }
+        if (typeName === 2) {
+          const str = inputValue;
+          if (JSON_NUMBER_REGEX.test(str)) {
+            const convertedValue = Number(str);
+            if (!isNaN(convertedValue)) {
+              return convertedValue;
+            }
+          }
+        }
+        return null;
+      });
+      __publicField(this, "functionType", ([inputValue]) => {
+        const type = this.getTypeName(inputValue);
+        const name = type !== void 0 ? this.TYPE_NAME_TABLE[type] : void 0;
+        if (!name) {
+          throw new Error("invalid-type");
+        }
+        return name;
+      });
+      __publicField(this, "functionZip", (array) => {
+        const length = Math.min(...array.map((arr) => arr.length));
+        return Array.from({ length }, (_, index) => array.map((arr) => arr[index]));
+      });
+      this._interpreter = interpreter;
+      this._functionTable = this.buildFunctionTable();
+    }
+    buildFunctionTable() {
+      return {
+        abs: { _func: ([v]) => Math.abs(v), _signature: s(NUM) },
+        ceil: { _func: ([v]) => Math.ceil(v), _signature: s(NUM) },
+        floor: { _func: ([v]) => Math.floor(v), _signature: s(NUM) },
+        lower: { _func: ([s2]) => s2.toLowerCase(), _signature: s(STR) },
+        upper: { _func: ([s2]) => s2.toUpperCase(), _signature: s(STR) },
+        keys: { _func: ([o]) => Object.keys(o), _signature: s(OBJ) },
+        values: { _func: ([o]) => Object.values(o), _signature: s(OBJ) },
+        avg: {
+          _func: ([arr]) => arr && arr.length ? arr.reduce((a, b) => a + b, 0) / arr.length : null,
+          _signature: s(ARR_NUM)
+        },
+        contains: { _func: this.functionContains, _signature: s([STR, ARR], ANY) },
+        ends_with: { _func: ([str, suf]) => str.endsWith(suf), _signature: s(STR, STR) },
+        find_first: {
+          _func: ([s2, sub2, st, en]) => findFirst(s2, sub2, st, en),
+          _signature: [...s(STR, STR), ...opt(NUM, NUM)]
+        },
+        find_last: {
+          _func: ([s2, sub2, st, en]) => findLast(s2, sub2, st, en),
+          _signature: [...s(STR, STR), ...opt(NUM, NUM)]
+        },
+        from_items: { _func: this.functionFromItems, _signature: s(ARR_ARR) },
+        group_by: { _func: this.functionGroupBy, _signature: s(ARR, EXP) },
+        items: { _func: ([o]) => Object.entries(o), _signature: s(OBJ) },
+        join: { _func: ([sep, arr]) => arr.join(sep), _signature: s(STR, ARR_STR) },
+        length: {
+          _func: ([v]) => typeof v === "string" ? [...v].length : Array.isArray(v) ? v.length : Object.keys(v).length,
+          _signature: s([STR, ARR, OBJ])
+        },
+        map: { _func: this.functionMap, _signature: s(EXP, ARR) },
+        max: {
+          _func: ([v]) => this.findExtreme(v, (cmp) => cmp > 0, Math.max),
+          _signature: s([ARR_NUM, ARR_STR])
+        },
+        max_by: {
+          _func: (args) => this.findExtremeBy(args, (cmp) => cmp > 0),
+          _signature: s(ARR, EXP)
+        },
+        merge: { _func: (args) => Object.assign({}, ...args), _signature: optVariadic(OBJ) },
+        min: {
+          _func: ([v]) => this.findExtreme(v, (cmp) => cmp < 0, Math.min),
+          _signature: s([ARR_NUM, ARR_STR])
+        },
+        min_by: {
+          _func: (args) => this.findExtremeBy(args, (cmp) => cmp < 0),
+          _signature: s(ARR, EXP)
+        },
+        not_null: {
+          _func: (args) => args.find((arg) => arg !== null) ?? null,
+          _signature: variadic(ANY)
+        },
+        pad_left: {
+          _func: ([s2, w, p]) => padLeft(s2, w, p),
+          _signature: [...s(STR, NUM), ...opt(STR)]
+        },
+        pad_right: {
+          _func: ([s2, w, p]) => padRight(s2, w, p),
+          _signature: [...s(STR, NUM), ...opt(STR)]
+        },
+        replace: {
+          _func: ([s2, str, by, c]) => replace(s2, str, by, c),
+          _signature: [...s(STR, STR, STR), ...opt(NUM)]
+        },
+        reverse: {
+          _func: ([v]) => typeof v === "string" ? [...v].reverse().join("") : [...v].reverse(),
+          _signature: s([STR, ARR])
+        },
+        sort: { _func: this.functionSort, _signature: s([ARR_STR, ARR_NUM]) },
+        sort_by: { _func: this.functionSortBy, _signature: s(ARR, EXP) },
+        split: {
+          _func: ([s2, sub2, c]) => split(s2, sub2, c),
+          _signature: [...s(STR, STR), ...opt(NUM)]
+        },
+        starts_with: { _func: ([str, pre]) => str.startsWith(pre), _signature: s(STR, STR) },
+        sum: { _func: ([arr]) => arr.reduce((x, y) => x + y, 0), _signature: s(ARR_NUM) },
+        to_array: { _func: ([v]) => Array.isArray(v) ? v : [v], _signature: s(ANY) },
+        to_number: { _func: this.functionToNumber, _signature: s(ANY) },
+        to_string: {
+          _func: ([v]) => typeof v === "string" ? v : JSON.stringify(v),
+          _signature: s(ANY)
+        },
+        trim: {
+          _func: ([s2, c]) => trim(s2, c),
+          _signature: [...s(STR), ...opt(STR)]
+        },
+        trim_left: {
+          _func: ([s2, c]) => trimLeft(s2, c),
+          _signature: [...s(STR), ...opt(STR)]
+        },
+        trim_right: {
+          _func: ([s2, c]) => trimRight(s2, c),
+          _signature: [...s(STR), ...opt(STR)]
+        },
+        type: { _func: this.functionType, _signature: s(ANY) },
+        zip: { _func: this.functionZip, _signature: variadic(ARR) }
+      };
+    }
+    /**
+     * Enhanced registerFunction with backward compatibility and new options
+     * @deprecated Use register() method for enhanced functionality
+     */
+    registerFunction(name, customFunction, signature, options) {
+      const result = this._registerInternal(name, customFunction, signature, options);
+      if (!result.success) {
+        throw new Error(result.message);
+      }
+    }
+    /**
+     * Internal registration method that bypasses TypeScript type checking
+     */
+    _registerInternal(name, customFunction, signature, options = {}) {
+      if (!name || typeof name !== "string" || name.trim() === "") {
+        return {
+          success: false,
+          reason: "invalid-name",
+          message: "Function name must be a non-empty string"
+        };
+      }
+      try {
+        this.validateInputSignatures(name, signature);
+      } catch (error) {
+        return {
+          success: false,
+          reason: "invalid-signature",
+          message: error instanceof Error ? error.message : "Invalid function signature"
+        };
+      }
+      const { override = false, warn = false } = options;
+      const exists = name in this._functionTable;
+      if (exists && !override) {
+        return {
+          success: false,
+          reason: "already-exists",
+          message: `Function already defined: ${name}(). Use { override: true } to replace it.`
+        };
+      }
+      if (exists && override && warn) {
+        console.warn(`Warning: Overriding existing function: ${name}()`);
+      }
+      this._functionTable[name] = {
+        _func: customFunction.bind(this),
+        _signature: signature
+      };
+      this._customFunctions.add(name);
+      const message = exists ? `Function ${name}() overridden successfully` : `Function ${name}() registered successfully`;
+      return { success: true, message };
+    }
+    /**
+     * Register a new function with enhanced options and type safety
+     */
+    register(name, customFunction, signature, options = {}) {
+      return this._registerInternal(name, customFunction, signature, options);
+    }
+    /**
+     * Unregister a custom function (built-in functions cannot be unregistered)
+     */
+    unregister(name) {
+      if (!this._customFunctions.has(name)) {
+        return false;
+      }
+      delete this._functionTable[name];
+      this._customFunctions.delete(name);
+      return true;
+    }
+    /**
+     * Check if a function is registered
+     */
+    isRegistered(name) {
+      return name in this._functionTable;
+    }
+    /**
+     * Get list of all registered function names
+     */
+    getRegistered() {
+      return Object.keys(this._functionTable);
+    }
+    /**
+     * Get list of custom (non-built-in) function names
+     */
+    getCustomFunctions() {
+      return Array.from(this._customFunctions);
+    }
+    /**
+     * Clear all custom functions (built-in functions remain)
+     */
+    clearCustomFunctions() {
+      for (const name of this._customFunctions) {
+        delete this._functionTable[name];
+      }
+      this._customFunctions.clear();
+    }
+    callFunction(name, resolvedArgs) {
+      const functionEntry = this._functionTable[name];
+      if (functionEntry === void 0) {
+        throw new Error(`Unknown function: ${name}()`);
+      }
+      this.validateArgs(name, resolvedArgs, functionEntry._signature);
+      return functionEntry._func.call(this, resolvedArgs);
+    }
+    validateInputSignatures(name, signature) {
+      for (let i = 0; i < signature.length; i += 1) {
+        if ("variadic" in signature[i] && i !== signature.length - 1) {
+          throw new Error(`Invalid arity: ${name}() 'variadic' argument ${i + 1} must occur last`);
+        }
+      }
+    }
+    validateArgs(name, args, signature) {
+      this.validateInputSignatures(name, signature);
+      this.validateArity(name, args, signature);
+      this.validateTypes(name, args, signature);
+    }
+    validateArity(name, args, signature) {
+      const numberOfRequiredArgs = signature.filter((argSignature) => !(argSignature.optional ?? false)).length;
+      const lastArgIsVariadic = signature[signature.length - 1]?.variadic ?? false;
+      const tooFewArgs = args.length < numberOfRequiredArgs;
+      const tooManyArgs = args.length > signature.length;
+      if (lastArgIsVariadic && tooFewArgs || !lastArgIsVariadic && (tooFewArgs || tooManyArgs)) {
+        const tooFewModifier = tooFewArgs && (!lastArgIsVariadic && numberOfRequiredArgs > 1 || lastArgIsVariadic) ? "at least " : "";
+        const pluralized = signature.length > 1;
+        throw new Error(
+          `Invalid arity: ${name}() takes ${tooFewModifier}${numberOfRequiredArgs} argument${pluralized && "s" || ""} but received ${args.length}`
+        );
+      }
+    }
+    validateTypes(name, args, signature) {
+      const lastSigIndex = signature.length - 1;
+      const isVariadic = signature[lastSigIndex]?.variadic ?? false;
+      for (let i = 0; i < args.length; i += 1) {
+        const sig = i < signature.length ? signature[i] : isVariadic ? signature[lastSigIndex] : void 0;
+        if (!sig) {
+          continue;
+        }
+        const currentSpec = sig.types;
+        const actualType = this.getTypeName(args[i]);
+        if (actualType === void 0) {
+          continue;
+        }
+        const typeMatched = currentSpec.some((expectedType) => this.typeMatches(actualType, expectedType, args[i]));
+        if (!typeMatched) {
+          const expected = currentSpec.map((typeId) => this.TYPE_NAME_TABLE[typeId]).join(" | ");
+          throw new Error(
+            `Invalid type: ${name}() expected argument ${i + 1} to be type (${expected}) but received type ${this.TYPE_NAME_TABLE[actualType]} instead.`
+          );
+        }
+      }
+    }
+    typeMatches(actual, expected, argValue) {
+      if (expected === 1) {
+        return true;
+      }
+      const subtype = ARRAY_SUBTYPES[expected];
+      if (subtype !== void 0) {
+        if (actual !== 3) {
+          return false;
+        }
+        const array = argValue;
+        return array.every((item) => {
+          const typeName = this.getTypeName(item);
+          return typeName === void 0 || this.typeMatches(typeName, subtype, item);
+        });
+      }
+      return actual === expected;
+    }
+    getTypeName(obj) {
+      if (obj === null) {
+        return 7;
+      }
+      if (typeof obj === "string") {
+        return 2;
+      }
+      if (typeof obj === "number") {
+        return 0;
+      }
+      if (typeof obj === "boolean") {
+        return 5;
+      }
+      if (Array.isArray(obj)) {
+        return 3;
+      }
+      if (typeof obj === "object") {
+        if (obj.expref) {
+          return 6;
+        }
+        return 4;
+      }
+      return;
+    }
+    createKeyFunction(exprefNode, allowedTypes) {
+      const interpreter = this._interpreter;
+      const keyFunc = (x) => {
+        const current = interpreter.visit(exprefNode, x);
+        if (!allowedTypes.includes(this.getTypeName(current))) {
+          const msg = `Invalid type: expected one of (${allowedTypes.map((t) => this.TYPE_NAME_TABLE[t]).join(" | ")}), received ${this.TYPE_NAME_TABLE[this.getTypeName(current)]}`;
+          throw new Error(msg);
+        }
+        return current;
+      };
+      return keyFunc;
+    }
+    findExtreme(inputValue, isBetter, mathFn) {
+      if (!inputValue.length) {
+        return null;
+      }
+      if (this.getTypeName(inputValue[0]) === 0) {
+        return mathFn(...inputValue);
+      }
+      const elements = inputValue;
+      let extreme = elements[0];
+      for (let i = 1; i < elements.length; i += 1) {
+        if (isBetter(Text.comparer(elements[i], extreme))) {
+          extreme = elements[i];
+        }
+      }
+      return extreme;
+    }
+    findExtremeBy(resolvedArgs, isBetter) {
+      const resolvedArray = resolvedArgs[0];
+      if (!resolvedArray.length) {
+        return null;
+      }
+      const exprefNode = resolvedArgs[1];
+      const interpreter = this._interpreter;
+      if (!interpreter) {
+        return null;
+      }
+      const firstKey = interpreter.visit(exprefNode, resolvedArray[0]);
+      const firstType = this.getTypeName(firstKey);
+      if (firstType !== 0 && firstType !== 2) {
+        throw new Error(
+          `Invalid type: expected one of (${this.TYPE_NAME_TABLE[
+            0
+            /* TYPE_NUMBER */
+          ]} | ${this.TYPE_NAME_TABLE[
+            2
+            /* TYPE_STRING */
+          ]}), received ${this.TYPE_NAME_TABLE[firstType]}`
+        );
+      }
+      let extremeRecord = resolvedArray[0];
+      let extremeKey = firstKey;
+      for (let i = 1; i < resolvedArray.length; i += 1) {
+        const currentKey = interpreter.visit(exprefNode, resolvedArray[i]);
+        const currentType = this.getTypeName(currentKey);
+        if (currentType !== firstType) {
+          throw new Error(
+            `Invalid type: expected (${this.TYPE_NAME_TABLE[firstType]}), received ${this.TYPE_NAME_TABLE[currentType]}`
+          );
+        }
+        const cmp = firstType === 0 ? currentKey - extremeKey : Text.comparer(currentKey, extremeKey);
+        if (isBetter(cmp)) {
+          extremeKey = currentKey;
+          extremeRecord = resolvedArray[i];
+        }
+      }
+      return extremeRecord;
+    }
+  };
+  var ScopeChain = class _ScopeChain {
+    constructor() {
+      __publicField(this, "inner");
+      __publicField(this, "data", {});
+    }
+    get currentScopeData() {
+      return this.data;
+    }
+    withScope(data) {
+      const outer = new _ScopeChain();
+      outer.inner = this;
+      outer.data = data;
+      return outer;
+    }
+    hasValue(identifier) {
+      if (Object.prototype.hasOwnProperty.call(this.data, identifier)) {
+        return true;
+      }
+      if (this.inner) {
+        return this.inner.hasValue(identifier);
+      }
+      return false;
+    }
+    getValue(identifier) {
+      if (Object.prototype.hasOwnProperty.call(this.data, identifier)) {
+        return this.data[identifier];
+      }
+      if (this.inner) {
+        return this.inner.getValue(identifier);
+      }
+      return null;
+    }
+  };
+  var emptyScopeChain = new ScopeChain();
+  var TreeInterpreter = class _TreeInterpreter {
+    constructor(options) {
+      __publicField(this, "runtime");
+      __publicField(this, "_rootValue", null);
+      __publicField(this, "_scope");
+      __publicField(this, "_options");
+      __publicField(this, "_depth", 0);
+      __publicField(this, "_maxDepth", DEFAULT_MAX_DEPTH);
+      __publicField(this, "_deadline", 0);
+      this.runtime = new Runtime(this);
+      this._scope = new ScopeChain();
+      this._maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+      if (options) {
+        this._options = options;
+        this._deadline = options.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : 0;
+      }
+    }
+    withScope(scope) {
+      const interpreter = new _TreeInterpreter(this._options);
+      interpreter.runtime = this.runtime;
+      interpreter._rootValue = this._rootValue;
+      interpreter._scope = this._scope.withScope(scope);
+      interpreter._depth = this._depth;
+      interpreter._maxDepth = this._maxDepth;
+      interpreter._deadline = this._deadline;
+      return interpreter;
+    }
+    search(node, value, options) {
+      if (options?.maxNodes !== void 0 && countNodes(node) > options.maxNodes) {
+        throw new Error(`Expression exceeds maximum allowed node count of ${options.maxNodes}`);
+      }
+      this._rootValue = value;
+      this._scope = emptyScopeChain;
+      this._options = options;
+      this._maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+      this._depth = 0;
+      this._deadline = options?.timeoutMs !== void 0 ? Date.now() + options.timeoutMs : 0;
+      const result = this.visit(node, value);
+      this.checkOutputSize(result);
+      return result;
+    }
+    checkOutputSize(val) {
+      const max = this._options?.maxOutputSize;
+      if (max === void 0 || val == null) {
+        return;
+      }
+      const size = Array.isArray(val) || typeof val === "string" ? val.length : typeof val === "object" ? Object.keys(val).length : 0;
+      if (size > max) {
+        throw new Error(`Output size exceeds maximum allowed size of ${max}`);
+      }
+    }
+    collect(target, item) {
+      target.push(item);
+      if (this._options?.maxOutputSize !== void 0 && target.length > this._options.maxOutputSize) {
+        throw new Error(`Output size exceeds maximum allowed size of ${this._options.maxOutputSize}`);
+      }
+    }
+    evaluateProjectionItems(items, right) {
+      const collected = [];
+      if (right.type === "Field") {
+        const key = right.name;
+        for (let i = 0; i < items.length; i++) {
+          if (this._deadline > 0 && Date.now() >= this._deadline) {
+            throw new Error(`Query execution timed out after ${this._options?.timeoutMs}ms`);
+          }
+          const elem = items[i];
+          if (!elem || typeof elem !== "object" || Array.isArray(elem)) {
+            continue;
+          }
+          if (!Object.prototype.hasOwnProperty.call(elem, key)) {
+            continue;
+          }
+          const val = elem[key];
+          if (val !== void 0 && val !== null) {
+            this.collect(collected, val);
+          }
+        }
+        return collected;
+      }
+      if (right.type === "Identity") {
+        for (let i = 0; i < items.length; i++) {
+          const elem = items[i];
+          if (elem !== null) {
+            this.collect(collected, elem);
+          }
+        }
+        return collected;
+      }
+      for (const elem of items) {
+        const current = this.visit(right, elem);
+        if (current !== null) {
+          this.collect(collected, current);
+        }
+      }
+      return collected;
+    }
+    visit(node, value) {
+      if (this._deadline > 0 && Date.now() >= this._deadline) {
+        throw new Error(`Query execution timed out after ${this._options?.timeoutMs}ms`);
+      }
+      if (this._depth >= this._maxDepth) {
+        throw new Error(`Evaluation exceeds maximum allowed depth of ${this._maxDepth}`);
+      }
+      this._depth += 1;
+      try {
+        return this.evaluateNode(node, value);
+      } finally {
+        this._depth -= 1;
+      }
+    }
+    evaluateNode(node, value) {
+      switch (node.type) {
+        case "Ternary": {
+          const condition = this.visit(node.condition, value);
+          if (!isFalse(condition)) {
+            return this.visit(node.trueExpr, value);
+          }
+          return this.visit(node.falseExpr, value);
+        }
+        case "Field":
+          const identifier = node.name;
+          if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            return null;
+          }
+          return Object.prototype.hasOwnProperty.call(value, identifier) ? value[identifier] ?? null : null;
+        case "LetExpression": {
+          const scope = {};
+          for (const binding of node.bindings) {
+            const bound = this.visit(binding, value);
+            for (const key of Object.keys(bound)) {
+              Object.defineProperty(scope, key, {
+                value: bound[key],
+                enumerable: true,
+                writable: true,
+                configurable: true
+              });
+            }
+          }
+          return this.withScope(scope).visit(node.expression, value);
+        }
+        case "Binding": {
+          const { variable, reference } = node;
+          const result = this.visit(reference, value);
+          const binding = {};
+          Object.defineProperty(binding, variable, {
+            value: result,
+            enumerable: true,
+            writable: true,
+            configurable: true
+          });
+          return binding;
+        }
+        case "Variable": {
+          const variable = node.name;
+          if (!this._scope.hasValue(variable)) {
+            throw new Error(`Error referencing undefined variable ${variable}`);
+          }
+          return this._scope.getValue(variable);
+        }
+        case "IndexExpression":
+          return this.visit(node.right, this.visit(node.left, value));
+        case "Subexpression": {
+          const result = this.visit(node.left, value);
+          return result != null ? this.visit(node.right, result) ?? null : null;
+        }
+        case "Index": {
+          if (!Array.isArray(value)) {
+            return null;
+          }
+          const index = node.value < 0 ? value.length + node.value : node.value;
+          return value[index] ?? null;
+        }
+        case "Slice": {
+          if (!Array.isArray(value) && typeof value !== "string") {
+            return null;
+          }
+          const target = typeof value === "string" ? [...value] : value;
+          const { start, stop, step } = this.computeSliceParams(target.length, node);
+          const sliced = this.slice(target, start, stop, step);
+          const res = typeof value === "string" ? sliced.join("") : sliced;
+          this.checkOutputSize(res);
+          return res;
+        }
+        case "Projection": {
+          const { left, right } = node;
+          const allowString = left.type === "IndexExpression" && left.right.type === "Slice";
+          const base = this.visit(left, value);
+          if (allowString && typeof base === "string") {
+            return this.visit(right, base);
+          }
+          return Array.isArray(base) ? this.evaluateProjectionItems(base, right) : null;
+        }
+        case "ValueProjection": {
+          const base = this.visit(node.left, value);
+          if (base === null || typeof base !== "object" || Array.isArray(base)) {
+            return null;
+          }
+          return this.evaluateProjectionItems(Object.values(base), node.right);
+        }
+        case "FilterProjection": {
+          const { left, right, condition } = node;
+          const base = this.visit(left, value);
+          if (!Array.isArray(base)) {
+            return null;
+          }
+          const results = [];
+          if (right.type === "Field") {
+            const key = right.name;
+            for (let i = 0; i < base.length; i++) {
+              const elem = base[i];
+              if (isFalse(this.visit(condition, elem))) {
+                continue;
+              }
+              if (!elem || typeof elem !== "object" || Array.isArray(elem)) {
+                continue;
+              }
+              if (!Object.prototype.hasOwnProperty.call(elem, key)) {
+                continue;
+              }
+              const val = elem[key];
+              if (val !== void 0 && val !== null) {
+                this.collect(results, val);
+              }
+            }
+            return results;
+          }
+          if (right.type === "Identity") {
+            for (let i = 0; i < base.length; i++) {
+              const elem = base[i];
+              if (isFalse(this.visit(condition, elem))) {
+                continue;
+              }
+              if (elem !== null) {
+                this.collect(results, elem);
+              }
+            }
+            return results;
+          }
+          for (const elem of base) {
+            if (isFalse(this.visit(condition, elem))) {
+              continue;
+            }
+            const result = this.visit(right, elem);
+            if (result !== null) {
+              this.collect(results, result);
+            }
+          }
+          return results;
+        }
+        case "Arithmetic": {
+          const first = this.visit(node.left, value);
+          const second = this.visit(node.right, value);
+          switch (node.operator) {
+            case "Plus":
+              return add(first, second);
+            case "Minus":
+              return sub(first, second);
+            case "Multiply":
+            case "Star":
+              return mul(first, second);
+            case "Divide":
+              return divide(first, second);
+            case "Modulo":
+              return mod(first, second);
+            case "Div":
+              return div(first, second);
+            default:
+              throw new Error(`Syntax error: unknown arithmetic operator: ${node.operator}`);
+          }
+        }
+        case "Unary": {
+          const operand = this.visit(node.operand, value);
+          switch (node.operator) {
+            case "Plus":
+              ensureNumbers(operand);
+              return operand;
+            case "Minus":
+              ensureNumbers(operand);
+              return -operand;
+            default:
+              throw new Error(`Syntax error: unknown arithmetic operator: ${node.operator}`);
+          }
+        }
+        case "Comparator": {
+          const first = this.visit(node.left, value);
+          const second = this.visit(node.right, value);
+          switch (node.name) {
+            case "EQ":
+              return strictDeepEqual(first, second);
+            case "NE":
+              return !strictDeepEqual(first, second);
+          }
+          if (typeof first !== "number" || typeof second !== "number") {
+            return null;
+          }
+          switch (node.name) {
+            case "GT":
+              return first > second;
+            case "GTE":
+              return first >= second;
+            case "LT":
+              return first < second;
+            case "LTE":
+              return first <= second;
+          }
+        }
+        case "Flatten": {
+          const original = this.visit(node.child, value);
+          const res = Array.isArray(original) ? original.flat() : null;
+          this.checkOutputSize(res);
+          return res;
+        }
+        case "Root":
+          return this._rootValue;
+        case "MultiSelectList": {
+          const collected = [];
+          for (const child of node.children) {
+            collected.push(this.visit(child, value));
+          }
+          this.checkOutputSize(collected);
+          return collected;
+        }
+        case "MultiSelectHash": {
+          const collected = {};
+          for (const child of node.children) {
+            Object.defineProperty(collected, child.name, {
+              value: this.visit(child.value, value),
+              enumerable: true,
+              writable: true,
+              configurable: true
+            });
+          }
+          this.checkOutputSize(collected);
+          return collected;
+        }
+        case "OrExpression": {
+          const result = this.visit(node.left, value);
+          if (isFalse(result)) {
+            return this.visit(node.right, value);
+          }
+          return result;
+        }
+        case "AndExpression": {
+          const result = this.visit(node.left, value);
+          if (isFalse(result)) {
+            return result;
+          }
+          return this.visit(node.right, value);
+        }
+        case "NotExpression":
+          return isFalse(this.visit(node.child, value));
+        case "Literal":
+          return node.value;
+        case "Pipe":
+          return this.visit(node.right, this.visit(node.left, value));
+        case "Function": {
+          if (this._options?.allowedFunctions && !this._options.allowedFunctions.includes(node.name)) {
+            throw new Error(`Function '${node.name}' is not allowed`);
+          }
+          if (this._options?.disallowedFunctions && this._options.disallowedFunctions.includes(node.name)) {
+            throw new Error(`Function '${node.name}' is disallowed`);
+          }
+          const args = [];
+          for (const child of node.children) {
+            args.push(this.visit(child, value));
+          }
+          const prevInterpreter = this.runtime._interpreter;
+          this.runtime._interpreter = this;
+          try {
+            const res = this.runtime.callFunction(node.name, args);
+            this.checkOutputSize(res);
+            return res;
+          } finally {
+            this.runtime._interpreter = prevInterpreter;
+          }
+        }
+        case "ExpressionReference":
+          return {
+            expref: true,
+            ...node.child
+          };
+        case "Current":
+        case "Identity":
+          return value;
+      }
+    }
+    computeSliceParams(arrayLength, sliceNode) {
+      let { start, stop, step } = sliceNode;
+      if (step === null) {
+        step = 1;
+      } else if (step === 0) {
+        const error = new Error("Invalid value: slice step cannot be 0");
+        error.name = "RuntimeError";
+        throw error;
+      }
+      start = start === null ? step < 0 ? arrayLength - 1 : 0 : this.capSliceRange(arrayLength, start, step);
+      stop = stop === null ? step < 0 ? -1 : arrayLength : this.capSliceRange(arrayLength, stop, step);
+      return { start, stop, step };
+    }
+    capSliceRange(arrayLength, actualValue, step) {
+      let nextActualValue = actualValue;
+      if (nextActualValue < 0) {
+        nextActualValue += arrayLength;
+        if (nextActualValue < 0) {
+          nextActualValue = step < 0 ? -1 : 0;
+        }
+      } else if (nextActualValue >= arrayLength) {
+        nextActualValue = step < 0 ? arrayLength - 1 : arrayLength;
+      }
+      return nextActualValue;
+    }
+    slice(collection, start, end, step) {
+      if (step === 1) {
+        return collection.slice(start, end);
+      }
+      const len = Math.max(0, Math.ceil((end - start) / step));
+      const result = new Array(len);
+      let idx = 0;
+      if (step > 0) {
+        for (let i = start; i < end; i += step) {
+          result[idx++] = collection[i];
+        }
+      } else {
+        for (let i = start; i > end; i += step) {
+          result[idx++] = collection[i];
+        }
+      }
+      return result;
+    }
+  };
+  var TreeInterpreterInstance = new TreeInterpreter();
+  var TreeInterpreter_default = TreeInterpreterInstance;
+  function compile(expression, options) {
+    return Parser_default.parse(expression, options);
+  }
+  var TreeInterpreter2 = TreeInterpreter_default;
+
+  // packages/recipe/src/jmes.ts
+  var cache = /* @__PURE__ */ new Map();
+  function compileJmes(expr) {
+    let ast = cache.get(expr);
+    if (!ast) {
+      ast = compile(expr);
+      if (cache.size > 2e3) cache.clear();
+      cache.set(expr, ast);
+    }
+    return ast;
+  }
+  function jmes(data, expr) {
+    const v = TreeInterpreter2.search(compileJmes(expr), data ?? null);
+    return v === void 0 ? null : v;
+  }
+  function jmesCtx(ctx, expr) {
+    return jmes(toJson(ctx), expr);
+  }
+  function truthy(v) {
+    if (v === null || v === void 0 || v === false || v === "") return false;
+    if (Array.isArray(v)) return v.length > 0;
+    if (typeof v === "object") return Object.keys(v).length > 0;
+    return true;
+  }
+  function toJson(v) {
+    if (v === void 0) return null;
+    if (v instanceof Date) return v.toISOString();
+    if (Array.isArray(v)) return v.map((x) => x === void 0 ? null : toJson(x));
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, x] of Object.entries(v)) if (x !== void 0) out[k] = toJson(x);
+      return out;
+    }
+    return v;
+  }
+
+  // packages/recipe/src/html.ts
+  var SELF = /* @__PURE__ */ new Set(["", ".", ":scope"]);
+  var NOT_TEXT = /* @__PURE__ */ new Set(["STYLE", "SCRIPT", "NOSCRIPT", "TEMPLATE"]);
+  function visibleText(node) {
+    if (!node.childNodes || NOT_TEXT.has((node.nodeName ?? "").toUpperCase())) return node.textContent ?? "";
+    let out = "";
+    const walk2 = (n) => {
+      const kids = n.childNodes;
+      if (!kids) return;
+      for (let i = 0; i < kids.length; i++) {
+        const c = kids[i];
+        if (c.nodeType === 3 || c.nodeType === 4) out += c.nodeValue ?? c.textContent ?? "";
+        else if (c.nodeType === 1 && !NOT_TEXT.has((c.nodeName ?? "").toUpperCase())) walk2(c);
+      }
+    };
+    walk2(node);
+    return out;
+  }
+  function readNode(node, attr) {
+    if (attr === "textContent") return (node.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (attr && attr !== "text") return node.getAttribute(attr);
+    return visibleText(node).replace(/\s+/g, " ").trim();
+  }
+  var MAX_JSON_VALUE = 256 * 1024;
+  function readValue(node, f) {
+    if (f.parse !== "json") return readNode(node, f.attr);
+    const raw = f.attr && f.attr !== "text" && f.attr !== "textContent" ? node.getAttribute(f.attr) : node.textContent ?? "";
+    if (raw === null || raw.length > MAX_JSON_VALUE) return null;
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+    if (!f.path) return data;
+    try {
+      return jmes(data, f.path) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  function select(root, selector) {
+    if (SELF.has(selector.trim())) return root;
+    return root.querySelector(selector);
+  }
+  function extractHtml(doc, spec) {
+    if (spec.all) {
+      return Array.from(doc.querySelectorAll(spec.selector)).map((n) => readValue(n, spec));
+    }
+    const node = doc.querySelector(spec.selector);
+    return node ? readValue(node, spec) : null;
+  }
+  function extractHtmlItems(doc, spec) {
+    const max = Math.min(spec.max ?? 50, 100);
+    const nodes = Array.from(doc.querySelectorAll(spec.selector)).slice(0, max);
+    return nodes.map((item) => {
+      const row = {};
+      for (const [name, f] of Object.entries(spec.fields)) {
+        const n = select(item, f.selector);
+        row[name] = n ? readValue(n, f) : null;
+      }
+      return row;
+    });
+  }
+  function extractEmbeddedJson(doc, spec, step) {
+    const node = doc.querySelector(spec.selector);
+    if (!node) {
+      if (spec.required === false) return Object.fromEntries(Object.keys(spec.vars).map((k) => [k, null]));
+      throw new RecipeError("expect_failed", `embedded_json: no element matches ${spec.selector}`, step);
+    }
+    let raw = (spec.attr ? node.getAttribute(spec.attr) : node.textContent) ?? "";
+    if (spec.strip_js || spec.strip_js_after !== void 0) {
+      let from = raw;
+      if (spec.strip_js_after !== void 0) {
+        const at = raw.indexOf(spec.strip_js_after);
+        if (at < 0) {
+          if (spec.required === false) return Object.fromEntries(Object.keys(spec.vars).map((k) => [k, null]));
+          throw new RecipeError("expect_failed", `embedded_json: ${spec.selector} does not contain ${JSON.stringify(spec.strip_js_after.slice(0, 60))}`, step);
+        }
+        from = raw.slice(at + spec.strip_js_after.length);
+      }
+      const cut = firstBalancedJson(from);
+      if (cut === null) throw new RecipeError("expect_failed", `embedded_json: no JSON object or array found in ${spec.selector}`, step);
+      raw = cut;
+    }
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      throw new RecipeError("expect_failed", `embedded_json: ${spec.selector}${spec.attr ? `[${spec.attr}]` : ""} is not valid JSON`, step);
+    }
+    if (spec.decode === "astro_props") data = decodeAstroProps(data);
+    const out = {};
+    for (const [name, expr] of Object.entries(spec.vars)) out[name] = jmes(data, expr);
+    return out;
+  }
+  function firstBalancedJson(text) {
+    const start = text.search(/[{[]/);
+    if (start < 0) return null;
+    let depth = 0;
+    let quote = null;
+    for (let i = start; i < text.length; i++) {
+      const c = text[i];
+      if (quote) {
+        if (c === "\\") i++;
+        else if (c === quote) quote = null;
+        continue;
+      }
+      if (c === '"' || c === "'" || c === "`") quote = c;
+      else if (c === "{" || c === "[") depth++;
+      else if (c === "}" || c === "]") {
+        depth--;
+        if (depth === 0) return text.slice(start, i + 1);
+      }
+    }
+    return null;
+  }
+  function decodeAstroProps(props) {
+    if (!props || typeof props !== "object" || Array.isArray(props)) return decodeAstroValue(props);
+    const out = {};
+    for (const [k, v] of Object.entries(props)) out[k] = decodeAstroValue(v);
+    return out;
+  }
+  function decodeAstroValue(v) {
+    if (!Array.isArray(v) || v.length !== 2 || typeof v[0] !== "number") return v;
+    const [type, value] = v;
+    switch (type) {
+      case 0:
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          const out = {};
+          for (const [k, x] of Object.entries(value)) out[k] = decodeAstroValue(x);
+          return out;
+        }
+        return value;
+      case 1:
+        return Array.isArray(value) ? value.map(decodeAstroValue) : value;
+      case 3:
+        return typeof value === "string" ? value : String(value);
+      default:
+        return value;
+    }
+  }
+
+  // packages/recipe/src/params.ts
+  function prepareParams(schema, input) {
+    if (input === void 0 || input === null) input = {};
+    if (typeof input !== "object" || Array.isArray(input)) {
+      throw new RecipeError("invalid_params", "params must be an object");
+    }
+    const params = { ...input };
+    const props = schema.properties ?? {};
+    const problems = [];
+    for (const key of Object.keys(params)) {
+      if (!(key in props)) {
+        if (schema.additionalProperties === false) problems.push(`unknown param "${key}"`);
+      }
+    }
+    for (const [key, prop] of Object.entries(props)) {
+      if (params[key] === void 0 && prop.default !== void 0) params[key] = structuredCloneSafe(prop.default);
+    }
+    for (const key of schema.required ?? []) {
+      if (params[key] === void 0 || params[key] === null) problems.push(`missing required param "${key}"`);
+    }
+    for (const [key, prop] of Object.entries(props)) {
+      const v = params[key];
+      if (v === void 0) continue;
+      const p = checkValue(key, v, prop);
+      if (p) problems.push(p);
+    }
+    if (problems.length) throw new RecipeError("invalid_params", problems.join("; "));
+    return params;
+  }
+  function typeOf(v) {
+    if (v === null) return "null";
+    if (Array.isArray(v)) return "array";
+    if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
+    return typeof v;
+  }
+  function typeMatches(actual, expected) {
+    if (expected === actual) return true;
+    if (expected === "number" && actual === "integer") return true;
+    return false;
+  }
+  function checkValue(key, v, s2) {
+    const actual = typeOf(v);
+    if (s2.type) {
+      const types = Array.isArray(s2.type) ? s2.type : [s2.type];
+      if (!types.some((t) => typeMatches(actual, t))) return `param "${key}" must be ${types.join(" or ")}`;
+    }
+    if (s2.enum && !s2.enum.some((e) => e === v)) return `param "${key}" must be one of ${s2.enum.map((e) => JSON.stringify(e)).join(", ")}`;
+    if (typeof v === "number") {
+      if (typeof s2.minimum === "number" && v < s2.minimum) return `param "${key}" must be \u2265 ${s2.minimum}`;
+      if (typeof s2.maximum === "number" && v > s2.maximum) return `param "${key}" must be \u2264 ${s2.maximum}`;
+    }
+    if (typeof v === "string") {
+      if (typeof s2.minLength === "number" && v.length < s2.minLength) return `param "${key}" is too short`;
+      if (typeof s2.maxLength === "number" && v.length > s2.maxLength) return `param "${key}" is too long`;
+      if (typeof s2.pattern === "string") {
+        let re = null;
+        try {
+          re = new RegExp(s2.pattern, "u");
+        } catch {
+          re = null;
+        }
+        if (re && !re.test(v)) return `param "${key}" does not match the expected format`;
+      }
+    }
+    return null;
+  }
+  function structuredCloneSafe(v) {
+    return v === null || typeof v !== "object" ? v : JSON.parse(JSON.stringify(v));
+  }
+
+  // packages/recipe/src/redact.ts
+  var REDACTED = "[redacted]";
+  function secretStrings(v, acc = []) {
+    if (v === null || v === void 0) return acc;
+    if (typeof v === "string") {
+      if (v.length >= 4) {
+        acc.push(v);
+        const enc2 = encodeURIComponent(v);
+        if (enc2 !== v) acc.push(enc2);
+      }
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      const s2 = String(v);
+      if (s2.length >= 6) acc.push(s2);
+    } else if (Array.isArray(v)) v.forEach((x) => secretStrings(x, acc));
+    else if (typeof v === "object") {
+      Object.values(v).forEach((x) => secretStrings(x, acc));
+    }
+    return acc;
+  }
+  function redactString(s2, secrets) {
+    let out = s2;
+    for (const sec of secrets) if (out.includes(sec)) out = out.split(sec).join(REDACTED);
+    return out;
+  }
+  function redactDeep(v, secrets) {
+    if (!secrets.length) return v;
+    return walk(v, secrets);
+  }
+  function walk(v, secrets) {
+    if (typeof v === "string") return redactString(v, secrets);
+    if (typeof v === "number" || typeof v === "boolean") {
+      const s2 = String(v);
+      return secrets.includes(s2) ? REDACTED : v;
+    }
+    if (Array.isArray(v)) return v.map((x) => walk(x, secrets));
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, x] of Object.entries(v)) out[redactString(k, secrets)] = walk(x, secrets);
+      return out;
+    }
+    return v;
+  }
+
+  // packages/recipe/src/template.ts
+  var FILTERS = [
+    "urlencode",
+    "json",
+    "lower",
+    "upper",
+    "trim",
+    "string",
+    "number",
+    "default",
+    "date",
+    "add_days",
+    "join",
+    "first"
+  ];
+  var cache2 = /* @__PURE__ */ new Map();
+  function parseTemplate(src) {
+    const hit = cache2.get(src);
+    if (hit) return hit;
+    const parts = [];
+    let i = 0;
+    while (i < src.length) {
+      const open = src.indexOf("{{", i);
+      if (open < 0) {
+        parts.push({ kind: "text", text: src.slice(i) });
+        break;
+      }
+      if (open > i) parts.push({ kind: "text", text: src.slice(i, open) });
+      const close = findClose(src, open + 2);
+      if (close < 0) throw new TemplateError(`unclosed {{ in template: ${truncate(src)}`);
+      parts.push({ kind: "expr", expr: parseExpr(src.slice(open + 2, close)) });
+      i = close + 2;
+    }
+    const parsed = {
+      parts,
+      single: parts.length === 1 && parts[0].kind === "expr"
+    };
+    if (cache2.size > 2e3) cache2.clear();
+    cache2.set(src, parsed);
+    return parsed;
+  }
+  function findClose(src, from) {
+    let quote = null;
+    for (let j = from; j < src.length; j++) {
+      const c = src[j];
+      if (quote) {
+        if (c === "\\") j++;
+        else if (c === quote) quote = null;
+        continue;
+      }
+      if (c === "'" || c === '"') quote = c;
+      else if (c === "}" && src[j + 1] === "}") return j;
+    }
+    return -1;
+  }
+  function splitPipes(s2) {
+    const out = [];
+    let quote = null;
+    let cur = "";
+    for (let j = 0; j < s2.length; j++) {
+      const c = s2[j];
+      if (quote) {
+        cur += c;
+        if (c === "\\" && j + 1 < s2.length) cur += s2[++j];
+        else if (c === quote) quote = null;
+        continue;
+      }
+      if (c === "'" || c === '"') {
+        quote = c;
+        cur += c;
+      } else if (c === "|") {
+        out.push(cur);
+        cur = "";
+      } else cur += c;
+    }
+    out.push(cur);
+    return out;
+  }
+  function parseExpr(inner) {
+    const [pathRaw, ...filterRaws] = splitPipes(inner);
+    const pathText = (pathRaw ?? "").trim();
+    if (!pathText) throw new TemplateError(`empty expression in {{${inner}}}`);
+    const path = parsePath(pathText);
+    const filters = filterRaws.map((f) => parseFilter(f.trim(), inner));
+    return { path, pathText, filters };
+  }
+  var IDENT = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
+  function parsePath(text) {
+    const segs = [];
+    for (const raw of text.split(".")) {
+      const m = /^([^[\]]*)((?:\[\d+\])*)$/.exec(raw);
+      if (!m) throw new TemplateError(`bad path "${text}"`);
+      const name = m[1];
+      if (name) {
+        if (!IDENT.test(name) && !/^\d+$/.test(name)) throw new TemplateError(`bad path segment "${name}" in "${text}"`);
+        segs.push(/^\d+$/.test(name) && segs.length > 0 ? Number(name) : name);
+      } else if (!m[2]) {
+        throw new TemplateError(`bad path "${text}"`);
+      }
+      for (const idx of m[2].matchAll(/\[(\d+)\]/g)) segs.push(Number(idx[1]));
+    }
+    if (typeof segs[0] !== "string") throw new TemplateError(`path must start with a name: "${text}"`);
+    return segs;
+  }
+  function parseFilter(raw, inner) {
+    const colon = raw.indexOf(":");
+    const name = (colon < 0 ? raw : raw.slice(0, colon)).trim();
+    if (!FILTERS.includes(name)) {
+      throw new TemplateError(`unknown filter "${name}" in {{${inner}}}`);
+    }
+    if (colon < 0) {
+      if (name === "default" || name === "date" || name === "add_days") {
+        throw new TemplateError(`filter "${name}" needs an argument in {{${inner}}}`);
+      }
+      return { name, hasArg: false };
+    }
+    const arg = parseLiteral(raw.slice(colon + 1).trim());
+    if (name === "add_days" && typeof arg !== "number") {
+      throw new TemplateError(`add_days needs a number in {{${inner}}}`);
+    }
+    return { name, arg, hasArg: true };
+  }
+  function parseLiteral(s2) {
+    if (s2.length >= 2 && (s2[0] === "'" || s2[0] === '"') && s2[s2.length - 1] === s2[0]) {
+      return s2.slice(1, -1).replace(/\\(.)/g, "$1");
+    }
+    if (s2 === "true") return true;
+    if (s2 === "false") return false;
+    if (s2 === "null") return null;
+    if (/^-?\d+(\.\d+)?$/.test(s2)) return Number(s2);
+    return s2;
+  }
+  function lookup(ctx, path) {
+    let cur = ctx;
+    for (const seg of path) {
+      if (cur === null || cur === void 0) return void 0;
+      if (typeof seg === "number") {
+        cur = Array.isArray(cur) ? cur[seg] : cur[String(seg)];
+      } else {
+        if (typeof cur !== "object") return void 0;
+        if (!Object.prototype.hasOwnProperty.call(cur, seg)) return void 0;
+        cur = cur[seg];
+      }
+    }
+    return cur;
+  }
+  function evalExpr(expr, ctx) {
+    let v = lookup(ctx, expr.path);
+    for (const f of expr.filters) v = applyFilter(f, v);
+    return v;
+  }
+  function applyFilter(f, v) {
+    switch (f.name) {
+      case "urlencode":
+        return encodeURIComponent(toText(v));
+      case "json":
+        return JSON.stringify(normalizeValue(v) ?? null);
+      case "lower":
+        return v == null ? v : toText(v).toLowerCase();
+      case "upper":
+        return v == null ? v : toText(v).toUpperCase();
+      case "trim":
+        return v == null ? v : toText(v).trim();
+      case "string":
+        return v == null ? "" : toText(v);
+      case "number": {
+        if (v == null || v === "") return v;
+        const n = typeof v === "number" ? v : Number(toText(v).trim());
+        if (Number.isNaN(n)) throw new TemplateError(`number filter: not a number`);
+        return n;
+      }
+      case "default":
+        return v === void 0 || v === null || v === "" ? f.arg : v;
+      case "date":
+        return v == null ? v : formatDate(toDate(v), String(f.arg));
+      case "add_days":
+        return v == null ? v : addDays(v, f.arg);
+      case "join": {
+        const sep = f.hasArg ? String(f.arg) : ",";
+        return Array.isArray(v) ? v.map((x) => toText(x)).join(sep) : v;
+      }
+      case "first":
+        return Array.isArray(v) ? v[0] : v;
+    }
+  }
+  function renderString(src, ctx) {
+    if (!src.includes("{{")) return src;
+    const t = parseTemplate(src);
+    if (t.single) return normalizeValue(evalExpr(t.parts[0].expr, ctx));
+    let out = "";
+    for (const p of t.parts) out += p.kind === "text" ? p.text : toText(evalExpr(p.expr, ctx));
+    return out;
+  }
+  function renderValue(value, ctx) {
+    if (typeof value === "string") return renderString(value, ctx);
+    if (Array.isArray(value)) return value.map((v) => renderValue(v, ctx));
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        const r = renderValue(v, ctx);
+        if (r !== void 0) out[k] = r;
+      }
+      return out;
+    }
+    return value;
+  }
+  function toText(v) {
+    if (v === void 0 || v === null) return "";
+    if (typeof v === "string") return v;
+    if (v instanceof Date) return localIso(v);
+    if (typeof v === "object") return JSON.stringify(normalizeValue(v));
+    return String(v);
+  }
+  function normalizeValue(v) {
+    if (v instanceof Date) return localIso(v);
+    if (Array.isArray(v)) return v.map(normalizeValue);
+    if (v && typeof v === "object") {
+      let changed = false;
+      const out = {};
+      for (const [k, x] of Object.entries(v)) {
+        const n = normalizeValue(x);
+        if (n !== x) changed = true;
+        out[k] = n;
+      }
+      return changed ? out : v;
+    }
+    return v;
+  }
+  var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+  function toDate(v) {
+    if (v instanceof Date) return v;
+    if (typeof v === "number") return new Date(v);
+    const s2 = String(v).trim();
+    const m = DATE_ONLY.exec(s2);
+    if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    const d = new Date(s2);
+    if (Number.isNaN(d.getTime())) throw new TemplateError(`not a date: "${truncate(s2)}"`);
+    return d;
+  }
+  function addDays(v, n) {
+    const dateOnly = typeof v === "string" && DATE_ONLY.test(v.trim());
+    const d = new Date(toDate(v).getTime());
+    d.setDate(d.getDate() + n);
+    return dateOnly ? formatDate(d, "YYYY-MM-DD") : d;
+  }
+  var pad = (n, w = 2) => String(n).padStart(w, "0");
+  function localIso(d) {
+    return formatDate(d, "YYYY-MM-DDTHH:mm:ss");
+  }
+  function formatDate(d, fmt) {
+    return fmt.replace(/YYYY|SSS|MM|DD|HH|mm|ss|ZZ/g, (tok) => {
+      switch (tok) {
+        case "ZZ": {
+          const off = -d.getTimezoneOffset();
+          const a = Math.abs(off);
+          return `${off < 0 ? "-" : "+"}${pad(Math.floor(a / 60))}:${pad(a % 60)}`;
+        }
+        case "YYYY":
+          return pad(d.getFullYear(), 4);
+        case "MM":
+          return pad(d.getMonth() + 1);
+        case "DD":
+          return pad(d.getDate());
+        case "HH":
+          return pad(d.getHours());
+        case "mm":
+          return pad(d.getMinutes());
+        case "ss":
+          return pad(d.getSeconds());
+        case "SSS":
+          return pad(d.getMilliseconds(), 3);
+        default:
+          return tok;
+      }
+    });
+  }
+  function truncate(s2, n = 80) {
+    return s2.length > n ? s2.slice(0, n) + "\u2026" : s2;
+  }
+
+  // packages/recipe/src/decoders.ts
+  function decodeTurboStream(text) {
+    const firstLine = text.split("\n", 1)[0] ?? "";
+    const values = JSON.parse(firstLine);
+    if (!Array.isArray(values)) throw new Error("turbo-stream: root is not an array");
+    const done = /* @__PURE__ */ new Map();
+    const hydrate = (index) => {
+      switch (index) {
+        case -1:
+        case -7:
+          return null;
+        // hole / undefined
+        case -2:
+          return null;
+        // NaN is not JSON
+        case -3:
+          return null;
+        // -Infinity
+        case -4:
+          return 0;
+        // -0
+        case -5:
+          return null;
+        case -6:
+          return null;
+      }
+      if (typeof index !== "number" || index < 0 || index >= values.length) return null;
+      if (done.has(index)) return done.get(index);
+      const v = values[index];
+      if (v === null || typeof v !== "object") {
+        done.set(index, v);
+        return v;
+      }
+      if (Array.isArray(v)) {
+        if (v.length && typeof v[0] === "string") return tagged(index, v);
+        const out2 = [];
+        done.set(index, out2);
+        for (const i of v) out2.push(hydrate(i));
+        return out2;
+      }
+      const out = {};
+      done.set(index, out);
+      for (const [k, vi] of Object.entries(v)) {
+        const key = /^_\d+$/.test(k) ? String(values[Number(k.slice(1))]) : k;
+        out[key] = hydrate(vi);
+      }
+      return out;
+    };
+    const tagged = (index, v) => {
+      const tag = v[0];
+      let out;
+      switch (tag) {
+        case "D": {
+          const d = new Date(v[1]);
+          out = Number.isNaN(d.getTime()) ? null : d.toISOString();
+          break;
+        }
+        case "B":
+        // BigInt
+        case "U":
+        // URL
+        case "R":
+        // RegExp
+        case "Y":
+          out = String(v[1]);
+          break;
+        case "S": {
+          const arr = [];
+          done.set(index, arr);
+          for (let i = 1; i < v.length; i++) arr.push(hydrate(v[i]));
+          return arr;
+        }
+        case "M": {
+          const obj = {};
+          done.set(index, obj);
+          for (let i = 1; i + 1 < v.length; i += 2) obj[String(hydrate(v[i]))] = hydrate(v[i + 1]);
+          return obj;
+        }
+        case "N": {
+          const obj = {};
+          done.set(index, obj);
+          for (let i = 1; i + 1 < v.length; i += 2) obj[String(values[v[i]])] = hydrate(v[i + 1]);
+          return obj;
+        }
+        case "E":
+          out = { error: String(v[1] ?? "") };
+          break;
+        case "P":
+        // unresolved promise (deferred data)
+        default:
+          out = null;
+      }
+      done.set(index, out);
+      return out;
+    };
+    return hydrate(0);
+  }
+
+  // packages/recipe/src/blocked.ts
+  var VENDOR_MARKERS = [
+    [/cf-chl|cf_chl_opt|challenge-platform|Just a moment\.\.\.|Attention Required! \| Cloudflare|cf-turnstile/i, "Cloudflare"],
+    [/OPS_BLOCKED|errors\.edgesuite\.net|Reference #\d+\.[0-9a-f]+|akamai|_abck|bm-verify|sec-cpt|sec-if-cpt|\/_sec\/cp_challenge|ak_bmsc/i, "Akamai"],
+    [/captcha-delivery\.com|datadome/i, "DataDome"],
+    [/px-captcha|_pxCaptcha|perimeterx|Press & Hold/i, "PerimeterX"],
+    [/awswaf|aws-waf-token|AwsWafIntegration|challenge\.js.*token/i, "AWS WAF"],
+    [/Incapsula incident|_Incapsula_Resource|imperva|Pardon Our Interruption/i, "Imperva"],
+    [/hcaptcha\.com|recaptcha|g-recaptcha|geetest|captcha/i, "a CAPTCHA"]
+  ];
+  function vendorFrom(text, headers) {
+    if ((headers("cf-mitigated") ?? "").toLowerCase() === "challenge") return "Cloudflare";
+    if (headers("x-datadome") || headers("x-dd-b")) return "DataDome";
+    if (/akamaighost/i.test(headers("server") ?? "")) return "Akamai";
+    const sample = text.length > 2e5 ? text.slice(0, 2e5) : text;
+    for (const [re, name] of VENDOR_MARKERS) if (re.test(sample)) return name;
+    return void 0;
+  }
+  function detectBlock(status, text, headers, unexpectedBody) {
+    if (status === 429) return { kind: "rate_limited", vendor: vendorFrom(text, headers) };
+    const vendor = vendorFrom(text, headers);
+    if (status === 403) return { kind: "challenge", vendor };
+    if ((status === 503 || status === 401 || status === 202 || status === 200 || status === 405) && vendor && (unexpectedBody || status !== 200)) {
+      return { kind: "challenge", vendor };
+    }
+    return null;
+  }
+  function blockMessage(site, status, b) {
+    if (b.kind === "rate_limited") {
+      return `${site.name} is rate-limiting requests (HTTP 429${b.vendor ? `, ${b.vendor}` : ""}). The Wield executor is working; wait a minute, then retry once.`;
+    }
+    return `${site.name} blocked the request with its bot protection (HTTP ${status}${b.vendor ? `, ${b.vendor}` : ""}). The Wield executor is online and working. Ask the user to open ${site.origin} in Chrome, use the site once (click a link or run a search, and solve a check if one appears), then retry.`;
+  }
+
+  // packages/recipe/src/interpreter.ts
+  var LIMITS = {
+    steps: 12,
+    foreach: 20,
+    requests: 40,
+    responseBytes: 5 * 1024 * 1024,
+    runMs: 6e4,
+    redirects: 3,
+    confirmMs: 13e4
+  };
+  var FORBIDDEN_HEADERS = /* @__PURE__ */ new Set(["cookie", "cookie2", "host", "set-cookie"]);
+  function stepDependencies(steps) {
+    const ids = steps.map((s2) => s2.id);
+    const esc = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const barrier = (s2) => !!s2.write || s2.request.method !== "GET";
+    return steps.map((s2, i) => {
+      const all = Array.from({ length: i }, (_, j) => j);
+      if (barrier(s2)) return all;
+      const { id: _id, ...rest } = s2;
+      const text = JSON.stringify(rest);
+      if (/\bsteps\b(?!\.[A-Za-z0-9_])/.test(text)) return all;
+      const deps = /* @__PURE__ */ new Set();
+      ids.slice(0, i).forEach((x, j) => {
+        if (new RegExp(`\\bsteps\\.${esc(x)}\\b`).test(text)) deps.add(j);
+      });
+      for (let j = i - 1; j >= 0; j--) {
+        if (barrier(steps[j])) {
+          deps.add(j);
+          break;
+        }
+      }
+      return [...deps].sort((a, b) => a - b);
+    });
+  }
+  async function runRecipe(recipe, params, adapters, opts = {}) {
+    return new Run(recipe, adapters, opts).execute(params);
+  }
+  async function checkLogin(target, adapters, opts = {}) {
+    const recipe = {
+      schema: "https://wield.run/schema/recipe/v1.json",
+      id: target.id ?? `${target.site.id}/login-check`,
+      version: 1,
+      site: target.site,
+      task: "Check login",
+      effect: "read",
+      requires_login: true,
+      login_check: target.login_check,
+      params: { type: "object", properties: {} },
+      auth: target.auth,
+      steps: [],
+      output: { schema: {}, value: "`true`" },
+      verify: { example_params: {}, checks: ["`true`"] }
+    };
+    const res = await new Run(recipe, adapters, { ...opts, timeoutMs: Math.min(opts.timeoutMs ?? 15e3, 15e3) }).execute({}, true);
+    if (res.ok) return true;
+    if (res.error.code === "login_required") return false;
+    return null;
+  }
+  function pageOf(base) {
+    try {
+      const u = new URL(base);
+      return { origin: u.origin, host: u.host };
+    } catch {
+      return { origin: "", host: "" };
+    }
+  }
+  var Run = class {
+    constructor(recipe, adapters, opts) {
+      this.recipe = recipe;
+      this.adapters = adapters;
+      this.opts = opts;
+      const l = { ...LIMITS };
+      for (const [k, v] of Object.entries(opts.limits ?? {})) {
+        const key = k;
+        if (typeof v === "number" && v < l[key]) l[key] = v;
+      }
+      this.limits = l;
+      this.allowed = /* @__PURE__ */ new Set();
+      for (const o of recipe.site?.origins ?? []) {
+        try {
+          const u = new URL(o);
+          if (u.protocol === "https:") this.allowed.add(u.origin);
+        } catch {
+        }
+      }
+      this.t0 = Date.now();
+      this.remainingMs = Math.min(opts.timeoutMs ?? l.runMs, l.runMs);
+      this.base = recipe.site?.origin ?? "";
+    }
+    limits;
+    allowed;
+    t0;
+    ac = new AbortController();
+    abortCode = null;
+    timer = null;
+    remainingMs;
+    armedAt = 0;
+    requests = 0;
+    secrets = [];
+    confirmed = false;
+    currentStep;
+    /** What relative request URLs resolve against: site.origin, or the listed language host the tab landed on. */
+    base;
+    /**
+     * English-first browsers get www.zalando.de redirected to en.zalando.de; the recipe's relative requests must then go
+     * to en.zalando.de (same-origin from the tab), not www (cross-origin, rejected). Only a host the recipe lists
+     * (site.locale_hosts, or an origin in site.origins) under the site's own domain qualifies. Never a wildcard.
+     */
+    async resolveBase() {
+      const site = this.recipe.site;
+      if (!this.adapters.pageUrl) return;
+      let page;
+      try {
+        page = new URL(await this.adapters.pageUrl());
+      } catch {
+        return;
+      }
+      if (page.protocol !== "https:" || page.origin === new URL(site.origin).origin) return;
+      const listed = (site.locale_hosts ?? []).includes(page.hostname) || this.allowed.has(page.origin);
+      const sameSite = page.hostname === site.id || page.hostname.endsWith(`.${site.id}`);
+      if (!listed || !sameSite) return;
+      this.base = page.origin;
+      this.allowed.add(page.origin);
+      this.emit("tab", "info", `${site.name} answered from ${page.host} (a listed language host); same-site requests go there`);
+    }
+    // -- lifecycle ------------------------------------------------------------
+    async execute(rawParams, loginOnly = false) {
+      const onCancel = () => this.abort("cancelled");
+      if (this.opts.signal?.aborted) this.abort("cancelled");
+      this.opts.signal?.addEventListener("abort", onCancel);
+      this.arm();
+      try {
+        this.staticChecks();
+        await this.resolveBase();
+        const params = prepareParams(this.recipe.params, rawParams);
+        const ctx = { params, vars: {}, steps: {}, now: this.opts.now ? this.opts.now() : /* @__PURE__ */ new Date(), page: pageOf(this.base) };
+        await this.derive(ctx);
+        if (this.recipe.login_check && (this.recipe.requires_login || loginOnly)) await this.loginCheck(ctx);
+        await this.runSteps(ctx);
+        this.currentStep = void 0;
+        let output = this.q({ params: ctx.params, steps: ctx.steps, now: localIsoNow(ctx.now), page: ctx.page }, this.recipe.output.value, "output");
+        output = redactDeep(normalizeValue(output), this.secrets);
+        const duration_ms = Date.now() - this.t0;
+        this.emit("done", "info", `ok in ${duration_ms} ms (${this.requests} requests)`);
+        return { ok: true, output: output ?? null, duration_ms, requests: this.requests };
+      } catch (e) {
+        const err = this.toRecipeError(e);
+        const duration_ms = Date.now() - this.t0;
+        const message = redactString(err.message, this.secrets);
+        this.emit("done", "error", `failed: ${err.code}${err.step ? ` at ${err.step}` : ""}`);
+        return {
+          ok: false,
+          error: { code: err.code, message, ...err.step ? { step: err.step } : {} },
+          duration_ms,
+          requests: this.requests
+        };
+      } finally {
+        this.disarm();
+        this.opts.signal?.removeEventListener("abort", onCancel);
+      }
+    }
+    toRecipeError(e) {
+      if (this.abortCode) return new RecipeError(this.abortCode, this.abortCode === "timeout" ? `run exceeded ${this.limits.runMs / 1e3} s` : "run cancelled", this.currentStep);
+      if (e instanceof RecipeError) {
+        if (!e.step && this.currentStep) e.step = this.currentStep;
+        return e;
+      }
+      if (e instanceof TemplateError) return new RecipeError("recipe_invalid", `template: ${e.message}`, this.currentStep);
+      const msg = e instanceof Error ? e.message : String(e);
+      return new RecipeError("expect_failed", msg, this.currentStep);
+    }
+    // -- time limit (paused while waiting for the user's Allow) ---------------
+    arm() {
+      this.armedAt = Date.now();
+      this.timer = setTimeout(() => this.abort("timeout"), Math.max(0, this.remainingMs));
+    }
+    disarm() {
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+        this.remainingMs -= Date.now() - this.armedAt;
+      }
+    }
+    abort(code) {
+      if (this.abortCode) return;
+      this.abortCode = code;
+      this.ac.abort();
+    }
+    checkAbort() {
+      if (this.abortCode) throw new RecipeError(this.abortCode, this.abortCode, this.currentStep);
+    }
+    /** Race a promise against timeout/cancel. */
+    guard(p) {
+      if (this.abortCode) return Promise.reject(new RecipeError(this.abortCode, this.abortCode));
+      return new Promise((resolve, reject) => {
+        const onAbort = () => reject(new RecipeError(this.abortCode ?? "cancelled", this.abortCode ?? "cancelled"));
+        this.ac.signal.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve(p).then(
+          (v) => {
+            this.ac.signal.removeEventListener("abort", onAbort);
+            resolve(v);
+          },
+          (err) => {
+            this.ac.signal.removeEventListener("abort", onAbort);
+            reject(err);
+          }
+        );
+      });
+    }
+    sleep(ms) {
+      return this.guard(new Promise((r) => setTimeout(r, ms)));
+    }
+    // -- static rules -----------------------------------------------------------
+    staticChecks() {
+      const r = this.recipe;
+      if (!r || typeof r !== "object" || !Array.isArray(r.steps) || !r.site || !r.output) {
+        throw new RecipeError("recipe_invalid", "not a recipe");
+      }
+      if (r.steps.length > this.limits.steps) {
+        throw new RecipeError("limit_exceeded", `recipe has ${r.steps.length} steps (max ${this.limits.steps})`);
+      }
+      if (this.allowed.size === 0) throw new RecipeError("recipe_invalid", "site.origins has no valid https origin");
+      for (const h of r.site.locale_hosts ?? []) {
+        if (typeof h !== "string" || !/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(h) || !(h === r.site.id || h.endsWith(`.${r.site.id}`))) {
+          throw new RecipeError("recipe_invalid", `site.locale_hosts: "${String(h)}" must be an exact host name under ${r.site.id} (no wildcards)`);
+        }
+      }
+      const all = r.login_check ? [r.login_check, ...r.steps] : r.steps;
+      const ids = /* @__PURE__ */ new Set();
+      for (const s2 of all) {
+        if (s2 !== r.login_check) {
+          if (ids.has(s2.id)) throw new RecipeError("recipe_invalid", `duplicate step id "${s2.id}"`, s2.id);
+          ids.add(s2.id);
+        }
+        for (const h of Object.keys(s2.request?.headers ?? {})) {
+          if (FORBIDDEN_HEADERS.has(h.toLowerCase())) {
+            throw new RecipeError("recipe_invalid", `header "${h}" is not allowed in recipes`, s2.id);
+          }
+        }
+        if (s2.write && r.effect !== "write") {
+          throw new RecipeError("recipe_invalid", `write step "${s2.id}" in a recipe with effect "read"`, s2.id);
+        }
+        if (s2 === r.login_check && s2.write) throw new RecipeError("recipe_invalid", "login_check cannot write", s2.id);
+        if (s2 === r.login_check && this.opts.trust !== "registry" && s2.request?.method !== "GET") {
+          throw new RecipeError("recipe_invalid", "an unsigned recipe's login_check must be a GET request", s2.id);
+        }
+      }
+    }
+    /** A step that changes data: marked write, or (unless registry-signed) any non-GET request. */
+    isWrite(s2) {
+      return s2.write === true || this.opts.trust !== "registry" && s2.request?.method !== "GET";
+    }
+    // -- auth.derive ------------------------------------------------------------
+    async derive(ctx) {
+      const list = this.recipe.auth?.derive ?? [];
+      for (const d of list) {
+        let raw = await this.guard(this.readDerive(d));
+        if (d.regex) raw = await this.guard(this.applyDeriveRegex(d, raw));
+        let value = raw ?? null;
+        if (value !== null && d.jmespath) {
+          try {
+            value = jmes(JSON.parse(String(raw)), d.jmespath);
+          } catch {
+            value = null;
+          }
+        }
+        this.secrets.push(...secretStrings(value));
+        this.secrets.sort((a, b) => b.length - a.length);
+        if ((value === null || value === "") && d.required !== false) {
+          throw new RecipeError(
+            this.recipe.requires_login ? "login_required" : "expect_failed",
+            `could not derive "${d.name}" from ${d.from}${this.recipe.requires_login ? " (are you logged in?)" : ""}`
+          );
+        }
+        ctx.vars[d.name] = value;
+      }
+    }
+    compileRegex(src, stepId) {
+      try {
+        return new RegExp(src);
+      } catch {
+        throw new RecipeError("recipe_invalid", `invalid regex in recipe`, stepId);
+      }
+    }
+    /** First capture group (or the whole match). For from=dom, the first element whose text matches wins. */
+    async applyDeriveRegex(d, raw) {
+      const re = this.compileRegex(d.regex);
+      const MAX = 2 * 1024 * 1024;
+      const pick = (s2) => {
+        if (s2 === null || s2 === void 0) return null;
+        const m = re.exec(s2.length > MAX ? s2.slice(0, MAX) : s2);
+        return m ? m[1] ?? m[0] : null;
+      };
+      if (d.from === "dom" && d.selector && this.adapters.queryDomAll) {
+        const all = await this.adapters.queryDomAll(d.selector, d.attr);
+        for (const s2 of all ?? []) {
+          const v = pick(s2);
+          if (v !== null) return v;
+        }
+        return null;
+      }
+      return pick(raw);
+    }
+    async readDerive(d) {
+      const a = this.adapters;
+      switch (d.from) {
+        case "cookie":
+          return d.key && a.getCookie ? a.getCookie(d.key) : null;
+        case "local_storage":
+          return d.key && a.getStorage ? a.getStorage("local", d.key) : null;
+        case "session_storage":
+          return d.key && a.getStorage ? a.getStorage("session", d.key) : null;
+        case "meta":
+          return d.selector && a.queryMeta ? a.queryMeta(d.selector, d.attr ?? "content") : null;
+        case "dom":
+          return d.selector && a.queryDom ? a.queryDom(d.selector, d.attr) : null;
+        case "page_url": {
+          if (!a.pageUrl) return null;
+          const u = await a.pageUrl();
+          if (!d.key) return u;
+          try {
+            return new URL(u).searchParams.get(d.key);
+          } catch {
+            return null;
+          }
+        }
+        default:
+          return null;
+      }
+    }
+    // -- login check ----------------------------------------------------------
+    async loginCheck(ctx) {
+      const step = this.recipe.login_check;
+      this.currentStep = step.id;
+      try {
+        await this.execRequest(step, ctx);
+      } catch (e) {
+        if (e instanceof RecipeError && (e.code === "expect_failed" || e.code === "login_required")) {
+          throw new RecipeError("login_required", `not logged in to ${this.recipe.site.name}`, step.id);
+        }
+        throw e;
+      }
+      this.emit("step", "info", `login check ok`);
+    }
+    // -- steps ------------------------------------------------------------------
+    async runSteps(ctx) {
+      const steps = this.recipe.steps;
+      if (this.opts.parallel === false) {
+        for (const step of steps) {
+          this.checkAbort();
+          await this.runStep(step, ctx);
+        }
+        return;
+      }
+      const deps = stepDependencies(steps);
+      let first = null;
+      const fail = (e, stepId) => {
+        if (first) return;
+        if (e instanceof RecipeError && !e.step) e.step = stepId;
+        first = e instanceof RecipeError || this.abortCode ? e : Object.assign(this.toRecipeError(e), { step: stepId });
+        if (!this.abortCode) this.ac.abort();
+      };
+      const done = [];
+      steps.forEach((step, i) => {
+        done[i] = Promise.all(deps[i].map((j) => done[j])).then(async () => {
+          if (first) throw first;
+          this.checkAbort();
+          try {
+            await this.runStep(step, ctx);
+          } catch (e) {
+            fail(e, step.id);
+            throw e;
+          }
+        });
+        done[i].catch(() => {
+        });
+      });
+      await Promise.allSettled(done);
+      if (first) throw first;
+    }
+    async runStep(step, ctx) {
+      this.currentStep = step.id;
+      if (step.when !== void 0 && !truthy(this.q(ctx, step.when, step.id))) {
+        ctx.steps[step.id] = null;
+        this.emit("step", "info", `step ${step.id} skipped`);
+        return;
+      }
+      if (this.isWrite(step) && !this.confirmed) await this.confirmWrites(step, ctx);
+      if (step.foreach) {
+        const fe = step.foreach;
+        let list = this.q(ctx, fe.in, step.id);
+        if (list === null) list = [];
+        if (!Array.isArray(list)) throw new RecipeError("expect_failed", `foreach.in did not produce an array`, step.id);
+        const max = Math.min(fe.max ?? 10, this.limits.foreach);
+        if (list.length > max) this.emit("step", "warn", `step ${step.id}: foreach capped at ${max} of ${list.length} items`);
+        const results = [];
+        for (const item of list.slice(0, max)) {
+          this.checkAbort();
+          const local = { ...ctx, item, [fe.as]: item };
+          const extracted = await this.execRequest(step, local);
+          results.push({ [fe.as]: item, ...extracted });
+        }
+        ctx.steps[step.id] = results;
+      } else {
+        ctx.steps[step.id] = await this.execRequest(step, ctx);
+      }
+      this.emit("step", "info", `step ${step.id} ok`);
+    }
+    async confirmWrites(first, ctx) {
+      const steps = this.recipe.steps;
+      const writes = [];
+      for (const s2 of steps.slice(steps.indexOf(first))) {
+        if (!this.isWrite(s2)) continue;
+        writes.push(this.describeWrite(s2, ctx));
+      }
+      let summary = this.recipe.task;
+      if (this.recipe.confirm?.summary) {
+        try {
+          summary = toText(renderString(this.recipe.confirm.summary, { params: ctx.params, steps: ctx.steps, now: ctx.now, page: ctx.page }));
+        } catch {
+          summary = this.recipe.confirm.summary;
+        }
+      }
+      summary = redactString(summary, this.secrets);
+      const req = {
+        recipe_id: this.recipe.id,
+        site: { id: this.recipe.site.id, name: this.recipe.site.name, origin: this.recipe.site.origin },
+        task: this.recipe.task,
+        summary,
+        writes
+      };
+      this.emit("confirm", "info", `waiting for Allow: ${writes.length} write request(s)`);
+      let ok = false;
+      this.disarm();
+      try {
+        if (this.adapters.confirm) {
+          ok = await this.guard(
+            Promise.race([
+              this.adapters.confirm(req),
+              new Promise((r) => setTimeout(() => r(false), this.limits.confirmMs))
+            ])
+          );
+        }
+      } finally {
+        if (!this.abortCode) this.arm();
+      }
+      this.checkAbort();
+      this.emit("confirm", ok ? "info" : "warn", ok ? "allowed by user" : "denied");
+      if (ok !== true) throw new RecipeError("confirmation_denied", "the user did not allow this write", first.id);
+      this.confirmed = true;
+    }
+    describeWrite(s2, ctx) {
+      try {
+        let local = ctx;
+        if (s2.foreach) {
+          const list = this.q(ctx, s2.foreach.in, s2.id);
+          const item = Array.isArray(list) ? list[0] : void 0;
+          local = { ...ctx, item, [s2.foreach.as]: item };
+        }
+        const b = this.build(s2.request, local, s2.id);
+        const preview = b.body !== void 0 ? redactString(b.body, this.secrets) : void 0;
+        return {
+          step: s2.id,
+          method: b.method,
+          origin: b.url.origin,
+          path: redactString(b.url.pathname, this.secrets),
+          body_fields: b.bodyFields,
+          ...preview !== void 0 ? { body_preview: preview.length > 4e3 ? `${preview.slice(0, 4e3)}\u2026` : preview } : {}
+        };
+      } catch {
+        const raw = s2.request.url.split("?")[0] ?? s2.request.url;
+        const v = s2.request.body?.value;
+        return {
+          step: s2.id,
+          method: s2.request.method,
+          origin: this.recipe.site.origin,
+          path: raw,
+          body_fields: v && typeof v === "object" && !Array.isArray(v) ? Object.keys(v) : []
+        };
+      }
+    }
+    // -- one request ------------------------------------------------------------
+    build(r, ctx, stepId) {
+      const urlText = toText(renderString(r.url, ctx));
+      let url;
+      try {
+        url = new URL(urlText, this.base);
+      } catch {
+        throw new RecipeError("recipe_invalid", `invalid request URL`, stepId);
+      }
+      for (const [k, v] of Object.entries(r.query ?? {})) {
+        const rv = renderValue(v, ctx);
+        if (rv === void 0 || rv === null) continue;
+        if (Array.isArray(rv)) {
+          for (const x of rv) if (x !== void 0 && x !== null) url.searchParams.append(k, toText(x));
+        } else url.searchParams.append(k, toText(rv));
+      }
+      const headers = {};
+      for (const [k, v] of Object.entries(r.headers ?? {})) {
+        if (FORBIDDEN_HEADERS.has(k.toLowerCase())) throw new RecipeError("recipe_invalid", `header "${k}" is not allowed in recipes`, stepId);
+        const rv = renderString(v, ctx);
+        if (rv === void 0 || rv === null) continue;
+        const text = toText(rv);
+        if (/[\r\n]/.test(text)) throw new RecipeError("recipe_invalid", `header "${k}" contains a line break`, stepId);
+        headers[k] = text;
+      }
+      const hasHeader = (name) => Object.keys(headers).some((h) => h.toLowerCase() === name);
+      let body;
+      let bodyFields = [];
+      if (r.body) {
+        if (r.method === "GET") throw new RecipeError("recipe_invalid", "GET requests cannot have a body", stepId);
+        const value = normalizeValue(renderValue(r.body.value, ctx));
+        const tv = r.body.value;
+        if (tv && typeof tv === "object" && !Array.isArray(tv)) bodyFields = Object.keys(tv);
+        if (r.body.type === "json") {
+          body = JSON.stringify(value ?? null);
+          if (!hasHeader("content-type")) headers["Content-Type"] = "application/json";
+        } else if (r.body.type === "form") {
+          const form = new URLSearchParams();
+          if (value && typeof value === "object" && !Array.isArray(value)) {
+            for (const [k, v] of Object.entries(value)) {
+              if (v === void 0 || v === null) continue;
+              if (Array.isArray(v)) v.forEach((x) => x !== null && x !== void 0 && form.append(k, toText(x)));
+              else form.append(k, toText(v));
+            }
+          } else if (typeof value === "string") {
+            body = value;
+          }
+          body ??= form.toString();
+          if (!hasHeader("content-type")) headers["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+        } else {
+          body = toText(value);
+          if (!hasHeader("content-type")) headers["Content-Type"] = "text/plain;charset=UTF-8";
+        }
+      }
+      return { url, method: r.method, headers, body, bodyFields, credentials: r.credentials ?? "include" };
+    }
+    checkOrigin(url, stepId, what = "request") {
+      if (url.protocol !== "https:" || !this.allowed.has(url.origin) || url.username || url.password) {
+        throw new RecipeError("origin_blocked", `${what} to ${url.protocol}//${url.host} is not in site.origins`, stepId);
+      }
+    }
+    async send(b, stepId) {
+      let cur = b;
+      for (let hop = 0; ; hop++) {
+        this.checkOrigin(cur.url, stepId, hop ? "redirect" : "request");
+        this.checkAbort();
+        if (++this.requests > this.limits.requests) {
+          throw new RecipeError("limit_exceeded", `more than ${this.limits.requests} requests in one run`, stepId);
+        }
+        const started = Date.now();
+        let resp;
+        try {
+          resp = await this.guard(
+            this.adapters.fetch({
+              url: cur.url.toString(),
+              method: cur.method,
+              headers: cur.headers,
+              body: cur.body,
+              credentials: cur.credentials,
+              redirect: "manual",
+              signal: this.ac.signal,
+              maxBytes: this.limits.responseBytes
+            })
+          );
+        } catch (e) {
+          if (this.abortCode || e instanceof RecipeError) throw e;
+          this.emitRequest(cur, 0, Date.now() - started, 0, "error");
+          throw new RecipeError("expect_failed", `${cur.method} ${cur.url.host}${cur.url.pathname} failed (network or CORS error)`, stepId);
+        }
+        const ms = Date.now() - started;
+        const bytes = typeof resp.bytes === "number" ? resp.bytes : utf8Length(resp.text ?? "");
+        this.emitRequest(cur, resp.status, ms, bytes);
+        if (bytes > this.limits.responseBytes) {
+          throw new RecipeError("limit_exceeded", `response larger than ${Math.round(this.limits.responseBytes / 1024 / 1024)} MB`, stepId);
+        }
+        const location2 = header(resp, "location");
+        const isRedirect = resp.status >= 300 && resp.status < 400 && resp.status !== 304;
+        if (resp.type === "opaqueredirect" || !isRedirect || !location2) return resp;
+        let target;
+        try {
+          target = new URL(location2, cur.url);
+        } catch {
+          return resp;
+        }
+        if (hop >= this.limits.redirects) throw new RecipeError("expect_failed", "too many redirects", stepId);
+        this.checkOrigin(target, stepId, "redirect");
+        const keep = resp.status === 307 || resp.status === 308;
+        cur = keep ? { ...cur, url: target } : { ...cur, url: target, method: "GET", body: void 0 };
+      }
+    }
+    async execRequest(step, ctx) {
+      if (step.delay_ms) await this.sleep(Math.min(step.delay_ms, 3e3));
+      const built = this.build(step.request, ctx, step.id);
+      const resp = await this.send(built, step.id);
+      const exp = step.expect ?? {};
+      const ex = step.extract ?? {};
+      const ctHeader = (header(resp, "content-type") ?? "").toLowerCase();
+      const parse = step.parse && step.parse !== "auto" ? step.parse : void 0;
+      const ct = parse ?? exp.content_type ?? (ctHeader.includes("json") ? "json" : ctHeader.includes("html") ? "html" : ex.json ? "json" : ex.html || ex.html_items || ex.embedded_json ? "html" : "text");
+      const text = resp.text ?? "";
+      let body = text;
+      let notJson = false;
+      if (ct === "json") {
+        try {
+          body = text.trim() === "" ? null : JSON.parse(text);
+        } catch {
+          notJson = true;
+        }
+      } else if (ct === "turbo_stream") {
+        try {
+          body = decodeTurboStream(text);
+        } catch {
+          notJson = true;
+        }
+      }
+      const opaque = resp.type === "opaqueredirect";
+      const status = resp.status;
+      const lr = exp.login_required_if;
+      if (lr) {
+        const statusHit = lr.status?.includes(status) || opaque && lr.status?.some((s2) => s2 >= 300 && s2 < 400);
+        if (statusHit) throw new RecipeError("login_required", `${this.recipe.site.name} asked for a login (HTTP ${opaque ? "redirect" : status})`, step.id);
+        if (lr.assert && this.safeTruthy({ body, status }, lr.assert, step.id)) {
+          throw new RecipeError("login_required", `${this.recipe.site.name} asked for a login`, step.id);
+        }
+      }
+      if (opaque) {
+        throw new RecipeError("expect_failed", `the site redirected (target hidden by the browser; not followed)`, step.id);
+      }
+      const okStatus = exp.status ?? [200];
+      const badStatus = !okStatus.includes(status);
+      if (badStatus || notJson) {
+        const block = detectBlock(status, text, (n) => header(resp, n), notJson);
+        if (block) throw new RecipeError("site_challenge", blockMessage(this.recipe.site, status, block), step.id);
+      }
+      if (badStatus) {
+        throw new RecipeError("expect_failed", `${this.recipe.site.name} answered HTTP ${status} (expected ${okStatus.join("/")}). The executor is online; the site's API may have changed.`, step.id);
+      }
+      if (notJson) throw new RecipeError("expect_failed", `${this.recipe.site.name} did not return ${ct === "turbo_stream" ? "a turbo-stream" : "JSON"}. The executor is online; the site's API may have changed.`, step.id);
+      const blockedPage = (e) => {
+        if (e instanceof RecipeError && e.code === "expect_failed" && ct !== "json" && ct !== "turbo_stream" && text.length < 6e4) {
+          const block = detectBlock(status, text, (n) => header(resp, n), true);
+          if (block) throw new RecipeError("site_challenge", blockMessage(this.recipe.site, status, block), step.id);
+        }
+        throw e;
+      };
+      if (exp.assert && !truthy(this.q({ body, status }, exp.assert, step.id))) {
+        blockedPage(new RecipeError("expect_failed", `assert failed: ${exp.assert}`, step.id));
+      }
+      const out = {};
+      if (ex.json) {
+        let data = body;
+        if (ct !== "json" && ct !== "turbo_stream") {
+          try {
+            data = JSON.parse(text);
+          } catch {
+            const block = detectBlock(status, text, (n) => header(resp, n), true);
+            if (block) throw new RecipeError("site_challenge", blockMessage(this.recipe.site, status, block), step.id);
+            throw new RecipeError("expect_failed", `${this.recipe.site.name} did not return JSON. The executor is online; the site's API may have changed.`, step.id);
+          }
+        }
+        for (const [name, expr] of Object.entries(ex.json)) out[name] = this.q(data, expr, step.id, true);
+      }
+      if (ex.html || ex.html_items || ex.embedded_json) {
+        try {
+          const doc = this.parseHtml(text, step.id);
+          for (const [name, spec] of Object.entries(ex.html ?? {})) out[name] = extractHtml(doc, spec);
+          for (const [name, spec] of Object.entries(ex.html_items ?? {})) out[name] = extractHtmlItems(doc, spec);
+          if (ex.embedded_json) Object.assign(out, extractEmbeddedJson(doc, ex.embedded_json, step.id));
+        } catch (e) {
+          blockedPage(e);
+        }
+      }
+      return out;
+    }
+    parseHtml(text, stepId) {
+      if (!this.adapters.parseHtml) throw new RecipeError("tab_error", "no HTML parser available", stepId);
+      return this.adapters.parseHtml(text);
+    }
+    // -- JMESPath helpers -------------------------------------------------------
+    /** Syntax errors are recipe bugs (recipe_invalid); runtime type errors mean the data changed (expect_failed). */
+    q(data, expr, stepId, isJson = false) {
+      try {
+        compileJmes(expr);
+      } catch (e) {
+        throw new RecipeError("recipe_invalid", `JMESPath syntax: ${expr} (${e.message})`, stepId);
+      }
+      try {
+        return isJson ? jmes(data, expr) : jmesCtx(data, expr);
+      } catch (e) {
+        throw new RecipeError("expect_failed", `JMESPath ${expr}: ${e.message}`, stepId);
+      }
+    }
+    safeTruthy(data, expr, stepId) {
+      try {
+        return truthy(this.q(data, expr, stepId));
+      } catch (e) {
+        if (e instanceof RecipeError && e.code === "recipe_invalid") throw e;
+        return false;
+      }
+    }
+    // -- events -----------------------------------------------------------------
+    emit(kind, level, msg, data) {
+      if (!this.adapters.emit) return;
+      const ev = {
+        type: "event",
+        run_id: this.opts.runId ?? "local",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        kind,
+        msg: redactString(msg, this.secrets)
+      };
+      if (data) ev.data = data;
+      try {
+        this.adapters.emit(ev);
+      } catch {
+      }
+    }
+    emitRequest(b, status, ms, bytes, level = "info") {
+      const path = redactString(b.url.pathname, this.secrets);
+      const kb = bytes >= 1024 ? `${Math.round(bytes / 1024)} KB` : `${bytes} B`;
+      const lvl = level === "error" ? "error" : status >= 400 || status === 0 ? "warn" : "info";
+      this.emit("request", lvl, `${b.method} ${b.url.host}${path} \u2192 ${status || (level === "error" ? "network error" : "redirect")} (${ms} ms, ${kb})`, {
+        method: b.method,
+        origin: b.url.origin,
+        path,
+        status,
+        ms,
+        bytes
+      });
+    }
+  };
+  function localIsoNow(d) {
+    const off = -d.getTimezoneOffset();
+    const sign = off >= 0 ? "+" : "-";
+    const a = Math.abs(off);
+    return `${localIso(d)}${sign}${String(Math.floor(a / 60)).padStart(2, "0")}:${String(a % 60).padStart(2, "0")}`;
+  }
+  function header(resp, name) {
+    const h = resp.headers;
+    if (!h) return null;
+    if (typeof h.get === "function") return h.get(name);
+    const rec = h;
+    for (const k of Object.keys(rec)) if (k.toLowerCase() === name) return rec[k] ?? null;
+    return null;
+  }
+  function utf8Length(s2) {
+    if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(s2).length;
+    return s2.length;
+  }
+
+  // packages/recipe/src/lint.ts
+  var OPERAND = String.raw`(?<![\w$.@])(§S|params\s*\.\s*[A-Za-z_]\w*|\$[A-Za-z_]\w*)`;
+  var COMPARISON = new RegExp(String.raw`${OPERAND}\s*(<=|>=|<|>)|(<=|>=|<|>)\s*${OPERAND}`, "g");
+
+  // packages/recipe/src/signature.ts
+  var enc = new TextEncoder();
+
+  // apps/extension/src/shared/types.ts
+  var BUILD_ID = "0.1.15+20261107220223.8c74";
+  var RELOAD_HINT = "Reload the Wield extension once: open chrome://extensions (vivaldi://extensions in Vivaldi) and click the reload arrow on the Wield card, then try again.";
+  var LIMITS2 = {
+    steps: 12,
+    foreach: 20,
+    requests: 40,
+    responseBytes: 5 * 1024 * 1024,
+    runMs: 6e4,
+    confirmMs: 12e4,
+    /** How long the "quick human check" note waits for a click in the site tab. */
+    humanCheckMs: 6e4,
+    tabLoadMs: 3e4,
+    /** Settle time after a tab we opened reaches `complete`, so anti-bot sensor scripts can post (tests/e2e/SPIKE.md). */
+    tabSettleMs: 1500
+  };
+
+  // apps/extension/src/content/index.ts
+  async function readCapped(res, maxBytes) {
+    if (!res.body) return { text: "", bytes: 0 };
+    const reader = res.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > maxBytes) {
+        await reader.cancel().catch(() => {
+        });
+        return { text: "", bytes };
+      }
+      chunks.push(value);
+    }
+    const all = new Uint8Array(bytes);
+    let off = 0;
+    for (const c of chunks) {
+      all.set(c, off);
+      off += c.byteLength;
+    }
+    const charset = /charset=([^;]+)/i.exec(res.headers.get("content-type") ?? "")?.[1]?.trim() ?? "utf-8";
+    let decoder;
+    try {
+      decoder = new TextDecoder(charset);
+    } catch {
+      decoder = new TextDecoder("utf-8");
+    }
+    return { text: decoder.decode(all), bytes };
+  }
+  function makeFetch(hooks) {
+    return async (req) => {
+      const url = new URL(req.url);
+      await hooks.pace(url.origin);
+      const res = await fetch(req.url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body,
+        credentials: req.credentials,
+        redirect: "manual",
+        signal: req.signal
+        // No `cache` option on purpose: cache: 'no-store' makes Chrome add Pragma and
+        // Cache-Control headers, and the request would no longer match the site's own XHR.
+      });
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      if (res.type === "opaqueredirect") return { status: 0, type: res.type, headers, text: "", bytes: 0 };
+      const { text, bytes } = await readCapped(res, req.maxBytes);
+      const challenge = detectChallenge(res.status, headers, text, url.host);
+      if (challenge) hooks.onChallenge(challenge);
+      return { status: res.status, type: res.type, headers, text, bytes };
+    };
+  }
+  function detectChallenge(status, headers, text, host) {
+    const h = (k) => headers[k] ?? "";
+    const head = text.slice(0, 4e3);
+    let vendor = null;
+    if (h("cf-mitigated") === "challenge" || (status === 403 || status === 503) && /Just a moment|cf-chl|challenge-platform/i.test(head)) vendor = "Cloudflare";
+    else if (h("x-amzn-waf-action") || (status === 401 || status === 403 || status === 405) && /Ich bin kein Roboter|awswaf|aws-waf-token/i.test(head)) vendor = "AWS WAF";
+    else if (h("x-datadome") || /captcha-delivery\.com/i.test(head)) vendor = status >= 400 ? "DataDome" : null;
+    else if (status === 403 && (/OPS_BLOCKED/.test(head) || /AkamaiGHost/i.test(h("server")) || h("akamai-grn"))) vendor = "Akamai";
+    else if (status === 429) vendor = "unknown";
+    if (!vendor) return null;
+    const info = { vendor, status, host };
+    if (vendor === "Akamai") {
+      const abck = readCookie("_abck");
+      info.sensor = abck == null ? "absent" : /~0~/.test(abck) ? "validated" : "not validated";
+    }
+    return info;
+  }
+  function readCookie(name) {
+    for (const part of document.cookie.split(";")) {
+      const i = part.indexOf("=");
+      if (i < 0) continue;
+      if (part.slice(0, i).trim() === name) {
+        const v = part.slice(i + 1).trim();
+        try {
+          return decodeURIComponent(v);
+        } catch {
+          return v;
+        }
+      }
+    }
+    return null;
+  }
+  function readNode2(el, attr) {
+    if (!el) return null;
+    return attr ? el.getAttribute(attr) : (el.textContent ?? "").trim();
+  }
+  function onRunPort(port) {
+    const ac = new AbortController();
+    const confirms = /* @__PURE__ */ new Map();
+    const paces = /* @__PURE__ */ new Map();
+    let challenge = null;
+    const post = (m) => {
+      try {
+        port.postMessage(m);
+      } catch {
+      }
+    };
+    port.onDisconnect.addListener(() => {
+      ac.abort();
+      for (const done of confirms.values()) done(false);
+      for (const done of paces.values()) done({ ok: false, message: "run ended" });
+    });
+    const hooks = {
+      pace: (origin) => new Promise((resolve, reject) => {
+        const id = crypto.randomUUID();
+        const backstop = setTimeout(() => paces.get(id)?.({ ok: false, message: `The Wield service worker did not answer. ${RELOAD_HINT}` }), 3e4);
+        paces.set(id, (r) => {
+          clearTimeout(backstop);
+          paces.delete(id);
+          if (r.ok) resolve();
+          else if (r.message?.startsWith("The Wield service worker")) reject(new RecipeError("tab_error", r.message));
+          else reject(new RecipeError("limit_exceeded", r.message ?? "paused by pacing"));
+        });
+        post({ type: "pace", id, origin });
+      }),
+      onChallenge: (c) => {
+        if (challenge) return;
+        challenge = c;
+        const sensor = c.sensor ? `; Akamai sensor cookie: ${c.sensor}` : "";
+        post({ type: "event", level: "warn", kind: "step", msg: `bot check from ${c.vendor} on ${c.host} (HTTP ${c.status})${sensor}` });
+      }
+    };
+    const adapters = {
+      fetch: makeFetch(hooks),
+      getCookie: (name) => readCookie(name),
+      getStorage: (area, key) => (area === "local" ? localStorage : sessionStorage).getItem(key),
+      queryMeta: (selector, attr) => readNode2(document.querySelector(selector), attr || "content"),
+      queryDom: (selector, attr) => readNode2(document.querySelector(selector), attr),
+      queryDomAll: (selector, attr) => Array.from(document.querySelectorAll(selector), (el) => attr ? el.getAttribute(attr) : el.textContent ?? ""),
+      pageUrl: () => location.href,
+      parseHtml: (html) => new DOMParser().parseFromString(html, "text/html"),
+      confirm: (info) => new Promise((resolve) => {
+        const id = crypto.randomUUID();
+        confirms.set(id, (allow) => {
+          confirms.delete(id);
+          resolve(allow);
+        });
+        post({ type: "confirm", id, info });
+      }),
+      emit: (ev) => post({ type: "event", level: ev.level, kind: ev.kind, msg: ev.msg, ...ev.data ? { data: ev.data } : {} })
+    };
+    port.onMessage.addListener(async (m) => {
+      if (m.type === "cancel") {
+        ac.abort();
+      } else if (m.type === "confirm_result") {
+        confirms.get(m.id)?.(m.allow === true);
+      } else if (m.type === "pace_result") {
+        paces.get(m.id)?.(m);
+      } else if (m.type === "run") {
+        post({ type: "ack", build: BUILD_ID });
+        if (m.build !== BUILD_ID) {
+          post({ type: "result", ok: false, requests: 0, error: { code: "tab_error", message: `Wield's files changed on disk but the extension was not reloaded (worker ${m.build ?? "older"}, page script ${BUILD_ID}). ${RELOAD_HINT}` } });
+          return;
+        }
+        const opts = { runId: m.run_id, signal: ac.signal, timeoutMs: m.timeout_ms, ...m.trust === "registry" ? { trust: "registry" } : {} };
+        try {
+          if (m.mode === "login_check") {
+            const r = m.recipe;
+            const logged_in = await checkLogin({ id: r.id, site: r.site, login_check: r.login_check, auth: r.auth }, adapters, opts);
+            post({ type: "result", ok: true, output: logged_in, requests: 0 });
+          } else {
+            const res = await runRecipe(m.recipe, m.params, adapters, opts);
+            if (res.ok) {
+              post({ type: "result", ok: true, output: res.output, requests: res.requests });
+            } else if (challenge && ["expect_failed", "login_required", "site_challenge"].includes(res.error.code)) {
+              const c = challenge;
+              const message = res.error.code === "site_challenge" ? res.error.message : `${c.host} answered with a bot check (${c.vendor}, HTTP ${c.status}) instead of data.`;
+              post({ type: "result", ok: false, requests: res.requests, challenge: c, error: { code: "site_challenge", message, ...res.error.step ? { step: res.error.step } : {} } });
+            } else {
+              post({ type: "result", ok: false, error: res.error, requests: res.requests });
+            }
+          }
+        } catch (e) {
+          post({ type: "result", ok: false, error: { code: "tab_error", message: String(e?.message ?? e).slice(0, 300) }, requests: 0 });
+        }
+      }
+    });
+  }
+  var CHECK_CSS = `
+  :host { all: initial; }
+  .card { position: fixed; right: 20px; bottom: 20px; z-index: 2147483647; width: 340px; box-sizing: border-box;
+    padding: 16px 16px 12px; border-radius: 10px; background: #fff; color: #3b3c38;
+    font: 14px/1.5 ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    box-shadow: 0 0 0 1px rgba(18,19,17,.08), 0 2px 2px rgba(18,19,17,.03), 0 12px 24px -6px rgba(18,19,17,.10), 0 32px 56px -20px rgba(18,19,17,.16); }
+  .brand { display: flex; align-items: center; gap: 6px; margin-bottom: 8px; color: #121311; font: 600 13px/1 ui-sans-serif, system-ui, sans-serif; letter-spacing: -0.03em; }
+  .brand svg { width: 14px; height: 14px; }
+  h2 { margin: 0 0 4px; color: #121311; font-size: 15px; font-weight: 560; line-height: 1.3; }
+  p { margin: 0; }
+  .foot { display: flex; align-items: center; justify-content: space-between; margin-top: 12px; padding-top: 10px; border-top: 1px solid #e2e2dd; }
+  .left { color: #5f605a; font-size: 12px; font-variant-numeric: tabular-nums; }
+  button { all: unset; cursor: pointer; padding: 6px 10px; border-radius: 6px; border: 1px solid #d1d1cb; color: #121311;
+    font: 11.5px/1 ui-monospace, "SF Mono", Menlo, monospace; text-transform: uppercase; letter-spacing: .06em; }
+  button:hover { background: #fafaf8; }
+  button:focus-visible { outline: 2px solid #121311; outline-offset: 2px; }
+  @media (prefers-color-scheme: dark) {
+    .card { background: #161715; color: #c8c9c2; box-shadow: 0 0 0 1px rgba(255,255,255,.09), 0 12px 24px -6px rgba(0,0,0,.55); }
+    .brand, h2, button { color: #f0f0ec; } .foot { border-color: #272825; } .left { color: #9a9b94; } button { border-color: #363733; } button:hover { background: #1b1c1a; }
+  }`;
+  function onCheckPort(port) {
+    let host = null;
+    let done = false;
+    let timer;
+    const send = (m) => {
+      try {
+        port.postMessage(m);
+      } catch {
+      }
+    };
+    const cleanup = () => {
+      clearInterval(timer);
+      window.removeEventListener("pointerdown", onInput, true);
+      window.removeEventListener("keydown", onInput, true);
+      window.removeEventListener("wheel", onInput, true);
+      host?.remove();
+      host = null;
+    };
+    const onInput = (e) => {
+      if (done || !e.isTrusted || host && e.composedPath().includes(host)) return;
+      done = true;
+      send({ type: "interacted" });
+      cleanup();
+    };
+    port.onDisconnect.addListener(cleanup);
+    port.onMessage.addListener((m) => {
+      if (m.type === "hide") return cleanup();
+      if (m.type !== "show" || host) return;
+      host = document.createElement("wield-check");
+      const root = host.attachShadow({ mode: "open" });
+      root.innerHTML = `<style>${CHECK_CSS}</style>
+      <div class="card" role="alertdialog" aria-labelledby="t" aria-describedby="d">
+        <div class="brand"><svg viewBox="0 0 24 24" aria-hidden="true"><defs><linearGradient id="wm-hd" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#ffd85a"/><stop offset=".5" stop-color="#ff9a24"/><stop offset="1" stop-color="#ff5200"/></linearGradient><linearGradient id="wm-ht" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#ff6a0a"/><stop offset="1" stop-color="currentColor"/></linearGradient></defs><g transform="translate(0 -2.45)"><path d="M7.0 11.6 2.4 16.6 7.0 21.6M17.0 11.6 21.6 16.6 17.0 21.6" fill="none" stroke="currentColor" stroke-width="2.7" stroke-linecap="round" stroke-linejoin="round"/><path d="M11.0 21.6 12.6 10.28" stroke="currentColor" stroke-width="2.3" stroke-linecap="round"/><g transform="translate(12.6 10.28) rotate(8.045051779050041)"><rect x="-1.15" y="-.2" width="2.3" height="2.4" fill="url(#wm-ht)"/></g><g transform="translate(12.908 8.102) rotate(8.05) scale(0.84)"><path d="M-4.6 -1.9 -2.9 -1.9 -2.4 -1.5 1.3 -1.5 4.4 -0.55 4.6 -0.2 4.6 0.2 4.4 0.55 1.3 1.5 -2.4 1.5 -2.9 1.9 -4.6 1.9Z" fill="url(#wm-hd)" stroke="url(#wm-hd)" stroke-width=".35" stroke-linejoin="round"/><path d="M-4.2 -1.25H-2.9M-1.9 -.95H1.0" stroke="#fff1b8" stroke-width=".55" stroke-linecap="round" opacity=".85"/><rect x="-1.4" y="1.35" width="2.8" height=".8" rx=".3" fill="currentColor"/></g><rect x="7.01" y="5.50" width="1.3" height="1.3" fill="#ffc23d"/><rect x="5.41" y="7.20" width=".9" height=".9" fill="#ff8a1f"/></g></svg>wield</div>
+        <h2 id="t"></h2>
+        <p id="d"></p>
+        <div class="foot"><span class="left" id="left"></span><button type="button" id="no">Not now</button></div>
+      </div>`;
+      root.getElementById("t").textContent = `${m.site_name} wants a quick check that a person is here.`;
+      root.getElementById("d").textContent = "Click anywhere on the page, or scroll a little. Your agent\u2019s request is then retried once.";
+      root.getElementById("no").addEventListener("click", () => {
+        if (done) return;
+        done = true;
+        send({ type: "dismissed" });
+        cleanup();
+      });
+      document.documentElement.append(host);
+      const until = Date.now() + m.timeout_ms;
+      const tick = () => {
+        const left = Math.max(0, Math.round((until - Date.now()) / 1e3));
+        const el = host?.shadowRoot?.getElementById("left");
+        if (el) el.textContent = `Waiting ${Math.floor(left / 60)}:${String(left % 60).padStart(2, "0")}`;
+      };
+      tick();
+      timer = setInterval(tick, 1e3);
+      window.addEventListener("pointerdown", onInput, true);
+      window.addEventListener("keydown", onInput, true);
+      window.addEventListener("wheel", onInput, true);
+    });
+  }
+  var REC_CSS = `
+  :host { all: initial; }
+  .bar { position: fixed; top: 12px; right: 12px; z-index: 2147483647; display: flex; align-items: center; gap: 10px;
+    padding: 8px 8px 8px 12px; border-radius: 10px; background: #16110c; color: #f7f3ec;
+    font: 13px/1.3 ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    box-shadow: 0 0 0 1px rgba(255,255,255,.08), 0 12px 32px -12px rgba(0,0,0,.6); }
+  .dot { width: 8px; height: 8px; border-radius: 50%; background: #ff7d70; box-shadow: 0 0 0 3px rgba(255,125,112,.25); }
+  .t { font-variant-numeric: tabular-nums; color: #aeafa8; }
+  b { font-weight: 600; color: #fff; }
+  button { all: unset; cursor: pointer; padding: 6px 10px; border-radius: 6px; font: 11.5px/1 ui-monospace, "SF Mono", Menlo, monospace;
+    text-transform: uppercase; letter-spacing: .06em; }
+  .done { background: #ffc23d; color: #16110c; }
+  .cancel { color: #ecece8; border: 1px solid #363733; }
+  button:focus-visible { outline: 2px solid #ffc23d; outline-offset: 2px; }
+  @media (prefers-reduced-motion: no-preference) { .dot { animation: p 1.6s ease-in-out infinite; } @keyframes p { 50% { opacity: .35; } } }`;
+  function labelFor(el) {
+    const aria = el.getAttribute("aria-label");
+    if (aria) return aria.trim();
+    const id = el.id;
+    if (id) {
+      const root = el.getRootNode();
+      const l = root.querySelector?.(`label[for="${CSS.escape(id)}"]`) ?? document.querySelector(`label[for="${CSS.escape(id)}"]`);
+      if (l?.textContent?.trim()) return l.textContent.trim();
+    }
+    const wrap = el.closest("label");
+    if (wrap?.textContent?.trim()) return wrap.textContent.trim();
+    return (el.getAttribute("placeholder") || el.getAttribute("name") || el.id || el.tagName.toLowerCase()).trim();
+  }
+  function onRecordPort(port) {
+    let host = null;
+    let timer;
+    const typed = /* @__PURE__ */ new Map();
+    const page = Math.random().toString(36).slice(2, 10);
+    const send = (m) => {
+      try {
+        port.postMessage(m);
+      } catch {
+      }
+    };
+    const isField = (el) => el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement;
+    const NOT_TEXT2 = /* @__PURE__ */ new Set(["password", "hidden", "submit", "button", "reset", "image", "file", "checkbox", "radio"]);
+    const note = (el, prefilledOk) => {
+      const type = String(el.type || el.tagName).toLowerCase();
+      if (type === "password" || type === "hidden" || el.getAttribute("autocomplete")?.includes("password")) return false;
+      if (prefilledOk && NOT_TEXT2.has(type)) return false;
+      let value = String(el.value ?? "");
+      if (el instanceof HTMLSelectElement) value = el.selectedOptions[0]?.textContent?.trim() || value;
+      if (!value.trim()) return false;
+      const prev = typed.get(el);
+      const next = { label: labelFor(el).slice(0, 80), ...el.getAttribute("name") ? { name: el.getAttribute("name") } : {}, input_type: type, value: value.slice(0, 200) };
+      if (prev && prev.value === next.value) return false;
+      typed.set(el, next);
+      return true;
+    };
+    const flushTyped = () => send({ type: "typed", page, typed: [...typed.values()] });
+    const onInput = (e) => {
+      if (!e.isTrusted) return;
+      const path = e.composedPath();
+      const el = path[0];
+      if (!isField(el) || host && path.includes(host)) return;
+      if (note(el, false)) flushTyped();
+    };
+    const fieldsNear = (start) => {
+      const form = start.form ?? start.closest("form");
+      if (form) return Array.from(form.elements).filter(isField);
+      const root = start.getRootNode();
+      return root instanceof ShadowRoot ? Array.from(root.querySelectorAll("input, textarea, select")).filter(isField) : [];
+    };
+    const onCommit = (e) => {
+      if (!e.isTrusted) return;
+      const path = e.composedPath();
+      if (host && path.includes(host)) return;
+      const first = path[0];
+      let start = null;
+      if (e.type === "keydown") {
+        if (e.key !== "Enter" || !isField(first)) return;
+        start = first;
+      } else if (e.type === "submit") {
+        start = first instanceof HTMLFormElement ? first : null;
+      } else {
+        start = path.find((n) => n instanceof HTMLButtonElement || n instanceof HTMLInputElement && /^(submit|image)$/.test(n.type)) ?? null;
+      }
+      if (!start) return;
+      let changed = isField(start) ? note(start, true) : false;
+      for (const f of fieldsNear(start)) changed = note(f, true) || changed;
+      if (changed) flushTyped();
+    };
+    let nonce = "";
+    const vouched = /* @__PURE__ */ new Set();
+    let documentSeen = false;
+    const verified = (en) => {
+      if (typeof en.url !== "string") return false;
+      if (en.kind === "document") {
+        const nav = performance.getEntriesByType("navigation")[0];
+        if (documentSeen || new URL(en.url, location.href).origin !== location.origin || en.url !== nav?.name && en.url !== location.href) return false;
+        documentSeen = true;
+        return true;
+      }
+      const started = Number(en.started);
+      for (const r of performance.getEntriesByType("resource")) {
+        if (r.name !== en.url || r.initiatorType !== "fetch" && r.initiatorType !== "xmlhttprequest") continue;
+        const at = performance.timeOrigin + r.startTime;
+        const key = `${r.name}|${r.startTime}`;
+        if (at < started - 1e3 || at > started + 15e3 || vouched.has(key)) continue;
+        vouched.add(key);
+        return true;
+      }
+      return false;
+    };
+    const relay = (en, tries = 0) => {
+      if (!nonce) return;
+      if (verified(en)) return send({ type: "entry", entry: en });
+      if (tries < 4) setTimeout(() => relay(en, tries + 1), [300, 1e3, 2500, 5e3][tries]);
+    };
+    const onPageMessage = (e) => {
+      const d = e.data;
+      if (e.source !== window || !d || !nonce || d.nonce !== nonce) return;
+      if (d.source === "wield-rec-hello") window.postMessage({ source: "wield-rec-ctl", nonce, cmd: "ready" }, location.origin);
+      else if (d.source === "wield-rec" && d.entry && typeof d.entry === "object") relay(d.entry);
+    };
+    const cleanup = () => {
+      clearInterval(timer);
+      document.removeEventListener("input", onInput, true);
+      document.removeEventListener("change", onInput, true);
+      document.removeEventListener("keydown", onCommit, true);
+      document.removeEventListener("click", onCommit, true);
+      document.removeEventListener("submit", onCommit, true);
+      window.removeEventListener("message", onPageMessage);
+      host?.remove();
+      host = null;
+    };
+    port.onDisconnect.addListener(cleanup);
+    port.onMessage.addListener((m) => {
+      if (m.type === "hide") return cleanup();
+      if (m.type !== "show" || host) return;
+      if (typeof m.nonce === "string" && m.nonce) {
+        nonce = m.nonce;
+        try {
+          performance.setResourceTimingBufferSize(1e3);
+        } catch {
+        }
+        window.addEventListener("message", onPageMessage);
+        window.postMessage({ source: "wield-rec-ctl", nonce, cmd: "ready" }, location.origin);
+      }
+      host = document.createElement("wield-recorder");
+      const root = host.attachShadow({ mode: "open" });
+      root.innerHTML = `<style>${REC_CSS}</style><div class="bar" role="status" aria-live="polite"><span class="dot" aria-hidden="true"></span>
+      <span>Recording on <b id="h"></b> \xB7 <span class="t" id="t">0:00</span></span>
+      <button class="cancel" id="c" type="button">Cancel</button><button class="done" id="d" type="button">Done</button></div>`;
+      root.getElementById("h").textContent = m.host ?? location.host;
+      root.getElementById("d").addEventListener("click", () => send({ type: "done" }));
+      root.getElementById("c").addEventListener("click", () => send({ type: "cancel" }));
+      document.documentElement.append(host);
+      const t0 = m.started_at ?? Date.now();
+      const tick = () => {
+        const s2 = Math.floor((Date.now() - t0) / 1e3);
+        const el = host?.shadowRoot?.getElementById("t");
+        if (el) el.textContent = `${Math.floor(s2 / 60)}:${String(s2 % 60).padStart(2, "0")}`;
+      };
+      tick();
+      let n = 0;
+      timer = setInterval(() => {
+        tick();
+        if (++n % 15 === 0) send({ type: "ping" });
+      }, 1e3);
+      document.addEventListener("input", onInput, true);
+      document.addEventListener("change", onInput, true);
+      document.addEventListener("keydown", onCommit, true);
+      document.addEventListener("click", onCommit, true);
+      document.addEventListener("submit", onCommit, true);
+    });
+  }
+  function onPort(port) {
+    if (port.name.startsWith("wield-run:")) onRunPort(port);
+    else if (port.name.startsWith("wield-check:")) onCheckPort(port);
+    else if (port.name.startsWith("wield-rec:")) onRecordPort(port);
+  }
+  if (globalThis.__wieldListener) {
+    try {
+      chrome.runtime.onConnect.removeListener(globalThis.__wieldListener);
+    } catch {
+    }
+  }
+  globalThis.__wieldListener = onPort;
+  chrome.runtime.onConnect.addListener(onPort);
+})();