{"version":3,"file":"validate-C0iI8guc.cjs","names":["z","collectTemplateStepIds","createWorkflow","cloneWorkflow","getSingleStepEntryId","derivePredicateLabel","predicateToCondition","_exhaustive","createStepFromAgent","createStepFromTool","mapVariable","inputSchemaOf"],"sources":["../src/workflows/stored/json-schema-to-zod.ts","../src/workflows/stored/validate/schema-utils.ts","../src/workflows/stored/mapping-config.ts","../src/workflows/stored/rehydrate.ts","../src/workflows/stored/graph.ts","../src/workflows/stored/validate/refs.ts","../src/workflows/stored/validate/types.ts","../src/workflows/stored/validate/repair-actions.ts","../src/workflows/stored/validate/schema-flow.ts","../src/workflows/stored/validate/schemas.ts","../src/workflows/stored/validate/structure.ts","../src/workflows/stored/validate/index.ts"],"sourcesContent":["/**\n * Minimal JSON-Schema ↔ Zod bridge for stored workflows: a converter for the\n * static subset Zod round-trips through `standardSchemaToJSONSchema`, plus a\n * non-throwing validator for the write path.\n */\nimport { z } from 'zod';\n\n/**\n * Minimal JSON-Schema shape we accept. Intentionally untyped on the value side\n * — different JSON Schema producers emit slightly different shapes and the\n * inline converter below just inspects the fields it cares about.\n */\nexport type JsonSchema = Record<string, any>;\n\n/**\n * Options controlling how `jsonSchemaToZod` handles JSON Schema keywords the\n * MVP converter doesn't support.\n *\n * - `throw` (default): hard-crash with a targeted error. Correct for the save\n *   path — the author is right there and can simplify the schema.\n * - `warn`: emit a warning via `onUnsupported` (if provided) and fall back to\n *   `z.any()` for the unsupported subtree. Correct for the boot-time load\n *   path — one bad pre-existing row must not take down startup for every\n *   other workflow.\n */\nexport interface JsonSchemaToZodOptions {\n  onUnsupportedSchema?: 'throw' | 'warn';\n  onUnsupported?: (message: string) => void;\n}\n\n/**\n * Inline converter sufficient for the static subset Zod typically emits when\n * round-tripped through `standardSchemaToJSONSchema`. Handles:\n *\n *  - `object` with `properties` + `required`\n *  - `string` / `number` / `integer` / `boolean` / `null`\n *  - `array` with `items`\n *  - `enum`\n *  - `description` (propagated via `.describe`)\n *\n * For more exotic schemas (unions, intersections, recursive refs) swap in\n * `json-schema-to-zod` from npm. Kept inline to avoid pulling a dependency\n * for the MVP demo.\n */\nexport function jsonSchemaToZod(schema: JsonSchema, opts?: JsonSchemaToZodOptions): z.ZodTypeAny {\n  return walk(schema, opts ?? {});\n}\n\n// JSON Schema keywords that this MVP converter does not support. If a stored\n// workflow's inputSchema/outputSchema uses any of these, silently converting\n// to z.any() would strip the constraint at rehydration and let bad data flow\n// through at execution — hard-crash instead so the corruption surfaces at\n// load time.\nconst UNSUPPORTED_SCHEMA_KEYS = [\n  'oneOf',\n  'anyOf',\n  'allOf',\n  'not',\n  '$ref',\n  'patternProperties',\n  'discriminator',\n] as const;\n\n/** Values `z.literal()` can represent — the only const/enum members that survive conversion losslessly. */\nfunction isLiteralValue(v: unknown): v is string | number | boolean | null {\n  return v === null || typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean';\n}\n\n/** Throw or warn-and-fallback per `onUnsupportedSchema`, matching the unsupported-keyword behavior. */\nfunction unsupported(message: string, opts: JsonSchemaToZodOptions): z.ZodTypeAny {\n  if (opts.onUnsupportedSchema === 'warn') {\n    opts.onUnsupported?.(message);\n    return z.any();\n  }\n  throw new Error(message);\n}\n\nfunction walk(schema: JsonSchema, opts: JsonSchemaToZodOptions): z.ZodTypeAny {\n  if (!schema || typeof schema !== 'object') return z.any();\n\n  for (const key of UNSUPPORTED_SCHEMA_KEYS) {\n    if (key in schema) {\n      return unsupported(\n        `Stored workflow schema uses unsupported JSON Schema keyword \"${key}\". ` +\n          `This converter only supports the static subset that Zod round-trips through ` +\n          `standardSchemaToJSONSchema (object, array, string, number, integer, boolean, null, enum, const). ` +\n          `Simplify the schema or extend jsonSchemaToZod to cover this keyword.`,\n        opts,\n      );\n    }\n  }\n\n  let out: z.ZodTypeAny;\n\n  if ('const' in schema) {\n    // Zod emits `{ const: value }` for z.literal() — preserve it instead of\n    // silently dropping the constraint. Non-primitive consts (objects/arrays)\n    // can't be represented by z.literal, so treat them as unsupported.\n    if (!isLiteralValue(schema.const)) {\n      return unsupported(\n        `Stored workflow schema uses a non-primitive \"const\" value (${JSON.stringify(schema.const)}). ` +\n          `Only string, number, boolean, and null literals are supported.`,\n        opts,\n      );\n    }\n    out = z.literal(schema.const);\n  } else if (Array.isArray(schema.enum) && schema.enum.length > 0) {\n    const values = schema.enum as unknown[];\n    if (!values.every(isLiteralValue)) {\n      return unsupported(\n        `Stored workflow schema uses an \"enum\" with non-primitive members. ` +\n          `Only string, number, boolean, and null enum members are supported.`,\n        opts,\n      );\n    }\n    if (values.every(v => typeof v === 'string')) {\n      out = z.enum(values as [string, ...string[]]);\n    } else {\n      // Mixed/non-string enums (e.g. [1, 2, 3] or ['a', 1]): preserve the\n      // original member types via literal union instead of coercing to string.\n      const literals: z.ZodTypeAny[] = values.map(v => z.literal(v as string | number | boolean | null));\n      out = literals.length === 1 ? literals[0]! : z.union(literals as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]);\n    }\n  } else if (Array.isArray(schema.type)) {\n    const options = schema.type.map((t: string) => walk({ ...schema, type: t }, opts));\n    // z.union requires a tuple of at least two members; guard shorter arrays.\n    if (options.length === 1) {\n      out = options[0]!;\n    } else {\n      out = z.union(options as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]);\n    }\n  } else {\n    switch (schema.type) {\n      case 'object': {\n        const shape: Record<string, z.ZodTypeAny> = {};\n        const required = new Set<string>(Array.isArray(schema.required) ? schema.required : []);\n        for (const [key, child] of Object.entries(schema.properties ?? {})) {\n          const childSchema = walk(child as JsonSchema, opts);\n          shape[key] = required.has(key) ? childSchema : childSchema.optional();\n        }\n        const obj = z.object(shape);\n        out = schema.additionalProperties === true ? obj.passthrough() : obj;\n        break;\n      }\n      case 'array':\n        // Tuple-form `items: [...]` positional schemas aren't representable by\n        // z.array(); converting to z.array(z.any()) would strip every\n        // positional constraint. Reject instead of silently widening.\n        if (Array.isArray(schema.items)) {\n          return unsupported(\n            `Stored workflow schema uses tuple-form \"items\" (an array of positional schemas). ` +\n              `Only a single item schema is supported; use \"items\": { ... } instead.`,\n            opts,\n          );\n        }\n        out = z.array(walk(schema.items ?? {}, opts));\n        break;\n      case 'string':\n        out = z.string();\n        break;\n      case 'number':\n        out = z.number();\n        break;\n      case 'integer':\n        out = z.number().int();\n        break;\n      case 'boolean':\n        out = z.boolean();\n        break;\n      case 'null':\n        out = z.null();\n        break;\n      case undefined:\n        // No `type` and no enum/typed-array — schema is just a description\n        // or annotation wrapper; permit z.any() for these.\n        out = z.any();\n        break;\n      default:\n        return unsupported(\n          `Stored workflow schema uses unsupported JSON Schema type \"${String(schema.type)}\". ` +\n            `This converter only supports object, array, string, number, integer, boolean, null, and enum.`,\n          opts,\n        );\n    }\n  }\n\n  if (typeof schema.description === 'string' && schema.description.length > 0) {\n    out = out.describe(schema.description);\n  }\n  return out;\n}\n\n/**\n * Result of a `validateStorableJsonSchema` call.\n * `unsupported` lists every offending keyword usage as `<jsonPointer>: <keyword>`\n * so callers can log or surface a targeted message per offense.\n */\nexport type StorableJsonSchemaValidation = { ok: true } | { ok: false; unsupported: string[] };\n\n/**\n * Non-throwing companion to `jsonSchemaToZod`. Walks a JSON Schema and reports\n * every unsupported-keyword usage without converting. Use this at write time\n * (e.g. inside `Mastra.addStoredWorkflow`) to surface a warning before the\n * schema is persisted — the row will still fail to rehydrate on the next boot\n * (`jsonSchemaToZod` throws), so this is a heads-up, not a guarantee.\n *\n * Callers decide whether to warn, reject, or ignore. This function never\n * throws for any input shape.\n */\nexport function validateStorableJsonSchema(schema: JsonSchema | undefined): StorableJsonSchemaValidation {\n  if (!schema || typeof schema !== 'object') return { ok: true };\n  const unsupported: string[] = [];\n  const visit = (node: unknown, path: string): void => {\n    if (!node || typeof node !== 'object') return;\n    const n = node as Record<string, unknown>;\n    for (const key of UNSUPPORTED_SCHEMA_KEYS) {\n      if (key in n) unsupported.push(`${path || '#'}: ${key}`);\n    }\n    if (n.properties && typeof n.properties === 'object') {\n      for (const [prop, child] of Object.entries(n.properties as Record<string, unknown>)) {\n        visit(child, `${path}/properties/${prop}`);\n      }\n    }\n    if (n.items) {\n      if (Array.isArray(n.items)) {\n        n.items.forEach((child, i) => visit(child, `${path}/items/${i}`));\n      } else {\n        visit(n.items, `${path}/items`);\n      }\n    }\n    if (n.additionalProperties && typeof n.additionalProperties === 'object') {\n      visit(n.additionalProperties, `${path}/additionalProperties`);\n    }\n  };\n  visit(schema, '');\n  return unsupported.length === 0 ? { ok: true } : { ok: false, unsupported };\n}\n","/**\n * Pure JSON-Schema helpers shared by schema-flow analysis and mapping-config\n * analysis. Everything here is best-effort and three-valued: a check only\n * reports `incompatible` when it can prove a mismatch, so absent or partial\n * schemas degrade to `unknown` instead of producing false positives.\n */\nimport { standardSchemaToJSONSchema, toStandardSchema } from '../../../schema';\nimport type { JsonSchema } from '../json-schema-to-zod';\n\nexport type SchemaCompatibility = 'compatible' | 'incompatible' | 'unknown';\n\n/**\n * Best-effort conversion of a live (Zod / standard) schema to JSON Schema for\n * registry-index building. Unconvertible or absent schemas yield `undefined`\n * (\"unknown\"), which schema-flow treats as never-incompatible.\n */\nexport function toJsonSchemaOrUndefined(schema: unknown): JsonSchema | undefined {\n  if (schema === undefined || schema === null) return undefined;\n  try {\n    return standardSchemaToJSONSchema(toStandardSchema(schema)) as JsonSchema;\n  } catch {\n    return undefined;\n  }\n}\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** True when both types are numeric, i.e. some mix of `integer` and `number`. */\nfunction isNumeric(sourceType: string, destinationType: string): boolean {\n  const numeric = new Set(['integer', 'number']);\n  return numeric.has(sourceType) && numeric.has(destinationType);\n}\n\n/**\n * Structural compatibility of `source` output feeding a `destination` input.\n * Recurses through array items and object properties; a destination `required`\n * key missing from the source is a proven incompatibility.\n */\nexport function schemaCompatibility(source: unknown, destination: unknown): SchemaCompatibility {\n  if (!isRecord(source) || !isRecord(destination)) return 'unknown';\n  const sourceType = typeof source.type === 'string' ? source.type : undefined;\n  const destinationType = typeof destination.type === 'string' ? destination.type : undefined;\n  if (!sourceType || !destinationType) return 'unknown';\n  // `integer` is a subtype of `number`, so a whole-number source satisfies a\n  // `number` destination. The reverse isn't provably wrong either: a `number`\n  // source can hold whole values at runtime, and this function only reports\n  // incompatibilities it can prove.\n  if (sourceType !== destinationType && !isNumeric(sourceType, destinationType)) return 'incompatible';\n  if (destinationType === 'array') return schemaCompatibility(source.items, destination.items);\n  if (destinationType !== 'object') return 'compatible';\n\n  const sourceProperties = isRecord(source.properties) ? source.properties : {};\n  const destinationProperties = isRecord(destination.properties) ? destination.properties : {};\n  const required = Array.isArray(destination.required)\n    ? destination.required.filter((key): key is string => typeof key === 'string')\n    : [];\n  for (const key of required) {\n    if (!(key in sourceProperties)) return 'incompatible';\n  }\n  for (const [key, destinationProperty] of Object.entries(destinationProperties)) {\n    if (!(key in sourceProperties)) continue;\n    if (schemaCompatibility(sourceProperties[key], destinationProperty) === 'incompatible') return 'incompatible';\n  }\n  return 'compatible';\n}\n\n/** Follows a dotted mapping path through object `properties`; `''`/`'.'` is the root. */\nexport function schemaAtPath(schema: JsonSchema | undefined, path: string): JsonSchema | undefined {\n  if (!schema || path === '' || path === '.') return schema;\n  let current: unknown = schema;\n  for (const segment of path.split('.')) {\n    if (!isRecord(current) || !isRecord(current.properties) || !isRecord(current.properties[segment])) return undefined;\n    current = current.properties[segment];\n  }\n  return current as JsonSchema;\n}\n\n/** Plain dotted segments only — no `$.`, brackets, or empty segments. */\nexport function isCanonicalMappingPath(path: string): boolean {\n  return path === '' || path === '.' || /^[^.[$\\]]+(?:\\.[^.[$\\]]+)*$/.test(path);\n}\n\n/** Infers a JSON Schema for a literal `{ value }` mapping source. */\nexport function schemaForValue(value: unknown): JsonSchema {\n  if (value === null) return { type: 'null' };\n  if (Array.isArray(value)) return { type: 'array' };\n  switch (typeof value) {\n    case 'string':\n    case 'boolean':\n      return { type: typeof value };\n    case 'number':\n      return { type: Number.isInteger(value) ? 'integer' : 'number' };\n    case 'object':\n      return { type: 'object' };\n    default:\n      return {};\n  }\n}\n","/**\n * The single home for stored `mapConfig` handling.\n *\n * A mapping entry's config crosses the storage boundary as a JSON string.\n * - {@link parseMapConfig} is the one parser (rehydration + validation both\n *   use it; rehydration via the throwing form).\n * - {@link analyzeMapConfig} is the one validator: it walks each descriptor,\n *   collects issues, and infers the mapping's output schema in the same pass\n *   (the two are inseparable — a descriptor's validity determines its\n *   contribution to the output shape).\n *\n * Template syntax checking delegates to `mapping-template.ts`'s\n * `validateTemplate` — the same parser the runtime uses — plus a scope check\n * over the placeholders' step ids.\n */\nimport { collectTemplateStepIds, validateTemplate } from '../mapping-template';\nimport type { JsonSchema } from './json-schema-to-zod';\nimport { isCanonicalMappingPath, isRecord, schemaAtPath, schemaForValue } from './validate/schema-utils';\nimport type { WorkflowValidationIssue } from './validate/types';\n\n/** Parses a stored mapConfig JSON string; throws with the step id on malformed JSON. */\nexport function parseMapConfig(raw: string, stepId: string): Record<string, any> {\n  try {\n    return JSON.parse(raw) as Record<string, any>;\n  } catch (e) {\n    throw new Error(`Stored mapping step \"${stepId}\" has invalid JSON mapConfig: ${(e as Error).message}`);\n  }\n}\n\n/** A recognizable Handlebars/Mustache placeholder: `{{ name }}`, `{{a.b}}`, … */\nconst HANDLEBARS_PLACEHOLDER = /\\{\\{\\s*[\\w$][\\w.$-]*\\s*\\}\\}/;\n\nexport interface MapConfigAnalysisOptions {\n  /** Issue path prefix of the mapping entry, e.g. `graph.2`. */\n  path: string;\n  /** Outputs of preceding workflow-local steps (schema may be undefined when unknown). */\n  availableOutputs: ReadonlyMap<string, JsonSchema | undefined>;\n  /** The workflow's input schema (for `{ initData: true }` sources). */\n  inputSchema: JsonSchema | undefined;\n  /** The workflow's request-context schema (for `{ requestContextPath }` sources). */\n  requestContextSchema: JsonSchema | undefined;\n}\n\nexport interface MapConfigAnalysis {\n  issues: WorkflowValidationIssue[];\n  /** Inferred output schema of the mapping step; undefined when the config is unusable. */\n  outputSchema: JsonSchema | undefined;\n}\n\n/**\n * Validates a mapping entry's raw `mapConfig` string and infers the step's\n * output schema. Every key must define exactly one source\n * (`value` | `template` | `requestContextPath` | `initData`/`step` + `path`);\n * step references must point at preceding workflow-local steps.\n */\nexport function analyzeMapConfig(rawConfig: string, opts: MapConfigAnalysisOptions): MapConfigAnalysis {\n  const issues: WorkflowValidationIssue[] = [];\n  const { path, availableOutputs } = opts;\n\n  let config: unknown;\n  try {\n    config = JSON.parse(rawConfig);\n  } catch {\n    config = undefined;\n  }\n  if (!isRecord(config)) {\n    issues.push({\n      code: 'invalid-map-config',\n      path: `${path}.mapConfig`,\n      message: 'Mapping config must be a JSON object.',\n    });\n    return { issues, outputSchema: undefined };\n  }\n\n  const properties: Record<string, JsonSchema> = {};\n  for (const [key, descriptor] of Object.entries(config)) {\n    const descriptorPath = `${path}.mapConfig.${key}`;\n    if (!isRecord(descriptor)) {\n      issues.push({\n        code: 'invalid-map-config',\n        path: descriptorPath,\n        message: 'Mapping descriptor must be an object.',\n      });\n      continue;\n    }\n    const forms = [\n      'value' in descriptor,\n      typeof descriptor.template === 'string',\n      typeof descriptor.requestContextPath === 'string',\n      'path' in descriptor,\n    ].filter(Boolean).length;\n    if (forms !== 1) {\n      issues.push({\n        code: 'invalid-map-config',\n        path: descriptorPath,\n        message: 'Mapping descriptor must define exactly one source.',\n      });\n      continue;\n    }\n    if ('value' in descriptor) {\n      properties[key] = schemaForValue(descriptor.value);\n      continue;\n    }\n    if (typeof descriptor.template === 'string') {\n      let syntaxError: string | undefined;\n      try {\n        validateTemplate(descriptor.template);\n      } catch (err) {\n        syntaxError = (err as Error).message;\n      }\n      // Handlebars-style `{{name}}` is not a workflow placeholder — the runtime\n      // would emit it literally, which is never what the author meant.\n      if (syntaxError === undefined && HANDLEBARS_PLACEHOLDER.test(descriptor.template)) {\n        syntaxError = `Templates use \\${...} placeholders (e.g. \"\\${initData.name}\"), not {{...}}. \"${descriptor.template}\" would be emitted literally.`;\n      }\n      const unknownStep =\n        syntaxError === undefined\n          ? collectTemplateStepIds(descriptor.template).find(stepId => !availableOutputs.has(stepId))\n          : undefined;\n      if (syntaxError !== undefined || unknownStep !== undefined) {\n        issues.push({\n          code: 'invalid-map-reference',\n          path: `${descriptorPath}.template`,\n          message: syntaxError ?? 'Template references must use an available workflow-local source.',\n        });\n      }\n      properties[key] = { type: 'string' };\n      continue;\n    }\n    if (typeof descriptor.requestContextPath === 'string') {\n      if (!isCanonicalMappingPath(descriptor.requestContextPath) || descriptor.requestContextPath === '') {\n        issues.push({\n          code: 'invalid-map-config',\n          path: `${descriptorPath}.requestContextPath`,\n          message: 'Mapping paths must use plain dotted segments.',\n        });\n      }\n      properties[key] = schemaAtPath(opts.requestContextSchema, descriptor.requestContextPath) ?? {};\n      continue;\n    }\n\n    if (typeof descriptor.path !== 'string' || !isCanonicalMappingPath(descriptor.path)) {\n      issues.push({\n        code: 'invalid-map-config',\n        path: `${descriptorPath}.path`,\n        message: 'Mapping paths must use plain dotted segments.',\n      });\n      continue;\n    }\n    const hasInitData = descriptor.initData === true;\n    const stepIds =\n      typeof descriptor.step === 'string' ? [descriptor.step] : Array.isArray(descriptor.step) ? descriptor.step : [];\n    if (hasInitData === stepIds.length > 0 || stepIds.some(stepId => typeof stepId !== 'string')) {\n      issues.push({\n        code: 'invalid-map-config',\n        path: descriptorPath,\n        message: 'Path mappings must reference exactly one of initData or step.',\n      });\n      continue;\n    }\n    let sourceSchema: JsonSchema | undefined;\n    if (hasInitData) {\n      sourceSchema = opts.inputSchema;\n    } else {\n      const missing = stepIds.find(stepId => !availableOutputs.has(stepId));\n      if (missing) {\n        issues.push({\n          code: 'invalid-map-reference',\n          path: `${descriptorPath}.step`,\n          message: `Mapping source \"${missing}\" must be a preceding workflow-local step.`,\n        });\n        continue;\n      }\n      sourceSchema = stepIds.map(stepId => availableOutputs.get(stepId)).find(Boolean);\n    }\n    const selectedSchema = schemaAtPath(sourceSchema, descriptor.path);\n    if (sourceSchema && !selectedSchema) {\n      issues.push({\n        code: 'invalid-map-config',\n        path: `${descriptorPath}.path`,\n        message: `Path \"${descriptor.path}\" does not exist in the source schema.`,\n      });\n    }\n    properties[key] = selectedSchema ?? {};\n  }\n  return { issues, outputSchema: { type: 'object', properties, required: Object.keys(config) } };\n}\n","/**\n * Storable → Runnable half of the workflow round-trip: rebuild a runnable\n * `Workflow` from the stored JSON form. References to agents/tools/workflows\n * are resolved against the live Mastra instance; throws if a reference is\n * missing — better to surface the failure at load time than at run time.\n */\nimport type { Mastra } from '../../mastra';\nimport { cloneWorkflow, createWorkflow } from '../create';\nimport { derivePredicateLabel } from '../predicate';\nimport type { Step } from '../step';\nimport { createStepFromAgent, createStepFromTool } from '../step-factories';\nimport type {\n  SerializedSingleStepEntry,\n  SerializedStepFlowEntry,\n  SerializedStepOptions,\n  SingleStepEntry,\n  StepFlowEntry,\n} from '../types';\nimport { getSingleStepEntryId } from '../utils';\nimport { mapVariable, predicateToCondition } from '../workflow';\nimport { jsonSchemaToZod } from './json-schema-to-zod';\nimport type { JsonSchema, JsonSchemaToZodOptions } from './json-schema-to-zod';\nimport { parseMapConfig } from './mapping-config';\n\n/** JSON shape persisted to WorkflowDefinitionsStorage. */\nexport interface StoredWorkflowGraph {\n  id: string;\n  description?: string;\n  metadata?: Record<string, unknown>;\n  inputSchema: JsonSchema;\n  outputSchema: JsonSchema;\n  stateSchema?: JsonSchema;\n  requestContextSchema?: JsonSchema;\n  graph: SerializedStepFlowEntry[];\n}\n\n/**\n * Wrapper so the return value isn't recognized as a thenable by `await`.\n * `Workflow` carries a `.then(step)` builder method — returning one directly\n * from an `async` function (or any `await`-ed call) makes the runtime call\n * that builder method as a Promise resolver and the call hangs forever.\n * Always destructure: `const { workflow } = await rehydrateWorkflow(...)`.\n */\nexport interface RehydratedWorkflow {\n  workflow: any;\n}\n\n/**\n * Options controlling how `rehydrateWorkflow` handles unsupported JSON Schema\n * keywords. Forwarded to `jsonSchemaToZod` for every schema on the definition\n * (top-level + per-step `agent.outputSchema`). See `JsonSchemaToZodOptions`.\n */\nexport type RehydrateWorkflowOptions = JsonSchemaToZodOptions;\n\nexport async function rehydrateWorkflow(\n  def: StoredWorkflowGraph,\n  mastra: Mastra,\n  opts?: RehydrateWorkflowOptions,\n): Promise<RehydratedWorkflow> {\n  const inputSchema = jsonSchemaToZod(def.inputSchema, opts);\n  const outputSchema = jsonSchemaToZod(def.outputSchema, opts);\n  const stateSchema = def.stateSchema ? jsonSchemaToZod(def.stateSchema, opts) : undefined;\n  const requestContextSchema = def.requestContextSchema ? jsonSchemaToZod(def.requestContextSchema, opts) : undefined;\n\n  const wf = createWorkflow({\n    id: def.id,\n    description: def.description,\n    metadata: def.metadata,\n    inputSchema: inputSchema as any,\n    outputSchema: outputSchema as any,\n    stateSchema: stateSchema as any,\n    requestContextSchema: requestContextSchema as any,\n  });\n\n  for (const entry of def.graph) {\n    applyGraphEntry(wf, entry, mastra, opts);\n  }\n  const built: any = wf.commit();\n  built.origin = 'stored';\n  return { workflow: built };\n}\n\nfunction applyGraphEntry(\n  wf: any,\n  entry: SerializedStepFlowEntry,\n  mastra: Mastra,\n  schemaOpts?: JsonSchemaToZodOptions,\n): void {\n  switch (entry.type) {\n    case 'agent':\n    case 'tool':\n      wf.__pushStepFlowEntry(rehydrateSingleEntry(entry, mastra, schemaOpts), entry);\n      return;\n    case 'mapping': {\n      const cfg = parseMapConfig(entry.mapConfig, entry.id);\n      const live = rehydrateMapConfig(cfg, mastra);\n      wf.map(live, { id: entry.id });\n      return;\n    }\n    case 'sleep': {\n      if (typeof entry.duration !== 'number') {\n        throw new Error(`Stored sleep \"${entry.id}\" missing literal duration.`);\n      }\n      // Push directly (not wf.sleep()) so the stored step id survives the\n      // round-trip — the builder generates a fresh random id per call.\n      const live: StepFlowEntry = { type: 'sleep', id: entry.id, duration: entry.duration };\n      wf.__pushStepFlowEntry(live, live);\n      return;\n    }\n    case 'sleepUntil': {\n      if (!(entry.date instanceof Date) && typeof entry.date !== 'string') {\n        throw new Error(`Stored sleepUntil \"${entry.id}\" missing literal date.`);\n      }\n      const date = entry.date instanceof Date ? entry.date : new Date(entry.date);\n      if (Number.isNaN(date.getTime())) {\n        throw new Error(`Stored sleepUntil \"${entry.id}\" has an unparseable date: ${String(entry.date)}`);\n      }\n      const live: StepFlowEntry = { type: 'sleepUntil', id: entry.id, date };\n      wf.__pushStepFlowEntry(live, { type: 'sleepUntil', id: entry.id, date });\n      return;\n    }\n    case 'parallel': {\n      const live: StepFlowEntry = {\n        type: 'parallel',\n        steps: entry.steps.map(s => rehydrateSingleEntry(s, mastra, schemaOpts)),\n      };\n      wf.__pushStepFlowEntry(live, entry);\n      return;\n    }\n    case 'foreach': {\n      if (entry.step.type === 'mapping') {\n        throw new Error(\n          `Foreach step cannot iterate a mapping: mappings project data, they don't execute per item. Use an agent, tool, or plain step as the foreach body.`,\n        );\n      }\n      const live: StepFlowEntry = {\n        type: 'foreach',\n        step: rehydrateSingleEntry(entry.step, mastra, schemaOpts),\n        opts: { concurrency: entry.opts?.concurrency ?? 1 },\n      };\n      wf.__pushStepFlowEntry(live, entry);\n      return;\n    }\n    case 'step': {\n      const live = rehydrateSingleEntry(entry, mastra, schemaOpts);\n      wf.__pushStepFlowEntry(live, entry);\n      return;\n    }\n    case 'workflow': {\n      const nested = assertWorkflowExists(mastra, entry.workflowId);\n      // A nested workflow executes as its own `Workflow`, so the engine keys its\n      // result by the workflow's intrinsic id. The portable definition addresses\n      // it by the declared call-site id, which is what mappings, predicates and\n      // `${stepResults...}` templates reference. Clone it under the declared id so\n      // every reference resolves instead of silently falling back to `initData`.\n      wf.then(entry.id && entry.id !== nested.id ? cloneWorkflow(nested as any, { id: entry.id }) : nested);\n      return;\n    }\n    case 'conditional': {\n      const predicates = entry.predicates;\n      if (!predicates || predicates.length !== entry.steps.length || predicates.some(p => !p)) {\n        throw new Error(\n          `Cannot rehydrate conditional step: missing or mismatched predicates. Only declarative predicate branches round-trip.`,\n        );\n      }\n      const steps = entry.steps.map(s => rehydrateSingleEntry(s, mastra, schemaOpts));\n      // Wire graphs may omit the Studio-facing condition labels; derive them\n      // from the predicates (same convention as the fluent builder).\n      const serializedConditions =\n        entry.serializedConditions ??\n        steps.map((s, i) => ({ id: `${getSingleStepEntryId(s)}-condition`, fn: derivePredicateLabel(predicates[i]!) }));\n      const live: StepFlowEntry = {\n        type: 'conditional',\n        steps,\n        conditions: predicates.map(p => predicateToCondition(p!)),\n        serializedConditions,\n        predicates,\n      };\n      wf.__pushStepFlowEntry(live, { ...entry, serializedConditions });\n      return;\n    }\n    case 'loop': {\n      const { predicate, loopType } = entry;\n      if (!predicate || (loopType !== 'dowhile' && loopType !== 'dountil')) {\n        throw new Error(\n          `Cannot rehydrate loop step: missing declarative predicate or loopType. Only declarative predicate loops round-trip.`,\n        );\n      }\n      const step = rehydrateSingleEntry(entry.step, mastra, schemaOpts);\n      const serializedCondition = entry.serializedCondition ?? {\n        id: `${getSingleStepEntryId(step)}-condition`,\n        fn: derivePredicateLabel(predicate),\n      };\n      const live: StepFlowEntry = {\n        type: 'loop',\n        step,\n        condition: predicateToCondition(predicate),\n        loopType,\n        serializedCondition,\n        predicate,\n      };\n      wf.__pushStepFlowEntry(live, { ...entry, serializedCondition });\n      return;\n    }\n    default: {\n      const _exhaustive: never = entry;\n      throw new Error(`Unknown stored step type: ${JSON.stringify(_exhaustive)}`);\n    }\n  }\n}\n\n/**\n * Reconstruct the options bag `.agent()` accepts from a serialized entry.\n * Restores `structuredOutput.schema` from `outputSchema` (JSON Schema → Zod)\n * and merges in `retries` / `metadata`. Returns `undefined` when nothing to\n * restore so `.agent(agentId)` stays a clean call.\n */\nfunction rebuildAgentOptions(\n  entry: {\n    outputSchema?: Record<string, any>;\n    options?: SerializedStepOptions;\n  },\n  schemaOpts?: JsonSchemaToZodOptions,\n): Record<string, any> | undefined {\n  const opts: Record<string, any> = {};\n  if (entry.outputSchema) {\n    opts.structuredOutput = { schema: jsonSchemaToZod(entry.outputSchema, schemaOpts) };\n  }\n  if (entry.options?.retries !== undefined) opts.retries = entry.options.retries;\n  if (entry.options?.metadata !== undefined) opts.metadata = entry.options.metadata;\n  return Object.keys(opts).length > 0 ? opts : undefined;\n}\n\nfunction rebuildToolOptions(entry: { options?: SerializedStepOptions }): Record<string, any> | undefined {\n  const opts: Record<string, any> = {};\n  if (entry.options?.retries !== undefined) opts.retries = entry.options.retries;\n  if (entry.options?.metadata !== undefined) opts.metadata = entry.options.metadata;\n  return Object.keys(opts).length > 0 ? opts : undefined;\n}\n\n/**\n * Build the live `SingleStepEntry` for a stored entry. Declarative agent/tool\n * entries stay declarative — both engines interpret them per-kind at\n * execution time (`runAgentEntry` / `runToolEntry`) — so no fake `Step`\n * wrapper is needed and the stored `id` / `outputSchema` / `retries` /\n * `metadata` round-trip losslessly in every position (top-level, parallel,\n * branch, foreach and loop bodies).\n *\n * `step` descriptors resolve agent-then-tool by id against the live Mastra\n * instance; `workflow` entries resolve the registered instance. Both become\n * plain `{ type: 'step' }` entries, same as the fluent builder emits.\n */\nfunction rehydrateSingleEntry(\n  entry: SerializedSingleStepEntry,\n  mastra: Mastra,\n  schemaOpts?: JsonSchemaToZodOptions,\n): SingleStepEntry {\n  switch (entry.type) {\n    case 'agent': {\n      const agent = tryGetAgentById(mastra, entry.agentId);\n      if (!agent) {\n        throw new Error(\n          `Stored workflow references agent \"${entry.agentId}\" which is not registered on this Mastra instance.`,\n        );\n      }\n      return {\n        type: 'agent',\n        id: entry.id,\n        agentId: entry.agentId,\n        agent,\n        options: rebuildAgentOptions(entry, schemaOpts),\n      };\n    }\n    case 'tool': {\n      const tool = mastra.getTool?.(entry.toolId);\n      if (!tool) {\n        throw new Error(\n          `Stored workflow references tool \"${entry.toolId}\" which is not registered on this Mastra instance.`,\n        );\n      }\n      return { type: 'tool', id: entry.id, toolId: entry.toolId, tool, options: rebuildToolOptions(entry) };\n    }\n    case 'step': {\n      const { id } = entry.step;\n      // Wrap the resolved agent/tool in a real Step (same adapters `createStep`\n      // uses) so the entry honors the executeStep contract instead of casting a\n      // raw Agent/Tool instance — those don't carry a step-shaped `execute`.\n      const agent = tryGetAgentById(mastra, id);\n      if (agent) {\n        return { type: 'step', step: createStepFromAgent(agent) as unknown as Step };\n      }\n      const tool = tryGetToolById(mastra, id);\n      if (tool) {\n        return { type: 'step', step: createStepFromTool(tool as any) as unknown as Step };\n      }\n      throw new Error(\n        `Stored workflow references step \"${id}\" which is not registered as an agent or tool on this Mastra instance.`,\n      );\n    }\n    case 'workflow': {\n      const nested = assertWorkflowExists(mastra, entry.workflowId);\n      // Same call-site identity rule as top-level nested workflows: run the\n      // clone under the declared id so results are keyed the way the portable\n      // definition addresses them.\n      const step = entry.id && entry.id !== nested.id ? cloneWorkflow(nested as any, { id: entry.id }) : nested;\n      return { type: 'step', step: step as unknown as Step };\n    }\n    case 'mapping':\n      throw new Error(\n        `mapping entries cannot appear inside .parallel(), .branch(), or .foreach(); they must be top-level.`,\n      );\n  }\n}\n\n/**\n * Rebuild the object shape that `.map()` accepts. Step sources remain workflow-local\n * step IDs because mapping execution resolves them from the run's step results.\n */\nfunction rehydrateMapConfig(cfg: Record<string, any>, mastra: Mastra): Record<string, any> {\n  const out: Record<string, any> = {};\n  for (const [key, source] of Object.entries(cfg)) {\n    if (!source || typeof source !== 'object') {\n      out[key] = source;\n      continue;\n    }\n    if ('template' in source) {\n      out[key] = { template: source.template };\n    } else if ('value' in source) {\n      out[key] = { value: source.value };\n    } else if ('requestContextPath' in source) {\n      out[key] = { requestContextPath: source.requestContextPath };\n    } else if ('initData' in source && typeof source.initData === 'string') {\n      const wf = mastra.getWorkflow?.(source.initData);\n      if (!wf) {\n        throw new Error(`Mapping references unknown workflow init-data \"${source.initData}\".`);\n      }\n      out[key] = mapVariable({ initData: wf as any, path: source.path });\n    } else if ('step' in source) {\n      out[key] = mapVariable({ step: source.step as any, path: source.path });\n    } else {\n      out[key] = source;\n    }\n  }\n  return out;\n}\n\n/**\n * Mastra.getAgentById throws when the id isn't registered; every by-id\n * resolution path in this file wants a nullable \"does it exist?\" answer so it\n * can fall through to a tool lookup or a targeted error. Swallow the not-found\n * throw and return undefined.\n */\nfunction tryGetAgentById(mastra: Mastra, id: string): any | undefined {\n  if (!id || typeof mastra.getAgentById !== 'function') return undefined;\n  try {\n    return mastra.getAgentById(id);\n  } catch {\n    return undefined;\n  }\n}\n\n/** Same nullable-lookup contract as `tryGetAgentById`, for tools — `Mastra.getTool` throws on a missing id. */\nfunction tryGetToolById(mastra: Mastra, id: string): any | undefined {\n  if (!id || typeof mastra.getTool !== 'function') return undefined;\n  try {\n    return mastra.getTool(id);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Workflow references resolve like agent references: intrinsic workflow id\n * first (`getWorkflowById` scans registered workflows by their own `id`),\n * falling back to the registration key. Stored definitions reference the\n * intrinsic id — the identity discovery advertises — which may differ from\n * the key the workflow was registered under (`workflows: { greetingWorkflow }`\n * vs `id: 'greeting-workflow'`).\n */\nfunction tryGetWorkflowById(mastra: Mastra, id: string): any | undefined {\n  if (!id) return undefined;\n  if (typeof (mastra as any).getWorkflowById === 'function') {\n    try {\n      return (mastra as any).getWorkflowById(id);\n    } catch {\n      // fall through to registration-key lookup\n    }\n  }\n  if (typeof (mastra as any).getWorkflow !== 'function') return undefined;\n  try {\n    return (mastra as any).getWorkflow(id);\n  } catch {\n    return undefined;\n  }\n}\n\nfunction assertWorkflowExists(mastra: Mastra, workflowId: string): any {\n  const wf = tryGetWorkflowById(mastra, workflowId);\n  if (!wf) {\n    throw new Error(\n      `Stored workflow references nested workflow \"${workflowId}\" which is not registered on this Mastra instance.`,\n    );\n  }\n  return wf;\n}\n","/**\n * Shared typed walker over a serialized workflow graph. Every consumer that\n * needs \"all the leaf entries in this graph\" (schema validation, reference\n * validation, nested-workflow dependency collection) goes through this one\n * function, so recursion into container entries lives in exactly one place\n * and is exhaustiveness-checked against `SerializedStepFlowEntry`.\n */\nimport type { SerializedSingleStepEntry, SerializedStepFlowEntry } from '../types';\nimport type { ValidatableStepFlowEntry } from './validate/types';\n\n/**\n * Invoke `visit` for every single-step (leaf) entry in the graph, recursing\n * into `parallel`/`conditional` children and `loop`/`foreach` bodies.\n *\n * Does NOT recurse into a nested workflow's inlined `serializedStepFlow` —\n * a nested workflow's own graph is validated when that workflow is added.\n * `sleep`/`sleepUntil` entries carry no references or schemas and are skipped.\n */\nexport function forEachSingleStepEntry(\n  entries: readonly SerializedStepFlowEntry[],\n  visit: (entry: SerializedSingleStepEntry) => void,\n): void {\n  for (const entry of entries) {\n    switch (entry.type) {\n      case 'step':\n      case 'agent':\n      case 'tool':\n      case 'mapping':\n      case 'workflow':\n        visit(entry);\n        break;\n      case 'parallel':\n      case 'conditional':\n        entry.steps.forEach(visit);\n        break;\n      case 'loop':\n      case 'foreach':\n        visit(entry.step);\n        break;\n      case 'sleep':\n      case 'sleepUntil':\n        break;\n      default: {\n        const _exhaustive: never = entry;\n        void _exhaustive;\n      }\n    }\n  }\n}\n\n/**\n * Collect the ids of every nested workflow referenced by a stored graph.\n * Used by boot-time loading to hydrate stored definitions in dependency order.\n */\nexport function collectNestedWorkflowIds(graph: readonly SerializedStepFlowEntry[]): Set<string> {\n  const out = new Set<string>();\n  forEachSingleStepEntry(graph, entry => {\n    if (entry.type === 'workflow') out.add(entry.workflowId);\n  });\n  return out;\n}\n\n/**\n * Same traversal as {@link forEachSingleStepEntry} but reports each leaf's\n * position as a dotted path (`graph.2`, `graph.2.steps.0`, `graph.2.step`) —\n * the path contract shared by validation issues and the Studio draft UI.\n *\n * Accepts the wider {@link ValidatableStepFlowEntry} union so both persisted\n * graphs and wire-shaped authoring submissions can be walked.\n */\nexport function forEachSingleStepEntryWithPath(\n  entries: readonly ValidatableStepFlowEntry[],\n  visit: (entry: SerializedSingleStepEntry, path: string) => void,\n): void {\n  entries.forEach((entry, index) => {\n    const path = `graph.${index}`;\n    switch (entry.type) {\n      case 'step':\n      case 'agent':\n      case 'tool':\n      case 'mapping':\n      case 'workflow':\n        visit(entry, path);\n        break;\n      case 'parallel':\n      case 'conditional':\n        entry.steps.forEach((child, childIndex) => visit(child, `${path}.steps.${childIndex}`));\n        break;\n      case 'loop':\n      case 'foreach':\n        visit(entry.step, `${path}.step`);\n        break;\n      case 'sleep':\n      case 'sleepUntil':\n        break;\n      default: {\n        const _exhaustive: never = entry;\n        void _exhaustive;\n      }\n    }\n  });\n}\n","/**\n * Reference checks against a caller-supplied registry index.\n *\n * Checks are gated per kind: a kind whose key is absent from the index is\n * skipped entirely, so callers that cannot enumerate (say) workflows never\n * produce false missing-reference issues. Mis-classified references get swap\n * hints (agent id that is actually a registered tool, and vice versa).\n *\n * `type: 'step'` descriptors are intentionally not checked — they resolve\n * late against the live Mastra instance at rehydration time.\n */\nimport { forEachSingleStepEntryWithPath } from '../graph';\nimport type { WorkflowRegistryIndex, WorkflowValidationInput, WorkflowValidationIssue } from './types';\n\nexport function validateWorkflowRefs(\n  def: WorkflowValidationInput,\n  index: WorkflowRegistryIndex,\n): WorkflowValidationIssue[] {\n  const issues: WorkflowValidationIssue[] = [];\n  forEachSingleStepEntryWithPath(def.graph, (entry, path) => {\n    switch (entry.type) {\n      case 'agent': {\n        if (!index.agents || index.agents[entry.agentId]) return;\n        issues.push({\n          code: 'missing-reference',\n          path: `${path}.agentId`,\n          message: index.tools?.[entry.agentId]\n            ? `Step \"${entry.id}\" declares { type: \"agent\", agentId: \"${entry.agentId}\" } but \"${entry.agentId}\" is a registered TOOL, not an agent. Change this entry to { type: \"tool\", toolId: \"${entry.agentId}\" }.`\n            : `Step \"${entry.id}\" declares agentId \"${entry.agentId}\" which is not a registered agent.`,\n        });\n        return;\n      }\n      case 'tool': {\n        if (!index.tools || index.tools[entry.toolId]) return;\n        issues.push({\n          code: 'missing-reference',\n          path: `${path}.toolId`,\n          message: index.agents?.[entry.toolId]\n            ? `Step \"${entry.id}\" declares { type: \"tool\", toolId: \"${entry.toolId}\" } but \"${entry.toolId}\" is a registered AGENT, not a tool. Change this entry to { type: \"agent\", agentId: \"${entry.toolId}\" }.`\n            : `Step \"${entry.id}\" declares toolId \"${entry.toolId}\" which is not a registered tool.`,\n        });\n        return;\n      }\n      case 'workflow': {\n        // Self-references are a structural issue (`self-reference`), and the\n        // registry may well contain a previous version of this very workflow\n        // on upsert — skip the existence check for them.\n        if (entry.workflowId === def.id) return;\n        if (!index.workflows || index.workflows[entry.workflowId]) return;\n        issues.push({\n          code: 'missing-reference',\n          path: `${path}.workflowId`,\n          message: `Step \"${entry.id}\" declares workflowId \"${entry.workflowId}\" which is not a registered workflow.`,\n        });\n        return;\n      }\n      default:\n        return;\n    }\n  });\n  return issues;\n}\n","/**\n * Shared vocabulary for the one stored-workflow validation domain.\n *\n * Every validation surface (Mastra save path, builder preflight, Studio draft\n * UI) speaks in `WorkflowValidationIssue`s produced by the collect-mode core\n * in `./index`. Throwing behavior is a presentation concern layered on top\n * (`assertValidStoredWorkflow`), not a separate rule set.\n */\nimport type { Predicate } from '../../predicate';\nimport type { SerializedSingleStepEntry, SerializedStepFlowEntry } from '../../types';\nimport type { JsonSchema } from '../json-schema-to-zod';\n\nexport type WorkflowValidationIssueCode =\n  | 'empty-graph'\n  | 'missing-step-id'\n  | 'duplicate-step-id'\n  | 'missing-reference'\n  | 'invalid-nested-workflow-id'\n  | 'invalid-map-config'\n  | 'invalid-map-reference'\n  | 'invalid-map-placement'\n  | 'invalid-parallel'\n  | 'invalid-foreach'\n  | 'invalid-conditional'\n  | 'invalid-loop'\n  | 'invalid-predicate-reference'\n  | 'incompatible-schema'\n  | 'unsupported-schema-keyword'\n  | 'self-reference';\n\nexport interface WorkflowValidationRepairSource {\n  source: { initData: true; path: string } | { step: string; path: string };\n  schema?: JsonSchema;\n  compatibility: 'compatible' | 'incompatible' | 'unknown';\n}\n\nexport interface WorkflowValidationRepairAction {\n  issueCode: WorkflowValidationIssueCode;\n  path: string;\n  entryId?: string;\n  containerId?: string;\n  childId?: string;\n  destinationField?: string;\n  expectedSchema?: JsonSchema;\n  actualSchema?: JsonSchema;\n  legalSources?: WorkflowValidationRepairSource[];\n  operation:\n    | 'insert-workflow-mapping-before'\n    | 'insert-workflow-mapping-after'\n    | 'set-workflow-mapping-source'\n    | 'set-workflow-predicate'\n    | 'update-workflow-step'\n    | 'remove-workflow-step';\n  arguments: Record<string, string | number | boolean>;\n  blocksCheckpoint: boolean;\n  blocksFinalize: boolean;\n}\n\nexport interface WorkflowValidationIssue {\n  code: WorkflowValidationIssueCode;\n  path: string;\n  message: string;\n  repair?: WorkflowValidationRepairAction;\n}\n\n/** Input/output shapes known for one registered dependency. */\nexport interface WorkflowRegistrySchemas {\n  inputSchema?: JsonSchema;\n  outputSchema?: JsonSchema;\n}\n\n/**\n * What the validator knows about the surrounding registries. Presence of a\n * top-level key means \"this kind was indexed, check references against it\";\n * an absent key skips reference checks for that kind (a caller that cannot\n * enumerate, say, workflows must not produce false missing-reference issues).\n * Schemas are optional per entry — when present they power schema-flow\n * analysis, when absent compatibility degrades to `unknown` (never a false\n * incompatibility).\n */\nexport interface WorkflowRegistryIndex {\n  agents?: Record<string, WorkflowRegistrySchemas>;\n  tools?: Record<string, WorkflowRegistrySchemas>;\n  workflows?: Record<string, WorkflowRegistrySchemas>;\n}\n\n/**\n * The graph-entry union validation accepts: the canonical serialized union,\n * widened only where the wire legitimately diverges from the fluent\n * serializer's output —\n *  - `sleepUntil.date` arrives as an ISO string over HTTP (Date at runtime)\n *  - `serializedConditions` / `serializedCondition` are fluent-builder debug\n *    labels; clients don't send them (rehydration derives them)\n *\n * `SerializedStepFlowEntry` is assignable to this union, and so is the\n * authoring subset (`WorkflowBuilderGraphEntry`) — asserted statically in\n * `workflows/builder`.\n */\nexport type ValidatableStepFlowEntry =\n  | SerializedSingleStepEntry\n  | Extract<SerializedStepFlowEntry, { type: 'sleep' }>\n  | (Omit<Extract<SerializedStepFlowEntry, { type: 'sleepUntil' }>, 'date'> & { date?: Date | string })\n  | Extract<SerializedStepFlowEntry, { type: 'parallel' }>\n  | (Omit<Extract<SerializedStepFlowEntry, { type: 'conditional' }>, 'serializedConditions'> & {\n      serializedConditions?: { id: string; fn: string }[];\n    })\n  | (Omit<Extract<SerializedStepFlowEntry, { type: 'loop' }>, 'serializedCondition'> & {\n      serializedCondition?: { id: string; fn: string };\n      predicate?: Predicate;\n    })\n  | Extract<SerializedStepFlowEntry, { type: 'foreach' }>;\n\n/**\n * The definition shape validation operates on — the common structural core of\n * `StoredWorkflowGraph` (persistence) and `WorkflowBuilderDefinition`\n * (authoring wire shape).\n */\nexport interface WorkflowValidationInput {\n  id: string;\n  description?: string;\n  inputSchema: JsonSchema;\n  outputSchema: JsonSchema;\n  stateSchema?: JsonSchema;\n  requestContextSchema?: JsonSchema;\n  graph: readonly ValidatableStepFlowEntry[];\n}\n\n/** Step id of a single-step (leaf) entry; `step` descriptors carry theirs nested. */\nexport function leafEntryId(entry: SerializedSingleStepEntry): string | undefined {\n  return entry.type === 'step' ? entry.step.id : entry.id;\n}\n","import type { SerializedSingleStepEntry } from '../../types';\nimport type { JsonSchema } from '../json-schema-to-zod';\nimport { schemaCompatibility } from './schema-utils';\nimport { leafEntryId } from './types';\nimport type {\n  WorkflowRegistryIndex,\n  WorkflowValidationInput,\n  WorkflowValidationIssue,\n  WorkflowValidationRepairAction,\n  WorkflowValidationRepairSource,\n} from './types';\n\nfunction inputSchemaOf(entry: SerializedSingleStepEntry, index: WorkflowRegistryIndex): JsonSchema | undefined {\n  switch (entry.type) {\n    case 'agent':\n      return (\n        index.agents?.[entry.agentId]?.inputSchema ?? {\n          type: 'object',\n          properties: { prompt: { type: 'string' } },\n          required: ['prompt'],\n        }\n      );\n    case 'tool':\n      return index.tools?.[entry.toolId]?.inputSchema;\n    case 'workflow':\n      return index.workflows?.[entry.workflowId]?.inputSchema;\n    case 'mapping':\n    case 'step':\n      return undefined;\n  }\n}\n\nfunction entryAtPath(def: WorkflowValidationInput, path: string): SerializedSingleStepEntry | undefined {\n  const match = /^graph\\.(\\d+)(?:\\.(steps)\\.(\\d+)|\\.(step))?/.exec(path);\n  if (!match) return undefined;\n  const entry = def.graph[Number(match[1])];\n  if (!entry) return undefined;\n  if (match[2] === 'steps' && (entry.type === 'parallel' || entry.type === 'conditional')) {\n    return entry.steps[Number(match[3])];\n  }\n  if (match[4] === 'step' && (entry.type === 'foreach' || entry.type === 'loop')) return entry.step;\n  if (\n    entry.type === 'agent' ||\n    entry.type === 'tool' ||\n    entry.type === 'workflow' ||\n    entry.type === 'mapping' ||\n    entry.type === 'step'\n  ) {\n    return entry;\n  }\n  return undefined;\n}\n\nfunction precedingSourceIds(def: WorkflowValidationInput, targetIndex: number): string[] {\n  const ids: string[] = [];\n  def.graph.slice(0, targetIndex).forEach(entry => {\n    if (entry.type === 'parallel' || entry.type === 'conditional') {\n      entry.steps.forEach(child => {\n        const childId = leafEntryId(child);\n        if (childId) ids.push(childId);\n      });\n    } else if (entry.type === 'foreach' || entry.type === 'loop') {\n      const childId = leafEntryId(entry.step);\n      if (childId) ids.push(childId);\n    }\n    // Container entries (parallel/conditional/foreach/loop) never produce a\n    // result keyed by their own id — only their executed children do. Advertising\n    // the container id here previously sent authors toward mappings that pass\n    // draft validation and then fail at run time.\n    if (entry.type === 'parallel' || entry.type === 'conditional' || entry.type === 'foreach' || entry.type === 'loop')\n      return;\n    const id = 'id' in entry && entry.id ? entry.id : entry.type === 'step' ? entry.step.id : undefined;\n    if (id) ids.push(id);\n  });\n  return ids;\n}\n\nfunction legalSources(\n  def: WorkflowValidationInput,\n  targetIndex: number,\n  expectedSchema: JsonSchema | undefined,\n  stepOutputs: Map<string, JsonSchema | undefined>,\n): WorkflowValidationRepairSource[] {\n  const sources: WorkflowValidationRepairSource[] = [\n    {\n      source: { initData: true, path: '' },\n      schema: def.inputSchema,\n      compatibility: schemaCompatibility(def.inputSchema, expectedSchema),\n    },\n    ...precedingSourceIds(def, targetIndex).map(stepId => {\n      const schema = stepOutputs.get(stepId);\n      return {\n        source: { step: stepId, path: '' } as const,\n        ...(schema ? { schema } : {}),\n        compatibility: schemaCompatibility(schema, expectedSchema),\n      };\n    }),\n  ];\n  return sources.filter(source => source.compatibility !== 'incompatible');\n}\n\nexport function addWorkflowValidationRepairActions(\n  def: WorkflowValidationInput,\n  index: WorkflowRegistryIndex,\n  issues: WorkflowValidationIssue[],\n  stepOutputs: Map<string, JsonSchema | undefined>,\n  entryInputs: Map<string, JsonSchema | undefined>,\n  finalOutput: JsonSchema | undefined,\n): WorkflowValidationIssue[] {\n  return issues.map(issue => {\n    const graphMatch = /^graph\\.(\\d+)/.exec(issue.path);\n    const targetIndex = graphMatch ? Number(graphMatch[1]) : def.graph.length;\n    const entry = entryAtPath(def, issue.path);\n    const entryId = entry ? leafEntryId(entry) : undefined;\n    let repair: WorkflowValidationRepairAction | undefined;\n\n    if (issue.code === 'incompatible-schema') {\n      // A foreach consumes a RAW ARRAY of its child's input, so the useful\n      // \"expected\" shape is the iterable — not the child input, and definitely\n      // not the workflow output schema the container path used to fall back to.\n      const containerEntry = graphMatch ? def.graph[targetIndex] : undefined;\n      const foreachChildInput =\n        containerEntry?.type === 'foreach' ? inputSchemaOf(containerEntry.step, index) : undefined;\n      const expectedSchema =\n        containerEntry?.type === 'foreach'\n          ? ({ type: 'array', ...(foreachChildInput ? { items: foreachChildInput } : {}) } as JsonSchema)\n          : entry\n            ? inputSchemaOf(entry, index)\n            : def.outputSchema;\n      const actualSchema =\n        issue.path === 'outputSchema'\n          ? finalOutput\n          : (entryInputs.get(issue.path) ?? (targetIndex === 0 ? def.inputSchema : undefined));\n      repair = {\n        issueCode: issue.code,\n        path: issue.path,\n        ...(entryId ? { entryId } : {}),\n        ...(expectedSchema ? { expectedSchema } : {}),\n        ...(actualSchema ? { actualSchema } : {}),\n        legalSources: legalSources(def, targetIndex, expectedSchema, stepOutputs),\n        // A foreach consumes a raw array, and mappings always emit an object —\n        // inserting a mapping can never satisfy it. Advertise fixing the\n        // upstream producer (or the foreach body) instead.\n        operation:\n          containerEntry?.type === 'foreach'\n            ? 'update-workflow-step'\n            : issue.path === 'outputSchema'\n              ? 'insert-workflow-mapping-after'\n              : 'insert-workflow-mapping-before',\n        arguments: entryId ? { targetStepId: entryId } : { targetPath: issue.path },\n        blocksCheckpoint: false,\n        blocksFinalize: true,\n      };\n    } else if (issue.code === 'invalid-map-config' || issue.code === 'invalid-map-reference') {\n      const destinationField = /\\.mapConfig\\.([^\\.]+)/.exec(issue.path)?.[1];\n      repair = {\n        issueCode: issue.code,\n        path: issue.path,\n        ...(entryId ? { entryId } : {}),\n        ...(destinationField ? { destinationField } : {}),\n        legalSources: legalSources(def, targetIndex, undefined, stepOutputs),\n        operation: 'set-workflow-mapping-source',\n        arguments: {\n          ...(entryId ? { mappingStepId: entryId } : {}),\n          ...(destinationField ? { field: destinationField } : {}),\n        },\n        blocksCheckpoint: false,\n        blocksFinalize: true,\n      };\n    } else if (issue.code === 'invalid-predicate-reference') {\n      repair = {\n        issueCode: issue.code,\n        path: issue.path,\n        ...(entryId ? { childId: entryId } : {}),\n        operation: 'set-workflow-predicate',\n        arguments: { predicatePath: issue.path },\n        blocksCheckpoint: false,\n        blocksFinalize: true,\n      };\n    } else if (issue.code === 'missing-reference') {\n      repair = {\n        issueCode: issue.code,\n        path: issue.path,\n        ...(entryId ? { entryId } : {}),\n        operation: 'update-workflow-step',\n        arguments: entryId ? { stepId: entryId } : { targetPath: issue.path },\n        blocksCheckpoint: false,\n        blocksFinalize: true,\n      };\n    } else if (issue.code === 'invalid-map-placement') {\n      repair = {\n        issueCode: issue.code,\n        path: issue.path,\n        ...(entryId ? { childId: entryId } : {}),\n        operation: 'remove-workflow-step',\n        arguments: entryId ? { stepId: entryId } : { targetPath: issue.path },\n        blocksCheckpoint: false,\n        blocksFinalize: true,\n      };\n    }\n\n    return repair ? { ...issue, repair } : issue;\n  });\n}\n","/**\n * Schema-flow analysis: a small type-checker over the workflow graph.\n *\n * Folds an inferred \"current schema\" through the top-level entries — each\n * step's output feeds the next step's input — and reports a proven mismatch\n * as `incompatible-schema`. Mapping configs are analyzed here (via\n * `mapping-config.ts`) because a mapping's validity and its output schema are\n * inseparable. Unknown schemas degrade to `undefined` and never produce false\n * positives.\n *\n * Unlike the old preflight implementation, state is threaded explicitly:\n * `fold` takes the incoming schema and returns the outgoing one — no\n * closure-mutable `currentSchema` with save/restore tricks.\n */\nimport type { PathOrLiteral, Predicate } from '../../predicate';\nimport type { SerializedSingleStepEntry } from '../../types';\nimport type { JsonSchema } from '../json-schema-to-zod';\nimport { analyzeMapConfig } from '../mapping-config';\nimport { isCanonicalMappingPath, isRecord, schemaAtPath, schemaCompatibility } from './schema-utils';\nimport { leafEntryId } from './types';\nimport type { WorkflowRegistryIndex, WorkflowValidationInput, WorkflowValidationIssue } from './types';\n\nexport interface GraphSchemaInference {\n  /** Output schema of each runtime-visible step id (undefined = unknown). */\n  stepOutputs: Map<string, JsonSchema | undefined>;\n  /** Input schema reaching each evaluated graph path (undefined = unknown). */\n  entryInputs: Map<string, JsonSchema | undefined>;\n  /** Inferred output of the last entry in the graph (undefined = unknown). */\n  finalOutput: JsonSchema | undefined;\n  issues: WorkflowValidationIssue[];\n}\n\n/** Agents accept `{ prompt }` unless the registry says otherwise. */\nconst agentInputSchema: JsonSchema = {\n  type: 'object',\n  properties: { prompt: { type: 'string' } },\n  required: ['prompt'],\n};\n\n/**\n * An agent entry without declared structured output returns exactly\n * `{ text }` at runtime (`runAgentEntry`), so invented output paths like\n * `.response` are provably wrong rather than unknown.\n */\nconst agentTextOutputSchema: JsonSchema = {\n  type: 'object',\n  properties: { text: { type: 'string' } },\n  required: ['text'],\n};\n\nfunction inputSchemaOf(entry: SerializedSingleStepEntry, index: WorkflowRegistryIndex): JsonSchema | undefined {\n  switch (entry.type) {\n    case 'agent':\n      return index.agents?.[entry.agentId]?.inputSchema ?? agentInputSchema;\n    case 'tool':\n      return index.tools?.[entry.toolId]?.inputSchema;\n    case 'workflow':\n      return index.workflows?.[entry.workflowId]?.inputSchema;\n    case 'mapping':\n    case 'step':\n      return undefined;\n  }\n}\n\nfunction outputSchemaOf(entry: SerializedSingleStepEntry, index: WorkflowRegistryIndex): JsonSchema | undefined {\n  switch (entry.type) {\n    case 'agent':\n      return entry.outputSchema ?? index.agents?.[entry.agentId]?.outputSchema ?? agentTextOutputSchema;\n    case 'tool':\n      return index.tools?.[entry.toolId]?.outputSchema;\n    case 'workflow':\n      return index.workflows?.[entry.workflowId]?.outputSchema;\n    case 'mapping':\n    case 'step':\n      return undefined;\n  }\n}\n\nfunction validatePredicate(\n  predicate: Predicate,\n  path: string,\n  context: {\n    initData: JsonSchema;\n    inputData: JsonSchema | undefined;\n    state: JsonSchema | undefined;\n    stepResults: Map<string, JsonSchema | undefined>;\n  },\n): WorkflowValidationIssue[] {\n  const issues: WorkflowValidationIssue[] = [];\n\n  const validatePath = (rawPath: string, issuePath: string) => {\n    if (!isCanonicalMappingPath(rawPath)) {\n      issues.push({\n        code: 'invalid-predicate-reference',\n        path: issuePath,\n        message: 'Predicate paths must use plain dotted segments rooted at initData, inputData, stepResults, or state.',\n      });\n      return;\n    }\n\n    const [root, ...segments] = rawPath.split('.');\n    let schema: JsonSchema | undefined;\n    let schemaPath = segments.join('.');\n    if (root === 'initData') schema = context.initData;\n    else if (root === 'inputData') schema = context.inputData;\n    else if (root === 'state') schema = context.state;\n    else if (root === 'stepResults') {\n      const stepId = segments.shift();\n      if (!stepId || !context.stepResults.has(stepId)) {\n        issues.push({\n          code: 'invalid-predicate-reference',\n          path: issuePath,\n          message: stepId\n            ? `Predicate step result \"${stepId}\" must reference a preceding top-level step.`\n            : 'Predicate stepResults paths must include a preceding top-level step id.',\n        });\n        return;\n      }\n      schema = context.stepResults.get(stepId);\n      schemaPath = segments.join('.');\n    } else {\n      issues.push({\n        code: 'invalid-predicate-reference',\n        path: issuePath,\n        message: 'Predicate paths must be rooted at initData, inputData, stepResults, or state.',\n      });\n      return;\n    }\n\n    if (schemaPath && isRecord(schema) && typeof schema.type === 'string' && !schemaAtPath(schema, schemaPath)) {\n      issues.push({\n        code: 'invalid-predicate-reference',\n        path: issuePath,\n        message: `Predicate path \"${rawPath}\" does not exist in the known schema.`,\n      });\n    }\n  };\n\n  const validateRef = (ref: PathOrLiteral, refPath: string) => {\n    if ('path' in ref) validatePath(ref.path, `${refPath}.path`);\n  };\n\n  switch (predicate.op) {\n    case 'and':\n    case 'or':\n      predicate.args.forEach((arg, index) => issues.push(...validatePredicate(arg, `${path}.args.${index}`, context)));\n      break;\n    case 'not':\n      issues.push(...validatePredicate(predicate.arg, `${path}.arg`, context));\n      break;\n    case 'exists':\n    case 'notExists':\n      validatePath(predicate.path, `${path}.path`);\n      break;\n    case 'truthy':\n    case 'falsy':\n      validateRef(predicate.value, `${path}.value`);\n      break;\n    case 'in':\n    case 'notIn':\n      validateRef(predicate.value, `${path}.value`);\n      break;\n    default:\n      validateRef(predicate.left, `${path}.left`);\n      validateRef(predicate.right, `${path}.right`);\n  }\n\n  return issues;\n}\n\nexport function inferGraphSchemas(def: WorkflowValidationInput, index: WorkflowRegistryIndex): GraphSchemaInference {\n  const issues: WorkflowValidationIssue[] = [];\n  const stepOutputs = new Map<string, JsonSchema | undefined>();\n  const entryInputs = new Map<string, JsonSchema | undefined>();\n\n  /** Evaluates one leaf entry: checks its input against `incoming`, returns its output. */\n  const evalLeaf = (\n    entry: SerializedSingleStepEntry,\n    path: string,\n    incoming: JsonSchema | undefined,\n    container: boolean,\n  ): JsonSchema | undefined => {\n    entryInputs.set(path, incoming);\n    if (entry.type === 'mapping') {\n      // Container placement is a structural issue; don't analyze the config twice.\n      if (container) return undefined;\n      const analysis = analyzeMapConfig(entry.mapConfig, {\n        path,\n        availableOutputs: stepOutputs,\n        inputSchema: def.inputSchema,\n        requestContextSchema: def.requestContextSchema,\n      });\n      issues.push(...analysis.issues);\n      return analysis.outputSchema;\n    }\n    if (entry.type === 'step') return undefined;\n    if (schemaCompatibility(incoming, inputSchemaOf(entry, index)) === 'incompatible') {\n      issues.push({\n        code: 'incompatible-schema',\n        path,\n        message: 'Step input is incompatible with the preceding workflow output.',\n      });\n    }\n    return outputSchemaOf(entry, index);\n  };\n\n  let current: JsonSchema | undefined = def.inputSchema;\n  def.graph.forEach((entry, entryIndex) => {\n    const path = `graph.${entryIndex}`;\n    switch (entry.type) {\n      case 'step':\n      case 'agent':\n      case 'tool':\n      case 'mapping':\n      case 'workflow':\n        current = evalLeaf(entry, path, current, false);\n        break;\n      case 'sleep':\n      case 'sleepUntil':\n        // Passthrough: sleeping does not reshape the data.\n        break;\n      case 'parallel':\n      case 'conditional': {\n        const incoming = current;\n        if (entry.type === 'conditional') {\n          entry.predicates?.forEach((predicate, predicateIndex) => {\n            if (!predicate) return;\n            issues.push(\n              ...validatePredicate(predicate, `${path}.predicates.${predicateIndex}`, {\n                initData: def.inputSchema,\n                inputData: incoming,\n                state: def.stateSchema,\n                stepResults: stepOutputs,\n              }),\n            );\n          });\n        }\n        const properties: Record<string, JsonSchema> = {};\n        entry.steps.forEach((child, childIndex) => {\n          const output = evalLeaf(child, `${path}.steps.${childIndex}`, incoming, true);\n          const childId = leafEntryId(child);\n          if (childId) {\n            stepOutputs.set(childId, output);\n            if (output) properties[childId] = output;\n          }\n        });\n        current = {\n          type: 'object',\n          properties,\n          ...(entry.type === 'parallel' ? { required: Object.keys(properties) } : {}),\n        };\n        break;\n      }\n      case 'foreach': {\n        const incoming = current;\n        if (isRecord(incoming) && typeof incoming.type === 'string' && incoming.type !== 'array') {\n          issues.push({\n            code: 'incompatible-schema',\n            path,\n            message:\n              'Foreach input must be a raw array. A mapping step cannot produce one — mappings always build an object — so the preceding step (or the workflow inputSchema itself) must already be an array of the child input.',\n          });\n        }\n        const items = isRecord(incoming?.items) ? (incoming.items as JsonSchema) : undefined;\n        const output = evalLeaf(entry.step, `${path}.step`, items, true);\n        const childId = leafEntryId(entry.step);\n        if (childId) stepOutputs.set(childId, output);\n        current = output ? { type: 'array', items: output } : output;\n        break;\n      }\n      case 'loop': {\n        const output = evalLeaf(entry.step, `${path}.step`, current, true);\n        const stepId = leafEntryId(entry.step);\n        if (stepId) stepOutputs.set(stepId, output);\n        if (entry.predicate) {\n          const loopStepOutputs = new Map(stepOutputs);\n          issues.push(\n            ...validatePredicate(entry.predicate, `${path}.predicate`, {\n              initData: def.inputSchema,\n              inputData: output,\n              state: def.stateSchema,\n              stepResults: loopStepOutputs,\n            }),\n          );\n        }\n        if (schemaCompatibility(output, inputSchemaOf(entry.step, index)) === 'incompatible') {\n          issues.push({\n            code: 'incompatible-schema',\n            path: `${path}.step`,\n            message: 'Loop step output is incompatible with its input for a subsequent iteration.',\n          });\n        }\n        current = output;\n        break;\n      }\n      default: {\n        const _exhaustive: never = entry;\n        void _exhaustive;\n      }\n    }\n    // Register the outputs of id-bearing top-level entries so later mappings\n    // and templates can reference them. `step` descriptors register too (their\n    // schema is unknown, which is fine — unknown never fails a check).\n    const id = 'id' in entry && entry.id ? entry.id : entry.type === 'step' ? entry.step.id : undefined;\n    if (id) stepOutputs.set(id, current);\n  });\n\n  if (schemaCompatibility(current, def.outputSchema) === 'incompatible') {\n    issues.push({\n      code: 'incompatible-schema',\n      path: 'outputSchema',\n      message: 'Workflow output schema is incompatible with the final step output.',\n    });\n  }\n  return { stepOutputs, entryInputs, finalOutput: current, issues };\n}\n","/**\n * JSON-Schema keyword checks: every schema embedded in the definition must be\n * convertible by `jsonSchemaToZod` (no oneOf/anyOf/allOf/not/$ref/\n * patternProperties/discriminator). Covers the four top-level schemas plus\n * each `agent.outputSchema` reachable through containers.\n */\nimport { forEachSingleStepEntryWithPath } from '../graph';\nimport { validateStorableJsonSchema } from '../json-schema-to-zod';\nimport type { JsonSchema } from '../json-schema-to-zod';\nimport type { WorkflowValidationInput, WorkflowValidationIssue } from './types';\n\nexport function validateWorkflowSchemas(def: WorkflowValidationInput): WorkflowValidationIssue[] {\n  const issues: WorkflowValidationIssue[] = [];\n  const check = (schema: JsonSchema | undefined, path: string, label: string): void => {\n    const result = validateStorableJsonSchema(schema);\n    if (result.ok) return;\n    issues.push({\n      code: 'unsupported-schema-keyword',\n      path,\n      message: `${label} uses JSON Schema keyword(s) jsonSchemaToZod cannot convert: ${result.unsupported.join(', ')}. Simplify the schema (or extend the converter).`,\n    });\n  };\n  check(def.inputSchema, 'inputSchema', 'inputSchema');\n  check(def.outputSchema, 'outputSchema', 'outputSchema');\n  if (def.stateSchema) check(def.stateSchema, 'stateSchema', 'stateSchema');\n  if (def.requestContextSchema) check(def.requestContextSchema, 'requestContextSchema', 'requestContextSchema');\n  forEachSingleStepEntryWithPath(def.graph, (entry, path) => {\n    if (entry.type === 'agent' && entry.outputSchema) {\n      check(entry.outputSchema, `${path}.outputSchema`, `step \"${entry.id}\" outputSchema`);\n    }\n  });\n  return issues;\n}\n","/**\n * Context-free structural rules: everything that can be decided from the\n * definition alone — ids, duplicates, entry placement, container arity,\n * declarative-predicate presence, nested-workflow identity, self-cycles.\n */\nimport { forEachSingleStepEntryWithPath } from '../graph';\nimport { leafEntryId } from './types';\nimport type { WorkflowValidationInput, WorkflowValidationIssue } from './types';\n\nconst TOP_LEVEL_PATH = /^graph\\.\\d+$/;\n\nexport function validateWorkflowStructure(def: WorkflowValidationInput): WorkflowValidationIssue[] {\n  const issues: WorkflowValidationIssue[] = [];\n\n  if (def.graph.length === 0) {\n    issues.push({ code: 'empty-graph', path: 'graph', message: 'Workflow graph must contain at least one step.' });\n  }\n\n  const seenIds = new Set<string>();\n  forEachSingleStepEntryWithPath(def.graph, (entry, path) => {\n    const id = leafEntryId(entry);\n    const idPath = entry.type === 'step' ? `${path}.step.id` : `${path}.id`;\n    if (!id) issues.push({ code: 'missing-step-id', path: idPath, message: 'Step id is required.' });\n    else if (seenIds.has(id))\n      issues.push({ code: 'duplicate-step-id', path: idPath, message: `Step id \"${id}\" is duplicated.` });\n    else seenIds.add(id);\n\n    if (entry.type === 'mapping' && !TOP_LEVEL_PATH.test(path)) {\n      issues.push({\n        code: 'invalid-map-placement',\n        path,\n        message: 'Persisted mapping steps must be top-level workflow entries.',\n      });\n    }\n\n    if (entry.type === 'workflow') {\n      if (entry.workflowId === def.id) {\n        issues.push({\n          code: 'self-reference',\n          path: `${path}.workflowId`,\n          message: `Step \"${entry.id}\" declares { type: \"workflow\", workflowId: \"${entry.workflowId}\" } which refers to itself. Nested workflow cycles are not allowed.`,\n        });\n      }\n    }\n  });\n\n  def.graph.forEach((entry, index) => {\n    const path = `graph.${index}`;\n    switch (entry.type) {\n      case 'parallel':\n      case 'conditional': {\n        if (entry.steps.length === 0) {\n          issues.push({\n            code: entry.type === 'parallel' ? 'invalid-parallel' : 'invalid-conditional',\n            path: `${path}.steps`,\n            message: `${entry.type} steps cannot be empty.`,\n          });\n        }\n        if (entry.type === 'conditional') {\n          if (!entry.predicates) {\n            issues.push({\n              code: 'invalid-conditional',\n              path,\n              message: 'Conditional entries must use declarative predicates.',\n            });\n          } else {\n            if (entry.steps.length !== entry.predicates.length) {\n              issues.push({\n                code: 'invalid-conditional',\n                path,\n                message: 'Conditional steps and predicates must be aligned.',\n              });\n            }\n            entry.predicates.forEach((predicate, predicateIndex) => {\n              if (predicate === null) {\n                issues.push({\n                  code: 'invalid-conditional',\n                  path: `${path}.predicates.${predicateIndex}`,\n                  message: 'Conditional entries must use declarative predicates.',\n                });\n              }\n            });\n          }\n        }\n        return;\n      }\n      case 'loop': {\n        if (!entry.predicate) {\n          issues.push({\n            code: 'invalid-loop',\n            path,\n            message: 'Loop entries must use a declarative predicate.',\n          });\n        }\n        return;\n      }\n      case 'foreach': {\n        if (entry.opts?.concurrency !== undefined && entry.opts.concurrency < 1) {\n          issues.push({\n            code: 'invalid-foreach',\n            path: `${path}.opts.concurrency`,\n            message: 'Concurrency must be positive.',\n          });\n        }\n        return;\n      }\n      default:\n        return;\n    }\n  });\n\n  return issues;\n}\n","/**\n * The one stored-workflow validation domain.\n *\n * `validateStoredWorkflow` is the collect-mode core every surface shares:\n * structure, JSON-Schema keywords, registry references, and schema-flow\n * analysis, each emitting `{ code, path, message }` issues. UIs consume the\n * array; the save path throws via `assertValidStoredWorkflow`.\n */\nimport { validateWorkflowRefs } from './refs';\nimport { addWorkflowValidationRepairActions } from './repair-actions';\nimport { inferGraphSchemas } from './schema-flow';\nimport { validateWorkflowSchemas } from './schemas';\nimport { validateWorkflowStructure } from './structure';\nimport type { WorkflowRegistryIndex, WorkflowValidationInput, WorkflowValidationIssue } from './types';\n\nexport type {\n  ValidatableStepFlowEntry,\n  WorkflowRegistryIndex,\n  WorkflowRegistrySchemas,\n  WorkflowValidationInput,\n  WorkflowValidationIssue,\n  WorkflowValidationIssueCode,\n  WorkflowValidationRepairAction,\n  WorkflowValidationRepairSource,\n} from './types';\nexport { validateWorkflowStructure } from './structure';\nexport { validateWorkflowRefs } from './refs';\nexport { validateWorkflowSchemas } from './schemas';\nexport { inferGraphSchemas } from './schema-flow';\nexport type { GraphSchemaInference } from './schema-flow';\nexport { schemaCompatibility, toJsonSchemaOrUndefined } from './schema-utils';\nexport type { SchemaCompatibility } from './schema-utils';\n\n/**\n * Runs every check and returns the collected issues (empty = valid).\n *\n * The registry index gates context-dependent checks: reference checks only\n * run for kinds present in the index, and schema-flow compatibility only\n * proves mismatches where schemas are known.\n */\nexport function validateStoredWorkflow(\n  def: WorkflowValidationInput,\n  index: WorkflowRegistryIndex = {},\n): WorkflowValidationIssue[] {\n  const inference = inferGraphSchemas(def, index);\n  return addWorkflowValidationRepairActions(\n    def,\n    index,\n    [\n      ...validateWorkflowStructure(def),\n      ...validateWorkflowSchemas(def),\n      ...validateWorkflowRefs(def, index),\n      ...inference.issues,\n    ],\n    inference.stepOutputs,\n    inference.entryInputs,\n    inference.finalOutput,\n  );\n}\n\n/** Throwing presentation of {@link validateStoredWorkflow} for the save path. */\nexport function assertValidStoredWorkflow(def: WorkflowValidationInput, index: WorkflowRegistryIndex = {}): void {\n  const issues = validateStoredWorkflow(def, index);\n  if (issues.length === 0) return;\n  const details = issues.map(issue => `- [${issue.code}] ${issue.path}: ${issue.message}`).join('\\n');\n  throw new Error(`Stored workflow \"${def.id}\" failed validation with ${issues.length} issue(s):\\n${details}`);\n}\n"],"mappings":"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"}