@livechat/platform-workflows 0.1.8 → 0.44.0-beta.v1

package/dist/domain.mjs

@@ -0,0 +1,2975 @@
+import {
+  HELPDESK_REFERENCE_NAMES,
+  LIVECHAT_REFERENCE_NAMES,
+  OTHER_TYPES,
+  SYSTEM_AI_AGENT_TRIGGER_NAME,
+  SYSTEM_AWAIT_TASK_CONVERTER,
+  SYSTEM_CONDITION_TASK_CONVERTER,
+  SYSTEM_CONSTRUCT_TASK_CONVERTER,
+  SYSTEM_CONVERT_TASK_CONVERTER,
+  SYSTEM_FORK_TASK_CONVERTER,
+  SYSTEM_FOR_EACH_TASK_CONVERTER,
+  SYSTEM_JOIN_TASK_CONVERTER,
+  SYSTEM_LOOP_TASK_CONVERTER,
+  SYSTEM_MANUAL_TRIGGER_NAME,
+  SYSTEM_NOTIFY_AI_AGENT_TASK_CONVERTER,
+  SYSTEM_REASONING_TASK_CONVERTER,
+  SYSTEM_SCHEDULED_TRIGGER_NAME,
+  SYSTEM_SCRIPT_TASK_CONVERTER,
+  SYSTEM_SWITCH_CASE_TASK_CONVERTER,
+  SYSTEM_TASK_NAMES,
+  SYSTEM_TERMINATE_TASK_CONVERTER,
+  SYSTEM_WAIT_TASK_CONVERTER,
+  TEXTAPP_PRODUCT_NAME,
+  WORKFLOW_ACTION_TASK_TEMPLATE,
+  WORKFLOW_AGENT_TRIGGER_TEMPLATE,
+  WORKFLOW_HTTP_TASK_OUTPUT_SCHEMA,
+  WORKFLOW_HTTP_TASK_TEMPLATE,
+  WORKFLOW_MANUAL_TRIGGER_TEMPLATE,
+  WORKFLOW_SCHEDULED_TRIGGER_TEMPLATE,
+  WORKFLOW_SYSTEM_WEBHOOK_TRIGGER_TEMPLATE,
+  WORKFLOW_WEBHOOK_TRIGGER_TEMPLATE,
+  capitalizeFirstLetter,
+  collectSchemaRefs,
+  generateObjectFromSchema,
+  getConditionOperatorsForType,
+  getSpecification,
+  getWorkflowReferenceDefRef,
+  getWorkflowReferenceDefinitionByName,
+  getWorkflowReferenceDefinitionFromSchema,
+  getWorkflowSpecificationItemByReference,
+  jsonUtils,
+  notEmpty,
+  rawItemConfigs,
+  resolveDisplayType,
+  toSchemaPropertiesPath,
+  validatePathAgainstSchema,
+  workflowReferences,
+  workflowResources
+} from "./chunk-6ZQIQVNX.mjs";
+import {
+  getWorkflowsEnv
+} from "./chunk-OAUPCV3P.mjs";
+
+// src/domain/common/build.ts
+import {
+  WorkflowCustomTaskName,
+  WorkflowItemKind,
+  WorkflowTaskType,
+  WorkflowTriggerType
+} from "@livechat/developer-studio-api";
+function buildTask(ctx, task) {
+  var _a;
+  const validTypes = Object.values(WorkflowTaskType);
+  if (!validTypes.includes(task.type)) {
+    ctx.errors.push(
+      `Unknown task type "${task.type}" for task "${task.name}". Valid types: ${validTypes.join(", ")}`
+    );
+    return null;
+  }
+  const config = ctx.spec.raw.items[task.name];
+  if (!config) {
+    ctx.errors.push(`Unknown task name: ${task.name}`);
+    return null;
+  }
+  if (config.kind !== WorkflowItemKind.Task) {
+    ctx.errors.push(`Invalid config found for: ${task.name}`);
+    return null;
+  }
+  if (task.type === WorkflowTaskType.http) {
+    return WORKFLOW_HTTP_TASK_TEMPLATE(
+      task.name,
+      task.taskReferenceName,
+      task.input,
+      void 0,
+      task.name === SYSTEM_TASK_NAMES.http
+    );
+  }
+  if (task.type === WorkflowTaskType.forkJoin) {
+    const targetForkTask = SYSTEM_FORK_TASK_CONVERTER(task);
+    return {
+      ...targetForkTask,
+      forkTasks: task.input.map((branch) => buildTasks(ctx, branch))
+    };
+  }
+  if (task.type === WorkflowTaskType.switch) {
+    let targetSwitchTask = void 0;
+    if (task.name === WorkflowCustomTaskName.condition) {
+      targetSwitchTask = SYSTEM_CONDITION_TASK_CONVERTER(task);
+    } else if (task.name === WorkflowCustomTaskName.switchCase) {
+      targetSwitchTask = SYSTEM_SWITCH_CASE_TASK_CONVERTER(task);
+    } else {
+      ctx.errors.push("Unknown switch type");
+      return null;
+    }
+    const decisionCases = {};
+    for (const [caseName, caseTasks] of Object.entries(
+      task.input.decisionCases
+    )) {
+      decisionCases[caseName] = buildTasks(ctx, caseTasks);
+    }
+    return {
+      ...targetSwitchTask,
+      decisionCases,
+      defaultCase: buildTasks(ctx, (_a = task.input.defaultCase) != null ? _a : [])
+    };
+  }
+  if (task.type === WorkflowTaskType.wait) {
+    return SYSTEM_WAIT_TASK_CONVERTER(task);
+  }
+  if (task.type === WorkflowTaskType.terminate) {
+    return SYSTEM_TERMINATE_TASK_CONVERTER(task);
+  }
+  if (task.type === WorkflowTaskType.doWhile) {
+    let targetDoWhileTask = void 0;
+    if (task.name === WorkflowCustomTaskName.loop) {
+      targetDoWhileTask = SYSTEM_LOOP_TASK_CONVERTER(task);
+    } else if (task.name === WorkflowCustomTaskName.forEach) {
+      targetDoWhileTask = SYSTEM_FOR_EACH_TASK_CONVERTER(task);
+    } else {
+      ctx.errors.push("Unknown doWhile type");
+      return null;
+    }
+    return {
+      ...targetDoWhileTask,
+      loopOver: buildTasks(ctx, task.input.loopOver)
+    };
+  }
+  if (task.type === WorkflowTaskType.inline) {
+    if (task.name === WorkflowCustomTaskName.script) {
+      return SYSTEM_SCRIPT_TASK_CONVERTER(task);
+    }
+    return {
+      name: task.name,
+      type: task.type,
+      taskReferenceName: task.taskReferenceName,
+      inputParameters: {
+        evaluatorType: task.input.evaluatorType,
+        expression: task.input.expression
+      }
+    };
+  }
+  if (task.type === WorkflowTaskType.transform) {
+    if (task.name === WorkflowCustomTaskName.convert) {
+      return SYSTEM_CONVERT_TASK_CONVERTER(task);
+    }
+    if (task.name === WorkflowCustomTaskName.construct) {
+      return SYSTEM_CONSTRUCT_TASK_CONVERTER(task);
+    }
+  }
+  if (task.type === WorkflowTaskType.simple) {
+    if (task.variant === WorkflowCustomTaskName.action) {
+      return WORKFLOW_ACTION_TASK_TEMPLATE(
+        task.name,
+        task.taskReferenceName,
+        task.input,
+        task.action
+      );
+    }
+    if (task.variant === WorkflowCustomTaskName.awaitAgent) {
+      return SYSTEM_AWAIT_TASK_CONVERTER(task);
+    }
+    if (task.variant === WorkflowCustomTaskName.notifyAgent) {
+      return SYSTEM_NOTIFY_AI_AGENT_TASK_CONVERTER(task);
+    }
+    if (task.variant === WorkflowCustomTaskName.reasoning) {
+      return SYSTEM_REASONING_TASK_CONVERTER(task);
+    }
+  }
+  return SYSTEM_JOIN_TASK_CONVERTER(task);
+}
+function buildTasks(ctx, taskCores) {
+  const tasks = [];
+  for (const taskCore of taskCores) {
+    const task = buildTask(ctx, taskCore);
+    if (task) {
+      tasks.push(task);
+    }
+  }
+  return tasks;
+}
+function buildTrigger(ctx, trigger) {
+  if (trigger.type === WorkflowTriggerType.webhook) {
+    return WORKFLOW_WEBHOOK_TRIGGER_TEMPLATE(trigger.name, trigger.input);
+  }
+  if (trigger.type === WorkflowTriggerType.webhookManual) {
+    return WORKFLOW_SYSTEM_WEBHOOK_TRIGGER_TEMPLATE(trigger.name, trigger);
+  }
+  if (trigger.type === WorkflowTriggerType.recurring) {
+    return WORKFLOW_SCHEDULED_TRIGGER_TEMPLATE(
+      SYSTEM_SCHEDULED_TRIGGER_NAME,
+      trigger
+    );
+  }
+  if (trigger.type === WorkflowTriggerType.manual) {
+    return WORKFLOW_MANUAL_TRIGGER_TEMPLATE(SYSTEM_MANUAL_TRIGGER_NAME, {
+      parameters: trigger.input
+    });
+  }
+  if (trigger.type === WorkflowTriggerType.agent) {
+    return WORKFLOW_AGENT_TRIGGER_TEMPLATE(
+      SYSTEM_AI_AGENT_TRIGGER_NAME,
+      trigger
+    );
+  }
+  ctx.errors.push(`Unknown trigger type: ${String(trigger.type)}`);
+  return null;
+}
+function buildWorkflowFromLight(input, spec) {
+  const ctx = {
+    spec: spec != null ? spec : getSpecification(),
+    errors: [],
+    referenceCounters: {}
+  };
+  const trigger = input.trigger ? buildTrigger(ctx, input.trigger) : null;
+  const tasks = buildTasks(ctx, input.tasks);
+  return {
+    workflow: {
+      name: input.name,
+      description: input.description,
+      trigger,
+      definition: {
+        name: input.name,
+        version: 0,
+        tasks,
+        inputParameters: []
+      }
+    },
+    errors: ctx.errors
+  };
+}
+
+// src/domain/common/prefill.tsx
+import { cloneDeep as cloneDeep2, get as get2, set as set2 } from "lodash-es";
+import { mergeDeep, WorkflowTaskType as WorkflowTaskType5 } from "@livechat/developer-studio-api";
+
+// src/utils/tracking.ts
+import * as amplitude from "@amplitude/analytics-browser";
+
+// src/domain/contexts/actions/types.ts
+var WorkflowElementActionType = /* @__PURE__ */ ((WorkflowElementActionType2) => {
+  WorkflowElementActionType2["AddTrigger"] = "add_trigger";
+  WorkflowElementActionType2["SwitchTrigger"] = "switch_trigger";
+  WorkflowElementActionType2["AddToTrigger"] = "add_to_trigger";
+  return WorkflowElementActionType2;
+})(WorkflowElementActionType || {});
+
+// src/domain/contexts/actions/utils.ts
+import {
+  WorkflowTriggerType as WorkflowTriggerType2
+} from "@livechat/developer-studio-api";
+var getWorkflowTaskActions = (config, suggestions, trigger) => {
+  var _a;
+  const actions = {};
+  Object.entries((_a = config.specification.inputReferences) != null ? _a : {}).forEach(
+    ([referenceName, paths]) => {
+      const currentAssetConfig = workflowReferences[referenceName];
+      if (!currentAssetConfig || currentAssetConfig.kind !== "resource" /* Resource */) {
+        return;
+      }
+      paths.forEach((ref) => {
+        const path = ref.value;
+        const suggestion = suggestions[path];
+        const hasSuggestions = suggestion && suggestion.length > 0;
+        if (!hasSuggestions) {
+          if (!(trigger == null ? void 0 : trigger.data.type)) {
+            actions[path] = {
+              type: "add_trigger" /* AddTrigger */,
+              referenceName
+            };
+          } else if ([
+            WorkflowTriggerType2.manual,
+            WorkflowTriggerType2.agent,
+            WorkflowTriggerType2.webhookManual
+          ].includes(trigger.data.type)) {
+            actions[path] = {
+              type: "add_to_trigger" /* AddToTrigger */,
+              referenceName
+            };
+          } else {
+            actions[path] = {
+              type: "switch_trigger" /* SwitchTrigger */,
+              referenceName
+            };
+          }
+        }
+      });
+    }
+  );
+  return actions;
+};
+
+// src/domain/contexts/assets/utils.ts
+function mergeAssets(prevAssets, newAssets) {
+  const result = { ...prevAssets };
+  Object.entries(newAssets).forEach(([resourceName, newResourceArray]) => {
+    if (resourceName in result) {
+      const existingResources = result[resourceName];
+      const mergedResources = [...existingResources];
+      newResourceArray.forEach((newResource) => {
+        const isDuplicate = existingResources.some(
+          (existing) => existing.reference.taskName === newResource.reference.taskName && existing.reference.ref.value === newResource.reference.ref.value
+        );
+        if (!isDuplicate) {
+          mergedResources.push(newResource);
+        } else {
+          const index = mergedResources.findIndex(
+            (existing) => existing.reference.taskName === newResource.reference.taskName && existing.reference.ref.value === newResource.reference.ref.value
+          );
+          if (index !== -1) {
+            mergedResources[index] = newResource;
+          }
+        }
+      });
+      result[resourceName] = mergedResources;
+    } else {
+      result[resourceName] = [...newResourceArray];
+    }
+  });
+  return result;
+}
+var getTriggerAssets = (trigger, specification) => {
+  const assetResources = Object.keys({
+    ...specification.outputReferences,
+    ...specification.outputResources
+  }).reduce((acc, resourceName) => {
+    var _a, _b, _c;
+    const outputReferences = (_a = specification.outputReferences) == null ? void 0 : _a[resourceName];
+    const outputResources = (_b = specification.outputResources) == null ? void 0 : _b[resourceName];
+    const items = (_c = outputReferences == null ? void 0 : outputReferences.map((refItem) => ({
+      reference: {
+        taskName: "workflow.input",
+        ref: refItem
+      },
+      resource: (outputResources == null ? void 0 : outputResources[0]) ? {
+        taskName: "workflow.input",
+        ref: outputResources[0]
+      } : void 0,
+      subject: refItem.subject
+    }))) != null ? _c : [];
+    if (items.length > 0) {
+      acc[resourceName] = items;
+    }
+    return acc;
+  }, {});
+  return assetResources;
+};
+var getTaskAssets = (task, specification, prevAssets) => {
+  const resources = Object.fromEntries(
+    Object.keys({
+      ...specification.outputReferences,
+      ...specification.outputResources
+    }).map((referenceName) => {
+      var _a, _b, _c, _d;
+      const existingAssets = prevAssets[referenceName];
+      const inputReferences = (_a = specification.inputReferences) == null ? void 0 : _a[referenceName];
+      const outputReferences = (_b = specification.outputReferences) == null ? void 0 : _b[referenceName];
+      const outputResources = (_c = specification.outputResources) == null ? void 0 : _c[referenceName];
+      const newAssetData = (_d = outputReferences == null ? void 0 : outputReferences.map((refItem) => ({
+        reference: {
+          taskName: task.taskReferenceName,
+          ref: refItem
+        },
+        resource: (outputResources == null ? void 0 : outputResources[0]) ? {
+          taskName: "workflow.input",
+          ref: outputResources[0]
+        } : void 0,
+        subject: refItem.subject
+      }))) != null ? _d : [];
+      const newAsset = [referenceName, newAssetData];
+      if (!inputReferences) {
+        return newAsset;
+      }
+      const isEmpty = inputReferences.some((res) => {
+        var _a2;
+        const value = (_a2 = jsonUtils.extractByPath(res.value, task)) == null ? void 0 : _a2[0];
+        if (!value) {
+          return true;
+        }
+        return false;
+      });
+      if (isEmpty) {
+        return [
+          referenceName,
+          newAssetData.map((item) => ({
+            ...item,
+            isNotConfirmed: true
+          }))
+        ];
+      }
+      const matchedAsset = existingAssets ? existingAssets.find((item) => {
+        return inputReferences.some((res) => {
+          var _a2;
+          const value = (_a2 = jsonUtils.extractByPath(res.value, task)) == null ? void 0 : _a2[0];
+          if (!value || typeof value !== "string") {
+            return false;
+          }
+          if (jsonUtils.containsTag(value)) {
+            return value.includes(
+              `${item.reference.taskName}.${item.reference.ref.value}`
+            );
+          }
+          return false;
+        });
+      }) : void 0;
+      if (matchedAsset) {
+        return [
+          referenceName,
+          [
+            {
+              reference: matchedAsset.reference,
+              resource: outputResources == null ? void 0 : outputResources[0]
+            }
+          ]
+        ];
+      }
+      return newAsset;
+    }).filter(([, resources2]) => resources2.length > 0)
+  );
+  return mergeAssets(prevAssets, resources);
+};
+
+// src/domain/contexts/configs/utils.ts
+import { cloneDeep, get, set } from "lodash-es";
+import {
+  WorkflowConditionTaskLogic,
+  WorkflowConditionTaskOperator,
+  WorkflowCustomTaskName as WorkflowCustomTaskName2,
+  WorkflowTaskType as WorkflowTaskType2,
+  WorkflowTriggerType as WorkflowTriggerType3
+} from "@livechat/developer-studio-api";
+
+// src/domain/contexts/frames/utils.ts
+function createFrameReferenceByContext(path, context) {
+  return createFrameReferenceByEnvironment(path, context == null ? void 0 : context.environment);
+}
+function createFrameReferenceByEnvironment(path, environment) {
+  const segments = path.split(".");
+  const frame = environment ? segments[0] === "workflow" ? segments[1] === "input" ? environment.workflow.input : void 0 : environment[segments[0]] : void 0;
+  return createFrameReference(path, frame);
+}
+var createFrameReference = (path, frame, options) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+  const segments = path.split(".");
+  let relativePath = (frame == null ? void 0 : frame.__meta) ? path.replaceAll(frame.__meta.basePath, "") : null;
+  relativePath = relativePath && relativePath.startsWith(".") ? relativePath.slice(1) : relativePath;
+  const contentRelativePath = relativePath && (frame == null ? void 0 : frame.__meta) ? relativePath.replaceAll(`${frame.__meta.contentBasePath}.`, "") : null;
+  const meta = frame == null ? void 0 : frame.__meta;
+  const { customization, specification } = (_b = (_a = meta == null ? void 0 : meta.config) != null ? _a : getWorkflowSpecificationItemByReference(path)) != null ? _b : {};
+  const arrayItemReferenceMatch = contentRelativePath ? /\[(\d+)\]$/.exec(contentRelativePath) : null;
+  const arrayItemIndex = (arrayItemReferenceMatch == null ? void 0 : arrayItemReferenceMatch[1]) ? parseInt(arrayItemReferenceMatch[1], 10) : void 0;
+  const { resolvedSchema: schema } = relativePath ? validatePathAgainstSchema(relativePath, specification == null ? void 0 : specification.output, {
+    supportAdditionalItems: options == null ? void 0 : options.supportAdditionalItems
+  }) : { resolvedSchema: void 0 };
+  const isArray = (schema == null ? void 0 : schema.type) === "array";
+  const isArrayReference = isArray && arrayItemIndex !== void 0;
+  const { value: reference } = (_c = schema ? getWorkflowReferenceDefinitionFromSchema(schema, arrayItemIndex) : void 0) != null ? _c : {};
+  const data = schema ? reference ? {
+    title: [
+      (_e = (_d = schema.title) != null ? _d : reference.title) != null ? _e : reference.displayName,
+      isArrayReference ? `[${arrayItemIndex}]` : ""
+    ].filter(notEmpty).join(""),
+    displayName: isArray ? isArrayReference ? `${schema.title}[${arrayItemIndex}]` : (_f = schema.title) != null ? _f : reference.pluralDisplayName : reference.displayName,
+    type: isArray ? isArrayReference ? reference.type : "array" : reference.type,
+    displayType: isArray ? isArrayReference ? reference.displayName : reference.pluralDisplayName : reference.displayName,
+    description: reference.description,
+    example: (_g = reference.examples) == null ? void 0 : _g[0]
+  } : {
+    title: (_i = (_h = schema.title) != null ? _h : segments.at(-1)) != null ? _i : "",
+    displayName: (_k = (_j = schema.title) != null ? _j : segments.at(-1)) != null ? _k : "",
+    type: schema.type,
+    displayType: resolveDisplayType(schema),
+    description: schema.description,
+    example: (_l = schema.examples) == null ? void 0 : _l[0]
+  } : {
+    title: (_n = (_m = customization == null ? void 0 : customization.displayName) != null ? _m : segments.at(-1)) != null ? _n : "",
+    displayName: (_p = (_o = customization == null ? void 0 : customization.displayName) != null ? _o : segments.at(-1)) != null ? _p : ""
+  };
+  let invalid = false;
+  let invalidReason = "";
+  let invalidLevel;
+  if (meta) {
+    if (!schema) {
+      invalid = true;
+      invalidLevel = "error";
+      invalidReason = segments[0] === "workflow" ? "Invalid trigger property" : "Invalid task property";
+    } else if (meta.config.stale) {
+      invalid = true;
+      invalidLevel = "warning";
+      invalidReason = segments[0] === "workflow" ? "Stale trigger property" : "Stale task property";
+    }
+  } else {
+    invalid = true;
+    invalidLevel = "error";
+    invalidReason = `${segments[0] === "workflow" ? "Trigger" : "Task"} not found`;
+  }
+  const outcome = relativePath ? (_q = jsonUtils.extractByPath(relativePath, frame)) == null ? void 0 : _q[0] : null;
+  const tag = {
+    // Paths
+    value: path,
+    targetValue: `\${${path}}`,
+    relativePath: contentRelativePath,
+    path: relativePath,
+    // Display
+    name: data.title,
+    displayName: data.displayName,
+    type: (_r = data.type) != null ? _r : "",
+    displayType: (_s = data.displayType) != null ? _s : "",
+    description: data.description,
+    example: data.example,
+    // Output
+    outcome,
+    // Schema
+    schema,
+    reference,
+    // Validation
+    invalid,
+    invalidReason,
+    invalidLevel,
+    // Source
+    source: {
+      index: meta == null ? void 0 : meta.index,
+      reference: frame == null ? void 0 : frame.__meta.basePath,
+      credentialId: frame == null ? void 0 : frame.__meta.credentialId,
+      customization
+    }
+  };
+  return tag;
+};
+
+// src/domain/contexts/configs/utils.ts
+function getWorkflowElementVersion(element) {
+  var _a;
+  if (element.type === WorkflowTriggerType3.webhook) {
+    return (_a = element.webhook.event.version) != null ? _a : element.version;
+  }
+  return element.version;
+}
+function getWorkflowElementConfig(elementData, workflowIntrospection, specification, environment) {
+  var _a, _b;
+  const itemConfig = specification.raw.items[elementData.name];
+  if (!itemConfig) {
+    throw new Error(
+      "Invalid workflow element - no config found for element with name: " + elementData.name
+    );
+  }
+  const itemProviderConfig = specification.raw.providers[itemConfig.customization.provider];
+  const itemProductConfig = itemConfig.customization.product ? (_a = itemProviderConfig.products) == null ? void 0 : _a[itemConfig.customization.product] : void 0;
+  const itemVersion = (_b = getWorkflowElementVersion(elementData)) != null ? _b : itemConfig.specifications.default;
+  let itemSpecification = itemConfig.specifications.versions[itemVersion];
+  if (itemSpecification && elementData.type === WorkflowTaskType2.http && elementData.name === WorkflowTaskType2.http) {
+    itemSpecification = {
+      ...itemSpecification,
+      ...adjustSpecificationForHttpTask(elementData, workflowIntrospection)
+    };
+  }
+  if (itemSpecification && elementData.name === WorkflowCustomTaskName2.convert) {
+    itemSpecification = {
+      ...itemSpecification,
+      ...adjustSpecificationForConvertTask(
+        elementData,
+        itemSpecification,
+        environment
+      )
+    };
+  }
+  if (itemSpecification && elementData.name === WorkflowCustomTaskName2.construct) {
+    itemSpecification = {
+      ...itemSpecification,
+      ...adjustSpecificationForConstructTask(
+        elementData,
+        itemSpecification,
+        environment
+      )
+    };
+  }
+  if (itemSpecification) {
+    itemSpecification = {
+      ...itemSpecification,
+      ...adjustOutputSchemaFromBindings(elementData, itemSpecification)
+    };
+  }
+  const config = {
+    ...itemConfig,
+    customization: {
+      ...itemConfig.customization,
+      providerDisplay: itemProviderConfig.displayName,
+      productDisplay: itemProductConfig == null ? void 0 : itemProductConfig.displayName
+    },
+    specification: itemSpecification
+  };
+  return config;
+}
+function adjustSpecificationForHttpTask(taskData, workflowIntrospection) {
+  const taskIntrospection = workflowIntrospection.tasks[taskData.taskReferenceName];
+  if (!(taskIntrospection == null ? void 0 : taskIntrospection.schema)) {
+    return {};
+  }
+  const output = WORKFLOW_HTTP_TASK_OUTPUT_SCHEMA(
+    taskIntrospection.schema
+  );
+  return { output };
+}
+function resolveBindingReferences(properties) {
+  return Object.fromEntries(
+    Object.entries(properties).filter((entry) => Boolean(entry[1])).map(([key, schema]) => {
+      var _a;
+      const type = typeof schema.type === "string" ? schema.type : void 0;
+      if (type == null ? void 0 : type.startsWith("references/")) {
+        const name = type.slice("references/".length);
+        const definition = getWorkflowReferenceDefinitionByName(name);
+        if (definition) {
+          return [
+            key,
+            {
+              ...definition,
+              title: (_a = schema.title) != null ? _a : definition.title,
+              $ref: getWorkflowReferenceDefRef(name)
+            }
+          ];
+        }
+      }
+      return [key, schema];
+    })
+  );
+}
+function narrowSchemaByConditions(itemsSchema, filterConditions, filterLogic) {
+  var _a, _b, _c;
+  if (!itemsSchema.oneOf || !Array.isArray(itemsSchema.oneOf) || !(filterConditions == null ? void 0 : filterConditions.length) || filterLogic === WorkflowConditionTaskLogic.OR) {
+    return itemsSchema;
+  }
+  const equalityOperators = /* @__PURE__ */ new Set([
+    WorkflowConditionTaskOperator.StringEqual,
+    WorkflowConditionTaskOperator.NumberEqual
+  ]);
+  const equalityConditions = filterConditions.filter(
+    (c) => c.field && c.value !== void 0 && equalityOperators.has(c.operator)
+  );
+  if (!equalityConditions.length) {
+    return itemsSchema;
+  }
+  const variants = itemsSchema.oneOf;
+  for (const condition of equalityConditions) {
+    const matchingVariant = variants.find((variant) => {
+      const variantProps = variant.properties;
+      if (!(variantProps == null ? void 0 : variantProps[condition.field])) return false;
+      return variantProps[condition.field].const === condition.value;
+    });
+    if (matchingVariant) {
+      const { oneOf: _, ...baseSchema } = itemsSchema;
+      const variantProps = (_a = matchingVariant.properties) != null ? _a : {};
+      const variantRequired = (_b = matchingVariant.required) != null ? _b : [];
+      return {
+        ...baseSchema,
+        properties: {
+          ...baseSchema.properties,
+          ...variantProps
+        },
+        required: [
+          .../* @__PURE__ */ new Set([
+            ...(_c = baseSchema.required) != null ? _c : [],
+            ...variantRequired
+          ])
+        ]
+      };
+    }
+  }
+  return itemsSchema;
+}
+function deriveOutputSchemaFromTransformer(taskData, sourceSchema) {
+  var _a, _b;
+  const transformer = taskData.inputParameters.transformer;
+  const sourceItemsSchema = (sourceSchema == null ? void 0 : sourceSchema.type) === "array" && sourceSchema.items ? Array.isArray(sourceSchema.items) ? sourceSchema.items[0] : sourceSchema.items : void 0;
+  switch (transformer) {
+    // → string
+    case "to_string":
+    case "uppercase":
+    case "lowercase":
+    case "trim":
+    case "replace":
+    case "join":
+      return { type: "string" };
+    // → number
+    case "to_number":
+    case "count":
+    case "sum":
+    case "average":
+      return { type: "number" };
+    // → array of strings
+    case "split":
+    case "keys":
+      return { type: "array", items: { type: "string" } };
+    // → array (preserves item schema, narrows discriminated unions)
+    case "filter": {
+      if (!sourceItemsSchema) return { type: "array" };
+      const narrowed = narrowSchemaByConditions(
+        sourceItemsSchema,
+        taskData.inputParameters.filterConditions,
+        taskData.inputParameters.filterLogic
+      );
+      return { type: "array", items: narrowed };
+    }
+    // → array (preserves item schema)
+    case "sort":
+    case "reverse":
+    case "unique":
+      return sourceItemsSchema ? { type: "array", items: sourceItemsSchema } : { type: "array" };
+    // → array (unknown items)
+    case "values":
+    case "flatten":
+      return { type: "array" };
+    // → array of plucked field values
+    case "pluck": {
+      if ((sourceItemsSchema == null ? void 0 : sourceItemsSchema.properties) && taskData.inputParameters.pluckField) {
+        const fieldSchema = sourceItemsSchema.properties[taskData.inputParameters.pluckField];
+        if (fieldSchema) {
+          return { type: "array", items: fieldSchema };
+        }
+      }
+      return { type: "array" };
+    }
+    // → single item from array
+    case "first":
+    case "last":
+      return sourceItemsSchema != null ? sourceItemsSchema : {};
+    // → object (subset of source)
+    case "pick":
+    case "omit": {
+      if ((sourceSchema == null ? void 0 : sourceSchema.type) === "object" && sourceSchema.properties) {
+        const targetFields = (_a = taskData.inputParameters.targetFields) != null ? _a : [];
+        if (transformer === "pick") {
+          return {
+            type: "object",
+            properties: Object.fromEntries(
+              targetFields.filter((f) => f in sourceSchema.properties).map((f) => [f, sourceSchema.properties[f]])
+            )
+          };
+        }
+        return {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(sourceSchema.properties).filter(
+              ([key]) => !targetFields.includes(key)
+            )
+          )
+        };
+      }
+      return {
+        type: "object",
+        properties: Object.fromEntries(
+          ((_b = taskData.inputParameters.targetFields) != null ? _b : []).map((f) => [f, {}])
+        )
+      };
+    }
+    // pass-through
+    case "none":
+      return sourceSchema != null ? sourceSchema : {};
+  }
+}
+function adjustSpecificationForConvertTask(taskData, itemSpecification, environment) {
+  const sourceSchema = resolveRefSchema(
+    taskData.inputParameters.source,
+    environment
+  );
+  const resultSchema = deriveOutputSchemaFromTransformer(
+    taskData,
+    sourceSchema
+  );
+  const taskOutputSchema = {
+    type: "object",
+    required: ["output"],
+    properties: {
+      output: {
+        type: "object",
+        required: ["result"],
+        properties: {
+          result: {
+            title: "Result",
+            ...resultSchema
+          }
+        }
+      }
+    }
+  };
+  const { references: taskOutputReferences, resources: taskOutputResources } = collectSchemaRefs(taskOutputSchema, false);
+  const inputAdjustment = adjustConvertConditionInputSchema(
+    itemSpecification,
+    sourceSchema
+  );
+  return {
+    output: taskOutputSchema,
+    outputReferences: taskOutputReferences,
+    outputResources: taskOutputResources,
+    ...inputAdjustment != null ? inputAdjustment : {}
+  };
+}
+function adjustConvertConditionInputSchema(itemSpecification, sourceSchema) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!itemSpecification.input) return void 0;
+  if (sourceSchema.type !== "array") return void 0;
+  const itemsSchema = Array.isArray(sourceSchema.items) ? sourceSchema.items[0] : sourceSchema.items;
+  if (!itemsSchema) return void 0;
+  const itemType = typeof itemsSchema.type === "string" ? itemsSchema.type : void 0;
+  if (!itemType) return void 0;
+  const isPrimitive = itemType === "string" || itemType === "number" || itemType === "integer" || itemType === "boolean";
+  let fieldPatch;
+  let fieldUiPatch;
+  let operatorPatch;
+  if (isPrimitive) {
+    fieldPatch = { type: "string", title: "Field", default: "" };
+    fieldUiPatch = { "ui:widget": "hidden" };
+    operatorPatch = {
+      type: "string",
+      title: "Type",
+      oneOf: getConditionOperatorsForType(itemType)
+    };
+  } else if (itemType === "object" && itemsSchema.properties) {
+    const props = itemsSchema.properties;
+    const fieldKeys = Object.keys(props);
+    if (!fieldKeys.length) return void 0;
+    fieldPatch = {
+      type: "string",
+      title: "Field",
+      oneOf: fieldKeys.map(
+        (k) => {
+          var _a2;
+          return {
+            const: k,
+            title: (_a2 = props[k].title) != null ? _a2 : k
+          };
+        }
+      )
+    };
+  } else {
+    return void 0;
+  }
+  const newInput = cloneDeep(itemSpecification.input);
+  const newInputUi = cloneDeep((_a = itemSpecification.inputUi) != null ? _a : {});
+  const inputProps = (_b = newInput.properties) != null ? _b : {};
+  const inputParams = inputProps.inputParameters;
+  const allOf = (_c = inputParams == null ? void 0 : inputParams.allOf) != null ? _c : [];
+  let patched = false;
+  for (const branch of allOf) {
+    const then = branch.then;
+    const thenProps = then == null ? void 0 : then.properties;
+    const fc = thenProps == null ? void 0 : thenProps.filterConditions;
+    if (!fc) continue;
+    const items = fc.items;
+    if (!items) continue;
+    const itemProps = (_d = items.properties) != null ? _d : {};
+    if (fieldPatch) itemProps.field = fieldPatch;
+    if (operatorPatch) itemProps.operator = operatorPatch;
+    items.properties = itemProps;
+    patched = true;
+  }
+  if (!patched) return void 0;
+  if (fieldUiPatch) {
+    const inputParamsUi = (_e = newInputUi.inputParameters) != null ? _e : {};
+    const fcUi = (_f = inputParamsUi.filterConditions) != null ? _f : {};
+    const fcItemsUi = (_g = fcUi.items) != null ? _g : {};
+    fcItemsUi.field = { ...(_h = fcItemsUi.field) != null ? _h : {}, ...fieldUiPatch };
+    fcUi.items = fcItemsUi;
+    inputParamsUi.filterConditions = fcUi;
+    newInputUi.inputParameters = inputParamsUi;
+  }
+  return { input: newInput, inputUi: newInputUi };
+}
+function resolveRefSchema(value, environment) {
+  var _a;
+  if (!value || !environment || !jsonUtils.containsTag(value)) return {};
+  const path = jsonUtils.escapeTag(value);
+  const ref = createFrameReferenceByEnvironment(path, environment);
+  return (_a = ref.schema) != null ? _a : {};
+}
+function adjustSpecificationForConstructTask(taskData, itemSpecification, environment) {
+  var _a, _b;
+  let resultSchema;
+  const keysFrom = taskData.inputParameters.keysFrom;
+  const valuesFrom = taskData.inputParameters.valuesFrom;
+  const valuesReferenceSchema = valuesFrom ? {
+    ...getWorkflowReferenceDefinitionByName(valuesFrom),
+    $ref: getWorkflowReferenceDefRef(valuesFrom)
+  } : void 0;
+  if (taskData.inputParameters.outputType === "object") {
+    const fields = (_a = taskData.inputParameters.fields) != null ? _a : [];
+    resultSchema = {
+      type: "object",
+      properties: Object.fromEntries(
+        fields.map((f) => [
+          f.key,
+          valuesReferenceSchema ? { ...valuesReferenceSchema, title: f.key } : { ...resolveRefSchema(f.value, environment), title: f.key }
+        ])
+      )
+    };
+  } else {
+    const elements = (_b = taskData.inputParameters.elements) != null ? _b : [];
+    let itemsSchema;
+    if (valuesReferenceSchema) {
+      itemsSchema = valuesReferenceSchema;
+    } else {
+      const itemSchemas = elements.map(
+        (e) => resolveRefSchema(e.value, environment)
+      );
+      itemsSchema = itemSchemas.length === 1 ? itemSchemas[0] : itemSchemas.length > 1 ? { oneOf: itemSchemas } : {};
+    }
+    resultSchema = { type: "array", items: itemsSchema };
+  }
+  if (keysFrom) {
+    resultSchema["x-keys-reference"] = keysFrom;
+  }
+  if (valuesFrom) {
+    resultSchema["x-values-reference"] = valuesFrom;
+  }
+  const taskOutputSchema = {
+    type: "object",
+    required: ["output"],
+    properties: {
+      output: {
+        type: "object",
+        required: ["result"],
+        properties: {
+          result: resultSchema
+        }
+      }
+    }
+  };
+  const { references: taskOutputReferences, resources: taskOutputResources } = collectSchemaRefs(taskOutputSchema, false);
+  const inputAdjustment = adjustConstructEntriesReferenceSchema(
+    taskData,
+    itemSpecification
+  );
+  return {
+    output: taskOutputSchema,
+    outputReferences: taskOutputReferences,
+    outputResources: taskOutputResources,
+    ...inputAdjustment != null ? inputAdjustment : {}
+  };
+}
+function adjustConstructEntriesReferenceSchema(taskData, itemSpecification) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!itemSpecification.input) return void 0;
+  const isObject = taskData.inputParameters.outputType === "object";
+  const keysFrom = taskData.inputParameters.keysFrom;
+  const valuesFrom = taskData.inputParameters.valuesFrom;
+  const branchKey = isObject ? "fields" : "elements";
+  const slotPatches = [];
+  if (isObject && keysFrom)
+    slotPatches.push({ slot: "key", refName: keysFrom });
+  if (valuesFrom) slotPatches.push({ slot: "value", refName: valuesFrom });
+  if (!slotPatches.length) return void 0;
+  const resolvedRefs = slotPatches.map((p) => ({
+    ...p,
+    definition: getWorkflowReferenceDefinitionByName(p.refName)
+  }));
+  if (resolvedRefs.some((r) => !r.definition)) return void 0;
+  const newInput = cloneDeep(itemSpecification.input);
+  const newInputUi = cloneDeep((_a = itemSpecification.inputUi) != null ? _a : {});
+  const inputProps = (_b = newInput.properties) != null ? _b : {};
+  const inputParams = inputProps.inputParameters;
+  const allOf = (_c = inputParams == null ? void 0 : inputParams.allOf) != null ? _c : [];
+  let patched = false;
+  for (const branch of allOf) {
+    const then = branch.then;
+    const thenProps = then == null ? void 0 : then.properties;
+    const container = thenProps == null ? void 0 : thenProps[branchKey];
+    if (!container) continue;
+    const cloned = cloneDeep(container);
+    const items = cloned.items;
+    const itemProps = (_d = items == null ? void 0 : items.properties) != null ? _d : {};
+    for (const { slot, refName, definition } of resolvedRefs) {
+      itemProps[slot] = {
+        ...definition,
+        title: slot === "key" ? "Key" : "Value",
+        $ref: getWorkflowReferenceDefRef(refName)
+      };
+    }
+    if (items) items.properties = itemProps;
+    thenProps[branchKey] = cloned;
+    patched = true;
+  }
+  if (!patched) return void 0;
+  const inputParamsUi = (_e = newInputUi.inputParameters) != null ? _e : {};
+  const containerUi = (_f = inputParamsUi[branchKey]) != null ? _f : {};
+  const containerItemsUi = (_g = containerUi.items) != null ? _g : {};
+  for (const { slot, definition } of resolvedRefs) {
+    const slotUi = (_h = containerItemsUi[slot]) != null ? _h : {};
+    delete slotUi["ui:inputType"];
+    slotUi["ui:widget"] = "select";
+    slotUi["ui:placeholder"] = `Select ${definition.displayName}`;
+    containerItemsUi[slot] = slotUi;
+  }
+  containerUi.items = containerItemsUi;
+  inputParamsUi[branchKey] = containerUi;
+  newInputUi.inputParameters = inputParamsUi;
+  const { references: inputReferences, resources: inputResources } = collectSchemaRefs(newInput, false);
+  return {
+    input: newInput,
+    inputUi: newInputUi,
+    inputReferences,
+    inputResources
+  };
+}
+function getBindingProperties(elementData, inputPath, format) {
+  var _a;
+  const rawData = get(elementData, inputPath);
+  if (!rawData) return {};
+  let properties;
+  if (format === "params-array") {
+    const params = rawData != null ? rawData : [];
+    properties = Object.fromEntries(
+      params.map((param) => [
+        param.name,
+        {
+          title: capitalizeFirstLetter(param.name || ""),
+          type: param.type
+        }
+      ])
+    );
+  } else {
+    properties = (_a = rawData.properties) != null ? _a : {};
+  }
+  return resolveBindingReferences(properties);
+}
+function buildBindingPropertyUiSchema(schema) {
+  var _a;
+  const ref = getWorkflowReferenceDefinitionFromSchema(schema);
+  if (ref) {
+    const isExternal = (_a = ref.value.configs) == null ? void 0 : _a.external;
+    return {
+      "ui:widget": isExternal ? "select" : void 0,
+      "ui:inputType": isExternal ? void 0 : "static",
+      "ui:placeholder": isExternal ? `Select ${ref.value.displayName}` : `Enter ${ref.value.displayName}`
+    };
+  }
+  if (schema.type === "boolean") {
+    return { "ui:widget": "select" };
+  }
+}
+function adjustOutputSchemaFromBindings(elementData, itemSpecification) {
+  var _a;
+  const {
+    output: currentOutput,
+    outputUi: currentOutputUi,
+    outputBindings: bindings
+  } = itemSpecification;
+  if (!currentOutput || !(bindings == null ? void 0 : bindings.length)) return void 0;
+  const output = cloneDeep(currentOutput);
+  const outputUi = currentOutputUi ? cloneDeep(currentOutputUi) : {};
+  for (const binding of bindings) {
+    const bindingSchemaPath = toSchemaPropertiesPath(binding.outputPath);
+    const bindingProperties = getBindingProperties(
+      elementData,
+      binding.inputPath,
+      binding.inputFormat
+    );
+    const node = binding.outputPath ? get(output, bindingSchemaPath) : output;
+    if (!node) continue;
+    node.properties = { ...node.properties, ...bindingProperties };
+    node.required = [
+      .../* @__PURE__ */ new Set([
+        ...Array.isArray(node.required) ? node.required : [],
+        ...Object.keys(bindingProperties)
+      ])
+    ];
+    node.additionalProperties = false;
+    node.additionalItems = true;
+    const nodeUi = Object.fromEntries(
+      Object.entries(bindingProperties).map(
+        ([key, schema]) => [key, buildBindingPropertyUiSchema(schema)]
+      ).filter((entry) => Boolean(entry[1]))
+    );
+    if (binding.outputPath) {
+      const existing = (_a = get(outputUi, binding.outputPath)) != null ? _a : {};
+      set(outputUi, binding.outputPath, { ...existing, ...nodeUi });
+    } else {
+      Object.assign(outputUi, nodeUi);
+    }
+  }
+  const { references: outputReferences, resources: outputResources } = collectSchemaRefs(output, false);
+  return {
+    output,
+    outputUi,
+    outputReferences,
+    outputResources
+  };
+}
+
+// src/domain/contexts/utils.ts
+import {
+  WorkflowExecutionTaskStatus,
+  WorkflowTaskType as WorkflowTaskType3,
+  WorkflowTriggerType as WorkflowTriggerType4
+} from "@livechat/developer-studio-api";
+var getTriggerContext = (workflowBundle, workflowFrames, specification) => {
+  var _a, _b, _c;
+  if (!((_a = workflowBundle.workflow.trigger) == null ? void 0 : _a.type)) {
+    return;
+  }
+  const stored = workflowBundle.workflow;
+  const triggerDefinition2 = workflowBundle.workflow.trigger.type === WorkflowTriggerType4.webhookManual ? {
+    ...workflowBundle.workflow.trigger,
+    webhook_url: (_b = stored.webhook_url) != null ? _b : stored.id ? `${getWorkflowsEnv("textApiUrl")}/workflow_platform/webhooks/${stored.id}` : void 0
+  } : workflowBundle.workflow.trigger;
+  const config = getWorkflowElementConfig(
+    triggerDefinition2,
+    (_c = workflowBundle.introspection) != null ? _c : { tasks: {} },
+    specification
+  );
+  const element = {
+    definition: triggerDefinition2,
+    execution: workflowBundle.execution ? {
+      name: workflowBundle.workflow.trigger.name,
+      type: workflowBundle.workflow.trigger.type,
+      status: WorkflowExecutionTaskStatus.Completed,
+      inputData: {},
+      outputData: workflowBundle.execution.data.input
+    } : void 0
+  };
+  const execution = workflowBundle.execution && element.execution ? {
+    isSuccess: true,
+    timestamp: workflowBundle.execution.started_at,
+    data: element.execution,
+    runtimeData: element.definition
+  } : void 0;
+  const frame = workflowFrames.input;
+  const environment = {
+    workflow: {}
+  };
+  return {
+    index: 1,
+    config,
+    data: element.definition,
+    execution,
+    frame,
+    environment
+  };
+};
+var getWorkflowInputFrame = (workflowBundle, specification) => {
+  var _a, _b, _c, _d, _e;
+  if (!((_a = workflowBundle.workflow.trigger) == null ? void 0 : _a.type)) {
+    return;
+  }
+  const config = getWorkflowElementConfig(
+    workflowBundle.workflow.trigger,
+    (_b = workflowBundle.introspection) != null ? _b : { tasks: {} },
+    specification
+  );
+  const execution = (_c = workflowBundle.execution) == null ? void 0 : _c.data.input;
+  const output = generateObjectFromSchema(
+    (_d = config.specification.output) != null ? _d : {},
+    execution
+  );
+  const frame = {
+    ...output,
+    __meta: {
+      index: 1,
+      basePath: "workflow.input",
+      credentialId: workflowBundle.workflow.trigger.type === WorkflowTriggerType4.webhook ? workflowBundle.workflow.trigger.webhook.credential_id : "text",
+      contentBasePath: config.specification.metadata.outputBasePath,
+      config: {
+        stale: false,
+        customization: config.customization,
+        specification: config.specification
+      },
+      properties: (_e = output == null ? void 0 : output.__meta.properties) != null ? _e : {}
+    }
+  };
+  return frame;
+};
+var getTaskContext = (taskData, workflowBundle, triggerContext, specification, carrier) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const config = getWorkflowElementConfig(
+    taskData,
+    (_a = workflowBundle.introspection) != null ? _a : { tasks: {} },
+    specification,
+    carrier.environment
+  );
+  const element = {
+    definition: taskData,
+    execution: workflowBundle.execution ? workflowBundle.execution.data.tasks.find(
+      (taskExecution) => taskExecution.referenceTaskName === taskData.taskReferenceName
+    ) : void 0
+  };
+  const introspection = (_b = workflowBundle.introspection) == null ? void 0 : _b.tasks[taskData.taskReferenceName];
+  const execution = workflowBundle.execution ? element.execution ? {
+    isSuccess: element.execution.status === WorkflowExecutionTaskStatus.Completed,
+    timestamp: void 0,
+    data: element.execution,
+    runtimeData: {
+      inputParameters: element.execution.inputData
+    }
+  } : {
+    isSuccess: false,
+    timestamp: void 0,
+    data: {
+      inputData: void 0,
+      outputData: void 0,
+      referenceTaskName: taskData.taskReferenceName,
+      taskDefName: taskData.name,
+      taskType: taskData.type,
+      status: WorkflowExecutionTaskStatus.NotExecuted
+    },
+    runtimeData: void 0
+  } : void 0;
+  const outputSchema = ((_c = config.specification.output) == null ? void 0 : _c.type) === "object" ? config.specification.output : void 0;
+  const output = outputSchema ? generateObjectFromSchema(outputSchema, {
+    output: (_d = element.execution) == null ? void 0 : _d.outputData
+  }) : void 0;
+  const frame = {
+    ...output,
+    __meta: {
+      index: carrier.currentTaskGlobalIndex,
+      credentialId: taskData.type === WorkflowTaskType3.http ? taskData.inputParameters.http_request.credentialId : void 0,
+      basePath: taskData.taskReferenceName,
+      contentBasePath: config.specification.metadata.outputBasePath,
+      config: {
+        stale: (_e = introspection == null ? void 0 : introspection.stale) != null ? _e : false,
+        customization: config.customization,
+        specification: config.specification
+      },
+      properties: (_f = output == null ? void 0 : output.__meta.properties) != null ? _f : {}
+    }
+  };
+  const environment = carrier.environment;
+  const assets = carrier.assets;
+  const newAssets = getTaskAssets(
+    taskData,
+    config.specification,
+    carrier.assets
+  );
+  const suggestions = Object.entries(
+    (_g = config.specification.inputReferences) != null ? _g : {}
+  ).reduce((acc, [name, paths]) => {
+    const assetResource = assets[name];
+    if (!assetResource) {
+      return acc;
+    }
+    return paths.reduce((innerAcc, ref) => {
+      var _a2;
+      const suggestions2 = assetResource.map((assetRef) => ({
+        isNotConfirmed: assetRef.isNotConfirmed,
+        value: `\${${assetRef.reference.taskName}.${assetRef.reference.ref.value}}`,
+        contextMatch: !ref.subject || !assetRef.subject || ref.subject === assetRef.subject
+      }));
+      return {
+        ...innerAcc,
+        [ref.value]: [...(_a2 = innerAcc[ref.value]) != null ? _a2 : [], ...suggestions2]
+      };
+    }, acc);
+  }, {});
+  const actions = getWorkflowTaskActions(config, suggestions, triggerContext);
+  const context = {
+    index: carrier.currentTaskGlobalIndex,
+    config,
+    data: element.definition,
+    introspection,
+    execution,
+    frame,
+    environment,
+    assets,
+    suggestions,
+    actions: Object.keys(actions).length > 0 ? actions : void 0
+  };
+  return {
+    context,
+    newAssets
+  };
+};
+var getTaskContexts = (workflowBundle, workflowFrames, triggerContext, specification) => {
+  var _a;
+  function taskReducer(tasks, initial) {
+    return tasks.reduce((result, taskData) => {
+      const { context: taskContext, newAssets } = getTaskContext(
+        taskData,
+        workflowBundle,
+        triggerContext,
+        specification,
+        result.carrier
+      );
+      result.contexts = {
+        ...result.contexts,
+        [taskData.taskReferenceName]: taskContext
+      };
+      result.carrier = {
+        assets: newAssets,
+        environment: {
+          ...result.carrier.environment,
+          [taskData.taskReferenceName]: taskContext.frame
+        },
+        currentTaskGlobalIndex: result.carrier.currentTaskGlobalIndex + 1
+      };
+      if (taskData.type === WorkflowTaskType3.switch) {
+        if (taskData.name === SYSTEM_TASK_NAMES.condition) {
+          taskData.decisionCases = {
+            TRUE: taskData.decisionCases.TRUE || [],
+            FALSE: taskData.decisionCases.FALSE || []
+          };
+        }
+        return Object.entries(taskData.decisionCases).reduce(
+          (innerResult, [_decisionCase, innerTasks]) => {
+            const decisionCaseResults = taskReducer(innerTasks, {
+              contexts: innerResult.contexts,
+              carrier: {
+                assets: result.carrier.assets,
+                environment: result.carrier.environment,
+                currentTaskGlobalIndex: innerResult.carrier.currentTaskGlobalIndex
+              }
+            });
+            return {
+              ...decisionCaseResults,
+              carrier: {
+                assets: innerResult.carrier.assets,
+                environment: innerResult.carrier.environment,
+                currentTaskGlobalIndex: decisionCaseResults.carrier.currentTaskGlobalIndex
+              }
+            };
+          },
+          result
+        );
+      }
+      if (taskData.type === WorkflowTaskType3.forkJoin) {
+        return taskData.forkTasks.reduce((innerResult, innerTasks) => {
+          const forkTaskResults = taskReducer(innerTasks, {
+            contexts: innerResult.contexts,
+            carrier: {
+              assets: result.carrier.assets,
+              environment: result.carrier.environment,
+              currentTaskGlobalIndex: innerResult.carrier.currentTaskGlobalIndex
+            }
+          });
+          return {
+            ...forkTaskResults,
+            carrier: {
+              assets: mergeAssets(
+                innerResult.carrier.assets,
+                forkTaskResults.carrier.assets
+              ),
+              environment: {
+                ...innerResult.carrier.environment,
+                ...forkTaskResults.carrier.environment
+              },
+              currentTaskGlobalIndex: forkTaskResults.carrier.currentTaskGlobalIndex
+            }
+          };
+        }, result);
+      }
+      if (taskData.type === WorkflowTaskType3.doWhile) {
+        const loopTaskResults = taskReducer(taskData.loopOver, {
+          contexts: result.contexts,
+          carrier: {
+            assets: result.carrier.assets,
+            environment: result.carrier.environment,
+            currentTaskGlobalIndex: result.carrier.currentTaskGlobalIndex
+          }
+        });
+        const { context: richDoWhileContext, newAssets: richDoWhileAssets } = getTaskContext(
+          taskData,
+          workflowBundle,
+          triggerContext,
+          specification,
+          loopTaskResults.carrier
+        );
+        return {
+          ...result,
+          contexts: {
+            ...loopTaskResults.contexts,
+            [taskData.taskReferenceName]: {
+              ...taskContext,
+              environment: richDoWhileContext.environment,
+              assets: richDoWhileAssets
+            }
+          }
+        };
+      }
+      return result;
+    }, initial);
+  }
+  const initialAssets = (triggerContext == null ? void 0 : triggerContext.config.specification) ? getTriggerAssets(triggerContext.data, triggerContext.config.specification) : void 0;
+  const initialEnvironment = {
+    workflow: workflowFrames
+  };
+  const {
+    contexts,
+    carrier: { environment, assets }
+  } = taskReducer(workflowBundle.workflow.definition.tasks, {
+    contexts: {},
+    carrier: {
+      assets: initialAssets != null ? initialAssets : {},
+      environment: initialEnvironment,
+      currentTaskGlobalIndex: ((_a = workflowBundle.workflow.trigger) == null ? void 0 : _a.type) ? 2 : 1
+    }
+  });
+  return {
+    tasks: contexts,
+    global: {
+      assets,
+      environment
+    }
+  };
+};
+var getWorkflowContexts = (workflow, sources = {}, dependencies = {}) => {
+  var _a;
+  const specification = (_a = dependencies.specification) != null ? _a : getSpecification();
+  const input = { workflow, ...sources };
+  const workflowFrames = {
+    input: getWorkflowInputFrame(input, specification)
+  };
+  const trigger = getTriggerContext(input, workflowFrames, specification);
+  const { tasks, global } = getTaskContexts(
+    input,
+    workflowFrames,
+    trigger,
+    specification
+  );
+  return {
+    trigger,
+    tasks,
+    global
+  };
+};
+
+// src/domain/credentials/utils.ts
+import {
+  CredentialType,
+  IntegrationNames
+} from "@livechat/developer-studio-api";
+import { getIntegrationsEnv } from "@livechat/platform-integrations/config";
+var getInternalCredentials = () => /* @__PURE__ */ new Map([
+  [IntegrationNames.Shopify, getIntegrationsEnv("shopifyClientId")],
+  [IntegrationNames.BigCommerce, getIntegrationsEnv("bigcommerceClientId")],
+  [IntegrationNames.HubSpot, getIntegrationsEnv("hubspotClientId")],
+  [IntegrationNames.Slack, getIntegrationsEnv("slackClientId")],
+  [IntegrationNames.Mailchimp, getIntegrationsEnv("mailchimpClientId")],
+  [IntegrationNames.Salesforce, getIntegrationsEnv("salesforceClientId")],
+  [IntegrationNames.Klaviyo, getIntegrationsEnv("klaviyoClientId")],
+  ["google", getIntegrationsEnv("googleClientId")]
+]);
+var getWorkflowCredentials = (credentials) => {
+  const internalCredentials = getInternalCredentials();
+  return credentials.map((credential) => {
+    let isInternal = credential.type === CredentialType.TextAuth;
+    if (!isInternal && credential.type === CredentialType.OAuth2) {
+      isInternal = internalCredentials.get(credential.provider) === credential.data.client_id;
+    }
+    return { ...credential, isInternal };
+  });
+};
+var getWorkflowElementDefaultCredentialId = (elementProvider, credentials) => {
+  if (elementProvider === OTHER_TYPES.SYSTEM) {
+    return;
+  }
+  const providerCredentials = credentials.filter(
+    (credential) => credential.provider === elementProvider
+  );
+  if (providerCredentials.length === 1) {
+    return providerCredentials[0].name;
+  } else if (providerCredentials.length > 1) {
+    const internalCredentials = providerCredentials.filter(
+      (credential) => credential.isInternal
+    );
+    if (internalCredentials.length === 1) {
+      return internalCredentials[0].name;
+    }
+  }
+};
+
+// src/domain/common/tasks/reduce.ts
+import { WorkflowTaskType as WorkflowTaskType4 } from "@livechat/developer-studio-api";
+function recursiveTaskReducer(tasks, reducer, level = 0) {
+  return tasks.reduce((result, task, taskIndex, allTasks) => {
+    const reducerResult = reducer(result, task, taskIndex, allTasks, level);
+    if (reducerResult) {
+      return reducerResult;
+    }
+    if (task.type === WorkflowTaskType4.switch) {
+      return [
+        ...result,
+        {
+          ...task,
+          decisionCases: Object.fromEntries(
+            Object.entries(task.decisionCases).map(
+              ([decisionCase, innerTasks]) => [
+                decisionCase,
+                recursiveTaskReducer(innerTasks, reducer, level + 1)
+              ]
+            )
+          )
+        }
+      ];
+    } else if (task.type === WorkflowTaskType4.forkJoin) {
+      return [
+        ...result,
+        {
+          ...task,
+          forkTasks: task.forkTasks.map(
+            (innerTasks) => recursiveTaskReducer(innerTasks, reducer, level + 1)
+          )
+        }
+      ];
+    } else if (task.type === WorkflowTaskType4.doWhile) {
+      return [
+        ...result,
+        {
+          ...task,
+          loopOver: recursiveTaskReducer(task.loopOver, reducer, level + 1)
+        }
+      ];
+    }
+    return [...result, task];
+  }, []);
+}
+function reduceTasksRecursively(tasks, reducer, initialValue, level = 0) {
+  return tasks.reduce((accumulator, task, taskIndex, allTasks) => {
+    let next = reducer(accumulator, task, taskIndex, allTasks, level);
+    if (task.type === WorkflowTaskType4.switch) {
+      next = Object.values(task.decisionCases).reduce(
+        (innerAccumulator, innerTasks) => reduceTasksRecursively(
+          innerTasks,
+          reducer,
+          innerAccumulator,
+          level + 1
+        ),
+        next
+      );
+    } else if (task.type === WorkflowTaskType4.forkJoin) {
+      next = task.forkTasks.reduce(
+        (innerAccumulator, innerTasks) => reduceTasksRecursively(
+          innerTasks,
+          reducer,
+          innerAccumulator,
+          level + 1
+        ),
+        next
+      );
+    } else if (task.type === WorkflowTaskType4.doWhile) {
+      next = reduceTasksRecursively(task.loopOver, reducer, next, level + 1);
+    }
+    return next;
+  }, initialValue);
+}
+
+// src/domain/common/prefill.tsx
+var CONTAINER_TASK_TYPES = [
+  WorkflowTaskType5.switch,
+  WorkflowTaskType5.forkJoin,
+  WorkflowTaskType5.doWhile
+];
+function isContainerTask(task) {
+  return CONTAINER_TASK_TYPES.includes(task.type);
+}
+function applyChange(workflow, change) {
+  const changed = mergeDeep(workflow, change);
+  changed.definition.tasks = recursiveTaskReducer(
+    changed.definition.tasks,
+    (result, task) => {
+      if (task.type === WorkflowTaskType5.join) {
+        const forkTask = result.at(-1);
+        return [
+          ...result,
+          {
+            ...task,
+            joinOn: forkTask.forkTasks.map((tasks) => {
+              var _a;
+              return (_a = tasks.at(-1)) == null ? void 0 : _a.taskReferenceName;
+            }).filter(notEmpty)
+          }
+        ];
+      }
+    }
+  );
+  return changed;
+}
+function assignDefaultCredential(element, context) {
+  const { specification, introspection, credentials } = context;
+  const config = getWorkflowElementConfig(
+    element,
+    introspection,
+    specification
+  );
+  const { isEditable } = config.customization.flags;
+  const { credentialPath } = config.specification.metadata;
+  if (!credentialPath || !isEditable) {
+    return element;
+  }
+  if (get2(element, credentialPath)) {
+    return element;
+  }
+  const credentialId = getWorkflowElementDefaultCredentialId(
+    config.customization.provider,
+    credentials
+  );
+  if (!credentialId) {
+    return element;
+  }
+  set2(element, credentialPath, credentialId);
+  return element;
+}
+function applyDefaultCredentials(workflow, context) {
+  var _a;
+  const trigger = ((_a = workflow.trigger) == null ? void 0 : _a.type) ? assignDefaultCredential(workflow.trigger, context) : workflow.trigger;
+  const tasks = recursiveTaskReducer(
+    workflow.definition.tasks,
+    (result, task) => {
+      if (isContainerTask(task)) {
+        return void 0;
+      }
+      return [...result, assignDefaultCredential(task, context)];
+    }
+  );
+  return {
+    ...workflow,
+    trigger,
+    definition: {
+      ...workflow.definition,
+      tasks
+    }
+  };
+}
+function applyWorkflowAssetBindings(workflow, context, previousContexts) {
+  var _a, _b;
+  const { specification, introspection } = context;
+  function taskUpdater(taskData, taskConfig, assets) {
+    var _a2, _b2, _c, _d;
+    const prevAssets = (_b2 = (_a2 = previousContexts.tasks[taskData.taskReferenceName]) == null ? void 0 : _a2.assets) != null ? _b2 : {};
+    Object.entries((_d = (_c = taskConfig.specification) == null ? void 0 : _c.inputReferences) != null ? _d : {}).forEach(
+      ([key, inputResourcePaths]) => {
+        inputResourcePaths.forEach((path) => {
+          var _a3, _b3, _c2;
+          const value = (_a3 = jsonUtils.extractByPath(path.value, taskData)) == null ? void 0 : _a3[0];
+          const currentAsset = assets[key];
+          const currentAssetConfig = workflowReferences[key];
+          if (currentAssetConfig.kind !== "resource" /* Resource */) {
+            return;
+          }
+          if (!value || typeof value !== "string") {
+            if ((currentAsset == null ? void 0 : currentAsset.length) === 1) {
+              set2(
+                taskData,
+                path.value,
+                jsonUtils.wrapWithTag(
+                  `${currentAsset[0].reference.taskName}.${currentAsset[0].reference.ref.value}`
+                )
+              );
+            }
+            return;
+          }
+          if (!jsonUtils.containsTag(value)) {
+            return;
+          }
+          if (!currentAsset) {
+            set2(taskData, path.value, null);
+            return;
+          }
+          const prev = (_b3 = prevAssets[key]) == null ? void 0 : _b3.find(
+            (x) => value.includes(
+              `\${${x.reference.taskName}.${x.reference.ref.value}}`
+            )
+          );
+          const currentAssetResource = (_c2 = currentAsset.find(
+            (a) => a.reference.ref.value === (prev == null ? void 0 : prev.reference.ref.value) && a.reference.taskName === prev.reference.taskName
+          )) != null ? _c2 : currentAsset.length === 1 ? currentAsset[0] : void 0;
+          if (!currentAssetResource) {
+            set2(taskData, path.value, null);
+            return;
+          }
+          set2(
+            taskData,
+            path.value,
+            jsonUtils.wrapWithTag(
+              `${currentAssetResource.reference.taskName}.${currentAssetResource.reference.ref.value}`
+            )
+          );
+        });
+      }
+    );
+    return taskData;
+  }
+  function taskReducer(tasks2, initial) {
+    return tasks2.reduce((result, taskData) => {
+      const taskConfig = getWorkflowElementConfig(
+        taskData,
+        introspection,
+        specification
+      );
+      const updatedTaskData = taskUpdater(
+        taskData,
+        taskConfig,
+        result.carrier.assets
+      );
+      const taskAssets = taskConfig.specification ? getTaskAssets(
+        updatedTaskData,
+        taskConfig.specification,
+        result.carrier.assets
+      ) : {};
+      result.carrier = {
+        assets: taskAssets
+      };
+      if (updatedTaskData.type === WorkflowTaskType5.switch) {
+        result.tasks = [
+          ...result.tasks,
+          {
+            ...updatedTaskData,
+            decisionCases: Object.fromEntries(
+              Object.entries(updatedTaskData.decisionCases).map(
+                ([decisionCase, innerTasks]) => {
+                  const decisionCaseResults = taskReducer(innerTasks, {
+                    tasks: [],
+                    carrier: {
+                      assets: initial.carrier.assets
+                    }
+                  });
+                  return [decisionCase, decisionCaseResults.tasks];
+                }
+              )
+            )
+          }
+        ];
+      } else if (updatedTaskData.type === WorkflowTaskType5.forkJoin) {
+        result.tasks = [
+          ...result.tasks,
+          {
+            ...updatedTaskData,
+            forkTasks: updatedTaskData.forkTasks.map((innerTasks) => {
+              const forkTaskResults = taskReducer(innerTasks, {
+                tasks: [],
+                carrier: {
+                  assets: initial.carrier.assets
+                }
+              });
+              return forkTaskResults.tasks;
+            })
+          }
+        ];
+      } else if (updatedTaskData.type === WorkflowTaskType5.doWhile) {
+        const loopTaskResults = taskReducer(updatedTaskData.loopOver, {
+          tasks: [],
+          carrier: {
+            assets: initial.carrier.assets
+          }
+        });
+        result.tasks = [
+          ...result.tasks,
+          {
+            ...updatedTaskData,
+            loopOver: loopTaskResults.tasks
+          }
+        ];
+      } else {
+        result.tasks = [...result.tasks, updatedTaskData];
+      }
+      return result;
+    }, initial);
+  }
+  const triggerConfig = ((_a = workflow.trigger) == null ? void 0 : _a.type) ? getWorkflowElementConfig(workflow.trigger, introspection, specification) : void 0;
+  const triggerAssets = ((_b = workflow.trigger) == null ? void 0 : _b.type) && (triggerConfig == null ? void 0 : triggerConfig.specification) ? getTriggerAssets(workflow.trigger, triggerConfig.specification) : {};
+  const { tasks } = taskReducer(workflow.definition.tasks, {
+    tasks: [],
+    carrier: {
+      assets: triggerAssets
+    }
+  });
+  return {
+    ...workflow,
+    definition: {
+      ...workflow.definition,
+      tasks
+    }
+  };
+}
+function prefillWorkflow(workflow, sources, dependencies) {
+  var _a, _b;
+  const specification = (_a = dependencies.specification) != null ? _a : getSpecification();
+  const introspection = (_b = sources.introspection) != null ? _b : { tasks: {} };
+  const normalized = applyChange(
+    cloneDeep2(workflow),
+    {}
+  );
+  const withCredentials = applyDefaultCredentials(normalized, {
+    ...dependencies,
+    specification,
+    introspection
+  });
+  const previousContexts = getWorkflowContexts(
+    withCredentials,
+    { introspection },
+    { specification }
+  );
+  return applyWorkflowAssetBindings(
+    withCredentials,
+    { specification, introspection },
+    previousContexts
+  );
+}
+
+// src/utils/schemaValidation.ts
+import Ajv from "ajv";
+import AjvWithErrors from "ajv-errors";
+import addFormats from "ajv-formats";
+import AjvWithKeywords from "ajv-keywords";
+function collectAllErrors(schemaNode) {
+  let errors = [];
+  if (Array.isArray(schemaNode.__errorsExtended)) {
+    errors = errors.concat(schemaNode.__errorsExtended);
+  }
+  for (const key in schemaNode) {
+    const node = schemaNode[key];
+    if (!key.startsWith("__") && typeof node === "object") {
+      errors = errors.concat(collectAllErrors(node));
+    }
+  }
+  return errors;
+}
+var buildErrorSchema = (validationErrors, data) => {
+  const adjustedErrors = validationErrors.map((rawError) => {
+    var _a;
+    let error = rawError;
+    let overrideMessage = true;
+    if (error.keyword === "errorMessage") {
+      const customError = error;
+      const innerError = customError.params.errors[0];
+      if (innerError) {
+        error = {
+          ...error,
+          keyword: innerError.keyword,
+          params: innerError.params,
+          schemaPath: innerError.schemaPath
+        };
+        overrideMessage = false;
+      }
+    }
+    if ("missingProperty" in error.params) {
+      if (error.params.missingProperty) {
+        error.instancePath = `${error.instancePath}/${error.params.missingProperty}`;
+        error.keyword = "requiredProperty";
+        if (error.params.missingProperty === "credentialId") {
+          error.keyword = "connection";
+        }
+        if (overrideMessage) {
+          error.message = "property is required";
+        }
+      }
+    }
+    if (overrideMessage) {
+      switch (error.keyword) {
+        case "type": {
+          const instanceJsonPath = error.instancePath.slice(1);
+          const value = instanceJsonPath ? (_a = jsonUtils.extractByPath(
+            instanceJsonPath.replaceAll("/", "."),
+            data
+          )) == null ? void 0 : _a[0] : void 0;
+          if (value === null) {
+            error.message = "This field cannot be empty";
+          } else {
+            error.message = "Invalid value type";
+          }
+          break;
+        }
+        case "required":
+          error.message = `Field '${error.params.missingProperty}' is required`;
+          break;
+        case "requiredProperty":
+          error.message = "This field cannot be empty";
+          break;
+        case "minLength":
+          error.message = `Must have more than ${error.params.limit} characters`;
+          break;
+        case "const":
+          error.message = "Must be one of enumeration";
+          break;
+        default:
+          break;
+      }
+    }
+    return error;
+  }).map((error) => {
+    var _a;
+    const instanceJsonPath = error.instancePath.slice(1);
+    const value = instanceJsonPath ? (_a = jsonUtils.extractByPath(
+      instanceJsonPath.replaceAll("/", "."),
+      data
+    )) == null ? void 0 : _a[0] : void 0;
+    if (typeof value === "string" && ["format", "pattern", "const", "enum", "oneOf"].includes(error.keyword)) {
+      if (error.keyword === "format" && error.params.format === "json") {
+        return error;
+      }
+      if (jsonUtils.containsTag(value)) {
+        return;
+      }
+    }
+    return error;
+  }).filter(notEmpty);
+  const errors = {};
+  function addToErrorSchema(current, path, item) {
+    var _a;
+    const [head, ...tail] = path;
+    if (!head) {
+      return false;
+    }
+    if (tail.length === 0) {
+      if (!current[head]) {
+        current[head] = {};
+      }
+      const fieldErrors = current[head];
+      if (item.message && item.message !== 'must match "then" schema' && item.message !== 'must match "else" schema') {
+        if (!fieldErrors.__errors) {
+          fieldErrors.__errors = [];
+        }
+        if (!fieldErrors.__errorsExtended) {
+          fieldErrors.__errorsExtended = [];
+        }
+        fieldErrors.__errors.push(item.message);
+        fieldErrors.__errorsExtended.push(item);
+        if (item.keyword) {
+          (_a = fieldErrors.__errorsByKeyword) != null ? _a : fieldErrors.__errorsByKeyword = {};
+          fieldErrors.__errorsByKeyword[item.keyword] = item;
+        }
+        return true;
+      }
+      return Object.keys(fieldErrors).length > 0;
+    }
+    if (!current[head]) {
+      current[head] = {};
+    }
+    const hasError = addToErrorSchema(
+      current[head],
+      tail,
+      item
+    );
+    if (!hasError) {
+      delete current[head];
+      return Object.keys(current).length > 0;
+    }
+    return true;
+  }
+  if (adjustedErrors.length > 0) {
+    adjustedErrors.forEach((item) => {
+      const path = item.instancePath.split("/").filter(Boolean);
+      addToErrorSchema(errors, path, item);
+    });
+  }
+  return errors;
+};
+var getValidator = (schema) => {
+  const ajv = new Ajv({
+    strict: false,
+    allErrors: true,
+    inlineRefs: false
+  });
+  addFormats(ajv);
+  ajv.addFormat("json", {
+    type: "string",
+    validate: (data) => {
+      try {
+        JSON.parse(data);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+  });
+  return AjvWithKeywords(AjvWithErrors(ajv)).compile(schema);
+};
+
+// src/domain/validation/schema/full.ts
+import {
+  WorkflowItemKind as WorkflowItemKind2,
+  WorkflowTriggerType as WorkflowTriggerType5
+} from "@livechat/developer-studio-api";
+
+// src/domain/validation/schema/defs.ts
+var jsonSchemaBaseOptions = [
+  {
+    const: "string",
+    title: "String",
+    "x-group": "Simple Types"
+  },
+  {
+    const: "number",
+    title: "Number",
+    "x-group": "Simple Types"
+  },
+  {
+    const: "boolean",
+    title: "Boolean",
+    "x-group": "Simple Types"
+  },
+  {
+    const: `references/${LIVECHAT_REFERENCE_NAMES.Chat}`,
+    title: "Chat",
+    "x-group": "References"
+  },
+  {
+    const: `references/${LIVECHAT_REFERENCE_NAMES.Thread}`,
+    title: "Thread",
+    "x-group": "References"
+  },
+  {
+    const: `references/${HELPDESK_REFERENCE_NAMES.Ticket}`,
+    title: "Ticket",
+    "x-group": "References"
+  }
+];
+var jsonSchema = {
+  type: "object",
+  default: {
+    title: "",
+    description: "",
+    type: "string"
+  },
+  required: ["title", "description", "type"],
+  properties: {
+    title: {
+      type: "string",
+      title: "Title"
+    },
+    description: {
+      type: "string",
+      title: "Description"
+    },
+    type: {
+      type: "string",
+      title: "Type",
+      default: "string",
+      oneOf: [
+        ...jsonSchemaBaseOptions,
+        {
+          const: "object",
+          title: "Object",
+          "x-group": "Simple Types"
+        },
+        {
+          const: "array",
+          title: "Array",
+          "x-group": "Simple Types"
+        }
+      ]
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: { type: { const: "object" } },
+        required: ["type"]
+      },
+      then: {
+        properties: {
+          properties: {
+            type: "object",
+            title: "Properties",
+            visible: true,
+            patternProperties: {
+              ".*": {
+                $ref: "#/$defs/jsonSchema"
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      if: {
+        properties: { type: { const: "array" } },
+        required: ["type"]
+      },
+      then: {
+        required: ["title", "description", "type", "items"],
+        properties: {
+          items: {
+            title: "Items",
+            $ref: "#/$defs/jsonSchema"
+          }
+        }
+      }
+    },
+    {
+      if: {
+        properties: { type: { const: "string" } },
+        required: ["type"]
+      },
+      then: {
+        properties: {}
+      }
+    },
+    {
+      if: {
+        properties: { type: { const: "number" } },
+        required: ["type"]
+      },
+      then: {
+        properties: {}
+      }
+    }
+  ]
+};
+var jsonSchemaSimplified = {
+  type: "object",
+  default: {
+    type: "string"
+  },
+  required: ["type"],
+  properties: {
+    type: {
+      type: "string",
+      title: "Type",
+      default: "string",
+      oneOf: jsonSchemaBaseOptions
+    }
+  }
+};
+
+// src/domain/validation/schema/full.ts
+var itemVersionCondition = (type, name, version) => {
+  const base = {
+    required: ["type", "name"],
+    properties: {
+      type: { const: type },
+      name: { const: name }
+    }
+  };
+  const isWebhookTrigger = type === WorkflowTriggerType5.webhook;
+  const versionMissing = isWebhookTrigger ? {
+    properties: {
+      webhook: {
+        properties: {
+          event: { not: { required: ["version"] } }
+        }
+      }
+    }
+  } : { not: { required: ["version"] } };
+  const versionMatches = (versionSchema) => isWebhookTrigger ? {
+    required: ["webhook"],
+    properties: {
+      webhook: {
+        required: ["event"],
+        properties: {
+          event: {
+            required: ["version"],
+            properties: { version: versionSchema }
+          }
+        }
+      }
+    }
+  } : {
+    required: ["version"],
+    properties: { version: versionSchema }
+  };
+  if (version === "v0") {
+    return {
+      allOf: [
+        base,
+        {
+          anyOf: [versionMissing, versionMatches({ enum: ["v0", null] })]
+        }
+      ]
+    };
+  }
+  return {
+    allOf: [base, versionMatches({ const: version })]
+  };
+};
+var collectSpecEntries = (kind) => Object.values(rawItemConfigs).filter((item) => item.kind === kind).flatMap(
+  (config) => Object.entries(config.specifications.versions).map((version) => ({
+    config,
+    version
+  }))
+);
+var taskSpecEntries = collectSpecEntries(WorkflowItemKind2.Task);
+var triggerSpecEntries = collectSpecEntries(WorkflowItemKind2.Trigger);
+var taskSchemas = Object.fromEntries(
+  taskSpecEntries.map(({ config, version: [version, specification] }) => [
+    `${config.key}_${version}`,
+    specification.input
+  ])
+);
+var tasksDefinition = {
+  type: "array",
+  default: [],
+  items: {
+    allOf: taskSpecEntries.map(
+      ({ config, version: [version, specification] }) => ({
+        if: itemVersionCondition(
+          specification.template.type,
+          config.key,
+          version
+        ),
+        then: {
+          $ref: `#/$defs/taskSchemas/${config.key}_${version}`
+        }
+      })
+    )
+  }
+};
+var triggerDefinition = [
+  {
+    if: {
+      properties: { type: { const: void 0 } }
+    },
+    then: {
+      required: ["type"],
+      properties: { type: { type: "string" } },
+      errorMessage: { required: "Add a trigger to start your workflow" }
+    }
+  },
+  ...triggerSpecEntries.map(
+    ({ config, version: [version, specification] }) => ({
+      if: itemVersionCondition(
+        specification.template.type,
+        config.key,
+        version
+      ),
+      then: specification.input
+    })
+  )
+];
+var WORKFLOW_SCHEMA_DEFS = {
+  $defs: {
+    tasks: tasksDefinition,
+    references: workflowReferences,
+    resources: workflowResources,
+    jsonSchema,
+    taskSchemas,
+    jsonSchemaSimplified
+  }
+};
+var workflowSchema = {
+  $schema: "http://json-schema.org/draft-07/schema",
+  type: "object",
+  title: "The root schema",
+  description: "The root schema comprises the entire JSON document.",
+  default: {},
+  examples: [
+    {
+      name: "first_sample_workflow",
+      description: "First Sample Workflow",
+      version: 1,
+      definition: {
+        tasks: [
+          {
+            name: "get_population_data",
+            taskReferenceName: "get_population_data",
+            inputParameters: {
+              http_request: {
+                uri: "https://datausa.io/api/data?drilldowns=Nation&measures=Population",
+                method: "GET"
+              }
+            },
+            type: "HTTP"
+          }
+        ],
+        inputParameters: null,
+        outputParameters: {
+          data: "${get_population_data.output.response.body.data}",
+          source: "${get_population_data.output.response.body.source}"
+        },
+        schemaVersion: 2,
+        restartable: true,
+        workflowStatusListenerEnabled: false,
+        timeoutPolicy: "ALERT_ONLY",
+        timeoutSeconds: 0
+      }
+    }
+  ],
+  properties: {
+    name: {
+      $id: "#/properties/name",
+      default: "",
+      description: "Workflow Name - should be without spaces or special characters. Underscores and periods are allowed.",
+      maxLength: 100,
+      minLength: 1,
+      title: "Workflow Name",
+      type: "string"
+    },
+    description: {
+      $id: "#/properties/description",
+      type: "string",
+      title: "Workflow Description",
+      description: "An brief description of your workflow for reference.",
+      default: "",
+      examples: ["First Sample Workflow"]
+    },
+    version: {
+      $id: "#/properties/version",
+      default: 0,
+      description: "An explanation about the purpose of this instance.",
+      examples: [1],
+      title: "The version schema",
+      minimum: 0,
+      type: "integer"
+    },
+    definition: {
+      $id: "#/properties/definition",
+      type: "object",
+      title: "Workflow Definition",
+      description: "This object holds the definition of your workflow.",
+      default: {},
+      properties: {
+        tasks: {
+          $id: "#/properties/definition/tasks",
+          $ref: "#/$defs/tasks",
+          minItems: 1,
+          title: "Workflow Tasks",
+          description: "This list holds the tasks for your workflow.",
+          errorMessage: {
+            minItems: "Add an action to complete your workflow."
+          }
+        },
+        inputParameters: {
+          $id: "#/properties/definition/inputParameters",
+          type: ["array", "null"],
+          title: "Workflow Input Parameters",
+          description: "An explanation about the purpose of this instance.",
+          default: [],
+          examples: [[]],
+          items: {
+            $id: "#/properties/inputParameters/items"
+          }
+        },
+        outputParameters: {
+          $id: "#/properties/definition/outputParameters",
+          type: "object",
+          title: "The outputParameters schema",
+          description: "An explanation about the purpose of this instance.",
+          default: {},
+          examples: [
+            {
+              data: "${get_population_data.output.response.body.data}",
+              source: "${get_population_data.output.response.body.source}"
+            }
+          ],
+          required: [],
+          properties: {},
+          additionalProperties: true
+        },
+        schemaVersion: {
+          $id: "#/properties/definition/schemaVersion",
+          type: "integer",
+          title: "Schema Version",
+          description: "Fixed schema version",
+          default: 2,
+          examples: [2]
+        },
+        restartable: {
+          $id: "#/properties/definition/restartable",
+          type: "boolean",
+          title: "Workflow restartable",
+          description: "Specify if the workflow is restartable.",
+          default: true,
+          examples: [true, false]
+        },
+        workflowStatusListenerEnabled: {
+          $id: "#/properties/definition/workflowStatusListenerEnabled",
+          type: "boolean",
+          title: "The workflowStatusListenerEnabled schema",
+          description: "An explanation about the purpose of this instance.",
+          default: false,
+          examples: [true, false]
+        },
+        timeoutPolicy: {
+          $id: "#/properties/definition/timeoutPolicy",
+          type: "string",
+          title: "The timeoutPolicy schema",
+          description: "An explanation about the purpose of this instance.",
+          default: "",
+          examples: ["ALERT_ONLY", "TIME_OUT_WF"]
+        },
+        timeoutSeconds: {
+          $id: "#/properties/definition/timeoutSeconds",
+          type: "integer",
+          title: "The timeoutSeconds schema",
+          description: "An explanation about the purpose of this instance.",
+          default: 0,
+          examples: [0]
+        }
+      }
+    },
+    trigger: {
+      $id: "#/properties/trigger",
+      type: "object",
+      title: "Workflow Trigger",
+      description: "This object holds the declaration of your workflow trigger.",
+      default: {},
+      allOf: triggerDefinition
+    }
+  },
+  required: ["definition", "trigger"],
+  $defs: WORKFLOW_SCHEMA_DEFS.$defs
+};
+
+// src/domain/validation/utils.ts
+import {
+  CredentialType as CredentialType2,
+  IntegrationNames as IntegrationNames2,
+  WorkflowExecutionTaskStatus as WorkflowExecutionTaskStatus2,
+  WorkflowTaskType as WorkflowTaskType6,
+  WorkflowTriggerType as WorkflowTriggerType6
+} from "@livechat/developer-studio-api";
+
+// src/domain/validation/types.ts
+var WorkflowValidationErrorType = /* @__PURE__ */ ((WorkflowValidationErrorType2) => {
+  WorkflowValidationErrorType2["Schema"] = "schema";
+  WorkflowValidationErrorType2["Resolver"] = "resolver";
+  WorkflowValidationErrorType2["Connection"] = "connection";
+  WorkflowValidationErrorType2["Activation"] = "activation";
+  WorkflowValidationErrorType2["Execution"] = "execution";
+  WorkflowValidationErrorType2["Stale"] = "stale";
+  return WorkflowValidationErrorType2;
+})(WorkflowValidationErrorType || {});
+
+// src/domain/validation/utils.ts
+var resolveTasksRecursively = (tasks, contexts) => tasks.map((task) => {
+  var _a;
+  const taskContext = contexts.tasks[task.taskReferenceName];
+  const resolveOptions = {
+    noFallback: true,
+    zeroArrayIndex: !taskContext.execution
+  };
+  if (task.type === WorkflowTaskType6.switch) {
+    const resolved = jsonUtils.resolveObjectByContext(
+      { ...task, decisionCases: {}, defaultCase: [] },
+      taskContext.environment,
+      resolveOptions
+    );
+    return {
+      ...resolved != null ? resolved : task,
+      decisionCases: Object.fromEntries(
+        Object.entries(task.decisionCases).map(([caseName, caseTasks]) => [
+          caseName,
+          resolveTasksRecursively(caseTasks, contexts)
+        ])
+      ),
+      ...task.defaultCase ? {
+        defaultCase: resolveTasksRecursively(task.defaultCase, contexts)
+      } : {}
+    };
+  }
+  if (task.type === WorkflowTaskType6.forkJoin) {
+    const resolved = jsonUtils.resolveObjectByContext(
+      { ...task, forkTasks: [] },
+      taskContext.environment,
+      resolveOptions
+    );
+    return {
+      ...resolved != null ? resolved : task,
+      forkTasks: task.forkTasks.map(
+        (branch) => resolveTasksRecursively(branch, contexts)
+      )
+    };
+  }
+  return (_a = jsonUtils.resolveObjectByContext(
+    task,
+    taskContext.environment,
+    resolveOptions
+  )) != null ? _a : task;
+});
+var validateSchema = (workflow, contexts, validateFunction) => {
+  var _a, _b;
+  const resolved = {
+    ...workflow,
+    definition: {
+      ...workflow.definition,
+      tasks: resolveTasksRecursively(workflow.definition.tasks, contexts)
+    },
+    trigger: jsonUtils.resolveObjectByContext(
+      workflow.trigger,
+      (_a = contexts.trigger) == null ? void 0 : _a.environment,
+      {
+        noFallback: true,
+        zeroArrayIndex: !((_b = contexts.trigger) == null ? void 0 : _b.execution)
+      }
+    )
+  };
+  try {
+    validateFunction(resolved);
+  } catch (error) {
+    if (error instanceof RangeError) {
+      return [];
+    }
+    throw error;
+  }
+  return (validateFunction.errors || []).filter(
+    // Filter out errors that comes from validation of "valid one of possible tasks"
+    // It's need to filter because for dynamic inputs sometimes task doesnt fit format, min/max length etc.
+    (x) => !/^#\/items\/allOf\/[^/]+\/if$/.exec(x.schemaPath)
+  ).map((error) => ({
+    ...error,
+    severity: "error"
+  }));
+};
+function validateCredential(credentialId, taskProvider, credentialPath, credentials) {
+  if (!credentialId) {
+    return [];
+  }
+  const errors = [];
+  const credential = credentials.find((c) => c.name === credentialId);
+  if (!credential) {
+    errors.push({
+      instancePath: credentialPath,
+      keyword: "connection" /* Connection */,
+      message: "Credential not found",
+      params: {},
+      severity: "error"
+    });
+  } else {
+    const expectedProvider = (taskProvider == null ? void 0 : taskProvider.startsWith(IntegrationNames2.Text)) ? IntegrationNames2.Text : taskProvider;
+    if (expectedProvider && taskProvider !== OTHER_TYPES.SYSTEM && credential.provider !== expectedProvider) {
+      errors.push({
+        instancePath: credentialPath,
+        keyword: "connection" /* Connection */,
+        message: `Credential provider mismatch (expected ${expectedProvider}, got ${credential.provider})`,
+        params: {},
+        severity: "error"
+      });
+    }
+    if (credential.type === CredentialType2.OAuth2 && !credential.data.connected) {
+      errors.push({
+        instancePath: credentialPath,
+        keyword: "connection" /* Connection */,
+        message: "Credential is not connected",
+        params: {},
+        severity: "error"
+      });
+    }
+  }
+  return errors;
+}
+var getActionFunctionError = (outputData) => {
+  const error = outputData == null ? void 0 : outputData.error;
+  return (error == null ? void 0 : error.type) === "function_error" ? error : void 0;
+};
+var validateTasks = (workflow, contexts, credentials, products) => {
+  function taskCompiler(task, baseInstancePath) {
+    var _a, _b, _c;
+    const context = contexts.tasks[task.taskReferenceName];
+    const config = context == null ? void 0 : context.config;
+    const environment = context == null ? void 0 : context.environment;
+    const execution = context == null ? void 0 : context.execution;
+    const resolvingErrors = jsonUtils.getMatchesInObject(task).map((match) => {
+      var _a2, _b2, _c2;
+      const segments = match.rawValue.split(".");
+      let message = "Invalid field value";
+      const params = {};
+      if (!(environment == null ? void 0 : environment[segments[0]])) {
+        if (segments[0]) {
+          if (contexts.tasks[segments[0]]) {
+            message += " - task not accessible";
+          } else {
+            message += " - task not found";
+          }
+        }
+      } else if (segments[0] === "workflow") {
+        if (segments[1] === "input") {
+          const resolved = validatePathAgainstSchema(
+            segments.slice(2).join("."),
+            (_a2 = environment.workflow.input) == null ? void 0 : _a2.__meta.config.specification.output
+          );
+          if (resolved.valid) {
+            return;
+          }
+          if (segments[2] === "body") {
+            if ((_b2 = workflow.trigger) == null ? void 0 : _b2.type) {
+              message += " - invalid trigger property";
+            } else {
+              message += " - trigger not found";
+            }
+          } else if (!((_c2 = workflow.trigger) == null ? void 0 : _c2.type) || workflow.trigger.type === WorkflowTriggerType6.recurring || workflow.trigger.type === WorkflowTriggerType6.webhook) {
+            message = "Couldn't use manual parameters when trigger is not manual";
+          } else {
+            message += " - invalid input property";
+          }
+        } else {
+          message += " - invalid property";
+        }
+      } else {
+        const elementFrame = environment[segments[0]];
+        const resolved = validatePathAgainstSchema(
+          segments.slice(1).join("."),
+          elementFrame == null ? void 0 : elementFrame.__meta.config.specification.output
+        );
+        if (resolved.valid) {
+          if (elementFrame == null ? void 0 : elementFrame.__meta.config.stale) {
+            message += " - stale property used";
+            return {
+              instancePath: `${baseInstancePath}/${match.instancePath}`,
+              keyword: "stale" /* Stale */,
+              message,
+              params,
+              severity: "error"
+            };
+          }
+          return;
+        }
+        message += " - invalid task property";
+      }
+      return {
+        instancePath: `${baseInstancePath}/${match.instancePath}`,
+        keyword: "resolver" /* Resolver */,
+        message,
+        params,
+        severity: "error"
+      };
+    }).filter(Boolean);
+    const actionFunctionError = (execution == null ? void 0 : execution.data.taskType) === WorkflowTaskType6.simple ? getActionFunctionError(execution.data.outputData) : void 0;
+    const executionErrors = (execution == null ? void 0 : execution.data.status) === WorkflowExecutionTaskStatus2.Failed ? [
+      execution.data.taskType === WorkflowTaskType6.http && ((_a = execution.data.outputData.response.body) == null ? void 0 : _a.type) === "function_error" ? execution.data.outputData.response.body.error_type === "unauthorized" ? {
+        instancePath: baseInstancePath,
+        keyword: "execution" /* Execution */,
+        message: execution.data.outputData.response.body.error,
+        params: {},
+        severity: "error"
+      } : {
+        instancePath: execution.data.outputData.response.body.affected_field ? `${baseInstancePath}/inputParameters/http_request/${execution.data.outputData.response.body.affected_field.field_location}/${execution.data.outputData.response.body.affected_field.field_path.replaceAll(
+          ".",
+          "/"
+        )}` : baseInstancePath,
+        keyword: "execution" /* Execution */,
+        message: execution.data.outputData.response.body.error,
+        params: {},
+        severity: "error"
+      } : actionFunctionError ? {
+        instancePath: ((_b = actionFunctionError.affected_field) == null ? void 0 : _b.field_path) ? `${baseInstancePath}/inputParameters/${actionFunctionError.affected_field.field_path.replaceAll(
+          ".",
+          "/"
+        )}` : baseInstancePath,
+        keyword: "execution" /* Execution */,
+        message: actionFunctionError.error,
+        params: {},
+        severity: "error"
+      } : {
+        instancePath: baseInstancePath,
+        keyword: "execution" /* Execution */,
+        message: execution.data.reasonForIncompletion,
+        params: {},
+        severity: "error"
+      }
+    ] : [];
+    const activationError = (config == null ? void 0 : config.customization.provider) !== IntegrationNames2.Text && (config == null ? void 0 : config.customization.provider.startsWith(IntegrationNames2.Text)) && !products.find(
+      ({ product }) => product === config.customization.providerDisplay || product === TEXTAPP_PRODUCT_NAME
+    ) && {
+      instancePath: baseInstancePath,
+      keyword: "activation" /* Activation */,
+      message: `${config.customization.providerDisplay} not activated`,
+      params: {},
+      severity: "error"
+    };
+    const credentialErrors = task.type === WorkflowTaskType6.http && "http_request" in task.inputParameters ? validateCredential(
+      task.inputParameters.http_request.credentialId,
+      config == null ? void 0 : config.customization.provider,
+      `${baseInstancePath}/inputParameters/http_request/credentialId`,
+      credentials
+    ) : [];
+    const staleError = ((_c = context == null ? void 0 : context.introspection) == null ? void 0 : _c.stale) ? {
+      instancePath: baseInstancePath,
+      keyword: "stale" /* Stale */,
+      message: "Task is stale - test it again to refresh its data",
+      params: {},
+      severity: "warning"
+    } : null;
+    return [
+      ...resolvingErrors,
+      ...executionErrors,
+      ...credentialErrors,
+      ...activationError ? [activationError] : [],
+      ...staleError ? [staleError] : []
+    ];
+  }
+  function taskReducer(tasks, initial, baseInstancePath) {
+    return tasks.reduce((result, task, taskIndex) => {
+      const taskBaseInstancePath = `${baseInstancePath}/${taskIndex}`;
+      if (task.type === WorkflowTaskType6.switch) {
+        result.push(
+          ...taskCompiler(
+            {
+              ...task,
+              decisionCases: {}
+            },
+            taskBaseInstancePath
+          )
+        );
+        return Object.entries(task.decisionCases).reduce(
+          (innerResult, [decisionCase, innerTasks]) => taskReducer(
+            innerTasks,
+            innerResult,
+            `${taskBaseInstancePath}/decisionCases/${decisionCase}`
+          ),
+          result
+        );
+      }
+      if (task.type === WorkflowTaskType6.forkJoin) {
+        result.push(
+          ...taskCompiler(
+            {
+              ...task,
+              forkTasks: []
+            },
+            taskBaseInstancePath
+          )
+        );
+        return task.forkTasks.reduce(
+          (innerResult, innerTasks, branchIndex) => taskReducer(
+            innerTasks,
+            innerResult,
+            `${taskBaseInstancePath}/forkTasks/${branchIndex}`
+          ),
+          result
+        );
+      }
+      if (task.type === WorkflowTaskType6.doWhile) {
+        result.push(
+          ...taskCompiler(
+            {
+              ...task,
+              loopOver: []
+            },
+            taskBaseInstancePath
+          )
+        );
+        const innerErrors = taskReducer(
+          task.loopOver,
+          result,
+          `${taskBaseInstancePath}/loopOver`
+        );
+        return [...result, ...innerErrors];
+      }
+      result.push(...taskCompiler(task, taskBaseInstancePath));
+      return result;
+    }, initial);
+  }
+  return taskReducer(workflow.definition.tasks, [], "/definition/tasks");
+};
+var validateTrigger = (trigger, contexts, credentials, products) => {
+  var _a, _b;
+  const config = (_a = contexts.trigger) == null ? void 0 : _a.config;
+  const execution = (_b = contexts.trigger) == null ? void 0 : _b.execution;
+  const resolvingErrors = jsonUtils.getMatchesInObject(trigger).map((match) => {
+    let message = "Invalid field value";
+    const segments = match.rawValue.split(".");
+    const params = {};
+    if (segments[0] === "workflow") {
+      message += " - invalid property";
+    } else {
+      message += " - invalid trigger property";
+    }
+    return {
+      instancePath: `/trigger/${match.instancePath}`,
+      keyword: "resolver" /* Resolver */,
+      message,
+      params,
+      severity: "error"
+    };
+  }).filter(Boolean);
+  const executionErrors = (execution == null ? void 0 : execution.data.status) === WorkflowExecutionTaskStatus2.Failed ? [
+    {
+      instancePath: "/trigger",
+      keyword: "execution" /* Execution */,
+      message: "Trigger execution failed",
+      params: {},
+      severity: "error"
+    }
+  ] : [];
+  const activationError = (config == null ? void 0 : config.customization.provider.startsWith(IntegrationNames2.Text)) && !products.find(
+    ({ product }) => product === config.customization.providerDisplay || product === TEXTAPP_PRODUCT_NAME
+  ) && {
+    instancePath: "/trigger",
+    keyword: "activation" /* Activation */,
+    message: `${config.customization.providerDisplay} not activated`,
+    params: {},
+    severity: "error"
+  };
+  const credentialErrors = trigger.type === WorkflowTriggerType6.webhook ? validateCredential(
+    trigger.webhook.credential_id,
+    config == null ? void 0 : config.customization.provider,
+    "/trigger/webhook/credential_id",
+    credentials
+  ) : [];
+  return [
+    ...resolvingErrors,
+    ...executionErrors,
+    ...credentialErrors,
+    ...activationError ? [activationError] : []
+  ];
+};
+function flattenErrorSchema(workflow, schema) {
+  var _a, _b;
+  function cutoffNestedErrors(errorObj) {
+    if (!errorObj) return void 0;
+    const entries = Object.entries(errorObj).map(([key, value]) => {
+      if (key.startsWith("__")) return [key, value];
+      const item = value;
+      return item.__errors ? [
+        key,
+        {
+          __errors: item.__errors,
+          __errorsExtended: item.__errorsExtended
+        }
+      ] : null;
+    }).filter(Boolean);
+    return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+  }
+  function processContainerTask(result, task, nestedGroups, nestedErrorGroups, containerErrors, nestedFieldName) {
+    const final = nestedGroups.reduce(
+      (acc, tasks, i) => flattenTaskErrors(tasks, {
+        tasksErrors: acc.tasksErrors,
+        errors: nestedErrorGroups[i]
+      }),
+      result
+    );
+    if (containerErrors) {
+      const cutoff = cutoffNestedErrors(
+        containerErrors[nestedFieldName]
+      );
+      const cutoffErrors = {
+        ...containerErrors,
+        [nestedFieldName]: cutoff
+      };
+      const allErrors = collectAllErrors(
+        cutoffErrors
+      );
+      if (allErrors.length > 0) {
+        final.tasksErrors[task.taskReferenceName] = cutoffErrors;
+        final.tasksErrors[task.taskReferenceName].__allErrors = allErrors;
+      }
+    }
+    return { tasksErrors: final.tasksErrors, errors: result.errors };
+  }
+  function flattenTaskErrors(tasks, initial) {
+    return tasks.reduce((result, task, taskIndex) => {
+      var _a2;
+      const taskErrorsSchema = (_a2 = result.errors) == null ? void 0 : _a2[taskIndex];
+      if (task.type === WorkflowTaskType6.switch) {
+        const switchErrors = taskErrorsSchema;
+        return processContainerTask(
+          result,
+          task,
+          Object.values(task.decisionCases),
+          Object.keys(task.decisionCases).map(
+            (key) => {
+              var _a3;
+              return (_a3 = switchErrors == null ? void 0 : switchErrors.decisionCases) == null ? void 0 : _a3[key];
+            }
+          ),
+          switchErrors,
+          "decisionCases"
+        );
+      }
+      if (task.type === WorkflowTaskType6.forkJoin) {
+        const forkErrors = taskErrorsSchema;
+        return processContainerTask(
+          result,
+          task,
+          task.forkTasks,
+          task.forkTasks.map((_, i) => {
+            var _a3;
+            return (_a3 = forkErrors == null ? void 0 : forkErrors.forkTasks) == null ? void 0 : _a3[i];
+          }),
+          forkErrors,
+          "forkTasks"
+        );
+      }
+      if (task.type === WorkflowTaskType6.doWhile) {
+        const loopErrors = taskErrorsSchema;
+        return processContainerTask(
+          result,
+          task,
+          [task.loopOver],
+          [loopErrors == null ? void 0 : loopErrors.loopOver],
+          loopErrors,
+          "loopOver"
+        );
+      }
+      if (taskErrorsSchema) {
+        const allErrors = collectAllErrors(taskErrorsSchema);
+        result.tasksErrors[task.taskReferenceName] = taskErrorsSchema;
+        result.tasksErrors[task.taskReferenceName].__allErrors = allErrors;
+      }
+      return result;
+    }, initial);
+  }
+  const { tasksErrors } = flattenTaskErrors(workflow.definition.tasks, {
+    errors: (_a = schema.definition) == null ? void 0 : _a.tasks,
+    tasksErrors: {}
+  });
+  return Object.fromEntries(
+    Object.entries({
+      trigger: schema.trigger ? {
+        ...schema.trigger,
+        __allErrors: collectAllErrors(schema.trigger)
+      } : void 0,
+      tasks: tasksErrors,
+      all: {
+        ...tasksErrors,
+        ...((_b = workflow.trigger) == null ? void 0 : _b.name) ? { [workflow.trigger.name]: schema.trigger } : {}
+      }
+    }).filter(([, value]) => Boolean(value))
+  );
+}
+var getWorkflowValidation = (workflow, internal, external, validator) => {
+  var _a;
+  const rawErrors = [
+    ...((_a = workflow.trigger) == null ? void 0 : _a.type) ? validateTrigger(
+      workflow.trigger,
+      internal.contexts,
+      internal.credentials,
+      external.products
+    ) : [],
+    ...validateTasks(
+      workflow,
+      internal.contexts,
+      internal.credentials,
+      external.products
+    ),
+    ...validateSchema(workflow, internal.contexts, validator)
+  ];
+  const schema = buildErrorSchema(rawErrors, workflow);
+  const errors = flattenErrorSchema(workflow, schema);
+  return {
+    isValid: !Object.values(schema).length,
+    raw: schema,
+    errors
+  };
+};
+
+// src/domain/validation/index.ts
+var schemaValidator;
+function validateWorkflow(workflow, sources, dependencies) {
+  var _a;
+  schemaValidator != null ? schemaValidator : schemaValidator = getValidator(workflowSchema);
+  const specification = (_a = dependencies.specification) != null ? _a : getSpecification();
+  const contexts = getWorkflowContexts(workflow, sources, { specification });
+  return getWorkflowValidation(
+    workflow,
+    {
+      contexts,
+      credentials: getWorkflowCredentials(dependencies.credentials)
+    },
+    { products: dependencies.products },
+    schemaValidator
+  );
+}
+
+// src/domain/index.ts
+export * from "@livechat/developer-studio-api/workflow-contracts";
+import { IntegrationNames as IntegrationNames3 } from "@livechat/developer-studio-api";
+export {
+  IntegrationNames3 as IntegrationNames,
+  WorkflowElementActionType,
+  WorkflowValidationErrorType,
+  applyChange,
+  applyDefaultCredentials,
+  applyWorkflowAssetBindings,
+  buildWorkflowFromLight,
+  createFrameReference,
+  createFrameReferenceByContext,
+  createFrameReferenceByEnvironment,
+  getTaskAssets,
+  getTriggerAssets,
+  getWorkflowContexts,
+  getWorkflowCredentials,
+  getWorkflowElementConfig,
+  getWorkflowElementDefaultCredentialId,
+  getWorkflowTaskActions,
+  mergeAssets,
+  prefillWorkflow,
+  recursiveTaskReducer,
+  reduceTasksRecursively,
+  validateWorkflow
+};