@skaile/workspaces 5.6.1 → 5.8.0

package/dist/{chunk-QCI6D7E4.js → chunk-NUELZWCF.js}

@@ -332,7 +332,7 @@ function ownValue(value, segment, position, path) {
   }
   return value[segment];
 }
-function resolvePath(raw, context, position, traverse) {
+function parsePathShape(raw, position) {
   const segments = raw.split(".");
   if (segments.length > FLOW_EXPRESSION_LIMITS.maxPathSegments) {
     throw expressionError(
@@ -345,43 +345,45 @@ function resolvePath(raw, context, position, traverse) {
   }
   const forbidden = segments.find((segment) => FORBIDDEN_PATH_SEGMENTS.has(segment));
   if (forbidden) throw expressionError(`contains forbidden path segment ${forbidden}`, position);
-  let value;
-  let remaining;
-  let skippedProducer;
   if (segments[0] === "flow" && segments[1] === "input") {
     if (segments.length === 2) {
       throw expressionError("path requires a JSON property suffix", position);
     }
-    value = context.flow.input;
-    remaining = segments.slice(2);
-  } else if (segments[0] === "defaults" && segments.length >= 2) {
-    value = context.defaults ?? {};
-    remaining = segments.slice(1);
-  } else if (segments[0] === "nodes" && segments.length === 3 && segments[2] === "status") {
-    value = context.nodes;
-    remaining = segments.slice(1);
-  } else if (segments[0] === "nodes" && segments.length >= 4 && segments[2] === "output" && segments[3] === "fields") {
+    return { root: "input", remaining: segments.slice(2) };
+  }
+  if (segments[0] === "defaults" && segments.length >= 2) {
+    return { root: "defaults", remaining: segments.slice(1) };
+  }
+  if (segments[0] === "nodes" && segments.length === 3 && segments[2] === "status") {
+    return { root: "nodes", remaining: segments.slice(1) };
+  }
+  if (segments[0] === "nodes" && segments.length >= 4 && segments[2] === "output" && segments[3] === "fields") {
     if (segments.length === 4) {
       throw expressionError("path requires a JSON property suffix", position);
     }
-    if (Object.hasOwn(context.nodes, segments[1]) && context.nodes[segments[1]].status === "skipped") {
-      skippedProducer = segments[1];
-    }
-    value = context.nodes;
-    remaining = segments.slice(1);
-  } else {
-    throw expressionError(`contains unsupported path ${raw}`, position);
+    return { root: "nodes", remaining: segments.slice(1), outputProducer: segments[1] };
   }
-  if (!traverse) return void 0;
-  if (skippedProducer !== void 0) {
-    throw expressionError(
-      `cannot read ${raw}: producer node ${skippedProducer} was skipped and produced no output`,
-      position,
-      raw,
-      skippedProducer
-    );
+  throw expressionError(`contains unsupported path ${raw}`, position);
+}
+function readPath(shape, raw, context, position) {
+  let value;
+  if (shape.root === "input") {
+    value = context.flow.input;
+  } else if (shape.root === "defaults") {
+    value = context.defaults ?? {};
+  } else {
+    value = context.nodes;
+    const producer = shape.outputProducer;
+    if (producer !== void 0 && Object.hasOwn(context.nodes, producer) && context.nodes[producer].status === "skipped") {
+      throw expressionError(
+        `cannot read ${raw}: producer node ${producer} was skipped and produced no output`,
+        position,
+        raw,
+        producer
+      );
+    }
   }
-  for (const segment of remaining) value = ownValue(value, segment, position, raw);
+  for (const segment of shape.remaining) value = ownValue(value, segment, position, raw);
   return value;
 }
 function compare(operator, left, right, position) {
@@ -418,35 +420,16 @@ function isBooleanOperand(value) {
 function assertBooleanOperand(value, position) {
   if (!isBooleanOperand(value)) throw expressionError("requires boolean operands", position);
 }
-var Parser = class {
-  constructor(tokens, context, onPath, onBooleanPath, onEvaluatedPath, onComparison) {
+var COMPARISON_OPERATORS = ["==", "!=", "<", "<=", ">", ">=", "in"];
+var ExpressionBuilder = class {
+  constructor(tokens) {
     this.tokens = tokens;
-    this.context = context;
-    this.onPath = onPath;
-    this.onBooleanPath = onBooleanPath;
-    this.onEvaluatedPath = onEvaluatedPath;
-    this.onComparison = onComparison;
   }
   tokens;
-  context;
-  onPath;
-  onBooleanPath;
-  onEvaluatedPath;
-  onComparison;
   index = 0;
   nesting = 0;
-  /** Literal `path == true` conjuncts already parsed, one frame per enclosing `&&` chain. */
-  guardFrames = [];
-  /**
-   * Guards the operand {@link parseComparison} just parsed establishes when true:
-   * its own path for a literal `path == true`, or every guard of a parenthesized
-   * `&&` group, which is true only when all its conjuncts are.
-   */
-  lastGuards = [];
-  /** Guards of the `&&` / `||` chain that just finished; empty once a `||` joined it. */
-  lastChainGuards = [];
-  parse(evaluate2 = true) {
-    const value = this.parseOr(evaluate2);
+  build() {
+    const root = this.parseOr();
     const trailing = this.peek();
     if (trailing.kind !== "eof") {
       throw expressionError(
@@ -454,7 +437,7 @@ var Parser = class {
         trailing.position
       );
     }
-    return value;
+    return root;
   }
   peek() {
     return this.tokens[this.index];
@@ -466,105 +449,79 @@ var Parser = class {
     if (this.peek().value !== value) return void 0;
     return this.take();
   }
-  parseOr(evaluate2) {
-    let value = this.parseAnd(evaluate2);
-    let disjunction = false;
+  parseOr() {
+    const operands = [this.parseAnd()];
+    const positions = [];
     while (this.peek().value === "||") {
-      disjunction = true;
-      const operator = this.take();
-      assertBooleanOperand(value, operator.position);
-      if (isStaticPath(value)) this.onBooleanPath?.(value.path);
-      const evaluateRight = evaluate2 && value === false;
-      const right = this.parseAnd(evaluateRight);
-      assertBooleanOperand(right, operator.position);
-      if (isStaticPath(right)) this.onBooleanPath?.(right.path);
-      value = evaluate2 ? value === true || right === true : STATIC_BOOLEAN;
-    }
-    if (disjunction) this.lastChainGuards = [];
-    return value;
+      positions.push(this.take().position);
+      operands.push(this.parseAnd());
+    }
+    return { kind: "or", operands, positions };
   }
-  parseAnd(evaluate2) {
-    const guards = [];
-    this.guardFrames.push(guards);
-    try {
-      let value = this.parseComparison(evaluate2);
-      guards.push(...this.lastGuards);
-      while (this.peek().value === "&&") {
-        const operator = this.take();
-        assertBooleanOperand(value, operator.position);
-        if (isStaticPath(value)) this.onBooleanPath?.(value.path);
-        const evaluateRight = evaluate2 && value === true;
-        const right = this.parseComparison(evaluateRight);
-        guards.push(...this.lastGuards);
-        assertBooleanOperand(right, operator.position);
-        if (isStaticPath(right)) this.onBooleanPath?.(right.path);
-        value = evaluate2 ? value === true && right === true : STATIC_BOOLEAN;
-      }
-      this.lastChainGuards = [...guards];
-      return value;
-    } finally {
-      this.guardFrames.pop();
+  parseAnd() {
+    const operands = [this.parseComparison()];
+    const positions = [];
+    while (this.peek().value === "&&") {
+      positions.push(this.take().position);
+      operands.push(this.parseComparison());
     }
+    return { kind: "and", operands, positions };
   }
-  parseComparison(evaluate2) {
-    const group = this.peek().value === "(";
-    const left = this.parseUnary(evaluate2);
+  parseComparison() {
+    const left = this.parseUnary();
     const token = this.peek();
-    if (token.kind !== "operator" || !["==", "!=", "<", "<=", ">", ">=", "in"].includes(String(token.value))) {
-      this.lastGuards = group ? this.lastChainGuards : [];
+    if (token.kind !== "operator" || !COMPARISON_OPERATORS.includes(String(token.value))) {
       return left;
     }
     this.take();
-    const right = this.parseUnary(evaluate2);
-    const operator = String(token.value);
-    this.onComparison?.({
-      operator,
-      left: isStaticPath(left) ? { path: left.path } : { literal: left },
-      right: isStaticPath(right) ? { path: right.path } : { literal: right },
-      guards: this.guardFrames.flat()
-    });
-    this.lastGuards = operator === "==" && isStaticPath(left) && right === true ? [left.path] : [];
-    return evaluate2 ? compare(operator, left, right, token.position) : STATIC_BOOLEAN;
+    const right = this.parseUnary();
+    return {
+      kind: "compare",
+      operator: String(token.value),
+      left,
+      right,
+      position: token.position
+    };
   }
-  parseUnary(evaluate2) {
+  parseUnary() {
     const operator = this.accept("!");
     if (operator) {
-      const value = this.parseUnary(evaluate2);
-      assertBooleanOperand(value, operator.position);
-      if (isStaticPath(value)) this.onBooleanPath?.(value.path);
-      return evaluate2 ? value === false : STATIC_BOOLEAN;
+      return { kind: "not", operand: this.parseUnary(), position: operator.position };
     }
-    return this.parsePrimary(evaluate2);
+    return this.parsePrimary();
   }
-  parsePrimary(evaluate2) {
+  parsePrimary() {
     const token = this.take();
-    if (token.kind === "value") return token.value;
+    if (token.kind === "value") return { kind: "literal", value: token.value };
     if (token.kind === "word") {
-      this.onPath?.(String(token.value));
-      resolvePath(String(token.value), this.context, token.position, false);
-      if (evaluate2) this.onEvaluatedPath?.(String(token.value));
-      return evaluate2 ? resolvePath(String(token.value), this.context, token.position, true) : { marker: STATIC_PATH, path: String(token.value) };
+      const path = String(token.value);
+      return {
+        kind: "path",
+        path,
+        position: token.position,
+        shape: parsePathShape(path, token.position)
+      };
     }
     if (token.value === "(") {
       this.enterNesting(token.position);
-      const value = this.parseOr(evaluate2);
+      const inner = this.parseOr();
       if (!this.accept(")"))
         throw expressionError("is missing a closing parenthesis", token.position);
       this.nesting--;
-      return value;
+      return { kind: "group", inner };
     }
     if (token.value === "[") {
       this.enterNesting(token.position);
-      const values = [];
+      const items = [];
       if (!this.accept("]")) {
         do
-          values.push(this.parsePrimary(evaluate2));
+          items.push(this.parsePrimary());
         while (this.accept(","));
         if (!this.accept("]"))
           throw expressionError("is missing a closing bracket", token.position);
       }
       this.nesting--;
-      return values;
+      return { kind: "list", items };
     }
     throw expressionError(`contains unexpected token ${String(token.value)}`, token.position);
   }
@@ -578,44 +535,185 @@ var Parser = class {
     }
   }
 };
-function inspectFlowExpressionComparisons(expression) {
+var ExpressionAnalyzer = class {
+  references = /* @__PURE__ */ new Map();
+  comparisons = [];
+  /** Literal `path == true` conjuncts already analyzed, one frame per enclosing `&&` chain. */
+  guardFrames = [];
+  /**
+   * Guards the operand {@link analyzeOperand} just analyzed establishes when true:
+   * its own path for a literal `path == true`, or every guard of a parenthesized
+   * `&&` group, which is true only when all its conjuncts are.
+   */
+  lastGuards = [];
+  /** Guards of the `&&` / `||` chain that just finished; empty once a `||` joined it. */
+  lastChainGuards = [];
+  record(path, booleanOperand) {
+    this.references.set(path, (this.references.get(path) ?? false) || booleanOperand);
+  }
+  booleanOperand(value, position) {
+    assertBooleanOperand(value, position);
+    if (isStaticPath(value)) this.record(value.path, true);
+  }
+  /** Static value of a node: literals as themselves, paths as markers, computed booleans as one marker. */
+  analyze(node) {
+    switch (node.kind) {
+      case "literal":
+        return node.value;
+      case "path":
+        this.record(node.path, false);
+        return { marker: STATIC_PATH, path: node.path };
+      case "list":
+        return node.items.map((item) => this.analyze(item));
+      case "group":
+        return this.analyze(node.inner);
+      case "not": {
+        const value = this.analyze(node.operand);
+        this.booleanOperand(value, node.position);
+        return STATIC_BOOLEAN;
+      }
+      case "compare": {
+        const left = this.analyze(node.left);
+        const right = this.analyze(node.right);
+        this.comparisons.push({
+          operator: node.operator,
+          left: isStaticPath(left) ? { path: left.path } : { literal: left },
+          right: isStaticPath(right) ? { path: right.path } : { literal: right },
+          guards: this.guardFrames.flat()
+        });
+        this.lastGuards = node.operator === "==" && isStaticPath(left) && right === true ? [left.path] : [];
+        return STATIC_BOOLEAN;
+      }
+      case "and":
+        return this.analyzeAnd(node);
+      case "or":
+        return this.analyzeOr(node);
+    }
+  }
+  analyzeOperand(node) {
+    if (node.kind === "compare") return this.analyze(node);
+    const value = this.analyze(node);
+    this.lastGuards = node.kind === "group" ? this.lastChainGuards : [];
+    return value;
+  }
+  analyzeAnd(node) {
+    const guards = [];
+    this.guardFrames.push(guards);
+    try {
+      let value = this.analyzeOperand(node.operands[0]);
+      guards.push(...this.lastGuards);
+      for (let index = 1; index < node.operands.length; index++) {
+        const position = node.positions[index - 1];
+        this.booleanOperand(value, position);
+        const right = this.analyzeOperand(node.operands[index]);
+        guards.push(...this.lastGuards);
+        this.booleanOperand(right, position);
+        value = STATIC_BOOLEAN;
+      }
+      this.lastChainGuards = [...guards];
+      return value;
+    } finally {
+      this.guardFrames.pop();
+    }
+  }
+  analyzeOr(node) {
+    let value = this.analyze(node.operands[0]);
+    for (let index = 1; index < node.operands.length; index++) {
+      const position = node.positions[index - 1];
+      this.booleanOperand(value, position);
+      const right = this.analyze(node.operands[index]);
+      this.booleanOperand(right, position);
+      value = STATIC_BOOLEAN;
+    }
+    if (node.operands.length > 1) this.lastChainGuards = [];
+    return value;
+  }
+};
+function assertBooleanValue(value, position) {
+  if (typeof value !== "boolean") throw expressionError("requires boolean operands", position);
+}
+function evaluateNode(node, context, onPath) {
+  switch (node.kind) {
+    case "literal":
+      return node.value;
+    case "path":
+      onPath?.(node.path);
+      return readPath(node.shape, node.path, context, node.position);
+    case "list":
+      return node.items.map((item) => evaluateNode(item, context, onPath));
+    case "group":
+      return evaluateNode(node.inner, context, onPath);
+    case "not": {
+      const value = evaluateNode(node.operand, context, onPath);
+      assertBooleanValue(value, node.position);
+      return value === false;
+    }
+    case "compare":
+      return compare(
+        node.operator,
+        evaluateNode(node.left, context, onPath),
+        evaluateNode(node.right, context, onPath),
+        node.position
+      );
+    case "and":
+    case "or": {
+      const continueOn = node.kind === "and";
+      let value = evaluateNode(node.operands[0], context, onPath);
+      for (let index = 1; index < node.operands.length; index++) {
+        const position = node.positions[index - 1];
+        assertBooleanValue(value, position);
+        if (value !== continueOn) continue;
+        value = evaluateNode(node.operands[index], context, onPath);
+        assertBooleanValue(value, position);
+      }
+      return value;
+    }
+  }
+}
+var COMPILED_EXPRESSION_LIMIT = 512;
+var compiledExpressions = /* @__PURE__ */ new Map();
+function compileExpression(expression) {
+  const cached = compiledExpressions.get(expression);
+  if (cached) return cached;
   const tokens = tokenize(expression);
-  if (expression.trim() === "default") return [];
-  const comparisons = [];
-  const context = { flow: { input: {} }, nodes: {} };
-  new Parser(
-    tokens,
-    context,
-    void 0,
-    void 0,
-    void 0,
-    (comparison) => comparisons.push(comparison)
-  ).parse(false);
-  return comparisons;
+  let compiled;
+  if (expression.trim() === "default") {
+    compiled = { references: [], comparisons: [], booleanResult: true };
+  } else {
+    const root = new ExpressionBuilder(tokens).build();
+    const analyzer = new ExpressionAnalyzer();
+    const result = analyzer.analyze(root);
+    compiled = {
+      root,
+      references: Array.from(analyzer.references, ([path, booleanOperand]) => ({
+        path,
+        booleanOperand
+      })),
+      comparisons: analyzer.comparisons,
+      booleanResult: typeof result === "boolean" || result === STATIC_BOOLEAN
+    };
+  }
+  if (compiledExpressions.size >= COMPILED_EXPRESSION_LIMIT) {
+    const oldest = compiledExpressions.keys().next();
+    if (!oldest.done) compiledExpressions.delete(oldest.value);
+  }
+  compiledExpressions.set(expression, compiled);
+  return compiled;
+}
+function inspectFlowExpressionComparisons(expression) {
+  return [...compileExpression(expression).comparisons];
 }
 function inspectFlowExpression(expression, requireBoolean = true) {
-  const tokens = tokenize(expression);
-  if (expression.trim() === "default") return [];
-  const references = /* @__PURE__ */ new Map();
-  const record2 = (path, booleanOperand) => {
-    references.set(path, (references.get(path) ?? false) || booleanOperand);
-  };
-  const context = { flow: { input: {} }, nodes: {} };
-  const result = new Parser(
-    tokens,
-    context,
-    (path) => record2(path, false),
-    (path) => record2(path, true)
-  ).parse(false);
-  if (requireBoolean && typeof result !== "boolean" && result !== STATIC_BOOLEAN) {
+  const compiled = compileExpression(expression);
+  if (requireBoolean && !compiled.booleanResult) {
     throw expressionError("must evaluate to a boolean");
   }
-  return Array.from(references, ([path, booleanOperand]) => ({ path, booleanOperand }));
+  return [...compiled.references];
 }
 function evaluateFlowExpression(expression, context) {
-  const tokens = tokenize(expression);
-  if (expression.trim() === "default") return true;
-  const result = new Parser(tokens, context).parse();
+  const { root } = compileExpression(expression);
+  if (root === void 0) return true;
+  const result = evaluateNode(root, context);
   if (typeof result !== "boolean") {
     throw expressionError("must evaluate to a boolean");
   }
@@ -625,16 +723,10 @@ function evaluate(expression, context) {
   return evaluateFlowExpression(expression, context);
 }
 function evaluateFlowExpressionValue(expression, context) {
-  const tokens = tokenize(expression);
-  if (expression.trim() === "default") return { value: true, paths: [] };
+  const { root } = compileExpression(expression);
+  if (root === void 0) return { value: true, paths: [] };
   const paths = [];
-  const value = new Parser(
-    tokens,
-    context,
-    void 0,
-    void 0,
-    (path) => paths.push(path)
-  ).parse();
+  const value = evaluateNode(root, context, (path) => paths.push(path));
   return { value, paths };
 }
 function originsForPath(path, nodeOutputOrigin, flowInputOrigins) {
@@ -779,11 +871,6 @@ function resolveFlowBindings(bindings, context, nodeOutputOrigin = {}, flowInput
   const values = {};
   const origins = {};
   const entries = Object.entries(bindings ?? {});
-  for (const [name] of entries) {
-    if (!FLOW_BINDING_NAME_PATTERN.test(name)) {
-      throw expressionError(`contains reserved binding name input.${name}`);
-    }
-  }
   for (const [name, authored] of entries) {
     const resolved = resolveBindingValue(
       authored,
@@ -912,6 +999,15 @@ var FlowOutputContractSchema = z2.strictObject({
       message: `output binding ${name} has no property in output.schema`
     });
   }
+  try {
+    compileOutputFieldsSchema(output.schema);
+  } catch (error) {
+    context.addIssue({
+      code: "custom",
+      path: ["schema"],
+      message: `output.schema: ${invalidOutputFieldsSchemaMessage(error)}`
+    });
+  }
 });
 var PreconditionSchema = z2.strictObject({
   expr: nonEmptyString,
@@ -1448,6 +1544,6 @@ function validateClassifierRules(flow, context) {
   }
 }
 
-export { FLOW_CAPTURE_CHANNELS, FLOW_CAPTURE_DESTINATION_PATTERN, FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, InputSchema, MISSING_FIELD, RESERVED_CLASSIFIER_FIELDS, captureDestinationFieldName, checkClassifierShape, classifierDecision, compileOutputFieldsSchema, consumedOutputFieldPaths, declaredFieldSchema, declaresReservedClassifierField, duplicateCaptureDestinationMessage, evaluate, evaluateFlowExpression, getConsumedOutputSchema, hasConstantlyFalsePrecondition, inspectFlowExpressionComparisons, invalidCaptureDestinationMessage, invalidOutputFieldsSchemaMessage, parseFlowDefinitionStructure, resolveFlowBindings, stableFlowJson, withoutReservedClassifierFields };
-//# sourceMappingURL=chunk-QCI6D7E4.js.map
-//# sourceMappingURL=chunk-QCI6D7E4.js.map
+export { FLOW_CAPTURE_CHANNELS, FLOW_CAPTURE_DESTINATION_PATTERN, FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, InputSchema, MISSING_FIELD, RESERVED_CLASSIFIER_FIELDS, captureDestinationFieldName, checkClassifierShape, classifierDecision, compileOutputFieldsSchema, consumedOutputFieldPaths, declaredFieldSchema, declaresReservedClassifierField, duplicateCaptureDestinationMessage, evaluate, evaluateFlowExpression, getConsumedOutputSchema, hasConstantlyFalsePrecondition, inspectFlowExpressionComparisons, invalidCaptureDestinationMessage, parseFlowDefinitionStructure, resolveFlowBindings, stableFlowJson, withoutReservedClassifierFields };
+//# sourceMappingURL=chunk-NUELZWCF.js.map
+//# sourceMappingURL=chunk-NUELZWCF.js.map