@skaile/workspaces 2.1.0 → 2.3.0

package/dist/chunk-ZE2KEPE2.js

@@ -0,0 +1,1002 @@
+import * as z from 'zod';
+
+// factory-assets/connectors/flow/contract/expression.ts
+var FLOW_EXPRESSION_LIMITS = Object.freeze({
+  maxLength: 4096,
+  maxTokens: 256,
+  maxNesting: 32,
+  maxPathSegments: 32,
+  maxCollectionItems: 1024
+});
+var FlowExpressionError = class extends Error {
+  /** Stable error name for callers that classify evaluator failures. */
+  name = "FlowExpressionError";
+};
+function expressionError(message, position) {
+  return new FlowExpressionError(
+    position === void 0 ? `Flow expression ${message}` : `Flow expression ${message} at ${position}`
+  );
+}
+function parseString(source, start) {
+  const quote = source[start];
+  let value = "";
+  let index = start + 1;
+  while (index < source.length) {
+    const character = source[index];
+    if (character === quote) return { value, end: index + 1 };
+    if (character !== "\\") {
+      value += character;
+      index++;
+      continue;
+    }
+    const escaped = source[index + 1];
+    if (escaped === void 0) throw expressionError("has an unterminated string", start);
+    const replacements = {
+      "\\": "\\",
+      "'": "'",
+      '"': '"',
+      n: "\n",
+      r: "\r",
+      t: "	",
+      b: "\b",
+      f: "\f"
+    };
+    if (escaped === "u") {
+      const hex = source.slice(index + 2, index + 6);
+      if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+        throw expressionError("has an invalid unicode escape", index);
+      }
+      value += String.fromCharCode(Number.parseInt(hex, 16));
+      index += 6;
+      continue;
+    }
+    if (!(escaped in replacements)) throw expressionError("has an invalid escape", index);
+    value += replacements[escaped];
+    index += 2;
+  }
+  throw expressionError("has an unterminated string", start);
+}
+function tokenize(source) {
+  if (source.length > FLOW_EXPRESSION_LIMITS.maxLength) {
+    throw expressionError(`exceeds the length limit of ${FLOW_EXPRESSION_LIMITS.maxLength}`);
+  }
+  const tokens = [];
+  const add = (token) => {
+    tokens.push(token);
+    if (tokens.length > FLOW_EXPRESSION_LIMITS.maxTokens) {
+      throw expressionError(`exceeds the token limit of ${FLOW_EXPRESSION_LIMITS.maxTokens}`);
+    }
+  };
+  let index = 0;
+  while (index < source.length) {
+    const character = source[index];
+    if (/\s/.test(character)) {
+      index++;
+      continue;
+    }
+    const pair = source.slice(index, index + 2);
+    if (["&&", "||", "==", "!=", "<=", ">="].includes(pair)) {
+      add({ kind: "operator", value: pair, position: index });
+      index += 2;
+      continue;
+    }
+    if (["!", "<", ">"].includes(character)) {
+      add({ kind: "operator", value: character, position: index });
+      index++;
+      continue;
+    }
+    if (["(", ")", "[", "]", ","].includes(character)) {
+      add({ kind: "punctuation", value: character, position: index });
+      index++;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      const parsed = parseString(source, index);
+      add({ kind: "value", value: parsed.value, position: index });
+      index = parsed.end;
+      continue;
+    }
+    const number2 = source.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+    if (number2) {
+      add({ kind: "value", value: Number(number2[0]), position: index });
+      index += number2[0].length;
+      continue;
+    }
+    const word = source.slice(index).match(/^[A-Za-z_][A-Za-z0-9_.-]*/);
+    if (word) {
+      const raw = word[0];
+      if (raw === "true") add({ kind: "value", value: true, position: index });
+      else if (raw === "false") add({ kind: "value", value: false, position: index });
+      else if (raw === "null") add({ kind: "value", value: null, position: index });
+      else if (raw === "in") add({ kind: "operator", value: raw, position: index });
+      else add({ kind: "word", value: raw, position: index });
+      index += raw.length;
+      continue;
+    }
+    throw expressionError(`contains unsupported token ${JSON.stringify(character)}`, index);
+  }
+  tokens.push({ kind: "eof", value: "", position: source.length });
+  return tokens;
+}
+var FORBIDDEN_PATH_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function ownValue(value, segment, position) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    throw expressionError("path does not exist", position);
+  }
+  if (!Object.hasOwn(value, segment)) throw expressionError("path does not exist", position);
+  return value[segment];
+}
+function resolvePath(raw, context, position, traverse) {
+  const segments = raw.split(".");
+  if (segments.length > FLOW_EXPRESSION_LIMITS.maxPathSegments) {
+    throw expressionError(
+      `exceeds the path traversal limit of ${FLOW_EXPRESSION_LIMITS.maxPathSegments}`,
+      position
+    );
+  }
+  if (segments.some((segment) => segment.length === 0)) {
+    throw expressionError("contains an empty path segment", position);
+  }
+  const forbidden = segments.find((segment) => FORBIDDEN_PATH_SEGMENTS.has(segment));
+  if (forbidden) throw expressionError(`contains forbidden path segment ${forbidden}`, position);
+  let value;
+  let remaining;
+  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") {
+    if (segments.length === 4) {
+      throw expressionError("path requires a JSON property suffix", position);
+    }
+    value = context.nodes;
+    remaining = segments.slice(1);
+  } else {
+    throw expressionError(`contains unsupported path ${raw}`, position);
+  }
+  if (!traverse) return void 0;
+  for (const segment of remaining) value = ownValue(value, segment, position);
+  return value;
+}
+function compare(operator, left, right, position) {
+  if (operator === "==") return Object.is(left, right);
+  if (operator === "!=") return !Object.is(left, right);
+  if (operator === "in") {
+    if (!Array.isArray(right))
+      throw expressionError("requires an array on the right of in", position);
+    if (right.length > FLOW_EXPRESSION_LIMITS.maxCollectionItems) {
+      throw expressionError(
+        `exceeds the collection item limit of ${FLOW_EXPRESSION_LIMITS.maxCollectionItems}`,
+        position
+      );
+    }
+    return right.some((candidate) => Object.is(candidate, left));
+  }
+  if (!(typeof left === "number" && typeof right === "number" || typeof left === "string" && typeof right === "string")) {
+    throw expressionError(`requires comparable operands for ${operator}`, position);
+  }
+  if (operator === "<") return left < right;
+  if (operator === "<=") return left <= right;
+  if (operator === ">") return left > right;
+  if (operator === ">=") return left >= right;
+  throw expressionError(`contains unsupported operator ${operator}`, position);
+}
+var STATIC_BOOLEAN = /* @__PURE__ */ Symbol("static-boolean");
+var STATIC_PATH = /* @__PURE__ */ Symbol("static-path");
+function isStaticPath(value) {
+  return typeof value === "object" && value !== null && value.marker === STATIC_PATH;
+}
+function isBooleanOperand(value) {
+  return typeof value === "boolean" || value === STATIC_BOOLEAN || isStaticPath(value);
+}
+function assertBooleanOperand(value, position) {
+  if (!isBooleanOperand(value)) throw expressionError("requires boolean operands", position);
+}
+var Parser = class {
+  constructor(tokens, context, onPath, onBooleanPath) {
+    this.tokens = tokens;
+    this.context = context;
+    this.onPath = onPath;
+    this.onBooleanPath = onBooleanPath;
+  }
+  tokens;
+  context;
+  onPath;
+  onBooleanPath;
+  index = 0;
+  nesting = 0;
+  parse(evaluate2 = true) {
+    const value = this.parseOr(evaluate2);
+    const trailing = this.peek();
+    if (trailing.kind !== "eof") {
+      throw expressionError(
+        `contains unexpected token ${String(trailing.value)}`,
+        trailing.position
+      );
+    }
+    return value;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  take() {
+    return this.tokens[this.index++];
+  }
+  accept(value) {
+    if (this.peek().value !== value) return void 0;
+    return this.take();
+  }
+  parseOr(evaluate2) {
+    let value = this.parseAnd(evaluate2);
+    while (this.peek().value === "||") {
+      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;
+    }
+    return value;
+  }
+  parseAnd(evaluate2) {
+    let value = this.parseComparison(evaluate2);
+    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);
+      assertBooleanOperand(right, operator.position);
+      if (isStaticPath(right)) this.onBooleanPath?.(right.path);
+      value = evaluate2 ? value === true && right === true : STATIC_BOOLEAN;
+    }
+    return value;
+  }
+  parseComparison(evaluate2) {
+    const left = this.parseUnary(evaluate2);
+    const token = this.peek();
+    if (token.kind !== "operator" || !["==", "!=", "<", "<=", ">", ">=", "in"].includes(String(token.value))) {
+      return left;
+    }
+    this.take();
+    const right = this.parseUnary(evaluate2);
+    return evaluate2 ? compare(String(token.value), left, right, token.position) : STATIC_BOOLEAN;
+  }
+  parseUnary(evaluate2) {
+    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 this.parsePrimary(evaluate2);
+  }
+  parsePrimary(evaluate2) {
+    const token = this.take();
+    if (token.kind === "value") return token.value;
+    if (token.kind === "word") {
+      this.onPath?.(String(token.value));
+      resolvePath(String(token.value), this.context, token.position, false);
+      return evaluate2 ? resolvePath(String(token.value), this.context, token.position, true) : { marker: STATIC_PATH, path: String(token.value) };
+    }
+    if (token.value === "(") {
+      this.enterNesting(token.position);
+      const value = this.parseOr(evaluate2);
+      if (!this.accept(")"))
+        throw expressionError("is missing a closing parenthesis", token.position);
+      this.nesting--;
+      return value;
+    }
+    if (token.value === "[") {
+      this.enterNesting(token.position);
+      const values = [];
+      if (!this.accept("]")) {
+        do
+          values.push(this.parsePrimary(evaluate2));
+        while (this.accept(","));
+        if (!this.accept("]"))
+          throw expressionError("is missing a closing bracket", token.position);
+      }
+      this.nesting--;
+      return values;
+    }
+    throw expressionError(`contains unexpected token ${String(token.value)}`, token.position);
+  }
+  enterNesting(position) {
+    this.nesting++;
+    if (this.nesting > FLOW_EXPRESSION_LIMITS.maxNesting) {
+      throw expressionError(
+        `exceeds the nesting limit of ${FLOW_EXPRESSION_LIMITS.maxNesting}`,
+        position
+      );
+    }
+  }
+};
+function inspectFlowExpression(expression, requireBoolean = true) {
+  const tokens = tokenize(expression);
+  if (expression.trim() === "default") return [];
+  const references = /* @__PURE__ */ new Map();
+  const record3 = (path, booleanOperand) => {
+    references.set(path, (references.get(path) ?? false) || booleanOperand);
+  };
+  const context = { flow: { input: {} }, nodes: {} };
+  const result = new Parser(
+    tokens,
+    context,
+    (path) => record3(path, false),
+    (path) => record3(path, true)
+  ).parse(false);
+  if (requireBoolean && typeof result !== "boolean" && result !== STATIC_BOOLEAN) {
+    throw expressionError("must evaluate to a boolean");
+  }
+  return Array.from(references, ([path, booleanOperand]) => ({ path, booleanOperand }));
+}
+function evaluateFlowExpression(expression, context) {
+  const tokens = tokenize(expression);
+  if (expression.trim() === "default") return true;
+  const result = new Parser(tokens, context).parse();
+  if (typeof result !== "boolean") {
+    throw expressionError("must evaluate to a boolean");
+  }
+  return result;
+}
+function evaluate(expression, context) {
+  return evaluateFlowExpression(expression, context);
+}
+var nonEmptyString = z.string().min(1);
+var jsonSchema = z.record(z.string(), z.json());
+var FlowInputContractSchema = z.strictObject({
+  schema: jsonSchema,
+  example: z.json().optional()
+});
+var FlowOutputContractSchema = z.strictObject({
+  schema: jsonSchema
+});
+var PreconditionSchema = z.strictObject({
+  expr: nonEmptyString,
+  message: nonEmptyString.optional()
+});
+var ArtifactContractSchema = z.strictObject({
+  kind: nonEmptyString,
+  lifetime: z.enum(["session", "persistent"])
+});
+var NodeOutputContractSchema = z.strictObject({
+  fields: jsonSchema.optional(),
+  artifacts: z.array(ArtifactContractSchema).optional()
+});
+var NodeContractSchema = z.strictObject({
+  requires: z.array(PreconditionSchema).optional(),
+  input: z.record(z.string(), z.json()).optional(),
+  output: NodeOutputContractSchema.optional()
+});
+var NodeGateSchema = z.strictObject({
+  approval: z.enum(["none", "optional", "mandatory"])
+});
+var NodeControlSchema = z.strictObject({
+  optional: z.boolean().optional(),
+  retries: z.number().int().min(0).optional(),
+  timeoutSec: z.number().positive().optional(),
+  parallelGroup: nonEmptyString.optional()
+});
+var runAssets = { assets: z.array(nonEmptyString).optional() };
+var AgentRunSchema = z.strictObject({
+  kind: z.literal("agent"),
+  instruction: nonEmptyString,
+  ...runAssets
+});
+var SubpromptRunSchema = z.strictObject({
+  kind: z.literal("subprompt"),
+  instruction: nonEmptyString,
+  model: nonEmptyString.optional(),
+  ...runAssets
+});
+var deterministicRun = {
+  runtime: z.enum(["shell", "node", "python"]).optional(),
+  command: nonEmptyString,
+  cwd: nonEmptyString.optional(),
+  successExit: z.array(z.number().int()).optional(),
+  capture: z.strictObject({ stdout: nonEmptyString.optional(), stderr: nonEmptyString.optional() }).optional(),
+  ...runAssets
+};
+var FunctionRunSchema = z.strictObject({
+  kind: z.literal("function"),
+  ...deterministicRun
+});
+var CheckRunSchema = z.strictObject({
+  kind: z.literal("check"),
+  onFail: z.enum(["escalate", "fail"]).default("escalate"),
+  ...deterministicRun
+});
+var InputChoiceSchema = z.strictObject({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  description: nonEmptyString.optional()
+});
+var FormFieldSchema = z.strictObject({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  type: z.enum(["text", "textarea", "number", "choice", "file", "date", "boolean"]),
+  required: z.boolean().optional(),
+  options: z.array(InputChoiceSchema).optional(),
+  accept: z.array(nonEmptyString).optional()
+});
+var InputSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("text"), multiline: z.boolean().optional() }),
+  z.strictObject({
+    kind: z.literal("choice"),
+    options: z.array(InputChoiceSchema).min(1),
+    multiple: z.boolean().optional()
+  }),
+  z.strictObject({ kind: z.literal("form"), fields: z.array(FormFieldSchema) }),
+  z.strictObject({
+    kind: z.literal("file"),
+    accept: z.array(nonEmptyString).optional(),
+    maxSize: z.number().positive().optional(),
+    multiple: z.boolean().optional()
+  })
+]);
+var GateRunSchema = z.strictObject({
+  kind: z.literal("gate"),
+  prompt: nonEmptyString,
+  schema: InputSchema,
+  ...runAssets
+});
+var RouteSchema = z.strictObject({
+  when: nonEmptyString,
+  target: nonEmptyString.nullable()
+});
+var RouterRunSchema = z.strictObject({
+  kind: z.literal("router"),
+  routes: z.array(RouteSchema).min(1),
+  ...runAssets
+});
+var RunSchema = z.discriminatedUnion("kind", [
+  AgentRunSchema,
+  SubpromptRunSchema,
+  FunctionRunSchema,
+  CheckRunSchema,
+  GateRunSchema,
+  RouterRunSchema
+]);
+var NodeSchema = z.strictObject({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  description: nonEmptyString,
+  phase: nonEmptyString.optional(),
+  run: RunSchema,
+  contract: NodeContractSchema.optional(),
+  gate: NodeGateSchema.optional(),
+  control: NodeControlSchema.optional()
+});
+var EdgeSchema = z.strictObject({
+  id: nonEmptyString,
+  source: nonEmptyString,
+  target: nonEmptyString,
+  type: z.enum(["flow", "parallel", "optional"])
+});
+var FlowDefaultsSchema = z.strictObject({
+  approval: z.enum(["checkpoint", "auto", "manual"]).optional(),
+  researchDepth: nonEmptyString.optional(),
+  autoReview: z.boolean().optional(),
+  subagentMode: z.boolean().optional(),
+  verbosity: nonEmptyString.optional(),
+  cliMode: z.boolean().optional(),
+  run_input: z.json().optional(),
+  parameters: z.record(z.string(), z.json()).optional()
+});
+var FlowMetaSchema = z.strictObject({
+  icon: nonEmptyString.optional(),
+  category: nonEmptyString.optional(),
+  tags: z.array(nonEmptyString).optional(),
+  stage: nonEmptyString.optional(),
+  onboarding: z.strictObject({
+    input_style: z.enum(["freeform", "structured", "repo"]),
+    placeholder: nonEmptyString.optional(),
+    fields: z.array(nonEmptyString).optional()
+  }).optional()
+});
+var FlowDefinitionObjectSchema = z.strictObject({
+  $schema: nonEmptyString.optional(),
+  schemaVersion: z.literal(2),
+  id: nonEmptyString,
+  version: nonEmptyString,
+  name: nonEmptyString,
+  description: nonEmptyString.optional(),
+  input: FlowInputContractSchema.optional(),
+  output: FlowOutputContractSchema.optional(),
+  defaults: FlowDefaultsSchema.optional(),
+  entry: nonEmptyString.optional(),
+  nodes: z.array(NodeSchema),
+  edges: z.array(EdgeSchema),
+  meta: FlowMetaSchema.optional()
+});
+function parseFlowDefinitionStructure(data) {
+  return FlowDefinitionObjectSchema.safeParse(data);
+}
+function bindingExpressions(value) {
+  if (typeof value === "string") {
+    return Array.from(value.matchAll(/\$\{([^{}]+)\}/g), (match) => match[1]);
+  }
+  if (Array.isArray(value)) return value.flatMap(bindingExpressions);
+  if (typeof value !== "object" || value === null) return [];
+  return Object.values(value).flatMap(bindingExpressions);
+}
+var MISSING_FIELD = /* @__PURE__ */ Symbol("missing-field");
+function declaredFieldSchema(schema, path) {
+  let current = schema;
+  for (const segment of path) {
+    if (typeof current !== "object" || current === null) return MISSING_FIELD;
+    const properties = current.properties;
+    if (typeof properties !== "object" || properties === null || !Object.hasOwn(properties, segment)) {
+      return MISSING_FIELD;
+    }
+    current = properties[segment];
+  }
+  return current;
+}
+function knownNonBooleanType(schema) {
+  if (typeof schema !== "object" || schema === null) return void 0;
+  const type = schema.type;
+  if (typeof type === "string") return type === "boolean" ? void 0 : type;
+  if (Array.isArray(type) && type.length > 0 && type.every((candidate) => typeof candidate === "string") && type.some((candidate) => candidate !== "boolean")) {
+    return type.join(" | ");
+  }
+  return void 0;
+}
+var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context) => {
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const [index, node] of flow.nodes.entries()) {
+    if (nodeIds.has(node.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["nodes", index, "id"],
+        message: `duplicate node id: ${node.id}`
+      });
+    }
+    nodeIds.add(node.id);
+    if (node.control?.optional === true && node.gate?.approval === "mandatory") {
+      context.addIssue({
+        code: "custom",
+        path: ["nodes", index, "control", "optional"],
+        message: "a node cannot be both optional and a mandatory approval gate"
+      });
+    }
+  }
+  if (flow.entry !== void 0 && !nodeIds.has(flow.entry)) {
+    context.addIssue({ code: "custom", path: ["entry"], message: `unknown node: ${flow.entry}` });
+  }
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const [edgeIndex, edge] of flow.edges.entries()) {
+    if (!nodeIds.has(edge.source)) {
+      context.addIssue({
+        code: "custom",
+        path: ["edges", edgeIndex, "source"],
+        message: `unknown node: ${edge.source}`
+      });
+    }
+    if (!nodeIds.has(edge.target)) {
+      context.addIssue({
+        code: "custom",
+        path: ["edges", edgeIndex, "target"],
+        message: `unknown node: ${edge.target}`
+      });
+    }
+    if (edge.type === "flow" && nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+      const edges = outgoing.get(edge.source) ?? [];
+      edges.push({ target: edge.target, path: ["edges", edgeIndex] });
+      outgoing.set(edge.source, edges);
+    }
+  }
+  for (const [nodeIndex, node] of flow.nodes.entries()) {
+    if (node.run.kind !== "router") continue;
+    for (const [routeIndex, route] of node.run.routes.entries()) {
+      if (route.target !== null && !nodeIds.has(route.target)) {
+        context.addIssue({
+          code: "custom",
+          path: ["nodes", nodeIndex, "run", "routes", routeIndex, "target"],
+          message: `unknown node: ${route.target}`
+        });
+      }
+    }
+  }
+  const validateExpression = (expression, path, requireBoolean = true) => {
+    let references;
+    try {
+      references = inspectFlowExpression(expression, requireBoolean);
+    } catch (error) {
+      context.addIssue({
+        code: "custom",
+        path,
+        message: error instanceof Error ? error.message : "invalid Flow expression"
+      });
+      return;
+    }
+    for (const reference of references) {
+      const segments = reference.path.split(".");
+      if (segments[0] !== "nodes") continue;
+      const producer = flow.nodes.find((node) => node.id === segments[1]);
+      if (!producer) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `unknown producer node: ${segments[1]}`
+        });
+        continue;
+      }
+      if (segments[2] === "status") {
+        if (reference.booleanOperand) {
+          context.addIssue({ code: "custom", path, message: "node status is not boolean" });
+        }
+        continue;
+      }
+      const outputSchema = producer.contract?.output?.fields;
+      if (!outputSchema) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `node ${producer.id} has no declared output fields`
+        });
+        continue;
+      }
+      const fieldPath = segments.slice(4);
+      const fieldSchema = declaredFieldSchema(outputSchema, fieldPath);
+      if (fieldSchema === MISSING_FIELD) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `node ${producer.id} does not declare output field ${fieldPath.join(".")}`
+        });
+        continue;
+      }
+      const nonBooleanType = reference.booleanOperand ? knownNonBooleanType(fieldSchema) : void 0;
+      if (nonBooleanType) {
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `node ${producer.id} output field ${fieldPath.join(".")} is ${nonBooleanType}, not boolean`
+        });
+      }
+    }
+  };
+  for (const [nodeIndex, node] of flow.nodes.entries()) {
+    for (const [requireIndex, requirement] of node.contract?.requires?.entries() ?? []) {
+      validateExpression(requirement.expr, [
+        "nodes",
+        nodeIndex,
+        "contract",
+        "requires",
+        requireIndex,
+        "expr"
+      ]);
+    }
+    for (const [bindingName, binding] of Object.entries(node.contract?.input ?? {})) {
+      for (const expression of bindingExpressions(binding)) {
+        validateExpression(
+          expression,
+          ["nodes", nodeIndex, "contract", "input", bindingName],
+          false
+        );
+      }
+    }
+    if (node.run.kind === "router") {
+      for (const [routeIndex, route] of node.run.routes.entries()) {
+        validateExpression(route.when, ["nodes", nodeIndex, "run", "routes", routeIndex, "when"]);
+      }
+    }
+  }
+  const state = /* @__PURE__ */ new Map();
+  for (const nodeId of nodeIds) {
+    if (state.has(nodeId)) continue;
+    const stack = [{ nodeId, next: 0 }];
+    state.set(nodeId, "active");
+    while (stack.length > 0) {
+      const frame = stack.at(-1);
+      if (!frame) break;
+      const arcs = outgoing.get(frame.nodeId) ?? [];
+      if (frame.next >= arcs.length) {
+        state.set(frame.nodeId, "done");
+        stack.pop();
+        continue;
+      }
+      const arc = arcs[frame.next++];
+      if (state.get(arc.target) === "active") {
+        context.addIssue({ code: "custom", path: arc.path, message: "flow graph must be acyclic" });
+      } else if (!state.has(arc.target)) {
+        state.set(arc.target, "active");
+        stack.push({ nodeId: arc.target, next: 0 });
+      }
+    }
+  }
+});
+var successfullyParsedDefinitions = /* @__PURE__ */ new WeakMap();
+function valueFingerprint(value, ancestors) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `string:${JSON.stringify(value)}`;
+  if (typeof value === "boolean") return `boolean:${value}`;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return null;
+    return `number:${Object.is(value, -0) ? "-0" : value}`;
+  }
+  if (typeof value !== "object" || ancestors.has(value)) return null;
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getPrototypeOf(value) !== Array.prototype) return null;
+      if (Object.getOwnPropertySymbols(value).length > 0) return null;
+      const names = Object.getOwnPropertyNames(value);
+      if (names.length !== value.length + 1 || !names.includes("length")) return null;
+      const items = [];
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return null;
+        const item = valueFingerprint(descriptor.value, ancestors);
+        if (item === null) return null;
+        items.push(item);
+      }
+      return `array:[${items.join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) return null;
+    if (Object.getOwnPropertySymbols(value).length > 0) return null;
+    const entries = [];
+    for (const key of Object.getOwnPropertyNames(value).sort()) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return null;
+      const nested = valueFingerprint(descriptor.value, ancestors);
+      if (nested === null) return null;
+      entries.push(`${JSON.stringify(key)}:${nested}`);
+    }
+    return `object:{${entries.join(",")}}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function definitionFingerprint(data) {
+  return valueFingerprint(data, /* @__PURE__ */ new Set());
+}
+var LegacyRouteSchema = z.looseObject({
+  condition: z.string().min(1),
+  target: z.string().min(1).nullable()
+});
+var LegacyNodeDataSchema = z.looseObject({
+  skill: z.string().min(1).optional(),
+  version: z.string().min(1).optional(),
+  label: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  optional: z.boolean().optional(),
+  approval: z.looseObject({ mandatory: z.boolean().optional() }).optional(),
+  parameters: z.record(z.string(), z.unknown()).optional(),
+  phase: z.string().min(1).optional(),
+  parallel_group: z.string().min(1).optional(),
+  flow: z.string().min(1).optional(),
+  message: z.string().min(1).optional(),
+  routes: z.array(LegacyRouteSchema).optional(),
+  assets: z.array(z.string().min(1)).optional()
+});
+var LegacyNodeSchema = z.looseObject({
+  id: z.string().min(1),
+  type: z.string().min(1).optional(),
+  skill: z.string().min(1).optional(),
+  label: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  data: LegacyNodeDataSchema.optional()
+});
+var LegacyEdgeSchema = z.looseObject({
+  id: z.string().min(1).optional(),
+  source: z.string().min(1),
+  target: z.string().min(1),
+  type: z.string().min(1).optional()
+});
+var LegacyFlowSchema = z.looseObject({
+  id: z.string().min(1),
+  version: z.string().min(1).optional(),
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  requires: z.array(z.string().min(1)).optional(),
+  globals: z.record(z.string(), z.unknown()).optional(),
+  entry: z.string().min(1).optional(),
+  nodes: z.array(LegacyNodeSchema).optional(),
+  edges: z.array(LegacyEdgeSchema).optional(),
+  meta: z.record(z.string(), z.unknown()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+function success(data) {
+  const fingerprint = definitionFingerprint(data);
+  if (fingerprint !== null) successfullyParsedDefinitions.set(data, fingerprint);
+  return { ok: true, data };
+}
+function failure(error) {
+  return {
+    ok: false,
+    errors: error.issues.map((issue) => ({
+      path: issue.path.map(String).join("."),
+      message: issue.message
+    }))
+  };
+}
+var LEGACY_DEFAULT_KEYS = {
+  approval_mode: "approval",
+  research_depth: "researchDepth",
+  auto_review: "autoReview",
+  subagent_mode: "subagentMode",
+  verbosity: "verbosity",
+  cli_mode: "cliMode",
+  run_input: "run_input"
+};
+function normalizeDefaults(globals) {
+  if (!globals) return void 0;
+  const known = {};
+  const parameters = {};
+  for (const [key, value] of Object.entries(globals)) {
+    const normalizedKey = LEGACY_DEFAULT_KEYS[key];
+    if (normalizedKey) {
+      known[normalizedKey] = key === "approval_mode" && value === "auto_approve" ? "auto" : value;
+    } else {
+      parameters[key] = value;
+    }
+  }
+  if (Object.keys(parameters).length > 0) known.parameters = parameters;
+  return Object.keys(known).length > 0 ? known : void 0;
+}
+function normalizeMeta(value) {
+  if (!value) return void 0;
+  const meta = {};
+  if (typeof value.icon === "string") meta.icon = value.icon;
+  if (typeof value.category === "string") meta.category = value.category;
+  if (Array.isArray(value.tags)) meta.tags = value.tags;
+  if (typeof value.stage === "string") meta.stage = value.stage;
+  if (typeof value.onboarding === "object" && value.onboarding !== null) {
+    const onboarding = value.onboarding;
+    if (onboarding.input_style === "freeform" || onboarding.input_style === "structured" || onboarding.input_style === "repo") {
+      meta.onboarding = {
+        input_style: onboarding.input_style,
+        ...typeof onboarding.placeholder === "string" ? { placeholder: onboarding.placeholder } : {},
+        ...Array.isArray(onboarding.fields) ? { fields: onboarding.fields } : {}
+      };
+    }
+  }
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function normalizeLegacyBinding(value) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, key) => {
+      const normalized = LEGACY_DEFAULT_KEYS[key];
+      return `\${defaults.${normalized ?? `parameters.${key}`}}`;
+    });
+  }
+  if (Array.isArray(value)) return value.map(normalizeLegacyBinding);
+  if (typeof value !== "object" || value === null) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [key, normalizeLegacyBinding(nested)])
+  );
+}
+function normalizeV1(data) {
+  const legacyResult = LegacyFlowSchema.safeParse(data);
+  if (!legacyResult.success) return failure(legacyResult.error);
+  const legacy = legacyResult.data;
+  const contradiction = (legacy.nodes ?? []).findIndex(
+    (node) => node.data?.optional === true && node.data.approval?.mandatory === true
+  );
+  if (contradiction !== -1) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: `nodes.${contradiction}.data`,
+          message: "a node cannot be both optional and a mandatory approval gate"
+        }
+      ]
+    };
+  }
+  const nodes = [];
+  for (const node of legacy.nodes ?? []) {
+    const data2 = node.data ?? {};
+    const kind = node.type;
+    const label = data2.label ?? node.label ?? data2.skill ?? node.skill ?? node.id;
+    const description = node.description ?? data2.description ?? data2.message ?? label;
+    if (kind !== "skill") {
+      const delegatedAsset = kind === "sub-flow" && data2.flow ? `flow:${data2.flow}` : void 0;
+      const assets2 = [...delegatedAsset ? [delegatedAsset] : [], ...data2.assets ?? []];
+      const parameters2 = data2.parameters ?? {};
+      nodes.push({
+        id: node.id,
+        label,
+        description,
+        phase: data2.phase,
+        run: {
+          kind: "router",
+          routes: [{ when: "default", target: null }],
+          assets: assets2.length > 0 ? assets2 : void 0
+        },
+        contract: {
+          requires: [{ expr: "false" }],
+          input: Object.keys(parameters2).length > 0 ? normalizeLegacyBinding(parameters2) : void 0
+        },
+        control: { optional: true, parallelGroup: data2.parallel_group }
+      });
+      continue;
+    }
+    const parameters = { ...data2.parameters ?? {} };
+    const authoredInstruction = parameters.instructions;
+    delete parameters.instructions;
+    const instruction = typeof authoredInstruction === "string" && authoredInstruction.length > 0 ? authoredInstruction : description;
+    const skill = data2.skill ?? node.skill;
+    const skillAsset = skill ? `skill:${skill}${data2.version !== void 0 ? `#${data2.version}` : ""}` : void 0;
+    const assets = [...skillAsset ? [skillAsset] : [], ...data2.assets ?? []];
+    const control = {
+      optional: data2.optional,
+      parallelGroup: data2.parallel_group
+    };
+    nodes.push({
+      id: node.id,
+      label,
+      description,
+      phase: data2.phase,
+      run: {
+        kind: "agent",
+        instruction,
+        assets: assets.length > 0 ? assets : void 0
+      },
+      contract: Object.keys(parameters).length > 0 ? { input: normalizeLegacyBinding(parameters) } : void 0,
+      gate: data2.approval?.mandatory === true ? { approval: "mandatory" } : void 0,
+      control: control.optional !== void 0 || control.parallelGroup !== void 0 ? control : void 0
+    });
+  }
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  const edges = (legacy.edges ?? []).map((edge, index) => ({
+    ...edge,
+    id: edge.id ?? `${edge.source}-${edge.target}-${index}`,
+    type: edge.type ?? "optional"
+  }));
+  const anchor = nodes.find((node) => node.id === legacy.entry) ?? (nodes.length > 0 ? nodes[0] : void 0);
+  if (anchor && legacy.requires && legacy.requires.length > 0) {
+    const run = anchor.run;
+    const existingAssets = Array.isArray(run.assets) ? run.assets : [];
+    run.assets = [.../* @__PURE__ */ new Set([...existingAssets, ...legacy.requires])];
+  }
+  const candidate = {
+    schemaVersion: 2,
+    id: legacy.id,
+    version: legacy.version ?? "1.0.0",
+    name: legacy.name,
+    description: legacy.description,
+    defaults: normalizeDefaults(legacy.globals),
+    entry: legacy.entry !== void 0 && nodeIds.has(legacy.entry) ? legacy.entry : void 0,
+    nodes,
+    edges,
+    meta: normalizeMeta({ ...legacy.metadata ?? {}, ...legacy.meta ?? {} })
+  };
+  const normalized = parseFlowDefinitionStructure({ ...candidate, edges: [] });
+  if (!normalized.success) return failure(normalized.error);
+  const parsed = { ...normalized.data, edges };
+  return success(parsed);
+}
+function parseFlowDefinition(data) {
+  if (typeof data === "object" && data !== null) {
+    const recorded = successfullyParsedDefinitions.get(data);
+    if (recorded !== void 0 && definitionFingerprint(data) === recorded) {
+      return { ok: true, data };
+    }
+  }
+  if (typeof data === "object" && data !== null && Object.hasOwn(data, "schemaVersion")) {
+    const result = FlowDefinitionSchema.safeParse(data);
+    return result.success ? success(result.data) : failure(result.error);
+  }
+  return normalizeV1(data);
+}
+
+export { FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, evaluate, evaluateFlowExpression, normalizeV1, parseFlowDefinition };
+//# sourceMappingURL=chunk-ZE2KEPE2.js.map
+//# sourceMappingURL=chunk-ZE2KEPE2.js.map