@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/case-validate-service-0q8krj2a.js

@@ -0,0 +1,2114 @@
+import {
+  contextEntry,
+  missingContextKeys,
+  readActivityTypeId
+} from "./packager-tool-ty1t2byf.js";
+import {
+  validateIntSvcNode
+} from "./packager-tool-mp59jtpm.js";
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-p7jgrm5r.js";
+import {
+  VALID_CASE_COMPLETION_RULE_TYPES,
+  VALID_CASE_EXIT_RULE_TYPES,
+  VALID_STAGE_COMPLETION_RULE_TYPES,
+  VALID_STAGE_ENTRY_RULE_TYPES,
+  VALID_STAGE_EXIT_RULE_TYPES,
+  VALID_TASK_ENTRY_RULE_TYPES
+} from "./packager-tool-sv0d6wb6.js";
+import"./packager-tool-dqs5qy9s.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-yc4kw997.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/case-validators/connector-validator.ts
+var CONNECTOR_TASK_TYPES = new Set([
+  "execute-connector-activity",
+  "wait-for-connector"
+]);
+var connectorTaskValidator = {
+  id: "uipath-connector",
+  appliesTo: (task) => CONNECTOR_TASK_TYPES.has(task.type),
+  validate: (task, ctx) => {
+    const data = task.data;
+    if (!data)
+      return [];
+    const context = data.context ?? [];
+    const inputs = data.inputs ?? [];
+    const isTrigger = task.type === "wait-for-connector";
+    const connectorKey = readContextValue(context, "connectorKey");
+    const objectName = readContextValue(context, "objectName");
+    const configurationStr = readMetadataConfiguration(context);
+    const httpMethod = readContextValue(context, "method");
+    const eventType = readContextValue(context, "eventType");
+    if (!connectorKey || !objectName || !configurationStr)
+      return [];
+    if (isTrigger ? !eventType : !httpMethod)
+      return [];
+    const bindings = ctx.schema.bindings ?? [];
+    const connectionId = resolveBindingRef(readContextValue(context, "connection"), bindings) ?? readContextValue(context, "resourceKey");
+    const folderKey = resolveBindingRef(readContextValue(context, "folderKey"), bindings);
+    const validationContext = {
+      nodeId: task.id,
+      nodeKind: isTrigger ? "trigger" : "activity",
+      connectionId,
+      folderKey,
+      objectName,
+      httpMethod: isTrigger ? undefined : httpMethod,
+      endpoint: readContextValue(context, "path"),
+      eventMode: readContextValue(context, "eventMode"),
+      eventType,
+      bodyParameters: readInputBody(inputs, "body"),
+      queryParameters: readInputBody(inputs, "queryParameters"),
+      pathParameters: readInputBody(inputs, "pathParameters"),
+      eventParameters: isTrigger ? readTriggerEventParameters(inputs) : undefined,
+      configuration: configurationStr
+    };
+    const path = `nodes[${ctx.stageId}].data.tasks[${task.id}].data`;
+    const issues = validateIntSvcNode(validationContext).map((issue) => ({
+      code: extractDapCode(issue.title) ?? "CONNECTOR_TASK_INVALID",
+      path,
+      message: issue.title,
+      severity: issue.type === "Error" ? "error" : "warning"
+    }));
+    issues.push(...validateCeqlFilterShape(task.id, ctx.stageId, inputs, configurationStr));
+    return issues;
+  }
+};
+function readContextValue(context, name) {
+  const entry = context.find((c) => c.name === name);
+  if (typeof entry?.value !== "string")
+    return;
+  return entry.value;
+}
+var BINDING_REF_PATTERN = /^=bindings\.([A-Za-z0-9_-]+)$/;
+function resolveBindingRef(rawValue, bindings) {
+  if (typeof rawValue !== "string")
+    return;
+  const match = BINDING_REF_PATTERN.exec(rawValue);
+  if (!match)
+    return rawValue;
+  const binding = bindings.find((b) => b.id === match[1]);
+  return typeof binding?.default === "string" ? binding.default : undefined;
+}
+function readMetadataConfiguration(context) {
+  const meta = context.find((c) => c.name === "metadata");
+  const body = meta?.body;
+  const apc = body?.activityPropertyConfiguration;
+  const config = apc?.configuration;
+  return typeof config === "string" ? config : undefined;
+}
+function readInputBody(inputs, name) {
+  const entry = inputs.find((i) => i.name === name);
+  const body = entry?.body;
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return body;
+  }
+  return;
+}
+function readTriggerEventParameters(inputs) {
+  const body = readInputBody(inputs, "body");
+  const parameters = body?.parameters;
+  if (parameters && typeof parameters === "object" && !Array.isArray(parameters)) {
+    return parameters;
+  }
+  return;
+}
+function extractDapCode(title) {
+  const m = title.match(/^\[(DAP-[A-Z]{2}-\d{4})\]/);
+  return m?.[1];
+}
+function validateCeqlFilterShape(taskId, stageId, inputs, configurationStr) {
+  const issues = [];
+  const queryParameters = readInputBody(inputs, "queryParameters");
+  if (queryParameters && Object.hasOwn(queryParameters, "$where")) {
+    issues.push({
+      code: "CONNECTOR_TASK_CEQL_DOLLAR_WHERE",
+      path: `nodes[${stageId}].data.tasks[${taskId}].data.inputs[name="queryParameters"].body["$where"]`,
+      severity: "error",
+      message: 'Connector task uses OData-style `"$where"` (with leading `$`) ' + "in queryParameters.body. CEQL uses bare `where` — rename the " + 'key from `"$where"` to `"where"`. The leading `$` is the OData ' + "system-query-option prefix and is not recognized by " + "uipath.connector.* nodes."
+    });
+  }
+  const queryWhereAuthored = queryParameters !== undefined && isNonEmptyString(queryParameters.where);
+  const savedTrees = readSavedFilterTrees(configurationStr);
+  const savedWhereAuthored = savedTrees !== undefined && isNonEmptyObject(savedTrees.where);
+  if (queryWhereAuthored && !savedWhereAuthored) {
+    issues.push({
+      code: "CONNECTOR_TASK_CEQL_MISSING_FILTER_TREE",
+      path: `nodes[${stageId}].data.tasks[${taskId}].data.context[name="metadata"].body.activityPropertyConfiguration.configuration.savedFilterTrees.where`,
+      severity: "error",
+      message: "Connector task has `queryParameters.where` set but no " + "matching `savedFilterTrees.where` AST inside the " + "essentialConfiguration. CEQL filters must be authored on " + "both sides — the runtime evaluates the expression, Studio " + "Web needs the AST to render the filter UI."
+    });
+  }
+  if (savedWhereAuthored && !queryWhereAuthored) {
+    issues.push({
+      code: "CONNECTOR_TASK_CEQL_MISSING_FILTER_EXPRESSION",
+      path: `nodes[${stageId}].data.tasks[${taskId}].data.inputs[name="queryParameters"].body.where`,
+      severity: "error",
+      message: "Connector task has `savedFilterTrees.where` AST but no " + "matching `queryParameters.where` expression. CEQL filters " + "must be authored on both sides — the runtime evaluates the " + "expression, not the AST."
+    });
+  }
+  return issues;
+}
+function readSavedFilterTrees(configurationStr) {
+  const jsonStr = configurationStr.replace(/^=jsonString:/, "");
+  const [, parsed] = catchError(() => JSON.parse(jsonStr));
+  if (!parsed)
+    return;
+  const ec = parsed.essentialConfiguration;
+  const trees = ec?.savedFilterTrees;
+  if (trees && typeof trees === "object" && !Array.isArray(trees)) {
+    return trees;
+  }
+  return;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isNonEmptyObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+
+// src/services/case-validators/task-hygiene-validator.ts
+var taskElementIdValidator = {
+  id: "uipath-task-element-id",
+  appliesTo: (task) => {
+    if (task.elementId !== undefined)
+      return false;
+    const data = task.data;
+    const hasIoArray = (key) => Array.isArray(data?.[key]) && data[key].length > 0;
+    return hasIoArray("inputs") || hasIoArray("outputs");
+  },
+  validate: (task, ctx) => {
+    const name = task.displayName ?? task.id ?? "task";
+    return [
+      {
+        code: "TASK_MISSING_ELEMENT_ID",
+        path: `nodes[${ctx.stageId}].data.tasks[${task.id ?? "?"}]`,
+        message: `Task "${name}" carries inputs or outputs but has no "elementId". Set it to "${ctx.stageId}-${task.id ?? "<taskId>"}" so those variables resolve to this task.`,
+        severity: "warning"
+      }
+    ];
+  }
+};
+var unconfiguredTaskValidator = {
+  id: "uipath-unconfigured-task",
+  appliesTo: (task) => task.type !== "wait-for-timer" && Object.keys(task.data ?? {}).length === 0,
+  validate: (task, ctx) => {
+    const name = task.displayName ?? task.id ?? "task";
+    return [
+      {
+        code: "TASK_NOT_CONFIGURED",
+        path: `nodes[${ctx.stageId}].data.tasks[${task.id ?? "?"}].data`,
+        message: `Task "${name}" (type "${task.type ?? "unknown"}") has an empty "data" block, so no other check can run on it. Configure the task or remove it.`,
+        severity: "warning"
+      }
+    ];
+  }
+};
+
+// src/services/case-validators/timer-validator.ts
+var TIMER_TYPES = ["timeDuration", "timeDate", "timeCycle"];
+var VALUE_FIELD = {
+  timeDuration: "timeDuration",
+  timeDate: "timeDate",
+  timeCycle: "timeCycle"
+};
+function issue(stageId, taskId, code, message) {
+  return {
+    code,
+    path: `nodes[${stageId}].data.tasks[${taskId ?? "?"}].data`,
+    message,
+    severity: "error"
+  };
+}
+var timerTaskValidator = {
+  id: "uipath-wait-for-timer",
+  appliesTo: (task) => task.type === "wait-for-timer",
+  validate: (task, ctx) => {
+    const name = task.displayName ?? task.id ?? "wait-for-timer task";
+    const data = task.data ?? {};
+    if (Object.keys(data).length === 0) {
+      return [
+        issue(ctx.stageId, task.id, "TIMER_TASK_NOT_CONFIGURED", `Timer task "${name}" has an empty "data" block, so it is not configured and no other check runs on it. Set "timerType" to one of ${TIMER_TYPES.join(", ")} and provide the matching value field.`)
+      ];
+    }
+    const timerType = data.timerType;
+    if (timerType === undefined) {
+      const message = typeof data.timer === "string" ? `Timer task "${name}" sets "timer" instead of "timerType". Rename the field to "timerType" (one of ${TIMER_TYPES.join(", ")}) — nothing reads "timer", so the timer stays unconfigured.` : `Timer task "${name}" has no "timerType". Set it to one of ${TIMER_TYPES.join(", ")} and provide the matching value field.`;
+      return [
+        issue(ctx.stageId, task.id, "TIMER_TASK_MISSING_TIMER_TYPE", message)
+      ];
+    }
+    if (typeof timerType !== "string" || !TIMER_TYPES.includes(timerType)) {
+      return [
+        issue(ctx.stageId, task.id, "TIMER_TASK_INVALID_TIMER_TYPE", `Timer task "${name}" has an invalid "timerType" (${JSON.stringify(timerType)}). Valid values: ${TIMER_TYPES.join(", ")}.`)
+      ];
+    }
+    const field = VALUE_FIELD[timerType];
+    const value = data[field];
+    if (typeof value !== "string" || value.trim() === "") {
+      return [
+        issue(ctx.stageId, task.id, "TIMER_TASK_MISSING_VALUE", `Timer task "${name}" declares "timerType": "${timerType}" but has no "${field}" value.`)
+      ];
+    }
+    return [];
+  }
+};
+// src/services/case-validators/strict-task-validators.ts
+var CONNECTOR_TASK_TYPES2 = new Set([
+  "execute-connector-activity",
+  "wait-for-connector"
+]);
+var SERVICE_TYPE_BY_TASK = {
+  "execute-connector-activity": "Intsvc.ActivityExecution",
+  "wait-for-connector": "Intsvc.WaitForEvent"
+};
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var taskData = (task) => asRecord(task.data);
+var taskLabel = (task) => task.displayName ?? task.id ?? "task";
+var taskPath = (stageId, task) => `nodes[${stageId}].data.tasks[${task.id ?? "?"}]`;
+var strictConnectorContextValidator = {
+  id: "strict-connector-context",
+  appliesTo: (task) => CONNECTOR_TASK_TYPES2.has(task.type ?? ""),
+  validate: (task, ctx) => {
+    const issues = [];
+    const context = taskData(task)?.context;
+    const missing = missingContextKeys(context);
+    if (missing.length > 0) {
+      issues.push({
+        code: "STRICT_CONNECTOR_CONTEXT_INCOMPLETE",
+        path: `${taskPath(ctx.stageId, task)}.data.context`,
+        severity: "error",
+        message: `Connector task "${taskLabel(task)}" is missing context ` + `entries: ${missing.join(", ")}. The default validator ` + "skips a task in this state as mid-authoring, so nothing " + "else reports it — under --strict an incomplete context " + "is a defect."
+      });
+    }
+    if (contextEntry(context, "metadata") !== undefined) {
+      if (readActivityTypeId(context) === undefined) {
+        issues.push({
+          code: "STRICT_CONNECTOR_ACTIVITY_TYPE_ID",
+          path: `${taskPath(ctx.stageId, task)}.data.context[metadata].body.activityPropertyConfiguration.UiPathActivityTypeId`,
+          severity: "error",
+          message: `Connector task "${taskLabel(task)}" has a metadata ` + "configuration with no UiPathActivityTypeId. The " + "connection id alone does not tell the runtime which " + "activity to run, so the task deploys and never binds."
+        });
+      }
+    }
+    const expectedServiceType = SERVICE_TYPE_BY_TASK[task.type ?? ""];
+    const serviceType = taskData(task)?.serviceType;
+    if (expectedServiceType !== undefined && serviceType !== undefined) {
+      if (serviceType !== expectedServiceType) {
+        issues.push({
+          code: "STRICT_CONNECTOR_SERVICE_TYPE",
+          path: `${taskPath(ctx.stageId, task)}.data.serviceType`,
+          severity: "error",
+          message: `Connector task "${taskLabel(task)}" declares ` + `serviceType "${String(serviceType)}"; a ` + `"${task.type}" task must declare ` + `"${expectedServiceType}".`
+        });
+      }
+    } else if (expectedServiceType !== undefined) {
+      issues.push({
+        code: "STRICT_CONNECTOR_SERVICE_TYPE",
+        path: `${taskPath(ctx.stageId, task)}.data.serviceType`,
+        severity: "error",
+        message: `Connector task "${taskLabel(task)}" declares no ` + `serviceType; a "${task.type}" task must declare ` + `"${expectedServiceType}".`
+      });
+    }
+    return issues;
+  }
+};
+var strictOutputShapeValidator = {
+  id: "strict-output-shape",
+  appliesTo: (task) => asArray(taskData(task)?.outputs).length > 0,
+  validate: (task, ctx) => {
+    const issues = [];
+    const base = `${taskPath(ctx.stageId, task)}.data.outputs`;
+    asArray(taskData(task)?.outputs).forEach((entry, index) => {
+      const output = asRecord(entry);
+      if (!output)
+        return;
+      const label = typeof output.name === "string" ? output.name : `#${index}`;
+      const path = `${base}[${label}]`;
+      const report = (code, message) => void issues.push({
+        code,
+        path,
+        severity: "error",
+        message
+      });
+      if (output.custom === true) {
+        const problems = [];
+        if (!("target" in output) || output.target !== "")
+          problems.push('"target" must be present and empty');
+        if (!("body" in output) || output.body !== "")
+          problems.push('"body" must be present and empty');
+        if (output.elementId !== "root")
+          problems.push('"elementId" must be "root"');
+        if ("id" in output)
+          problems.push('"id" must be absent');
+        if ("originalVar" in output)
+          problems.push('"originalVar" must be absent');
+        if (problems.length > 0) {
+          report("STRICT_CUSTOM_OUTPUT_SHAPE", `Custom output "${label}" is malformed: ` + `${problems.join("; ")}. The converter reads these ` + "keys positionally, so a dropped or renamed one " + "writes the value nowhere.");
+        }
+        return;
+      }
+    });
+    return issues;
+  }
+};
+var strictInputReferenceValidator = {
+  id: "strict-input-reference",
+  appliesTo: (task) => asArray(taskData(task)?.inputs).length > 0,
+  validate: (task, ctx) => {
+    const issues = [];
+    const base = `${taskPath(ctx.stageId, task)}.data.inputs`;
+    asArray(taskData(task)?.inputs).forEach((entry, index) => {
+      const input = asRecord(entry);
+      if (!input)
+        return;
+      const label = typeof input.name === "string" ? input.name : `#${index}`;
+      const value = input.value;
+      if (typeof value !== "string")
+        return;
+      if (value === "") {
+        issues.push({
+          code: "STRICT_INPUT_UNBOUND",
+          path: `${base}[${label}]`,
+          severity: "warning",
+          message: `Input "${label}" on task "${taskLabel(task)}" has no ` + "value. If the task is finished, this input never " + "receives data."
+        });
+        return;
+      }
+      if (!value.startsWith("="))
+        return;
+      if (value.startsWith("=js:") || value.startsWith("=metadata") || value.startsWith("=bindings.")) {
+        return;
+      }
+      if (/^=vars\.[A-Za-z0-9_]+$/.test(value))
+        return;
+      issues.push({
+        code: "STRICT_INPUT_REF_FORM",
+        path: `${base}[${label}]`,
+        severity: "error",
+        message: `Input "${label}" references "${value}". A variable ` + 'reference must be "=vars.<name>" — a bare "=<id>" is ' + "not resolved by the converter."
+      });
+    });
+    return issues;
+  }
+};
+var strictTaskValidators = [
+  strictConnectorContextValidator,
+  strictOutputShapeValidator,
+  strictInputReferenceValidator
+];
+
+// src/services/case-validators/index.ts
+var defaultTaskValidators = [
+  connectorTaskValidator,
+  timerTaskValidator,
+  taskElementIdValidator,
+  unconfiguredTaskValidator
+];
+
+// src/services/case-validate-service.ts
+var mapCanvasSeverity = (severity) => {
+  const normalized = (severity ?? "error").toUpperCase();
+  return normalized === "CRITICAL" || normalized === "ERROR" ? "error" : "warning";
+};
+var checksTaskContent = (profile) => profile === "full" || profile === "strict";
+var SKELETON_V2_SKIPPED_CANVAS_CODES = new Set([
+  "CASE_MGMT_STAGE_TASKS_MISSING",
+  "CASE_MGMT_STAGE_TASK_SELECTION_MISSING",
+  "CASE_MGMT_STAGE_TASK_ENTRY_CONDITION_MISSING",
+  "CASE_MGMT_STAGE_TASK_NAME_DUPLICATE",
+  "CASE_MGMT_STAGE_TASK_NAME_INVALID",
+  "CASE_MGMT_TASK_OUTPUT_VARIABLE_MULTIPLE",
+  "CASE_MGMT_TASK_OUTPUT_VARIABLE_REQUIRED",
+  "CASE_MGMT_STAGE_NO_TASKS_RUNNING_ON_RE_ENTRY",
+  "TASK_TIMER_OUT_OF_RANGE",
+  "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_TASK_IDS_MISSING",
+  "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_TASK_MISSING",
+  "CASE_MGMT_ROOT_CASE_CONDITION_RULE_NO_REQUIRED_TASK"
+]);
+var isTaskScopedCanvasIssue = (issue2) => SKELETON_V2_SKIPPED_CANVAS_CODES.has(issue2.code) || issue2.additionalErrorInfo?.taskId !== undefined;
+function parseSemverMajor(version) {
+  if (!version)
+    return null;
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (!match)
+    return null;
+  return Number.parseInt(match[1], 10);
+}
+function slaToHours(sla) {
+  if (!sla?.count || sla.count <= 0)
+    return 0;
+  const multipliers = {
+    h: 1,
+    d: 24,
+    w: 168,
+    m: 5040
+  };
+  return sla.count * (multipliers[sla.unit ?? "h"] ?? 1);
+}
+function rulesMatch(a, b) {
+  if (a.length !== b.length)
+    return false;
+  return a.every((andGroupA, i) => {
+    const andGroupB = b[i];
+    if (!andGroupB || andGroupA.length !== andGroupB.length)
+      return false;
+    return andGroupA.every((ruleA, j) => {
+      const ruleB = andGroupB[j];
+      if (!ruleB || ruleA.rule !== ruleB.rule)
+        return false;
+      switch (ruleA.rule) {
+        case "wait-for-connector":
+          return ruleA.conditionExpression === ruleB.conditionExpression && JSON.stringify(ruleA.uipath) === JSON.stringify(ruleB.uipath);
+        case "case-entered":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "current-stage-entered":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "adhoc":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "selected-stage-completed":
+          return ruleA.selectedStageId === ruleB.selectedStageId && ruleA.conditionExpression === ruleB.conditionExpression;
+        case "selected-stage-exited":
+          return ruleA.selectedStageId === ruleB.selectedStageId && ruleA.conditionExpression === ruleB.conditionExpression;
+        case "selected-tasks-completed": {
+          const aIds = ruleA.selectedTasksIds ?? [];
+          const bIds = ruleB.selectedTasksIds ?? [];
+          return aIds.length === bIds.length && aIds.every((id) => bIds.includes(id)) && ruleA.conditionExpression === ruleB.conditionExpression;
+        }
+        case "required-stages-completed":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "required-tasks-completed":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "user-selected-stage":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        case "runs-sequentially":
+          return ruleA.conditionExpression === ruleB.conditionExpression;
+        default:
+          return false;
+      }
+    });
+  });
+}
+function stageLabel(node) {
+  return node.data.label ?? node.id;
+}
+function triggerLabel(node) {
+  return node.data.label ?? node.id;
+}
+function edgeLabel(edge) {
+  return edge.data.label ?? edge.id;
+}
+function flatTasks(stage) {
+  return (stage.data.tasks ?? []).flat();
+}
+function findRequiredFieldError(fields) {
+  for (const field of fields ?? []) {
+    if (field.required && (field.value === undefined || field.value === null || field.value === "")) {
+      return field.name;
+    }
+  }
+  return null;
+}
+function findRequiredFieldErrorInUiPath(uipath) {
+  return findRequiredFieldError(uipath?.context) ?? findRequiredFieldError(uipath?.inputs) ?? findRequiredFieldError(uipath?.outputs) ?? null;
+}
+function flatConditionRules(condition) {
+  return (condition.rules ?? []).flat();
+}
+function conditionLabel(condition) {
+  return condition.displayName ?? condition.id ?? "(unnamed)";
+}
+function hasCaseManagerStageWithTasks(schema) {
+  return schema.nodes.some((n) => {
+    if (n.type !== "case-management:Stage" && n.type !== "case-management:ExceptionStage") {
+      return false;
+    }
+    const data = n.data;
+    if (data.isCaseManagerStage !== true)
+      return false;
+    return (data.tasks ?? []).some((group) => Array.isArray(group) && group.length > 0);
+  });
+}
+function findFirstStageAfterTrigger(schema) {
+  const triggerIds = new Set(schema.nodes.filter((n) => n.type === "case-management:Trigger").map((n) => n.id));
+  return schema.edges.filter((e) => triggerIds.has(e.source)).map((e) => e.target)[0];
+}
+var VALID_RULE_TYPES = new Set([
+  "wait-for-connector",
+  "case-entered",
+  "selected-stage-completed",
+  "selected-stage-exited",
+  "selected-tasks-completed",
+  "current-stage-entered",
+  "adhoc",
+  "required-stages-completed",
+  "required-tasks-completed",
+  "user-selected-stage",
+  "runs-sequentially",
+  "stage-complete",
+  "condition",
+  "timer"
+]);
+var VALID_TASK_TYPES = new Set([
+  "process",
+  "action",
+  "agent",
+  "api-workflow",
+  "rpa",
+  "external-agent",
+  "wait-for-timer",
+  "wait-for-connector",
+  "execute-connector-activity",
+  "case-management"
+]);
+var VALID_NODE_TYPES = new Set([
+  "case-management:Trigger",
+  "case-management:Stage",
+  "case-management:ExceptionStage",
+  "case-management:StickyNote"
+]);
+var VALID_EDGE_TYPES = new Set([
+  "case-management:TriggerEdge",
+  "case-management:Edge"
+]);
+var VALID_EXIT_CONDITION_TYPES = new Set([
+  "exit-only",
+  "wait-for-user",
+  "return-to-origin"
+]);
+var VALID_SLA_UNITS = new Set(["min", "h", "d", "w", "m"]);
+var VALID_ESCALATION_TRIGGER_TYPES = new Set([
+  "at-risk",
+  "sla-breached"
+]);
+var VALID_TRIGGER_SERVICE_TYPES = new Set([
+  "None",
+  "Intsvc.EventTrigger",
+  "Intsvc.TimerTrigger"
+]);
+
+class CaseValidateService {
+  fs;
+  taskValidators;
+  constructor(options = {}) {
+    this.fs = getFileSystem();
+    this.taskValidators = [
+      ...defaultTaskValidators,
+      ...options.extraTaskValidators ?? []
+    ];
+  }
+  async validateFile(filePath, options = {}) {
+    const profile = options.profile ?? "full";
+    const absolutePath = this.fs.path.resolve(filePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    const stats = await this.fs.stat(absolutePath);
+    if (stats?.isDirectory()) {
+      throw new Error(`Expected a file but got a directory: ${absolutePath}`);
+    }
+    logger.info(`
+Validating: ${absolutePath}
+`);
+    const content = await this.fs.readFile(absolutePath, "utf-8");
+    if (!content) {
+      throw new Error(`File is empty: ${absolutePath}`);
+    }
+    const [parseError, schema] = catchError(() => JSON.parse(content));
+    if (parseError) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        issues: [
+          {
+            code: "INVALID_JSON",
+            path: "(root)",
+            message: "File is not valid JSON",
+            severity: "error"
+          }
+        ]
+      };
+    }
+    const rawSchema = schema;
+    if (rawSchema.root && !rawSchema.metadata) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        issues: [
+          {
+            code: "INVALID_SCHEMA_VERSION",
+            path: "(root)",
+            message: "Detected a V19-shaped schema (top-level `root`). V20 flattens the top level and moves case-specific fields under `metadata` — please migrate the file to V20.",
+            severity: "error"
+          }
+        ]
+      };
+    }
+    if (!schema.nodes || !schema.edges) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        issues: [
+          {
+            code: "INVALID_SCHEMA",
+            path: "(root)",
+            message: "Missing required top-level fields: nodes, edges",
+            severity: "error"
+          }
+        ]
+      };
+    }
+    const issues = schema.metadata?.allowAdhocOptionalStageTasks ? [
+      ...this.validateMetadata(schema, profile),
+      ...this.validateEnums(schema, profile),
+      ...this.validateTriggers(schema, profile),
+      ...this.validateAdhocNodes(schema, profile),
+      ...checksTaskContent(profile) ? this.validateOutputVariableUniqueness(schema) : [],
+      ...checksTaskContent(profile) ? this.runTaskValidators(schema, profile) : []
+    ] : [
+      ...this.validateMetadata(schema, profile),
+      ...this.validateEnums(schema, profile),
+      ...this.validateStructure(schema),
+      ...this.validateTriggers(schema, profile),
+      ...this.validatePrimaryStages(schema, profile),
+      ...this.validateSecondaryStages(schema, profile),
+      ...this.validateEdges(schema, profile),
+      ...profile !== "skeleton" ? this.validateOverallCase(schema) : [],
+      ...checksTaskContent(profile) ? this.validateOutputVariableUniqueness(schema) : [],
+      ...checksTaskContent(profile) ? this.runTaskValidators(schema, profile) : []
+    ];
+    return {
+      success: issues.filter((i) => i.severity === "error").length === 0,
+      filePath: absolutePath,
+      issues
+    };
+  }
+  runSupplementalRules(parsed, profile) {
+    const issues = [];
+    const name = parsed.name;
+    if (typeof name !== "string" || name.trim() === "") {
+      issues.push({
+        code: "CASE_MGMT_ROOT_NAME_MISSING",
+        path: "name",
+        severity: "error",
+        message: "Case name is missing or blank. Deployment keys the case " + "definition by name, so a whitespace-only name yields an " + "unaddressable case."
+      });
+    }
+    const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+    const seen = new Set;
+    const reported = new Set;
+    for (const node of nodes) {
+      const id = node.id;
+      if (typeof id !== "string" || id === "")
+        continue;
+      if (seen.has(id) && !reported.has(id)) {
+        reported.add(id);
+        issues.push({
+          code: "CASE_MGMT_NODE_ID_DUPLICATE",
+          path: `nodes[${id}]`,
+          severity: "error",
+          message: `More than one node uses the id "${id}". Node ids are ` + "the reference target for edges, rules and task " + "bindings, so a duplicate makes every reference to it " + "ambiguous at deploy time."
+        });
+      }
+      seen.add(id);
+    }
+    if (profile !== "skeleton") {
+      issues.push(...this.checkEntryRuleSlots(nodes, {
+        includeTaskSlots: checksTaskContent(profile)
+      }));
+    }
+    return issues;
+  }
+  checkEntryRuleSlots(nodes, options) {
+    const issues = [];
+    const knownSomewhere = new Set([
+      ...VALID_TASK_ENTRY_RULE_TYPES,
+      ...VALID_STAGE_ENTRY_RULE_TYPES,
+      ...VALID_STAGE_EXIT_RULE_TYPES,
+      ...VALID_STAGE_COMPLETION_RULE_TYPES,
+      ...VALID_CASE_EXIT_RULE_TYPES,
+      ...VALID_CASE_COMPLETION_RULE_TYPES
+    ]);
+    const check = (conditions, allowed, slotLabel, path) => {
+      if (!Array.isArray(conditions))
+        return;
+      for (const condition of conditions) {
+        const groups = condition?.rules;
+        if (!Array.isArray(groups))
+          continue;
+        for (const group of groups) {
+          if (!Array.isArray(group))
+            continue;
+          for (const entry of group) {
+            const rule = entry?.rule;
+            if (typeof rule !== "string")
+              continue;
+            if (allowed.includes(rule))
+              continue;
+            if (!knownSomewhere.has(rule))
+              continue;
+            issues.push({
+              code: "CASE_MGMT_RULE_SLOT_MISMATCH",
+              path,
+              severity: "error",
+              message: `Rule "${rule}" does not belong in a ${slotLabel}. ` + `Allowed there: ${allowed.join(", ")}. The rule is ` + "valid in a different slot, so the plan deploys and " + "the scheduler evaluates it against the wrong " + "context — the condition does not mean what the " + "author wrote."
+            });
+          }
+        }
+      }
+    };
+    for (const node of nodes) {
+      const data = node.data ?? {};
+      const nodeId = typeof node.id === "string" ? node.id : "(node)";
+      check(data.entryConditions, VALID_STAGE_ENTRY_RULE_TYPES, "stage entry condition", `nodes[${nodeId}].data.entryConditions`);
+      const lanes = options.includeTaskSlots && Array.isArray(data.tasks) ? data.tasks : [];
+      for (const lane of lanes) {
+        if (!Array.isArray(lane))
+          continue;
+        for (const task of lane) {
+          const taskId = typeof task?.id === "string" ? task.id : "(task)";
+          check(task?.entryConditions, VALID_TASK_ENTRY_RULE_TYPES, "task entry condition", `nodes[${nodeId}].data.tasks[${taskId}].entryConditions`);
+        }
+      }
+    }
+    return issues;
+  }
+  async validateFileUsingSDK(filePath, options = {}) {
+    const profile = options.profile ?? "full";
+    const absolutePath = this.fs.path.resolve(filePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    const stats = await this.fs.stat(absolutePath);
+    if (stats?.isDirectory()) {
+      throw new Error(`Expected a file but got a directory: ${absolutePath}`);
+    }
+    logger.info(`
+Validating: ${absolutePath}
+`);
+    const content = await this.fs.readFile(absolutePath, "utf-8");
+    if (!content) {
+      throw new Error(`File is empty: ${absolutePath}`);
+    }
+    const [parseError, parsed] = catchError(() => JSON.parse(content));
+    if (parseError) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        issues: [
+          {
+            code: "INVALID_JSON",
+            path: "(root)",
+            message: "File is not valid JSON",
+            severity: "error"
+          }
+        ]
+      };
+    }
+    const issues = [];
+    const { validateCaseCanvasJson, validateCaseDiskJsonSchema } = await loadCaseSchemaAsync();
+    const [diskCallError, diskResultRaw] = catchError(() => validateCaseDiskJsonSchema(parsed));
+    if (diskCallError) {
+      issues.push({
+        code: "CASE_MGMT_DISK_SCHEMA_VALIDATION_FAILED",
+        path: "(root)",
+        message: diskCallError.message,
+        severity: "error"
+      });
+      return {
+        success: false,
+        filePath: absolutePath,
+        issues
+      };
+    }
+    const diskResult = diskResultRaw;
+    for (const issue2 of diskResult.issues ?? []) {
+      issues.push({
+        code: "CASE_MGMT_DISK_SCHEMA_INVALID",
+        path: issue2.path && issue2.path !== "" ? issue2.path : "(root)",
+        message: issue2.message,
+        severity: "error"
+      });
+    }
+    if (diskResult.migrationError) {
+      issues.push({
+        code: "CASE_MGMT_MIGRATION_FAILED",
+        path: "(root)",
+        message: diskResult.migrationError,
+        severity: "error"
+      });
+    }
+    if (diskResult.valid && profile !== "skeleton") {
+      const [canvasCallError, canvasResultRaw] = catchError(() => validateCaseCanvasJson(parsed));
+      if (canvasCallError) {
+        issues.push({
+          code: "CASE_MGMT_CANVAS_VALIDATION_FAILED",
+          path: "(root)",
+          message: canvasCallError.message,
+          severity: "error"
+        });
+      } else {
+        const canvasIssues = canvasResultRaw ?? [];
+        for (const ce of canvasIssues) {
+          if (profile === "skeleton-v2" && isTaskScopedCanvasIssue(ce)) {
+            continue;
+          }
+          issues.push({
+            code: ce.code,
+            path: ce.elementId ? `nodes[${ce.elementId}]` : "(root)",
+            message: ce.message,
+            severity: mapCanvasSeverity(ce.severity)
+          });
+        }
+      }
+    }
+    if (diskResult.valid && checksTaskContent(profile)) {
+      issues.push(...this.runTaskValidators(parsed, profile));
+    }
+    if (diskResult.valid) {
+      issues.push(...this.runSupplementalRules(parsed, profile));
+    }
+    if (diskResult.valid && profile === "strict") {
+      const { runStrictCaseRules } = await import("./strict-case-rules-303vjvas.js");
+      issues.push(...runStrictCaseRules(parsed));
+      if (options.sddPath !== undefined) {
+        const sddPath = this.fs.path.resolve(options.sddPath);
+        if (await this.fs.exists(sddPath)) {
+          const sddText = await this.fs.readFile(sddPath, "utf-8") ?? "";
+          const { auditCaseplanAgainstSdd } = await import("./strict-sdd-audit-qdmc9e1y.js");
+          issues.push(...auditCaseplanAgainstSdd(parsed, sddText, this.fs.path.basename(sddPath)));
+        } else {
+          issues.push({
+            code: "STRICT_SDD_FILE_NOT_FOUND",
+            path: options.sddPath,
+            severity: "error",
+            message: `SDD not found at "${sddPath}". --sdd audits the caseplan against the SDD that specifies it, so there is nothing to audit against.`
+          });
+        }
+      }
+    }
+    return {
+      success: issues.filter((i) => i.severity === "error").length === 0,
+      filePath: absolutePath,
+      issues
+    };
+  }
+  validateMetadata(schema, profile) {
+    const issues = [];
+    const metadata = schema.metadata ?? {};
+    const rawSchema = schema;
+    const rawMetadata = metadata;
+    if (!schema.name || schema.name.trim() === "") {
+      issues.push({
+        code: "CASE_MGMT_ROOT_NAME_MISSING",
+        path: "name",
+        message: "Case definition name is missing",
+        severity: "error"
+      });
+    }
+    const versionMajor = parseSemverMajor(schema.version);
+    if (versionMajor === null) {
+      issues.push({
+        code: "CASE_MGMT_INVALID_VERSION",
+        path: "version",
+        message: `Schema version "${String(schema.version ?? "(missing)")}" is not a valid semver — expected "<major>.<minor>.<patch>" with major >= 20`,
+        severity: "error"
+      });
+    } else if (versionMajor < 20) {
+      issues.push({
+        code: "CASE_MGMT_INVALID_VERSION",
+        path: "version",
+        message: `Schema version "${String(schema.version)}" predates V20 — this validator requires major version >= 20`,
+        severity: "error"
+      });
+    }
+    if (!schema.id || !/^case-[A-Za-z0-9]{10}$/.test(schema.id)) {
+      issues.push({
+        code: "CASE_MGMT_INVALID_ID",
+        path: "id",
+        message: `Case id "${String(schema.id ?? "(missing)")}" does not match the V20 format "case-<10 alphanumeric chars>"`,
+        severity: "error"
+      });
+    }
+    if (!metadata.caseIdentifier || metadata.caseIdentifier.trim() === "") {
+      issues.push({
+        code: "CASE_MGMT_ROOT_CASE_ID_MISSING",
+        path: "metadata.caseIdentifier",
+        message: "Case identifier is missing",
+        severity: "error"
+      });
+    }
+    if (rawSchema.caseExitConditions || rawSchema.caseExitRules) {
+      issues.push({
+        code: "CASE_MGMT_CASE_EXIT_CONDITIONS_MISPLACED",
+        path: rawSchema.caseExitRules ? "caseExitRules" : "caseExitConditions",
+        message: rawSchema.caseExitRules ? "caseExitRules is at the top level of the JSON file but should be inside metadata (metadata.caseExitRules)" : "caseExitConditions is at the top level and was renamed to caseExitRules in V20 — move it under metadata.caseExitRules",
+        severity: "error"
+      });
+    }
+    if (rawMetadata.caseExitConditions && !metadata.caseExitRules?.length) {
+      issues.push({
+        code: "CASE_MGMT_CASE_EXIT_CONDITIONS_MISPLACED",
+        path: "metadata.caseExitConditions",
+        message: "metadata.caseExitConditions was renamed to metadata.caseExitRules in V20",
+        severity: "error"
+      });
+    }
+    if (profile === "skeleton")
+      return issues;
+    const rootSlaRules = metadata.slaRules ?? [];
+    const stageHoursTotal = schema.nodes.filter((n) => n.type === "case-management:Stage").reduce((sum, s) => sum + slaToHours(s.data.sla), 0);
+    for (let i = 0;i < rootSlaRules.length; i++) {
+      const rule = rootSlaRules[i];
+      const hasEscalations = rule.escalationRule != null && rule.escalationRule.length > 0;
+      const hasValue = rule.count != null && rule.count > 0;
+      if (hasEscalations && !hasValue) {
+        issues.push({
+          code: "CASE_MGMT_ROOT_NO_SLA_ESCALATIONS",
+          path: `metadata.slaRules[${i}]`,
+          message: "Root SLA rule has escalation rules but no SLA value is set",
+          severity: "warning"
+        });
+      }
+      if (hasEscalations) {
+        const missingRecipients = (rule.escalationRule ?? []).some((e) => !e.action?.recipients || e.action.recipients.length === 0);
+        if (missingRecipients) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_ESCALATION_RECIPIENTS_MISSING",
+            path: `metadata.slaRules[${i}].escalationRule`,
+            message: "Root SLA rule has an escalation rule with no recipients",
+            severity: "warning"
+          });
+        }
+      }
+      const ruleHours = slaToHours(rule);
+      if (ruleHours > 0 && stageHoursTotal > 0 && ruleHours < stageHoursTotal) {
+        issues.push({
+          code: "CASE_MGMT_ROOT_SLA_LESS_THAN_NODES",
+          path: `metadata.slaRules[${i}]`,
+          message: `Root SLA rule (${ruleHours}h) is less than the sum of all stage SLAs (${stageHoursTotal}h)`,
+          severity: "warning"
+        });
+      }
+    }
+    const caseExitRules = metadata.caseExitRules ?? [];
+    const completeConditions = caseExitRules.filter((c) => c.marksCaseComplete);
+    if (completeConditions.length === 0 && metadata.allowAdhocOptionalStageTasks !== true) {
+      issues.push({
+        code: "CASE_MGMT_ROOT_CASE_EXIT_CONDITIONS_MISSING",
+        path: "metadata.caseExitRules",
+        message: "The case has no exit condition that marks the case as complete",
+        severity: "error"
+      });
+    }
+    for (const condition of caseExitRules) {
+      if (!condition.rules || condition.rules.length === 0) {
+        issues.push({
+          code: "CASE_MGMT_CASE_EXIT_CONDITION_NO_RULES",
+          path: "metadata.caseExitRules",
+          message: "A case exit condition has no rules",
+          severity: "error"
+        });
+      }
+    }
+    issues.push(...this.validateConditionsBattery({
+      conditions: caseExitRules,
+      schema,
+      currentStage: undefined,
+      path: "metadata.caseExitRules",
+      elementLabel: "Case",
+      duplicateCode: "CASE_MGMT_ROOT_CASE_CONDITION_DUPLICATE",
+      profile
+    }));
+    return issues;
+  }
+  validateEnums(schema, profile) {
+    const issues = [];
+    for (const node of schema.nodes) {
+      if (!VALID_NODE_TYPES.has(node.type)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path: `nodes[${node.id}].type`,
+          message: `Node "${node.id}" has invalid type "${node.type}". Expected one of: ${[...VALID_NODE_TYPES].join(", ")}`,
+          severity: "error"
+        });
+      }
+    }
+    for (const edge of schema.edges) {
+      if (!VALID_EDGE_TYPES.has(edge.type)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path: `edges[${edge.id}].type`,
+          message: `Edge "${edge.id}" has invalid type "${edge.type}". Expected one of: ${[...VALID_EDGE_TYPES].join(", ")}`,
+          severity: "error"
+        });
+      }
+    }
+    const triggers = schema.nodes.filter((n) => n.type === "case-management:Trigger");
+    for (const trigger of triggers) {
+      const serviceType = trigger.data.uipath?.serviceType;
+      if (serviceType != null && !VALID_TRIGGER_SERVICE_TYPES.has(serviceType)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path: `nodes[${trigger.id}].data.uipath.serviceType`,
+          message: `Trigger "${triggerLabel(trigger)}" has invalid serviceType "${serviceType}". Expected one of: ${[...VALID_TRIGGER_SERVICE_TYPES].join(", ")}`,
+          severity: "error"
+        });
+      }
+    }
+    const allStages = schema.nodes.filter((n) => n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage");
+    for (const stage of allStages) {
+      const name = stageLabel(stage);
+      const path = `nodes[${stage.id}]`;
+      for (const task of flatTasks(stage)) {
+        if (!VALID_TASK_TYPES.has(task.type)) {
+          issues.push({
+            code: "INVALID_ENUM_VALUE",
+            path,
+            message: `Stage "${name}" has a task with invalid type "${task.type}". Expected one of: ${[...VALID_TASK_TYPES].join(", ")}`,
+            severity: "error"
+          });
+        }
+      }
+      if (profile === "skeleton")
+        continue;
+      const slaUnit = stage.data.sla?.unit;
+      if (slaUnit != null && !VALID_SLA_UNITS.has(slaUnit)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path: `${path}.data.sla.unit`,
+          message: `Stage "${name}" has invalid SLA unit "${slaUnit}". Expected one of: ${[...VALID_SLA_UNITS].join(", ")}`,
+          severity: "error"
+        });
+      }
+      issues.push(...this.validateEscalationTriggerTypes(stage.data.sla?.escalationRule, path, `Stage "${name}"`));
+      for (const ec of stage.data.exitConditions ?? []) {
+        if (ec.type != null && !VALID_EXIT_CONDITION_TYPES.has(ec.type)) {
+          issues.push({
+            code: "INVALID_ENUM_VALUE",
+            path: `${path}.exitConditions`,
+            message: `Stage "${name}" has an exit condition with invalid type "${ec.type}". Expected one of: ${[...VALID_EXIT_CONDITION_TYPES].join(", ")}`,
+            severity: "error"
+          });
+        }
+      }
+      for (const ec of stage.data.exitConditions ?? []) {
+        issues.push(...this.validateRuleTypes(ec.rules, `${path}.exitConditions`, `Stage "${name}" exit condition`));
+      }
+      for (const ec of stage.data.entryConditions ?? []) {
+        issues.push(...this.validateRuleTypes(ec.rules, `${path}.entryConditions`, `Stage "${name}" entry condition`));
+      }
+      for (const task of flatTasks(stage)) {
+        for (const ec of task.entryConditions ?? []) {
+          issues.push(...this.validateRuleTypes(ec.rules, path, `Stage "${name}" task entry condition`));
+        }
+      }
+    }
+    if (profile === "skeleton")
+      return issues;
+    for (const slaRule of schema.metadata?.slaRules ?? []) {
+      if (slaRule.unit != null && !VALID_SLA_UNITS.has(slaRule.unit)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path: "metadata.slaRules",
+          message: `Root SLA rule has invalid unit "${slaRule.unit}". Expected one of: ${[...VALID_SLA_UNITS].join(", ")}`,
+          severity: "error"
+        });
+      }
+      issues.push(...this.validateEscalationTriggerTypes(slaRule.escalationRule, "metadata.slaRules", "Root SLA rule"));
+    }
+    for (const cer of schema.metadata?.caseExitRules ?? []) {
+      issues.push(...this.validateRuleTypes(cer.rules, "metadata.caseExitRules", "Case exit condition"));
+    }
+    for (const edge of schema.edges) {
+      if (edge.type !== "case-management:Edge")
+        continue;
+      const caseEdge = edge;
+      issues.push(...this.validateRuleTypes(caseEdge.data.rules, `edges[${edge.id}]`, `Edge "${edgeLabel(edge)}"`));
+    }
+    return issues;
+  }
+  validateRuleTypes(rules, path, context) {
+    const issues = [];
+    for (const andGroup of rules ?? []) {
+      for (const rule of andGroup) {
+        if (!VALID_RULE_TYPES.has(rule.rule)) {
+          issues.push({
+            code: "INVALID_ENUM_VALUE",
+            path,
+            message: `${context} has a rule with invalid type "${rule.rule}". Expected one of: ${[...VALID_RULE_TYPES].join(", ")}`,
+            severity: "error"
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  validateEscalationTriggerTypes(escalationRules, path, context) {
+    const issues = [];
+    for (const esc of escalationRules ?? []) {
+      const triggerType = esc.triggerInfo?.type;
+      if (triggerType != null && !VALID_ESCALATION_TRIGGER_TYPES.has(triggerType)) {
+        issues.push({
+          code: "INVALID_ENUM_VALUE",
+          path,
+          message: `${context} has an escalation with invalid triggerInfo.type "${triggerType}". Expected one of: ${[...VALID_ESCALATION_TRIGGER_TYPES].join(", ")}`,
+          severity: "error"
+        });
+      }
+    }
+    return issues;
+  }
+  validateRuleContents(rule, condition, currentStage, schema, path, elementLabel, profile) {
+    const issues = [];
+    const condName = conditionLabel(condition);
+    switch (rule.rule) {
+      case "selected-stage-completed":
+      case "selected-stage-exited": {
+        if (!rule.selectedStageId) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_STAGE_ID_MISSING",
+            path,
+            message: `${elementLabel} condition "${condName}" has a "${rule.rule}" rule with no selectedStageId`,
+            severity: "error"
+          });
+          break;
+        }
+        const target = schema.nodes.find((n) => n.id === rule.selectedStageId);
+        if (!target || target.type !== "case-management:Stage" && target.type !== "case-management:ExceptionStage") {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_STAGE_MISSING",
+            path,
+            message: `${elementLabel} condition "${condName}" references a non-existent stage "${rule.selectedStageId}"`,
+            severity: "error"
+          });
+          break;
+        }
+        const targetStage = target;
+        const targetName = stageLabel(targetStage);
+        const expectedMarksComplete = rule.rule === "selected-stage-completed";
+        const matchingExit = (targetStage.data.exitConditions ?? []).find((c) => (c.marksStageComplete ?? false) === expectedMarksComplete);
+        if (!matchingExit) {
+          issues.push({
+            code: expectedMarksComplete ? "CASE_MGMT_ROOT_CASE_COMPLETE_CONDITION_RULE_SELECTED_STAGE_ID_NOT_FOUND" : "CASE_MGMT_ROOT_CASE_EXIT_CONDITION_RULE_SELECTED_STAGE_ID_NOT_FOUND",
+            path,
+            message: expectedMarksComplete ? `${elementLabel} condition "${condName}" references stage "${targetName}", which has no exit condition that marks the stage complete` : `${elementLabel} condition "${condName}" references stage "${targetName}", which has no non-completing exit condition`,
+            severity: "error"
+          });
+        }
+        break;
+      }
+      case "selected-tasks-completed": {
+        if (profile !== "full")
+          break;
+        if (!rule.selectedTasksIds || rule.selectedTasksIds.length === 0) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_TASK_IDS_MISSING",
+            path,
+            message: `${elementLabel} condition "${condName}" has a "selected-tasks-completed" rule with no selectedTasksIds`,
+            severity: "error"
+          });
+          break;
+        }
+        if (currentStage) {
+          const allTaskIds = new Set(flatTasks(currentStage).map((t) => t.id).filter((id) => Boolean(id)));
+          const missing = rule.selectedTasksIds.find((id) => !allTaskIds.has(id));
+          if (missing) {
+            issues.push({
+              code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_SELECTED_TASK_MISSING",
+              path,
+              message: `${elementLabel} condition "${condName}" references task "${missing}" which is not in this stage`,
+              severity: "error"
+            });
+          }
+        }
+        break;
+      }
+      case "required-stages-completed": {
+        const allPrimaryStages = schema.nodes.filter((n) => n.type === "case-management:Stage" && n.data.isCaseManagerStage !== true);
+        if (allPrimaryStages.length > 0) {
+          const hasRequired = allPrimaryStages.some((s) => s.data.isRequired === true);
+          if (!hasRequired) {
+            issues.push({
+              code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_NO_REQUIRED_STAGE",
+              path,
+              message: `${elementLabel} condition "${condName}" has a "required-stages-completed" rule but no primary stage is marked isRequired`,
+              severity: "error"
+            });
+          }
+        }
+        break;
+      }
+      case "required-tasks-completed": {
+        if (profile !== "full")
+          break;
+        if (currentStage) {
+          const tasks = flatTasks(currentStage);
+          if (tasks.length > 0) {
+            const hasRequired = tasks.some((t) => t.isRequired === true);
+            if (!hasRequired) {
+              issues.push({
+                code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_NO_REQUIRED_TASK",
+                path,
+                message: `${elementLabel} condition "${condName}" has a "required-tasks-completed" rule but no task in this stage is marked isRequired`,
+                severity: "error"
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "user-selected-stage": {
+        const otherStages = schema.nodes.filter((n) => (n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage") && n.id !== currentStage?.id);
+        const hasWaitForUser = otherStages.some((s) => s.data.exitConditions?.some((c) => c.type === "wait-for-user"));
+        if (!hasWaitForUser) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_USER_SELECTED_STAGE_MISSING",
+            path,
+            message: `${elementLabel} condition "${condName}" uses "user-selected-stage" but no other stage has a wait-for-user exit condition`,
+            severity: "error"
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    return issues;
+  }
+  validateConditionDuplicates(conditions, duplicateCode, path, duplicateMessage) {
+    const issues = [];
+    for (let i = 0;i < conditions.length; i++) {
+      for (let j = i + 1;j < conditions.length; j++) {
+        const a = conditions[i];
+        const b = conditions[j];
+        if (a.rules && b.rules && rulesMatch(a.rules, b.rules)) {
+          issues.push({
+            code: duplicateCode,
+            path,
+            message: duplicateMessage(a, b),
+            severity: "error"
+          });
+          break;
+        }
+      }
+    }
+    return issues;
+  }
+  validateConditionTooSimilar(conditions, currentStage, schema, path, elementLabel, profile) {
+    const issues = [];
+    const requiredStageIds = schema.nodes.filter((n) => n.type === "case-management:Stage" && n.data.isRequired === true && n.data.isCaseManagerStage !== true).map((n) => n.id);
+    const requiredTaskIds = currentStage ? flatTasks(currentStage).filter((t) => t.isRequired === true).map((t) => t.id ?? "").filter((id) => id !== "") : [];
+    const sameSet = (a, b) => a.length === b.length && a.every((id) => b.includes(id));
+    const checked = [];
+    for (const condition of conditions) {
+      const firstRule = condition.rules?.[0]?.[0] ?? null;
+      if (!firstRule) {
+        checked.push(condition);
+        continue;
+      }
+      for (const other of checked) {
+        const otherFirst = other.rules?.[0]?.[0] ?? null;
+        if (!otherFirst)
+          continue;
+        if (firstRule.conditionExpression !== otherFirst.conditionExpression)
+          continue;
+        let overlap = false;
+        if (firstRule.rule === "required-stages-completed" && otherFirst.rule === "selected-stage-completed" || firstRule.rule === "selected-stage-completed" && otherFirst.rule === "required-stages-completed") {
+          const ruleStages = firstRule.rule === "required-stages-completed" ? requiredStageIds : [firstRule.selectedStageId ?? ""];
+          const otherStages = otherFirst.rule === "required-stages-completed" ? requiredStageIds : [otherFirst.selectedStageId ?? ""];
+          overlap = sameSet(ruleStages, otherStages);
+        } else if (profile === "full" && (firstRule.rule === "required-tasks-completed" && otherFirst.rule === "selected-tasks-completed" || firstRule.rule === "selected-tasks-completed" && otherFirst.rule === "required-tasks-completed")) {
+          const ruleTasks = firstRule.rule === "required-tasks-completed" ? requiredTaskIds : firstRule.selectedTasksIds ?? [];
+          const otherTasks = otherFirst.rule === "required-tasks-completed" ? requiredTaskIds : otherFirst.selectedTasksIds ?? [];
+          overlap = sameSet(ruleTasks, otherTasks);
+        }
+        if (overlap) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_TOO_SIMILAR",
+            path,
+            message: `${elementLabel} condition "${conditionLabel(condition)}" overlaps with condition "${conditionLabel(other)}" (different rule types but the same target set)`,
+            severity: "error"
+          });
+          break;
+        }
+      }
+      checked.push(condition);
+    }
+    return issues;
+  }
+  validateConditionsBattery(opts) {
+    const issues = [];
+    for (const condition of opts.conditions) {
+      const condName = conditionLabel(condition);
+      for (const rule of flatConditionRules(condition)) {
+        if (!rule.rule) {
+          issues.push({
+            code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_MISSING",
+            path: opts.path,
+            message: `${opts.elementLabel} condition "${condName}" has a rule object with no rule type set`,
+            severity: "error"
+          });
+          continue;
+        }
+        issues.push(...this.validateRuleContents(rule, condition, opts.currentStage, opts.schema, opts.path, opts.elementLabel, opts.profile));
+      }
+    }
+    issues.push(...this.validateConditionDuplicates(opts.conditions, opts.duplicateCode, opts.path, (a, b) => `${opts.elementLabel} has duplicate conditions "${conditionLabel(a)}" and "${conditionLabel(b)}"`));
+    issues.push(...this.validateConditionTooSimilar(opts.conditions, opts.currentStage, opts.schema, opts.path, opts.elementLabel, opts.profile));
+    return issues;
+  }
+  validateTaskEntryConditions(stage, schema) {
+    const issues = [];
+    const path = `nodes[${stage.id}]`;
+    const stageName = stageLabel(stage);
+    const data = stage.data;
+    let isCaseManagerStage = data.isCaseManagerStage;
+    if (isCaseManagerStage == null) {
+      isCaseManagerStage = findFirstStageAfterTrigger(schema) === stage.id;
+    }
+    if (isCaseManagerStage && schema.metadata?.allowAdhocOptionalStageTasks === true) {
+      return issues;
+    }
+    const tasks = flatTasks(stage);
+    for (const task of tasks) {
+      const taskName = task.displayName ?? task.id ?? "(unnamed)";
+      if (!task.data || Object.keys(task.data).length === 0) {
+        continue;
+      }
+      if (!task.entryConditions?.length) {
+        issues.push({
+          code: "CASE_MGMT_STAGE_TASK_ENTRY_CONDITION_MISSING",
+          path,
+          message: `Stage "${stageName}" task "${taskName}" has no entry condition (it would never run)`,
+          severity: "error"
+        });
+        continue;
+      }
+      issues.push(...this.validateConditionsBattery({
+        conditions: task.entryConditions,
+        schema,
+        currentStage: stage,
+        path,
+        elementLabel: `Stage "${stageName}" task "${taskName}"`,
+        duplicateCode: "CASE_MGMT_TASK_ENTRY_CONDITION_DUPLICATE",
+        profile: "full"
+      }));
+    }
+    return issues;
+  }
+  validateStructure(schema) {
+    const issues = [];
+    const hasTrigger = schema.nodes.some((n) => n.type === "case-management:Trigger");
+    if (!hasTrigger) {
+      issues.push({
+        code: "CASE_MGMT_NO_TRIGGER_NODE",
+        path: "nodes",
+        message: "The case definition has no trigger node",
+        severity: "error"
+      });
+    }
+    const hasStage = schema.nodes.some((n) => n.type === "case-management:Stage");
+    if (!hasStage) {
+      issues.push({
+        code: "CASE_MGMT_NO_STAGE_NODE",
+        path: "nodes",
+        message: "The case definition has no stage nodes",
+        severity: "error"
+      });
+    }
+    return issues;
+  }
+  validateTriggers(schema, profile) {
+    const issues = [];
+    const triggers = schema.nodes.filter((n) => n.type === "case-management:Trigger");
+    const triggerTargets = new Set;
+    for (const trigger of triggers) {
+      const name = triggerLabel(trigger);
+      const outgoing = schema.edges.filter((e) => e.source === trigger.id);
+      if (profile !== "skeleton") {
+        const missingTriggerField = findRequiredFieldErrorInUiPath(trigger.data.uipath);
+        if (missingTriggerField) {
+          issues.push({
+            code: "EMPTY_REQUIRED_FIELD",
+            path: `nodes[${trigger.id}]`,
+            message: `Trigger "${name}" has required field "${missingTriggerField}" that is empty`,
+            severity: "error"
+          });
+        }
+      }
+      if (outgoing.length === 0) {
+        issues.push({
+          code: "CASE_MGMT_TRIGGER_NO_EDGES",
+          path: `nodes[${trigger.id}]`,
+          message: `Trigger "${name}" has no outgoing edges`,
+          severity: "error"
+        });
+      } else {
+        for (const edge of outgoing) {
+          triggerTargets.add(edge.target);
+        }
+      }
+    }
+    if (triggerTargets.size > 1) {
+      const canonicalTarget = [...triggerTargets][0];
+      for (const trigger of triggers) {
+        const name = triggerLabel(trigger);
+        const outgoing = schema.edges.filter((e) => e.source === trigger.id);
+        for (const edge of outgoing) {
+          if (edge.target === canonicalTarget)
+            continue;
+          issues.push({
+            code: "CASE_MGMT_TRIGGER_EDGE_TO_WRONG_STAGE",
+            path: `nodes[${trigger.id}]`,
+            message: `Trigger "${name}" does not point to the same first stage as other triggers`,
+            severity: "error"
+          });
+          break;
+        }
+      }
+    }
+    return issues;
+  }
+  validateStageShared(stage, labelCounts, profile) {
+    const issues = [];
+    const path = `nodes[${stage.id}]`;
+    const name = stageLabel(stage);
+    if (!stage.data.label || stage.data.label.trim() === "") {
+      issues.push({
+        code: "CASE_MGMT_STAGE_NAME_MISSING",
+        path,
+        message: "Stage name is missing",
+        severity: "error"
+      });
+    } else if ((labelCounts.get(stage.data.label.trim()) ?? 0) > 1) {
+      issues.push({
+        code: "CASE_MGMT_STAGE_NAME_NOT_UNIQUE",
+        path,
+        message: `Stage name "${name}" is not unique`,
+        severity: "error"
+      });
+    }
+    if (profile === "skeleton")
+      return issues;
+    const raw = stage;
+    if (raw.entryConditions && !stage.data.entryConditions?.length) {
+      issues.push({
+        code: "CASE_MGMT_STAGE_ENTRY_CONDITIONS_MISPLACED",
+        path,
+        message: `Stage "${name}" has entryConditions on the node instead of inside data (should be data.entryConditions)`,
+        severity: "error"
+      });
+    }
+    if (raw.exitConditions && !stage.data.exitConditions?.length) {
+      issues.push({
+        code: "CASE_MGMT_STAGE_EXIT_CONDITIONS_MISPLACED",
+        path,
+        message: `Stage "${name}" has exitConditions on the node instead of inside data (should be data.exitConditions)`,
+        severity: "error"
+      });
+    }
+    const allTasks = profile === "full" ? flatTasks(stage) : [];
+    if (profile === "full" && allTasks.length === 0) {
+      issues.push({
+        code: "CASE_MGMT_STAGE_TASKS_MISSING",
+        path,
+        message: `Stage "${name}" has no tasks`,
+        severity: "warning"
+      });
+    } else {
+      for (const task of allTasks) {
+        if (!task.data || Object.keys(task.data).length === 0) {
+          issues.push({
+            code: "CASE_MGMT_STAGE_TASK_SELECTION_MISSING",
+            path,
+            message: `Stage "${name}" has a task with no configuration`,
+            severity: "warning"
+          });
+        } else {
+          const taskData2 = task.data;
+          const missingField = findRequiredFieldErrorInUiPath(taskData2);
+          if (missingField) {
+            issues.push({
+              code: "EMPTY_REQUIRED_FIELD",
+              path,
+              message: `Stage "${name}" has a task with required field "${missingField}" that is empty`,
+              severity: "error"
+            });
+          } else if (task.type === "action" && !task.data.taskTitle) {
+            issues.push({
+              code: "EMPTY_REQUIRED_FIELD",
+              path,
+              message: `Stage "${name}" has an action task with no title`,
+              severity: "error"
+            });
+          }
+        }
+        for (const entryCondition of task.entryConditions ?? []) {
+          if (!entryCondition.rules || entryCondition.rules.length === 0) {
+            issues.push({
+              code: "CASE_MGMT_ROOT_CASE_CONDITION_RULE_MISSING",
+              path,
+              message: `Stage "${name}" has a task with an entry condition with no rules`,
+              severity: "error"
+            });
+          }
+        }
+        const taskDataRaw = task.data;
+        const taskDisplayName = task.displayName ?? task.id ?? "(unnamed)";
+        if (taskDataRaw?.entryConditions && !task.entryConditions?.length) {
+          issues.push({
+            code: "CASE_MGMT_TASK_ENTRY_CONDITIONS_MISPLACED",
+            path,
+            message: `Stage "${name}" task "${taskDisplayName}" has entryConditions inside data (should be on the task object, not data.entryConditions)`,
+            severity: "error"
+          });
+        }
+      }
+    }
+    const sla = stage.data.sla;
+    if (sla) {
+      const hasEscalations = sla.escalationRule != null && sla.escalationRule.length > 0;
+      const hasValue = sla.count != null && sla.count > 0;
+      if (hasEscalations && !hasValue) {
+        issues.push({
+          code: "CASE_MGMT_STAGE_NO_SLA_ESCALATIONS",
+          path,
+          message: `Stage "${name}" has SLA escalation rules but no SLA value is set`,
+          severity: "warning"
+        });
+      }
+      if (hasEscalations) {
+        const missingRecipients = (sla.escalationRule ?? []).some((e) => !e.action?.recipients || e.action.recipients.length === 0);
+        if (missingRecipients) {
+          issues.push({
+            code: "CASE_MGMT_STAGE_ESCALATION_RECIPIENTS_MISSING",
+            path,
+            message: `Stage "${name}" has an escalation rule with no recipients`,
+            severity: "warning"
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  detectReEntryStages(schema) {
+    const stages = schema.nodes.filter((n) => n.type === "case-management:Stage");
+    const stageIds = new Set(stages.map((s) => s.id));
+    const adj = new Map;
+    for (const stage of stages)
+      adj.set(stage.id, []);
+    for (const edge of schema.edges) {
+      if (edge.type === "case-management:Edge" && stageIds.has(edge.source) && stageIds.has(edge.target)) {
+        adj.get(edge.source)?.push(edge.target);
+      }
+    }
+    const reEntryTargets = new Set;
+    const visited = new Set;
+    const inStack = new Set;
+    for (const start of stages) {
+      if (visited.has(start.id))
+        continue;
+      const stack = [[start.id, 0]];
+      visited.add(start.id);
+      inStack.add(start.id);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const neighbors = adj.get(frame[0]) ?? [];
+        if (frame[1] >= neighbors.length) {
+          stack.pop();
+          inStack.delete(frame[0]);
+        } else {
+          const neighbor = neighbors[frame[1]++];
+          if (inStack.has(neighbor)) {
+            reEntryTargets.add(neighbor);
+          } else if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            inStack.add(neighbor);
+            stack.push([neighbor, 0]);
+          }
+        }
+      }
+    }
+    return reEntryTargets;
+  }
+  buildLabelCounts(schema) {
+    const counts = new Map;
+    for (const stage of schema.nodes.filter((n) => n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage")) {
+      const label = stage.data.label?.trim() ?? "";
+      if (label)
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return counts;
+  }
+  validatePrimaryStages(schema, profile) {
+    const issues = [];
+    const stages = schema.nodes.filter((n) => n.type === "case-management:Stage");
+    const secondaryStages = schema.nodes.filter((n) => n.type === "case-management:ExceptionStage");
+    const reEntryStages = profile === "full" ? this.detectReEntryStages(schema) : new Set;
+    const labelCounts = this.buildLabelCounts(schema);
+    const suppressMissingErrors = hasCaseManagerStageWithTasks(schema);
+    for (const stage of stages) {
+      const path = `nodes[${stage.id}]`;
+      const name = stageLabel(stage);
+      const entryConditions = stage.data.entryConditions ?? [];
+      const exitConditions = stage.data.exitConditions ?? [];
+      issues.push(...this.validateStageShared(stage, labelCounts, profile));
+      const incomingEdges = schema.edges.filter((e) => e.target === stage.id);
+      if (incomingEdges.length === 0) {
+        const hasSendToStage = secondaryStages.some((ss) => ss.data.exitConditions?.some((ec) => ec.exitToStageId === stage.id));
+        const hasWaitForUser = exitConditions.some((ec) => ec.type === "wait-for-user");
+        if (!hasSendToStage && !hasWaitForUser) {
+          issues.push({
+            code: "CASE_MGMT_STAGE_EDGES_MISSING",
+            path,
+            message: `Stage "${name}" has no incoming edges`,
+            severity: "error"
+          });
+        }
+      }
+      if (profile === "skeleton")
+        continue;
+      if (entryConditions.length === 0 && !suppressMissingErrors) {
+        issues.push({
+          code: "CASE_MGMT_STAGE_ENTRY_CONDITION_MISSING",
+          path,
+          message: `Stage "${name}" has no entry condition`,
+          severity: "error"
+        });
+      }
+      const hasCompleteExit = exitConditions.some((c) => c.marksStageComplete === true);
+      if (!hasCompleteExit && !suppressMissingErrors) {
+        issues.push({
+          code: "CASE_MGMT_STAGE_EXIT_CONDITION_MISSING",
+          path,
+          message: `Stage "${name}" has no exit condition that marks the stage as complete`,
+          severity: "error"
+        });
+      }
+      const allTasks = flatTasks(stage);
+      if (reEntryStages.has(stage.id)) {
+        const hasReEntryTask = allTasks.some((t) => t.shouldRunOnlyOnce === false || t.shouldRunOnlyOnce === undefined);
+        if (!hasReEntryTask) {
+          issues.push({
+            code: "CASE_MGMT_STAGE_NO_TASKS_RUNNING_ON_RE_ENTRY",
+            path,
+            message: `Stage "${name}" can be re-entered but no task is marked to run on re-entry`,
+            severity: "warning"
+          });
+        }
+      }
+      for (const condition of entryConditions) {
+        for (const rule of flatConditionRules(condition)) {
+          if ((rule.rule === "selected-stage-completed" || rule.rule === "selected-stage-exited") && rule.selectedStageId === stage.id) {
+            issues.push({
+              code: "CASE_MGMT_STAGE_ENTRY_CONDITION_RULE_SELF_REFERENCE_WARNING",
+              path,
+              message: `Stage "${name}" entry condition "${conditionLabel(condition)}" references its own stage`,
+              severity: "warning"
+            });
+          }
+        }
+      }
+      const hasWaitForUserExit = exitConditions.some((c) => c.type === "wait-for-user");
+      if (hasWaitForUserExit) {
+        const otherStages = schema.nodes.filter((n) => (n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage") && n.id !== stage.id);
+        const hasUserSelectedStageEntry = otherStages.some((s) => (s.data.entryConditions ?? []).some((c) => flatConditionRules(c).some((r) => r.rule === "user-selected-stage")));
+        if (!hasUserSelectedStageEntry) {
+          issues.push({
+            code: "CASE_MGMT_STAGE_EXIT_CONDITION_USER_SELECTED_STAGE_MISSING",
+            path,
+            message: `Stage "${name}" has a "wait-for-user" exit condition but no other stage has a "user-selected-stage" entry rule`,
+            severity: "error"
+          });
+        }
+      }
+      issues.push(...this.validateConditionsBattery({
+        conditions: entryConditions,
+        schema,
+        currentStage: stage,
+        path,
+        elementLabel: `Stage "${name}"`,
+        duplicateCode: "CASE_MGMT_STAGE_ENTRY_CONDITION_DUPLICATE",
+        profile
+      }));
+      issues.push(...this.validateConditionsBattery({
+        conditions: exitConditions,
+        schema,
+        currentStage: stage,
+        path,
+        elementLabel: `Stage "${name}"`,
+        duplicateCode: "CASE_MGMT_STAGE_EXIT_CONDITION_DUPLICATE",
+        profile
+      }));
+      const outgoingEdges = schema.edges.filter((e) => e.source === stage.id && e.type === "case-management:Edge");
+      for (const condition of exitConditions) {
+        if (!condition.rules)
+          continue;
+        for (const edge of outgoingEdges) {
+          const edgeRules = edge.data.rules;
+          if (edgeRules && rulesMatch(condition.rules, edgeRules)) {
+            issues.push({
+              code: "CASE_MGMT_STAGE_EXIT_CONDITION_DUPLICATE_EDGE",
+              path,
+              message: `Stage "${name}" has an exit condition that duplicates outgoing edge "${edgeLabel(edge)}"`,
+              severity: "error"
+            });
+            break;
+          }
+        }
+      }
+      for (const condition of exitConditions) {
+        if (!condition.rules)
+          continue;
+        for (const ss of secondaryStages) {
+          const ssName = stageLabel(ss);
+          for (const ec of ss.data.entryConditions ?? []) {
+            if (!ec.rules || ec.rules.length === 0)
+              continue;
+            if (rulesMatch(condition.rules, ec.rules)) {
+              issues.push({
+                code: "CASE_MGMT_STAGE_EDGE_DUPLICATE_CONDITION_STAGE",
+                path,
+                message: `Stage "${name}" has an exit condition that duplicates the entry rules of secondary stage "${ssName}"`,
+                severity: "error"
+              });
+              break;
+            }
+          }
+        }
+      }
+      for (const condition of exitConditions) {
+        const allRules = (condition.rules ?? []).flat();
+        for (const rule of allRules) {
+          const missingField = findRequiredFieldErrorInUiPath(rule.uipath);
+          if (missingField) {
+            issues.push({
+              code: "EMPTY_REQUIRED_FIELD",
+              path,
+              message: `Stage "${name}" has an exit condition rule with required field "${missingField}" that is empty`,
+              severity: "error"
+            });
+          }
+        }
+      }
+      if (profile === "full") {
+        issues.push(...this.validateTaskEntryConditions(stage, schema));
+      }
+    }
+    return issues;
+  }
+  validateSecondaryStages(schema, profile) {
+    const issues = [];
+    const secondaryStages = schema.nodes.filter((n) => n.type === "case-management:ExceptionStage");
+    const labelCounts = this.buildLabelCounts(schema);
+    const suppressMissingErrors = hasCaseManagerStageWithTasks(schema);
+    for (const stage of secondaryStages) {
+      const path = `nodes[${stage.id}]`;
+      const name = stageLabel(stage);
+      issues.push(...this.validateStageShared(stage, labelCounts, profile));
+      const hasDirectEdges = schema.edges.some((e) => e.source === stage.id || e.target === stage.id);
+      if (hasDirectEdges) {
+        issues.push({
+          code: "CASE_MGMT_SECONDARY_STAGE_EDGES",
+          path,
+          message: `Secondary stage "${name}" has direct edges (secondary stages use entry/exit conditions instead)`,
+          severity: "error"
+        });
+      }
+      if (profile === "skeleton")
+        continue;
+      const entryConditions = stage.data.entryConditions ?? [];
+      if (entryConditions.length === 0) {
+        if (!suppressMissingErrors) {
+          issues.push({
+            code: "CASE_MGMT_SECONDARY_STAGE_ENTRY_RULES_MISSING",
+            path,
+            message: `Secondary stage "${name}" has no entry conditions`,
+            severity: "warning"
+          });
+        }
+      } else {
+        for (const condition of entryConditions) {
+          if (!condition.rules || condition.rules.length === 0) {
+            issues.push({
+              code: "CASE_MGMT_SECONDARY_STAGE_EXIT_RULES_MISSING",
+              path,
+              message: `Secondary stage "${name}" has an entry condition with no rules`,
+              severity: "error"
+            });
+          }
+        }
+        const stageRules = entryConditions.flatMap((c) => c.rules ?? []);
+        for (const otherStage of secondaryStages) {
+          if (otherStage.id === stage.id)
+            continue;
+          const otherName = stageLabel(otherStage);
+          const otherRules = (otherStage.data.entryConditions ?? []).flatMap((c) => c.rules ?? []);
+          if (stageRules.length > 0 && otherRules.length > 0 && rulesMatch(stageRules, otherRules)) {
+            issues.push({
+              code: "CASE_MGMT_SECONDARY_STAGE_ENTRY_RULES_DUPLICATE",
+              path,
+              message: `Secondary stage "${name}" has entry rules that duplicate those of "${otherName}"`,
+              severity: "error"
+            });
+            break;
+          }
+        }
+        for (const condition of entryConditions) {
+          if (!condition.rules || condition.rules.length === 0)
+            continue;
+          for (const edge of schema.edges) {
+            if (edge.type !== "case-management:Edge")
+              continue;
+            const caseEdge = edge;
+            const edgeRules = caseEdge.data.rules;
+            if (edgeRules && rulesMatch(condition.rules, edgeRules)) {
+              issues.push({
+                code: "CASE_MGMT_SECONDARY_STAGE_ENTRY_RULES_DUPLICATE_EDGE",
+                path,
+                message: `Secondary stage "${name}" has an entry condition that duplicates edge "${edgeLabel(edge)}"`,
+                severity: "error"
+              });
+              break;
+            }
+          }
+        }
+      }
+      const exitConditions = stage.data.exitConditions ?? [];
+      if (exitConditions.length === 0) {
+        if (!suppressMissingErrors) {
+          issues.push({
+            code: "CASE_MGMT_SECONDARY_STAGE_EXIT_RULES_MISSING",
+            path,
+            message: `Secondary stage "${name}" has no exit conditions`,
+            severity: "error"
+          });
+        }
+      } else {
+        for (const condition of exitConditions) {
+          if (!condition.rules || condition.rules.length === 0) {
+            issues.push({
+              code: "CASE_MGMT_SECONDARY_STAGE_EXIT_RULES_MISSING",
+              path,
+              message: `Secondary stage "${name}" has an exit condition with no rules`,
+              severity: "error"
+            });
+          }
+        }
+      }
+      if (profile === "full") {
+        issues.push(...this.validateTaskEntryConditions(stage, schema));
+      }
+    }
+    return issues;
+  }
+  validateEdges(schema, profile) {
+    const issues = [];
+    const secondaryStages = schema.nodes.filter((n) => n.type === "case-management:ExceptionStage");
+    const nodeIds = new Set(schema.nodes.map((n) => n.id));
+    const edgesBySource = new Map;
+    for (const edge of schema.edges) {
+      if (!nodeIds.has(edge.source)) {
+        issues.push({
+          code: "EDGE_INVALID_SOURCE",
+          path: `edges[${edge.id}]`,
+          message: `Edge "${edgeLabel(edge)}" source node "${edge.source}" does not exist`,
+          severity: "error"
+        });
+      }
+      if (!nodeIds.has(edge.target)) {
+        issues.push({
+          code: "EDGE_INVALID_TARGET",
+          path: `edges[${edge.id}]`,
+          message: `Edge "${edgeLabel(edge)}" target node "${edge.target}" does not exist`,
+          severity: "error"
+        });
+      }
+      const group = edgesBySource.get(edge.source) ?? [];
+      group.push(edge);
+      edgesBySource.set(edge.source, group);
+    }
+    if (profile === "skeleton")
+      return issues;
+    for (const [, edges] of edgesBySource) {
+      const caseEdges = edges.filter((e) => e.type === "case-management:Edge");
+      for (let i = 0;i < caseEdges.length; i++) {
+        let hasDuplicate = false;
+        for (let j = i + 1;j < caseEdges.length && !hasDuplicate; j++) {
+          const a = caseEdges[i];
+          const b = caseEdges[j];
+          if (a.data.rules && b.data.rules && rulesMatch(a.data.rules, b.data.rules)) {
+            issues.push({
+              code: "CASE_MGMT_STAGE_EDGE_DUPLICATE_CONDITION",
+              path: `edges[${a.id}]`,
+              message: `Two or more edges from the same source node have duplicate conditions`,
+              severity: "error"
+            });
+            hasDuplicate = true;
+          }
+        }
+      }
+      for (const edge of caseEdges) {
+        if (!edge.data.rules)
+          continue;
+        for (const ss of secondaryStages) {
+          const ssName = stageLabel(ss);
+          for (const ec of ss.data.entryConditions ?? []) {
+            if (!ec.rules || ec.rules.length === 0)
+              continue;
+            if (rulesMatch(edge.data.rules, ec.rules)) {
+              issues.push({
+                code: "CASE_MGMT_STAGE_EDGE_DUPLICATE_CONDITION_STAGE",
+                path: `edges[${edge.id}]`,
+                message: `Edge "${edgeLabel(edge)}" has conditions that duplicate the entry rules of secondary stage "${ssName}"`,
+                severity: "error"
+              });
+              break;
+            }
+          }
+        }
+        const allEdgeRules = (edge.data.rules ?? []).flat();
+        for (const rule of allEdgeRules) {
+          const missingRuleField = findRequiredFieldErrorInUiPath(rule.uipath);
+          if (missingRuleField) {
+            issues.push({
+              code: "EMPTY_REQUIRED_FIELD",
+              path: `edges[${edge.id}]`,
+              message: `Edge "${edgeLabel(edge)}" has a rule with required field "${missingRuleField}" that is empty`,
+              severity: "error"
+            });
+          }
+        }
+      }
+    }
+    return issues;
+  }
+  validateOverallCase(schema) {
+    const issues = [];
+    const stages = schema.nodes.filter((n) => n.type === "case-management:Stage");
+    if (stages.length === 0)
+      return issues;
+    const allStageNodes = schema.nodes.filter((n) => n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage");
+    const hasExplicitTerminal = allStageNodes.some((s) => s.data.exitConditions?.some((ec) => ec.type === "exit-only")) || (schema.metadata?.caseExitRules ?? []).length > 0;
+    if (hasExplicitTerminal)
+      return issues;
+    const hasImplicitTerminal = stages.every((s) => schema.edges.some((e) => e.target === s.id));
+    if (!hasImplicitTerminal) {
+      issues.push({
+        code: "CASE_MGMT_VALID_TERMINAL_EXIT_MISSING",
+        path: "(overall)",
+        message: "The case definition has no valid terminal exit (not all stages have incoming edges and no explicit terminal exit condition)",
+        severity: "error"
+      });
+    }
+    return issues;
+  }
+  validateAdhocNodes(schema, profile) {
+    const issues = [];
+    const labelCounts = this.buildLabelCounts(schema);
+    const triggerIds = new Set(schema.nodes.filter((n) => n.type === "case-management:Trigger").map((n) => n.id));
+    const masterStageId = schema.edges.filter((e) => triggerIds.has(e.source)).map((e) => e.target)[0];
+    const masterStage = masterStageId ? schema.nodes.find((n) => n.id === masterStageId && (n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage")) : undefined;
+    if (!masterStage) {
+      issues.push({
+        code: "CASE_MGMT_NO_MASTER_ADHOC_STAGE",
+        path: "nodes",
+        message: "The adhoc case definition has no master orchestration stage",
+        severity: "error"
+      });
+    } else {
+      issues.push(...this.validateStageShared(masterStage, labelCounts, profile));
+      if (profile === "full") {
+        issues.push(...this.validateTaskEntryConditions(masterStage, schema));
+      }
+    }
+    const otherStages = schema.nodes.filter((n) => (n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage") && n.id !== masterStageId);
+    if (otherStages.length === 0) {
+      if (profile !== "skeleton") {
+        issues.push({
+          code: "CASE_MGMT_NO_ADDITIONAL_STAGE_NODES",
+          path: "nodes",
+          message: "The adhoc case definition has no additional stage nodes besides the master stage",
+          severity: "error"
+        });
+      }
+    } else {
+      for (const stage of otherStages) {
+        issues.push(...this.validateStageShared(stage, labelCounts, profile));
+        if (profile === "full") {
+          issues.push(...this.validateTaskEntryConditions(stage, schema));
+        }
+      }
+    }
+    return issues;
+  }
+  validateOutputVariableUniqueness(schema) {
+    const issues = [];
+    const allStages = schema.nodes.filter((n) => n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage");
+    const seen = new Map;
+    for (const stage of allStages) {
+      const name = stageLabel(stage);
+      for (const task of flatTasks(stage)) {
+        const taskName = task.displayName ?? task.id ?? "(unnamed)";
+        const outputs = task.data?.outputs ?? [];
+        for (const output of outputs) {
+          const varId = output.var ?? output.id;
+          if (!varId)
+            continue;
+          const location = `"${name}"/"${taskName}"`;
+          const existing = seen.get(varId);
+          if (existing) {
+            issues.push({
+              code: "CASE_MGMT_DUPLICATE_OUTPUT_VARIABLE",
+              path: `nodes[${stage.id}]`,
+              message: `Output variable "${varId}" in ${location} duplicates the same variable in ${existing}`,
+              severity: "error"
+            });
+          } else {
+            seen.set(varId, location);
+          }
+        }
+      }
+    }
+    return issues;
+  }
+  runTaskValidators(schema, profile = "full") {
+    const issues = [];
+    const validators = profile === "strict" ? [...this.taskValidators, ...strictTaskValidators] : this.taskValidators;
+    if (!Array.isArray(schema.nodes))
+      return issues;
+    const stages = schema.nodes.filter((n) => n.type === "case-management:Stage" || n.type === "case-management:ExceptionStage");
+    for (const stage of stages) {
+      const tasks = (stage.data.tasks ?? []).flat();
+      for (const task of tasks) {
+        const ctx = { schema, stageId: stage.id };
+        for (const validator of validators) {
+          if (!validator.appliesTo(task))
+            continue;
+          issues.push(...validator.validate(task, ctx));
+        }
+      }
+    }
+    return issues;
+  }
+}
+export {
+  CaseValidateService
+};
+
+//# debugId=73947324AD8898D364756E2164756E21