@prompd/core 0.5.2 → 0.5.4

package/dist/index.cjs

@@ -3395,11 +3395,19 @@ var MAX_PACKAGE_SIZE = 50 * 1024 * 1024;
 function slugify(name) {
   return name.toLowerCase().replace(/[@/]+/g, "-").replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function resolvePackageDir(root, type, name) {
-  return joinPosix(root, ".prompd", getInstallDirForType(type), name);
+var DEFAULT_INSTALL_DIR = ".prompd";
+function checkInstallDir(dir) {
+  const d = dir ?? DEFAULT_INSTALL_DIR;
+  if (!/^\.[A-Za-z0-9][A-Za-z0-9._-]*$/.test(d)) {
+    throw new Error(`Invalid installDir "${d}": expected a single dot-directory name like ".prompd".`);
+  }
+  return d;
+}
+function resolvePackageDir(root, installDir, type, name) {
+  return joinPosix(root, installDir, getInstallDirForType(type), name);
 }
-function resolveInstallDir(root, type, name, version) {
-  return joinPosix(resolvePackageDir(root, type, name), version);
+function resolveInstallDir(root, installDir, type, name, version) {
+  return joinPosix(resolvePackageDir(root, installDir, type, name), version);
 }
 async function addWorkspaceDependency(store, root, name, version) {
   if (!store.readFile) return;
@@ -3441,6 +3449,7 @@ async function installPackage(opts) {
 }
 async function installInternal(opts, visited) {
   const { ref, root, store, download, global, tools, deployTool } = opts;
+  const installDir = checkInstallDir(opts.installDir);
   const parsed = parsePackageReference(ref);
   const bytes = await download(parsed.name, parsed.version);
   if (bytes.length > MAX_PACKAGE_SIZE) {
@@ -3467,11 +3476,11 @@ async function installInternal(opts, visited) {
     if (!store.writeBytes) {
       throw new Error("Installing a node-template requires a PackageStore with writeBytes (binary). This host does not support it.");
     }
-    const dir = joinPosix(root, ".prompd", getInstallDirForType("node-template"));
+    const dir = joinPosix(root, installDir, getInstallDirForType("node-template"));
     installedPath = joinPosix(dir, `${slugify(name)}-${version}.pdpkg`);
     await store.writeBytes(installedPath, bytes);
   } else {
-    installedPath = resolveInstallDir(root, type, name, version);
+    installedPath = resolveInstallDir(root, installDir, type, name, version);
     const base = normalizePosix(installedPath);
     await store.removeDir?.(installedPath);
     for (const [rel, content] of files) {
@@ -3494,13 +3503,14 @@ async function installInternal(opts, visited) {
 }
 async function uninstallPackage(opts) {
   const { root, store, global } = opts;
+  const installDir = checkInstallDir(opts.installDir);
   if (!store.removeDir) throw new Error("Uninstall requires a PackageStore with removeDir.");
   const parsed = parsePackageReference(opts.ref);
   const name = parsed.name;
   const removed = [];
   for (const type of ["package", "workflow", "skill", "node-template"]) {
     if (type === "node-template") {
-      const dir = joinPosix(root, ".prompd", getInstallDirForType("node-template"));
+      const dir = joinPosix(root, installDir, getInstallDirForType("node-template"));
       if (!store.readdir || !store.removeFile || !store.readBytes) continue;
       try {
         for (const entry of await store.readdir(dir)) {
@@ -3518,7 +3528,7 @@ async function uninstallPackage(opts) {
       } catch {
       }
     } else {
-      const dir = resolvePackageDir(root, type, name);
+      const dir = resolvePackageDir(root, installDir, type, name);
       await store.removeDir(dir);
       removed.push(dir);
     }
@@ -5084,6 +5094,817 @@ function forkJoinId(file, parallelId) {
   return file.edges.find((e) => members.has(e.source) && e.targetHandle?.startsWith("input-"))?.target;
 }
 
+// src/lib/expression.ts
+var BRANDED = /* @__PURE__ */ new WeakSet();
+var ExpressionError = class _ExpressionError extends Error {
+  constructor(message, construct, position) {
+    super(message);
+    this.name = "ExpressionError";
+    this.construct = construct;
+    this.position = position;
+    if (new.target === _ExpressionError) {
+      BRANDED.add(this);
+      Object.freeze(this);
+    }
+  }
+};
+function isOwnExpressionError(e) {
+  return typeof e === "object" && e !== null && BRANDED.has(e);
+}
+function ownDataField(o, key) {
+  const d = Object.getOwnPropertyDescriptor(o, key);
+  return d && "value" in d ? d.value : void 0;
+}
+function expressionErrorFields(e) {
+  if (e === null || typeof e !== "object") return null;
+  try {
+    if (ownDataField(e, "name") !== "ExpressionError") return null;
+    const construct = ownDataField(e, "construct");
+    const position = ownDataField(e, "position");
+    if (typeof construct !== "string" || typeof position !== "number") return null;
+    const message = ownDataField(e, "message");
+    return { construct, position, message: typeof message === "string" ? message : "" };
+  } catch {
+    return null;
+  }
+}
+function ownMessage(e) {
+  if (e === null || typeof e !== "object") return "unknown error";
+  try {
+    const m = ownDataField(e, "message");
+    return typeof m === "string" ? m : "unknown error";
+  } catch {
+    return "unknown error";
+  }
+}
+function isExpressionError(e) {
+  return isOwnExpressionError(e) || expressionErrorFields(e) !== null;
+}
+var MAX_EXPRESSION_LENGTH = 2e3;
+var MAX_EXPRESSION_DEPTH = 64;
+var BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var STRING_METHODS = /* @__PURE__ */ new Set([
+  "includes",
+  "startsWith",
+  "endsWith",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "indexOf",
+  "slice"
+]);
+var ARRAY_METHODS = /* @__PURE__ */ new Set(["includes", "indexOf", "join", "slice"]);
+var KEYWORD_CONSTRUCTS = /* @__PURE__ */ new Map([
+  ["new", "'new'"],
+  ["typeof", "'typeof'"],
+  ["void", "'void'"],
+  ["delete", "'delete'"],
+  ["in", "the 'in' operator"],
+  ["instanceof", "'instanceof'"],
+  ["function", "a function expression"],
+  ["class", "a class expression"],
+  ["this", "'this'"],
+  ["await", "'await'"],
+  ["yield", "'yield'"],
+  ["import", "'import'"],
+  ["super", "'super'"],
+  ["let", "a declaration"],
+  ["var", "a declaration"],
+  ["const", "a declaration"],
+  ["return", "a statement"]
+]);
+var ASSIGNMENT_OPS = ["=", "+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "&&=", "||=", "??="];
+var OP_CONSTRUCTS = new Map([
+  ...ASSIGNMENT_OPS.map((o) => [o, "assignment"]),
+  ["=>", "an arrow function"],
+  ["++", "increment/decrement"],
+  ["--", "increment/decrement"],
+  ["&", "a bitwise operator"],
+  ["|", "a bitwise operator"],
+  ["^", "a bitwise operator"],
+  ["~", "a bitwise operator"],
+  ["<<", "a bitwise operator"],
+  [">>", "a bitwise operator"],
+  [">>>", "a bitwise operator"],
+  ["**", "the exponent operator"],
+  [",", "the comma operator"],
+  [";", "a statement separator"],
+  ["...", "spread"]
+]);
+var OPS = [
+  ...ASSIGNMENT_OPS,
+  "...",
+  "===",
+  "!==",
+  ">>>",
+  "=>",
+  "**",
+  "?.",
+  "??",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "&&",
+  "||",
+  "++",
+  "--",
+  "<<",
+  ">>",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  ",",
+  ":",
+  ".",
+  "?",
+  "!",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  ">",
+  "&",
+  "|",
+  "^",
+  "~",
+  ";"
+].sort((a, b) => b.length - a.length);
+function disallowed(construct, position) {
+  return new ExpressionError(`${construct} is not allowed in a workflow expression`, construct, position);
+}
+function syntax(message, position) {
+  return new ExpressionError(message, "syntax error", position);
+}
+function describeExpressionFailure(kind, label, e) {
+  const f = expressionErrorFields(e);
+  if (!f) return `${kind} on "${label}" has an invalid expression: ${ownMessage(e)}.`;
+  return f.construct === "syntax error" || f.construct === "evaluation error" ? `${kind} on "${label}" has an invalid expression: ${f.message} (position ${f.position}).` : `${kind} on "${label}" can't run: ${f.construct}, which workflow expressions can't do (position ${f.position}).`;
+}
+var SIMPLE_ESCAPES = /* @__PURE__ */ new Map([
+  ["n", "\n"],
+  ["t", "	"],
+  ["r", "\r"],
+  ["b", "\b"],
+  ["f", "\f"],
+  ["v", "\v"],
+  ["0", "\0"]
+]);
+function readString(src, start) {
+  const q = src[start];
+  let out = "";
+  let i = start + 1;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === q) return [out, i + 1];
+    if (c === "\n") break;
+    if (c === "\\") {
+      const n = src[i + 1];
+      if (n === void 0) break;
+      const simple = SIMPLE_ESCAPES.get(n);
+      if (simple !== void 0) {
+        out += simple;
+        i += 2;
+        continue;
+      }
+      if (n === "x" || n === "u") {
+        const len = n === "x" ? 2 : 4;
+        const hex = src.slice(i + 2, i + 2 + len);
+        if (!new RegExp(`^[0-9a-fA-F]{${len}}$`).test(hex)) throw syntax("invalid escape sequence", i);
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 2 + len;
+        continue;
+      }
+      out += n;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  throw syntax("unterminated string", start);
+}
+function tokenize(src) {
+  const toks = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === "`") throw disallowed("a template literal", i);
+    if (c === '"' || c === "'") {
+      const [s, next] = readString(src, i);
+      toks.push({ t: "str", v: s, p: i });
+      i = next;
+      continue;
+    }
+    if (/[0-9]/.test(c) || c === "." && /[0-9]/.test(src[i + 1] ?? "")) {
+      const m = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/.exec(src.slice(i));
+      if (!m) throw syntax("invalid number", i);
+      toks.push({ t: "num", v: Number(m[0]), p: i });
+      i += m[0].length;
+      if (/[A-Za-z_$0-9]/.test(src[i] ?? "")) throw syntax("invalid number", i);
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(c)) {
+      const m = /^[A-Za-z_$][\w$]*/.exec(src.slice(i));
+      const name = m ? m[0] : c;
+      toks.push({ t: "id", v: name, p: i });
+      i += name.length;
+      continue;
+    }
+    const op = OPS.find((o) => src.startsWith(o, i) && !(o === "?." && /[0-9]/.test(src[i + 2] ?? "")));
+    if (!op) throw syntax(`unexpected character '${c}'`, i);
+    toks.push({ t: "op", v: op, p: i });
+    i += op.length;
+  }
+  toks.push({ t: "eof", p: src.length });
+  return toks;
+}
+var Parser = class {
+  constructor(toks) {
+    this.toks = toks;
+    this.i = 0;
+    this.depth = 0;
+  }
+  parseAll() {
+    const n = this.expr();
+    const t = this.peek();
+    if (t.t !== "eof") throw this.unexpected(t);
+    return n;
+  }
+  peek() {
+    return this.toks[this.i];
+  }
+  next() {
+    return this.toks[this.i++];
+  }
+  isOp(v) {
+    const t = this.peek();
+    return t.t === "op" && t.v === v;
+  }
+  eatOp(v) {
+    if (this.isOp(v)) {
+      this.i++;
+      return true;
+    }
+    return false;
+  }
+  expectOp(v) {
+    if (!this.eatOp(v)) throw this.unexpected(this.peek());
+  }
+  enter(p) {
+    if (++this.depth > MAX_EXPRESSION_DEPTH) throw disallowed(`nesting deeper than ${MAX_EXPRESSION_DEPTH} levels`, p);
+  }
+  leave() {
+    this.depth--;
+  }
+  unexpected(t) {
+    if (t.t === "eof") return syntax("unexpected end of expression", t.p);
+    if (t.t === "id") {
+      const kw = KEYWORD_CONSTRUCTS.get(t.v);
+      return kw ? disallowed(kw, t.p) : syntax(`unexpected '${t.v}'`, t.p);
+    }
+    if (t.t !== "op") return syntax("unexpected value", t.p);
+    const c = OP_CONSTRUCTS.get(t.v);
+    return c ? disallowed(c, t.p) : syntax(`unexpected '${t.v}'`, t.p);
+  }
+  expr() {
+    this.enter(this.peek().p);
+    try {
+      return this.conditional();
+    } finally {
+      this.leave();
+    }
+  }
+  conditional() {
+    const test = this.nullish();
+    if (!this.eatOp("?")) return test;
+    const yes = this.expr();
+    this.expectOp(":");
+    const no = this.expr();
+    return { k: "cond", test, yes, no };
+  }
+  binaryLevel(ops, nextLevel) {
+    let l = nextLevel();
+    for (; ; ) {
+      const t = this.peek();
+      if (t.t !== "op" || !ops.includes(t.v)) return l;
+      this.i++;
+      l = { k: "bin", op: t.v, l, r: nextLevel(), p: t.p };
+    }
+  }
+  nullish() {
+    return this.binaryLevel(["??"], () => this.or());
+  }
+  or() {
+    return this.binaryLevel(["||"], () => this.and());
+  }
+  and() {
+    return this.binaryLevel(["&&"], () => this.equality());
+  }
+  equality() {
+    return this.binaryLevel(["==", "!=", "===", "!=="], () => this.relational());
+  }
+  relational() {
+    return this.binaryLevel(["<", "<=", ">", ">="], () => this.additive());
+  }
+  additive() {
+    return this.binaryLevel(["+", "-"], () => this.multiplicative());
+  }
+  multiplicative() {
+    return this.binaryLevel(["*", "/", "%"], () => this.unary());
+  }
+  unary() {
+    const t = this.peek();
+    if (t.t === "op" && (t.v === "!" || t.v === "-" || t.v === "+")) {
+      this.i++;
+      this.enter(t.p);
+      try {
+        return { k: "unary", op: t.v, arg: this.unary(), p: t.p };
+      } finally {
+        this.leave();
+      }
+    }
+    if (t.t === "op" && (t.v === "++" || t.v === "--" || t.v === "~")) throw this.unexpected(t);
+    return this.postfix();
+  }
+  postfix() {
+    let n = this.primary();
+    for (; ; ) {
+      const t = this.peek();
+      if (t.t !== "op") return n;
+      if (t.v === "." || t.v === "?.") {
+        this.i++;
+        const optional = t.v === "?.";
+        if (optional && this.isOp("(")) throw disallowed("an optional call", t.p);
+        if (optional && this.eatOp("[")) {
+          const prop = this.computedKey(t.p);
+          n = { k: "member", obj: n, prop, optional: true, p: t.p };
+          continue;
+        }
+        const name = this.next();
+        if (name.t !== "id") throw syntax("expected a property name", name.p);
+        if (BLOCKED_KEYS.has(name.v)) throw disallowed(`access to ${name.v}`, name.p);
+        n = { k: "member", obj: n, prop: name.v, optional, p: name.p };
+        continue;
+      }
+      if (t.v === "[") {
+        this.i++;
+        n = { k: "member", obj: n, prop: this.computedKey(t.p), optional: false, p: t.p };
+        continue;
+      }
+      if (t.v === "(") {
+        if (n.k === "member" && typeof n.prop === "string" && !n.paren) {
+          if (!STRING_METHODS.has(n.prop) && !ARRAY_METHODS.has(n.prop)) throw disallowed(`call to ${n.prop}`, t.p);
+          this.i++;
+          n = { k: "call", recv: n.obj, name: n.prop, args: this.args(), optional: n.optional, p: t.p };
+          continue;
+        }
+        if (n.k === "id") throw disallowed(`call to ${n.name}`, t.p);
+        if (n.k === "member" && typeof n.prop !== "string" && !n.paren) throw disallowed("a computed method call", t.p);
+        throw disallowed("a function call", t.p);
+      }
+      if (t.v === "++" || t.v === "--") throw this.unexpected(t);
+      return n;
+    }
+  }
+  /** `[expr]` after `[` or `?.[`; a literal blocked key is rejected here, a computed one at evaluation. */
+  computedKey(p) {
+    const prop = this.expr();
+    this.expectOp("]");
+    if (prop.k === "lit" && typeof prop.v === "string" && BLOCKED_KEYS.has(prop.v)) throw disallowed(`access to ${prop.v}`, p);
+    return prop;
+  }
+  args() {
+    const out = [];
+    if (this.eatOp(")")) return out;
+    for (; ; ) {
+      if (this.isOp("...")) throw disallowed("spread", this.peek().p);
+      out.push(this.expr());
+      if (this.eatOp(")")) return out;
+      this.expectOp(",");
+    }
+  }
+  primary() {
+    const t = this.next();
+    if (t.t === "num" || t.t === "str") return { k: "lit", v: t.v };
+    if (t.t === "id") {
+      if (t.v === "true") return { k: "lit", v: true };
+      if (t.v === "false") return { k: "lit", v: false };
+      if (t.v === "null") return { k: "lit", v: null };
+      if (t.v === "undefined") return { k: "lit", v: void 0 };
+      const kw = KEYWORD_CONSTRUCTS.get(t.v);
+      if (kw) throw disallowed(kw, t.p);
+      if (this.isOp("=>")) throw disallowed("an arrow function", this.peek().p);
+      return { k: "id", name: t.v, p: t.p };
+    }
+    if (t.t === "eof") throw syntax("unexpected end of expression", t.p);
+    if (t.t === "op") {
+      if (t.v === "(") {
+        if (this.isOp(")")) throw disallowed("an arrow function", t.p);
+        const inner = this.expr();
+        this.expectOp(")");
+        if (this.isOp("=>")) throw disallowed("an arrow function", this.peek().p);
+        return inner.k === "member" || inner.k === "call" ? { ...inner, paren: true } : inner;
+      }
+      if (t.v === "[") {
+        const items = [];
+        if (this.eatOp("]")) return { k: "arr", items };
+        for (; ; ) {
+          if (this.isOp("...")) throw disallowed("spread", this.peek().p);
+          items.push(this.expr());
+          if (this.eatOp("]")) return { k: "arr", items };
+          this.expectOp(",");
+        }
+      }
+      if (t.v === "{") return this.objectLiteral();
+      if (t.v === "/") throw disallowed("a regex literal", t.p);
+    }
+    throw this.unexpected(t);
+  }
+  objectLiteral() {
+    const props = [];
+    if (this.eatOp("}")) return { k: "obj", props };
+    for (; ; ) {
+      const k = this.next();
+      if (k.t === "op" && k.v === "...") throw disallowed("spread", k.p);
+      if (k.t === "op" && k.v === "[") throw disallowed("a computed key", k.p);
+      if (k.t !== "id" && k.t !== "str") throw syntax("expected a property name", k.p);
+      if (BLOCKED_KEYS.has(k.v)) throw disallowed(`access to ${k.v}`, k.p);
+      this.expectOp(":");
+      props.push({ key: k.v, value: this.expr() });
+      if (this.eatOp("}")) return { k: "obj", props };
+      this.expectOp(",");
+    }
+  }
+};
+function stripWrapper(expr) {
+  const t = expr.trim();
+  return t.startsWith("{{") && t.endsWith("}}") ? t.slice(2, -2).trim() : t;
+}
+function parseExpression(expr) {
+  const src = stripWrapper(expr);
+  if (src.length > MAX_EXPRESSION_LENGTH) {
+    throw disallowed(`an expression longer than ${MAX_EXPRESSION_LENGTH} characters`, MAX_EXPRESSION_LENGTH);
+  }
+  if (!src) throw syntax("empty expression", 0);
+  return new Parser(tokenize(src)).parseAll();
+}
+function validateExpression(expr) {
+  try {
+    parseExpression(expr);
+    return null;
+  } catch (e) {
+    if (isExpressionError(e)) return e;
+    throw e;
+  }
+}
+var SHORT = /* @__PURE__ */ Symbol("optional-chain-short-circuit");
+function ownData(obj, key) {
+  const d = Object.getOwnPropertyDescriptor(obj, key);
+  if (!d || !("value" in d)) return void 0;
+  return typeof d.value === "function" ? void 0 : d.value;
+}
+function isCanonicalIndex(key) {
+  const n = Number(key);
+  return Number.isInteger(n) && n >= 0 && String(n) === key;
+}
+function isPlainObject(o) {
+  const proto = Object.getPrototypeOf(o);
+  return proto === Object.prototype || proto === null;
+}
+function isPlainArray(o) {
+  return Array.isArray(o) && Object.getPrototypeOf(o) === Array.prototype;
+}
+function dataValue(v) {
+  if (typeof v === "function") return void 0;
+  if (v === null || typeof v !== "object") return v;
+  return isPlainArray(v) || isPlainObject(v) ? v : void 0;
+}
+function readProp(obj, key, p, options) {
+  if (BLOCKED_KEYS.has(key)) throw disallowed(`access to ${key}`, p);
+  return dataValue(readOwnMember(obj, key, options));
+}
+var MAX_JSON_NAV_LENGTH = 1e6;
+function stripCodeFence(s) {
+  const open = s.indexOf("```");
+  if (open === -1) return s;
+  const close = s.indexOf("```", open + 3);
+  if (close === -1) return s;
+  const inner = s.slice(open + 3, close);
+  return inner.startsWith("json") ? inner.slice(4) : inner;
+}
+function parseJsonFromString(s) {
+  if (s.length > MAX_JSON_NAV_LENGTH) return void 0;
+  const text = stripCodeFence(s).trim();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function readOwnMember(obj, key, options) {
+  if (typeof obj === "string") {
+    if (key === "length") return obj.length;
+    if (isCanonicalIndex(key)) {
+      return Number(key) < obj.length ? obj.charAt(Number(key)) : void 0;
+    }
+    if (options?.parseJsonStrings) {
+      const parsed = parseJsonFromString(obj);
+      if (parsed !== null && typeof parsed === "object" && (isPlainArray(parsed) || isPlainObject(parsed))) {
+        return readOwnMember(parsed, key, options);
+      }
+    }
+    return void 0;
+  }
+  if (obj === null || typeof obj !== "object") return void 0;
+  if (isPlainArray(obj)) return key === "length" ? ownIndexLength(obj) : ownData(obj, key);
+  if (isPlainObject(obj)) return ownData(obj, key);
+  return void 0;
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  if (Array.isArray(v)) return "an array";
+  const t = typeof v;
+  return t === "object" ? "an object" : `a ${t}`;
+}
+function prim(v, p, what) {
+  if (v === null) return v;
+  const t = typeof v;
+  if (t === "object" || t === "function" || t === "symbol") {
+    throw new ExpressionError(`${what} needs a plain value, not ${describeType(v)}`, "evaluation error", p);
+  }
+  return v;
+}
+function propKey(v, p) {
+  const pv = prim(v, p, "a computed property key");
+  return typeof pv === "string" ? pv : String(pv);
+}
+function ownIndexLength(a) {
+  const d = Object.getOwnPropertyDescriptor(a, "length");
+  if (!d || !("value" in d)) return 0;
+  const v = d.value;
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 0 ? v : 0;
+}
+var MAX_ARRAY_SCAN = 1e6;
+function scanLength(a, name, p) {
+  const len = ownIndexLength(a);
+  if (len > MAX_ARRAY_SCAN) {
+    throw new ExpressionError(
+      `${name} on an array longer than ${MAX_ARRAY_SCAN} elements is not allowed in a workflow expression`,
+      "evaluation error",
+      p
+    );
+  }
+  return len;
+}
+function ownIndexDescriptor(a, i) {
+  return Object.getOwnPropertyDescriptor(a, String(i));
+}
+function ownIndex(a, i) {
+  const d = ownIndexDescriptor(a, i);
+  return d && "value" in d ? d.value : void 0;
+}
+function toIntegerOrInfinity(v) {
+  const n = Number(v);
+  if (Number.isNaN(n) || n === 0) return 0;
+  if (!Number.isFinite(n)) return n;
+  const t = Math.trunc(n);
+  return t === 0 ? 0 : t;
+}
+function sameValueZero(x, y) {
+  return x === y || typeof x === "number" && typeof y === "number" && Number.isNaN(x) && Number.isNaN(y);
+}
+function arraySlice(a, args, p) {
+  const startArg = args.length > 0 ? prim(args[0], p, "a slice argument") : void 0;
+  const endArg = args.length > 1 ? prim(args[1], p, "a slice argument") : void 0;
+  const len = scanLength(a, "slice", p);
+  const relStart = startArg === void 0 ? 0 : toIntegerOrInfinity(startArg);
+  const k = relStart < 0 ? Math.max(len + relStart, 0) : Math.min(relStart, len);
+  const relEnd = endArg === void 0 ? len : toIntegerOrInfinity(endArg);
+  const final = relEnd < 0 ? Math.max(len + relEnd, 0) : Math.min(relEnd, len);
+  const count = Math.max(final - k, 0);
+  const out = [];
+  for (let j = 0; j < count; j++) out.push(dataValue(ownIndex(a, k + j)));
+  return out;
+}
+function arrayJoin(a, args, p) {
+  const sepArg = args.length > 0 ? prim(args[0], p, "the join separator") : void 0;
+  const sep = sepArg === void 0 ? "," : String(sepArg);
+  const len = scanLength(a, "join", p);
+  const parts = [];
+  for (let i = 0; i < len; i++) {
+    const e = ownIndex(a, i);
+    if (e === void 0 || e === null) {
+      parts.push("");
+      continue;
+    }
+    parts.push(String(prim(e, p, "an array element passed to join")));
+  }
+  return parts.join(sep);
+}
+function arrayIncludes(a, args, p) {
+  const search = args[0];
+  const fromArg = args.length > 1 ? prim(args[1], p, "a fromIndex argument") : void 0;
+  const len = scanLength(a, "includes", p);
+  const rel = fromArg === void 0 ? 0 : toIntegerOrInfinity(fromArg);
+  const from = rel < 0 ? Math.max(len + rel, 0) : rel;
+  for (let i = from; i < len; i++) {
+    if (sameValueZero(ownIndex(a, i), search)) return true;
+  }
+  return false;
+}
+function arrayIndexOf(a, args, p) {
+  const search = args[0];
+  const fromArg = args.length > 1 ? prim(args[1], p, "a fromIndex argument") : void 0;
+  const len = scanLength(a, "indexOf", p);
+  const rel = fromArg === void 0 ? 0 : toIntegerOrInfinity(fromArg);
+  const from = rel < 0 ? Math.max(len + rel, 0) : rel;
+  for (let i = from; i < len; i++) {
+    const d = ownIndexDescriptor(a, i);
+    if (d === void 0) continue;
+    if (("value" in d ? d.value : void 0) === search) return i;
+  }
+  return -1;
+}
+function looseEq(l, r) {
+  const lRef = l !== null && (typeof l === "object" || typeof l === "function");
+  const rRef = r !== null && (typeof r === "object" || typeof r === "function");
+  if (lRef || rRef) return l === r;
+  return l == r;
+}
+function callMethod(recv, name, args, p) {
+  if (typeof recv === "string" && STRING_METHODS.has(name)) {
+    const fn = Reflect.get(String.prototype, name);
+    if (typeof fn === "function") {
+      const primArgs = args.map((a) => prim(a, p, `an argument to ${name}`));
+      return Reflect.apply(fn, recv, primArgs);
+    }
+  }
+  if (Array.isArray(recv) && Object.getPrototypeOf(recv) === Array.prototype && ARRAY_METHODS.has(name)) {
+    if (name === "join") return arrayJoin(recv, args, p);
+    if (name === "slice") return arraySlice(recv, args, p);
+    if (name === "includes") return arrayIncludes(recv, args, p);
+    if (name === "indexOf") return arrayIndexOf(recv, args, p);
+  }
+  const msg = `call to ${name} on ${describeType(recv)}`;
+  if (STRING_METHODS.has(name) || ARRAY_METHODS.has(name)) {
+    throw new ExpressionError(`${msg} is not allowed in a workflow expression`, "evaluation error", p);
+  }
+  throw disallowed(msg, p);
+}
+function toNum(v) {
+  return typeof v === "number" ? v : Number(v);
+}
+function missingOperand(p) {
+  return new ExpressionError(
+    "arithmetic on a missing value (a hyphenated name like a-b is subtraction; read it as nodes['a-b'])",
+    "evaluation error",
+    p
+  );
+}
+function arithOperand(v, p, what) {
+  const pv = prim(v, p, what);
+  if (pv === void 0) throw missingOperand(p);
+  return pv;
+}
+var Evaluator = class {
+  constructor(scope, options = {}) {
+    this.scope = scope;
+    this.options = options;
+  }
+  run(n) {
+    return this.val(n);
+  }
+  val(n) {
+    const v = this.ev(n);
+    return v === SHORT ? void 0 : v;
+  }
+  /** The object side of a member or call. Continues an optional chain (SHORT
+   * propagates) unless the object was parenthesized, which ends the chain. */
+  chain(n) {
+    return (n.k === "member" || n.k === "call") && !n.paren ? this.ev(n) : this.val(n);
+  }
+  ev(n) {
+    switch (n.k) {
+      case "lit":
+        return n.v;
+      case "id":
+        return dataValue(ownData(this.scope, n.name));
+      case "arr":
+        return n.items.map((x) => this.val(x));
+      case "obj": {
+        const o = {};
+        for (const pr of n.props) o[pr.key] = this.val(pr.value);
+        return o;
+      }
+      case "member": {
+        const o = this.chain(n.obj);
+        if (o === SHORT) return SHORT;
+        if (n.optional && (o === null || o === void 0)) return SHORT;
+        const key = typeof n.prop === "string" ? n.prop : propKey(this.val(n.prop), n.p);
+        return readProp(o, key, n.p, this.options);
+      }
+      case "call": {
+        const r = this.chain(n.recv);
+        if (r === SHORT) return SHORT;
+        if (n.optional && (r === null || r === void 0)) return SHORT;
+        return callMethod(r, n.name, n.args.map((a) => this.val(a)), n.p);
+      }
+      case "unary": {
+        const v = this.val(n.arg);
+        if (n.op === "!") return !v;
+        const pv = prim(v, n.p, `unary '${n.op}'`);
+        return n.op === "-" ? -toNum(pv) : toNum(pv);
+      }
+      case "cond":
+        return this.val(n.test) ? this.val(n.yes) : this.val(n.no);
+      case "bin":
+        return this.bin(n);
+    }
+  }
+  bin(n) {
+    if (n.op === "&&") {
+      const l2 = this.val(n.l);
+      return l2 ? this.val(n.r) : l2;
+    }
+    if (n.op === "||") {
+      const l2 = this.val(n.l);
+      return l2 ? l2 : this.val(n.r);
+    }
+    if (n.op === "??") {
+      const l2 = this.val(n.l);
+      return l2 === null || l2 === void 0 ? this.val(n.r) : l2;
+    }
+    const l = this.val(n.l);
+    const r = this.val(n.r);
+    switch (n.op) {
+      case "+": {
+        const lp = prim(l, n.p, "'+'");
+        const rp = prim(r, n.p, "'+'");
+        if (typeof lp === "string" || typeof rp === "string") return String(lp) + String(rp);
+        if (lp === void 0 || rp === void 0) throw missingOperand(n.p);
+        return toNum(lp) + toNum(rp);
+      }
+      case "-":
+        return toNum(arithOperand(l, n.p, "'-'")) - toNum(arithOperand(r, n.p, "'-'"));
+      case "*":
+        return toNum(arithOperand(l, n.p, "'*'")) * toNum(arithOperand(r, n.p, "'*'"));
+      case "/":
+        return toNum(arithOperand(l, n.p, "'/'")) / toNum(arithOperand(r, n.p, "'/'"));
+      case "%":
+        return toNum(arithOperand(l, n.p, "'%'")) % toNum(arithOperand(r, n.p, "'%'"));
+      case "==":
+        return looseEq(l, r);
+      case "!=":
+        return !looseEq(l, r);
+      case "===":
+        return l === r;
+      case "!==":
+        return l !== r;
+      case "<":
+        return prim(l, n.p, "'<'") < prim(r, n.p, "'<'");
+      case "<=":
+        return prim(l, n.p, "'<='") <= prim(r, n.p, "'<='");
+      case ">":
+        return prim(l, n.p, "'>'") > prim(r, n.p, "'>'");
+      case ">=":
+        return prim(l, n.p, "'>='") >= prim(r, n.p, "'>='");
+      default:
+        throw syntax(`unknown operator '${n.op}'`, 0);
+    }
+  }
+};
+function thrownDetail(e) {
+  if (e === null || typeof e !== "object" && typeof e !== "function") return String(e);
+  const d = Object.getOwnPropertyDescriptor(e, "message");
+  return d && "value" in d && typeof d.value === "string" ? d.value : "unknown error";
+}
+function evaluateExpression(expr, scope, options) {
+  const ast = parseExpression(expr);
+  try {
+    return new Evaluator(scope, options).run(ast);
+  } catch (e) {
+    if (isOwnExpressionError(e)) throw e;
+    let detail = "unknown error";
+    try {
+      detail = thrownDetail(e);
+    } catch {
+    }
+    throw new ExpressionError(`the expression could not be evaluated: ${detail}`, "evaluation error", 0);
+  }
+}
+
 exports.AnthropicFormatter = AnthropicFormatter;
 exports.BUILTIN_COMMAND_EXECUTABLES = BUILTIN_COMMAND_EXECUTABLES;
 exports.CODE_EXTENSIONS = CODE_EXTENSIONS;
@@ -5100,8 +5921,13 @@ exports.DOCKABLE_NODE_TYPES = DOCKABLE_NODE_TYPES;
 exports.DependencyResolutionStage = DependencyResolutionStage;
 exports.EXTENSION_TO_LANGUAGE = EXTENSION_TO_LANGUAGE;
 exports.EXTENSION_TO_LANGUAGE_ALIASES = EXTENSION_TO_LANGUAGE_ALIASES;
+exports.ExpressionError = ExpressionError;
 exports.HybridFileSystem = HybridFileSystem;
 exports.LexicalAnalysisStage = LexicalAnalysisStage;
+exports.MAX_ARRAY_SCAN = MAX_ARRAY_SCAN;
+exports.MAX_EXPRESSION_DEPTH = MAX_EXPRESSION_DEPTH;
+exports.MAX_EXPRESSION_LENGTH = MAX_EXPRESSION_LENGTH;
+exports.MAX_JSON_NAV_LENGTH = MAX_JSON_NAV_LENGTH;
 exports.MEMORY_OPERATIONS_BY_MODE = MEMORY_OPERATIONS_BY_MODE;
 exports.MarkdownFormatter = MarkdownFormatter;
 exports.MemoryFileSystem = MemoryFileSystem;
@@ -5127,7 +5953,9 @@ exports.createCoreStages = createCoreStages;
 exports.createEmptyWorkflow = createEmptyWorkflow;
 exports.createPrompdEnvironment = createPrompdEnvironment;
 exports.createWorkflowNode = createWorkflowNode;
+exports.describeExpressionFailure = describeExpressionFailure;
 exports.dirnamePosix = dirnamePosix;
+exports.evaluateExpression = evaluateExpression;
 exports.extname = extname;
 exports.extractPdpkg = extractPdpkg;
 exports.forkJoinId = forkJoinId;
@@ -5138,6 +5966,7 @@ exports.getLanguageAliasesForExtension = getLanguageAliasesForExtension;
 exports.getLanguageForExtension = getLanguageForExtension;
 exports.installPackage = installPackage;
 exports.isAbsolutePosix = isAbsolutePosix;
+exports.isExpressionError = isExpressionError;
 exports.isPrompdFile = isPrompdFile;
 exports.isValidPackageReference = isValidPackageReference;
 exports.isValidPackageType = isValidPackageType;
@@ -5155,6 +5984,7 @@ exports.serializeWorkflow = serializeWorkflow;
 exports.stripFilePath = stripFilePath;
 exports.traceForkBranches = traceForkBranches;
 exports.uninstallPackage = uninstallPackage;
+exports.validateExpression = validateExpression;
 exports.validateWorkflow = validateWorkflow;
 exports.validateWorkflowQuick = validateWorkflowQuick;
 //# sourceMappingURL=index.cjs.map