@uipath/case-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{case-validate-service-84drzwx3.js → case-validate-service-jcdf4n67.js}

@@ -1,20 +1,32 @@
 import {
   ACTIVITY_TYPE_ID_PATH,
-  BINDING_REFERENCE_PREFIX,
-  NAME_BOUND_TASK_TYPES,
-  RESOLVED_IDENTITY_KEYS,
   activityTypeIdMessage,
   contextEntries,
   contextEntry,
   missingContextKeys,
   readActivityTypeId
-} from "./packager-tool-d4sjk46c.js";
+} from "./packager-tool-cv05dwac.js";
+import {
+  CONNECTOR_TASK_TYPES,
+  SERVICE_TYPE_BY_TASK
+} from "./packager-tool-dthjwajc.js";
+import {
+  BINDING_REFERENCE_PREFIX,
+  NAME_BOUND_TASK_TYPES,
+  RESOLVED_IDENTITY_KEYS
+} from "./packager-tool-d7jjng8a.js";
+import {
+  readRegistryLedger
+} from "./packager-tool-b250k6w4.js";
 import {
   validateIntSvcNode
-} from "./packager-tool-3qkp2fts.js";
+} from "./packager-tool-76ms0wdw.js";
 import {
-  loadCaseSchemaAsync
-} from "./packager-tool-p7jgrm5r.js";
+  MIN_SUPPORTED_MAJOR,
+  compareCaseSchemaVersions,
+  parseCaseSchemaVersion,
+  resolveCaseSchemaVersion
+} from "./packager-tool-57pzrd0g.js";
 import {
   VALID_CASE_COMPLETION_RULE_TYPES,
   VALID_CASE_EXIT_RULE_TYPES,
@@ -22,30 +34,55 @@ import {
   VALID_STAGE_ENTRY_RULE_TYPES,
   VALID_STAGE_EXIT_RULE_TYPES,
   VALID_TASK_ENTRY_RULE_TYPES
-} from "./packager-tool-sv0d6wb6.js";
-import"./packager-tool-yrsrzz1a.js";
+} from "./packager-tool-nj4seavy.js";
+import"./packager-tool-v99ygh9f.js";
 import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
 import"./packager-tool-yc4kw997.js";
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-cmwets3m.js";
 import {
   catchError,
   logger
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
 
+// src/services/case-validators/connector-activity-validator.ts
+var ACTIVITY_CONTEXT_KEYS = ["metadata", "objectName"];
+var connectorActivityValidator = {
+  id: "uipath-connector-activity",
+  appliesTo: (task) => CONNECTOR_TASK_TYPES.has(task.type ?? "") && Object.keys(task.data ?? {}).length > 0,
+  validate: (task, ctx) => {
+    const context = task.data?.context;
+    const missing = ACTIVITY_CONTEXT_KEYS.filter((key) => contextEntry(context, key) === undefined);
+    if (missing.length === 0)
+      return [];
+    const name = task.displayName ?? task.id ?? "task";
+    return [
+      {
+        code: "CASE_MGMT_CONNECTOR_ACTIVITY_UNRESOLVED",
+        path: `nodes[${ctx.stageId}].data.tasks[${task.id ?? "?"}].data.context`,
+        severity: "error",
+        message: `Connector task "${name}" has no ${missing.map((key) => `\`${key}\``).join(" or ")} context entry, so Studio Web shows it ` + "with no activity selected and it cannot run. Fetch the " + "activity with `uip maestro case spec` and write it into " + "the task with `uip maestro case splice`, or empty the " + "task's `data` to leave it as a placeholder."
+      }
+    ];
+  }
+};
+
 // src/services/case-validators/connector-validator.ts
-var CONNECTOR_TASK_TYPES = new Set([
+var CONNECTOR_TASK_TYPES2 = new Set([
   "execute-connector-activity",
   "wait-for-connector"
 ]);
 var connectorTaskValidator = {
   id: "uipath-connector",
-  appliesTo: (task) => CONNECTOR_TASK_TYPES.has(task.type),
+  appliesTo: (task) => CONNECTOR_TASK_TYPES2.has(task.type),
   validate: (task, ctx) => {
     const data = task.data;
     if (!data)
@@ -281,14 +318,6 @@ var timerTaskValidator = {
 };
 // src/services/case-validators/strict-task-validators.ts
 var TRIGGER_TASK_TYPES = new Set(["wait-for-connector"]);
-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 VARS_READS = [
@@ -309,17 +338,19 @@ 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 ?? ""),
+  appliesTo: (task) => CONNECTOR_TASK_TYPES.has(task.type ?? "") && Object.keys(taskData(task) ?? {}).length > 0,
   validate: (task, ctx) => {
     const issues = [];
-    const context = taskData(task)?.context;
-    const missing = missingContextKeys(context, TRIGGER_TASK_TYPES.has(task.type ?? ""));
+    const data = taskData(task);
+    const context = data?.context;
+    const reportedByDefault = new Set(Object.keys(data ?? {}).length > 0 ? ACTIVITY_CONTEXT_KEYS : []);
+    const missing = missingContextKeys(context, TRIGGER_TASK_TYPES.has(task.type ?? ""), ctx.schema.bindings).filter((key) => !reportedByDefault.has(key));
     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."
+        message: `Connector task "${taskLabel(task)}" is missing context ` + `entries: ${missing.join(", ")}. The runtime binds the ` + "task through these, so it deploys and cannot run — " + "under --strict an incomplete context is a defect."
       });
     }
     if (contextEntry(context, "metadata") !== undefined) {
@@ -539,11 +570,43 @@ var strictTaskValidators = [
 // src/services/case-validators/index.ts
 var defaultTaskValidators = [
   connectorTaskValidator,
+  connectorActivityValidator,
   timerTaskValidator,
   taskElementIdValidator,
   unconfiguredTaskValidator
 ];
 
+// src/services/registry-ledger-lookup.ts
+var findRegistryLedger = async (fs, casePlanPath) => {
+  const dir = fs.path.dirname(casePlanPath);
+  const candidates = [];
+  for (const up of ["", "..", "../.."]) {
+    for (const leaf of ["tasks", "."]) {
+      candidates.push(fs.path.join(dir, up, leaf, "registry-resolved.json"));
+    }
+  }
+  for (const candidate of candidates) {
+    if (!await fs.exists(candidate))
+      continue;
+    const [readError, text] = await catchError(fs.readFile(candidate, "utf-8"));
+    if (readError || text === undefined || text === null)
+      continue;
+    const [parseError, document] = await catchError(Promise.resolve().then(() => JSON.parse(text)));
+    if (parseError) {
+      logger.warn(`Ignored ${candidate}: not JSON, so a placeholder it might justify still reports as unresolved work.`);
+      continue;
+    }
+    const ledger = readRegistryLedger(document);
+    if (ledger === undefined) {
+      logger.warn(`Found ${candidate} but no resolution entries in it — an entry needs a \`task\` name carrying \`matches\` or \`selected\`, within four levels of the root. Placeholders it might justify will report as unresolved work.`);
+      continue;
+    }
+    logger.info(`Read ${candidate}: ${ledger.unresolvable.size} task(s) recorded unresolvable`);
+    return ledger;
+  }
+  return;
+};
+
 // src/services/case-validate-service.ts
 var mapCanvasSeverity = (severity) => {
   const normalized = (severity ?? "error").toUpperCase();
@@ -565,165 +628,53 @@ var SKELETON_V2_SKIPPED_CANVAS_CODES = new Set([
   "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;
-    }
+function findLegacySpellings(parsed, profile) {
+  const issues = [];
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return issues;
   }
-  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 version = parsed.version;
+  if (version === undefined || typeof version === "string" && version.trim() === "") {
+    return issues;
+  }
+  const severity = profile === "strict" ? "error" : "warning";
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  nodes.forEach((node, index) => {
+    if (node?.type === "case-management:Trigger") {
+      issues.push({
+        code: "CASE_MGMT_LEGACY_TRIGGER_TYPE",
+        path: `nodes[${index}].type`,
+        message: `Trigger node "${String(node.id ?? index)}" has the legacy type "case-management:Trigger". Write "uipath.case.trigger". Studio Web reads a document with the legacy type as schema v20 and migrates it on every open.`,
+        severity
+      });
     }
-    const data = n.data;
-    if (data.isCaseManagerStage !== true)
-      return false;
-    return (data.tasks ?? []).some((group) => Array.isArray(group) && group.length > 0);
   });
+  const walk = (value, path) => {
+    if (Array.isArray(value)) {
+      for (const [i, one] of value.entries())
+        walk(one, `${path}[${i}]`);
+      return;
+    }
+    if (value === null || typeof value !== "object")
+      return;
+    const record = value;
+    if (typeof record.rule === "string" && typeof record.selectedStageId === "string") {
+      issues.push({
+        code: "CASE_MGMT_LEGACY_STAGE_SELECTOR",
+        path: `${path}.selectedStageId`,
+        message: `Rule "${String(record.id ?? record.rule)}" selects its stage with the legacy key "selectedStageId". Write "selectedStageIds": ["${record.selectedStageId}"]. The schema package rejects the legacy key in a document at the current version.`,
+        severity
+      });
+    }
+    for (const [key, child] of Object.entries(record)) {
+      walk(child, `${path}.${key}`);
+    }
+  };
+  walk(parsed.nodes, "nodes");
+  walk(parsed.edges, "edges");
+  walk(parsed.metadata, "metadata");
+  return issues;
 }
-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"
-]);
 var AUTHORING_MARKER_LIMIT = 50;
 var XREF_MARKER = "$xref(";
 var PLANNING_NOTATION_PREFIXES = ["<-", "->"];
@@ -869,6 +820,77 @@ var findConnectorInputDefects = (nodes) => {
   }
   return found;
 };
+var findDeadMetadataReferences = (parsed) => {
+  const found = [];
+  for (const { entry, path } of taskSlotEntries(asArrayValue(parsed.nodes).map(asRecordValue).filter((n) => n !== undefined), ["outputs"])) {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return found;
+    if (entry === undefined)
+      continue;
+    for (const field of ["value", "source"]) {
+      const value = entry[field];
+      if (typeof value === "string" && value.startsWith("=metadata.")) {
+        found.push({ path: `${path}.${field}`, value });
+      }
+    }
+  }
+  return found;
+};
+var VARS_PREFIX = "=vars.";
+var findDanglingTriggerBridges = (parsed) => {
+  const found = [];
+  const variables = asRecordValue(parsed.variables);
+  const slotElements = new Map;
+  for (const slot of asArrayValue(variables?.inputs).map(asRecordValue)) {
+    const id = slot?.id;
+    if (typeof id !== "string" || id === "")
+      continue;
+    const element = slot?.elementId;
+    slotElements.set(id, typeof element === "string" && element !== "" ? element : undefined);
+  }
+  for (const node of asArrayValue(parsed.nodes).map(asRecordValue).filter((one) => one !== undefined)) {
+    const nodeType = String(node.type ?? "");
+    if (nodeType !== "case-management:Trigger" && nodeType !== "uipath.case.trigger") {
+      continue;
+    }
+    const nodeId = String(node.id ?? "");
+    const data = asRecordValue(node.data);
+    for (const container of ["inputs", "uipath"]) {
+      const outputs = asArrayValue(asRecordValue(data?.[container])?.outputs);
+      for (const [index, entry] of outputs.entries()) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return found;
+        const bridge = asRecordValue(entry);
+        const source = bridge?.source;
+        if (typeof source !== "string" || source === "")
+          continue;
+        const variable = bridge?.var;
+        if (typeof variable !== "string" || variable === "")
+          continue;
+        if (!source.startsWith(VARS_PREFIX)) {
+          found.push({
+            path: `nodes[${nodeId}].data.${container}.outputs[${index}].source`,
+            source,
+            variable
+          });
+          continue;
+        }
+        const named = source.slice(VARS_PREFIX.length);
+        if (slotElements.has(named)) {
+          const element = slotElements.get(named);
+          if (element === undefined || element === nodeId)
+            continue;
+        }
+        found.push({
+          path: `nodes[${nodeId}].data.${container}.outputs[${index}].source`,
+          source,
+          variable
+        });
+      }
+    }
+  }
+  return found;
+};
 var findReassignedOutputsWithoutOriginalVar = (parsed) => {
   const found = [];
   for (const { entry, name, path } of taskSlotEntries(asArrayValue(parsed.nodes).map(asRecordValue).filter((n) => n !== undefined), ["outputs"])) {
@@ -1244,7 +1266,7 @@ var findSchemaTypeMismatches = (parsed, migrationError) => {
   }
   return found;
 };
-var findConnectorTasksWithoutInputs = (nodes) => {
+var findConnectorTasksWithoutInputs = (nodes, bindings) => {
   const found = [];
   for (const node of nodes) {
     const data = asRecordValue(node.data);
@@ -1264,7 +1286,7 @@ var findConnectorTasksWithoutInputs = (nodes) => {
         const context = taskData2.context;
         if (contextEntries(context).length === 0)
           continue;
-        if (missingContextKeys(context, type === "wait-for-connector").length > 0)
+        if (missingContextKeys(context, type === "wait-for-connector", bindings).length > 0)
           continue;
         const inputs = taskData2.inputs;
         if (inputs !== undefined && !Array.isArray(inputs))
@@ -1326,6 +1348,43 @@ var findUnknownSlaKeys = (parsed, nodes) => {
   }
   return found;
 };
+var GUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var findGroupRecipientLiterals = (schema) => {
+  const found = [];
+  const visit = (rules, where) => {
+    for (const [index, entry] of asArrayValue(rules).entries()) {
+      const rule = asRecordValue(entry);
+      for (const [at, raw] of asArrayValue(rule?.escalationRule).entries()) {
+        const escalation = asRecordValue(raw);
+        const action = asRecordValue(escalation?.action);
+        for (const [slot, person] of asArrayValue(action?.recipients).entries()) {
+          const recipient = asRecordValue(person);
+          if (recipient?.scope !== "UserGroup")
+            continue;
+          const target = recipient.target;
+          if (typeof target !== "string" || target.trim() === "") {
+            continue;
+          }
+          if (GUID_SHAPE.test(target.trim()) || target.includes("<UNRESOLVED")) {
+            continue;
+          }
+          found.push({
+            path: `${where}[${index}].escalationRule[${at}].action.recipients[${slot}].target`,
+            value: target
+          });
+        }
+      }
+    }
+  };
+  visit(schema.metadata?.slaRules, "metadata.slaRules");
+  for (const node of asArrayValue(schema.nodes)) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    visit(data.slaRules, `nodes[${labelOf(node, "?")}].data.slaRules`);
+  }
+  return found;
+};
 var findLiteralResourceBindings = (nodes) => {
   const found = [];
   for (const node of nodes) {
@@ -1459,6 +1518,45 @@ var findUnresolvedConnectorResourceKeys = (parsed) => {
   }, () => found.length >= AUTHORING_MARKER_LIMIT);
   return found;
 };
+var findDuplicateOutputNames = (parsed) => {
+  const found = [];
+  for (const node of asArrayValue(parsed.nodes)) {
+    const record = asRecordValue(node);
+    const data = asRecordValue(record?.data);
+    if (record === undefined || data === undefined)
+      continue;
+    const stage = labelOf(record, "?");
+    for (const lane of asArrayValue(data.tasks)) {
+      for (const task of asArrayValue(lane)) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return found;
+        const taskRecord = asRecordValue(task);
+        const taskData2 = asRecordValue(taskRecord?.data);
+        if (taskRecord === undefined || taskData2 === undefined) {
+          continue;
+        }
+        const label = labelOf(taskRecord, "?");
+        const seen = new Map;
+        for (const output of asArrayValue(taskData2.outputs)) {
+          const name = asRecordValue(output)?.name;
+          if (typeof name !== "string" || name === "")
+            continue;
+          seen.set(name, (seen.get(name) ?? 0) + 1);
+        }
+        for (const [name, count] of seen) {
+          if (count < 2)
+            continue;
+          found.push({
+            path: `nodes[${stage}].data.tasks[${label}].data.outputs[${name}]`,
+            name,
+            task: `${stage}/${label}`
+          });
+        }
+      }
+    }
+  }
+  return found;
+};
 var findDuplicateOutputIds = (parsed) => {
   const found = [];
   const owners = new Map;
@@ -1722,92 +1820,6 @@ class CaseValidateService {
       ...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 taskContent = checksTaskContent(profile);
@@ -1940,6 +1952,30 @@ Validating: ${absolutePath}
         message: `resourceKey "${key}" has ${present} but no \`${missing}\` ` + 'entry. A resource is addressed by folderPath + "." + ' + "name, so one key is one resource and it needs both " + "entries sharing that key: 'uip solution resources " + "refresh' resolves the pair, and bindings_v2.json is " + "derived from it, so half a pair ships a solution that " + "resolves this resource to nothing. Give both entries the " + "same resourceKey and set each one's propertyAttribute to " + "the half it carries."
       });
     }
+    for (const { path, value } of slaContent ? findGroupRecipientLiterals(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_ESCALATION_RECIPIENT_LITERAL",
+        path,
+        severity: "error",
+        message: `Escalation recipient targets the group "${value}" by ` + "name. A `UserGroup` recipient is addressed by the " + "tenant's id for that group, so a name here notifies " + "nobody — and it looks resolved, which is why nothing " + "else reports it. Put the group's id in `target` and keep " + "its name in `value`, or leave an `<UNRESOLVED: …>` " + "marker in `target` until the id is known."
+      });
+    }
+    for (const { path, source, variable } of findDanglingTriggerBridges(parsed)) {
+      issues.push({
+        code: "CASE_MGMT_TRIGGER_BRIDGE_SOURCE_DANGLING",
+        path,
+        severity: "error",
+        message: `The trigger bridge for "${variable}" reads ` + `\`${source}\`, which names no entry in ` + "`variables.inputs[]`. The bridge is the only thing that " + "copies a caller's value from the formal argument slot to " + "its companion at trigger fire, so a source that names no " + `slot copies nothing and \`=vars.${variable}\` is ` + "undefined at run time while the plan still validates. " + "Point `source` at the formal slot's own `id`."
+      });
+    }
+    for (const { path, value } of taskContent ? findDeadMetadataReferences(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_METADATA_REFERENCE_NOT_EXPRESSION",
+        path,
+        severity: "error",
+        message: `"${value}" resolves through nothing. \`metadata\` is a ` + "namespace the runtime puts in scope inside a `=js:` " + "expression, not a path prefix that routes one — there " + "is no `=metadata.` prefix, so unlike `=vars.` or " + "`=bindings.` this reads no value and the plan still " + `validates. Write it as \`=js:${value.slice(1)}\`.`
+      });
+    }
     for (const { path, name: name2, fields } of taskContent ? findLiteralResourceBindings(nodes) : []) {
       issues.push({
         code: "CASE_MGMT_RESOURCE_TASK_LITERAL_BINDING",
@@ -1972,7 +2008,7 @@ Validating: ${absolutePath}
         message: `This context's \`resourceKey\` is "${value}", which is ` + `not the key of the connection \`${binding}\` that its ` + "own `connection` entry names. The runtime resolves the " + "connection through this key, so the connector never " + `fires. ${elsewhere === undefined ? "The usual cause is the objectName copied into it. Set it to that binding's resolved connection key." : `That key belongs to \`${elsewhere}\`, so the wrong field may be the \`connection\` entry: decide which connection this context is for, then make both name it. Setting the key from \`${binding}\` without checking repairs this into a plan that is consistently wrong.`}`
       });
     }
-    for (const { path, name: name2 } of taskContent ? findConnectorTasksWithoutInputs(nodes) : []) {
+    for (const { path, name: name2 } of taskContent ? findConnectorTasksWithoutInputs(nodes, parsed.bindings) : []) {
       issues.push({
         code: "CASE_MGMT_CONNECTOR_INPUTS_EMPTY",
         path,
@@ -1980,6 +2016,14 @@ Validating: ${absolutePath}
         message: `Connector task "${name2}" has a spliced \`data.context\` ` + "but no inputs. The context comes from the case spec " + "response, so the spec was fetched and read; " + "`data.inputs` is the `CaseShape.Inputs` splice from that " + "same response, and an empty array means that splice was " + "skipped. Nothing else reports it — the shape is " + "internally consistent and every container check has " + "nothing to look at — while the activity runs with no " + "parameters at all. Splice `CaseShape.Inputs` from the " + "case spec response."
       });
     }
+    for (const { path, name: name2, task } of taskContent ? findDuplicateOutputNames(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_OUTPUT_NAME_DUPLICATE",
+        path,
+        severity: "error",
+        message: `Task "${task}" has two outputs named "${name2}". The ` + "parser keeps one row per name, so the other is dropped " + "and whatever it wrote is never written. A duplicate " + "`id` is reported separately and cannot see this one: " + "the dropped row often carries no id at all. Emit one " + "output for the value, carrying the id other tasks " + "reference it by."
+      });
+    }
     for (const { path, id, first, second } of taskContent ? findDuplicateOutputIds(parsed) : []) {
       issues.push({
         code: "CASE_MGMT_OUTPUT_ID_DUPLICATE",
@@ -2141,6 +2185,9 @@ Validating: ${absolutePath}
       };
     }
     const issues = [];
+    const versionIssues = await this.checkDeclaredVersion(parsed);
+    issues.push(...versionIssues);
+    issues.push(...findLegacySpellings(parsed, profile));
     const { validateCaseCanvasJson, validateCaseDiskJsonSchema } = await loadCaseSchemaAsync();
     const [diskCallError, diskResultRaw] = catchError(() => validateCaseDiskJsonSchema(parsed));
     if (diskCallError) {
@@ -2157,22 +2204,42 @@ Validating: ${absolutePath}
       };
     }
     const diskResult = diskResultRaw;
+    const version = parsed?.version;
+    const versionMissing = (version === undefined || typeof version === "string" && version.trim() === "") && (diskResult.issues ?? []).some((i) => i.path === "version");
     for (const issue2 of diskResult.issues ?? []) {
+      const path = issue2.path && issue2.path !== "" ? issue2.path : "(root)";
+      if (versionIssues.length > 0 && path === "version")
+        continue;
+      if (versionMissing && path.includes("."))
+        continue;
       issues.push({
         code: "CASE_MGMT_DISK_SCHEMA_INVALID",
-        path: issue2.path && issue2.path !== "" ? issue2.path : "(root)",
-        message: issue2.message,
+        path,
+        message: versionMissing && path === "version" ? `${issue2.message}. The version is missing, so nested fields were not checked — set "version" to the version the case plan was written at.` : issue2.message,
         severity: "error"
       });
     }
     if (diskResult.migrationError) {
+      const {
+        describeMisplacedRuleGroupMember,
+        findMisplacedRuleGroupMembers
+      } = await import("./rule-group-members-zje7n3kf.js");
+      const misplaced = findMisplacedRuleGroupMembers(parsed);
       const ruleTypePaths = findRuleTypeKeys(parsed);
-      if (ruleTypePaths.length > 0) {
+      if (misplaced.length > 0 || ruleTypePaths.length > 0) {
+        for (const member of misplaced) {
+          issues.push({
+            code: "CASE_MGMT_RULE_GROUP_MEMBER_NOT_A_RULE",
+            path: member.path,
+            message: describeMisplacedRuleGroupMember(member),
+            severity: "error"
+          });
+        }
         for (const rulePath of ruleTypePaths) {
           issues.push({
             code: "INVALID_RULE_DISCRIMINATOR",
             path: rulePath,
-            message: 'This rule is keyed "ruleType"; the discriminator ' + 'is "rule". Rename the key, keep its value. While ' + 'any rule uses "ruleType" no rule matches, and ' + "the schema reports a version migration failure " + "instead of this.",
+            message: 'This rule is keyed "ruleType"; the discriminator is "rule". Rename the key, keep its value. While any rule uses "ruleType" no rule matches, and the schema reports a version migration failure instead of this.',
             severity: "error"
           });
         }
@@ -2188,10 +2255,13 @@ Validating: ${absolutePath}
             });
           }
         } else {
+          const { diagnoseMigrationFailure } = await import("./migration-diagnosis-ag2sgd1e.js");
+          const diagnosis = diagnoseMigrationFailure(parsed, diskResult.migrationError, validateCaseDiskJsonSchema);
+          const explanation = diagnosis === undefined ? "" : diagnosis.typeIsTheBlocker ? ` This document is valid with ${diagnosis.offending.map((type) => `\`${type}\``).join(", ")} written as the legacy \`case-management:*\` name, so the node type is what this schema version rejects — the migration step that rejected it accepts only those four names, and it ran because the document matched an older version.` : diagnosis.remainingError === undefined ? ` The node type is not the only blocker: ${diagnosis.offending.map((type) => `\`${type}\``).join(", ")} could not be mapped to a legacy name to test.` : ` The node type is a symptom, not the cause: with ${diagnosis.offending.map((type) => `\`${type}\``).join(", ")} written as its legacy name the document still fails, on ${diagnosis.remainingError}. Fix that first.`;
           issues.push({
             code: "CASE_MGMT_MIGRATION_FAILED",
             path: "(root)",
-            message: diskResult.migrationError,
+            message: `${diskResult.migrationError}${explanation}`,
             severity: "error"
           });
         }
@@ -2228,15 +2298,16 @@ Validating: ${absolutePath}
       issues.push(...this.runSupplementalRules(parsed, profile));
     }
     if (diskResult.valid && profile === "strict") {
-      const { runStrictCaseRules } = await import("./strict-case-rules-x6t0vb40.js");
+      const { runStrictCaseRules } = await import("./strict-case-rules-ksy8q7pg.js");
       issues.push(...runStrictCaseRules(parsed));
       issues.push(...await this.checkBindingsSidecar(absolutePath, parsed));
+      issues.push(...await this.checkEntryPointsSidecar(absolutePath, 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-8e2fh9jg.js");
-          issues.push(...auditCaseplanAgainstSdd(parsed, sddText, this.fs.path.basename(sddPath)));
+          const { auditCaseplanAgainstSdd } = await import("./strict-sdd-audit-k6hh0mbr.js");
+          issues.push(...auditCaseplanAgainstSdd(parsed, sddText, this.fs.path.basename(sddPath), await findRegistryLedger(this.fs, absolutePath)));
         } else {
           issues.push({
             code: "STRICT_SDD_FILE_NOT_FOUND",
@@ -2253,9 +2324,39 @@ Validating: ${absolutePath}
       issues
     };
   }
-  async checkBindingsSidecar(casePlanPath, parsed) {
-    const { compareCaseBindingsV2 } = await import("./case-bindings-service-1wxfghzd.js");
-    const [error, comparison] = await catchError(compareCaseBindingsV2(casePlanPath, parsed));
+  async checkEntryPointsSidecar(casePlanPath, parsed) {
+    const dir = this.fs.path.dirname(casePlanPath);
+    const candidates = [
+      this.fs.path.join(dir, "entry-points.json"),
+      this.fs.path.join(dir, "..", "entry-points.json")
+    ];
+    for (const candidate of candidates) {
+      if (!await this.fs.exists(candidate))
+        continue;
+      const [readError, text] = await catchError(this.fs.readFile(candidate, "utf-8"));
+      const unreadable = (why) => [
+        {
+          code: "STRICT_ENTRY_POINT_SIDECAR_UNREADABLE",
+          path: this.fs.path.basename(candidate),
+          severity: "error",
+          message: `\`${this.fs.path.basename(candidate)}\` is next to this case plan and ${why}, so none of the entry-point checks could run. The runtime launches whichever BPMN this file's first entry resolves to, and \`case pack\` fails on a file it cannot read, so the package would not ship. Fix the file, or delete it if the project does not need one.`
+        }
+      ];
+      if (readError || text === undefined || text === null) {
+        return unreadable(readError === undefined ? "could not be found (it may have been removed while validating)" : `could not be read (${readError.message})`);
+      }
+      const [parseError, document] = await catchError(Promise.resolve().then(() => JSON.parse(text)));
+      if (parseError) {
+        return unreadable(`is not JSON (${parseError.message})`);
+      }
+      const { checkEntryPoints } = await import("./strict-entry-points-v14d7y50.js");
+      return checkEntryPoints(document, parsed, this.fs.path.basename(candidate), this.fs.path.basename(casePlanPath));
+    }
+    return [];
+  }
+  async checkBindingsSidecar(casePlanPath, parsed) {
+    const { compareCaseBindingsV2 } = await import("./case-bindings-service-c2mze9vj.js");
+    const [error, comparison] = await catchError(compareCaseBindingsV2(casePlanPath, parsed));
     if (error || comparison === undefined)
       return [];
     const remedy = `Run 'uip maestro case bindings sync ${this.fs.path.basename(casePlanPath)}' to regenerate it.`;
@@ -2274,6 +2375,8 @@ Validating: ${absolutePath}
         return comparison.expectedCount === 0 ? [] : issue2(`No bindings_v2.json next to the case plan, but its bindings produce ${comparison.expectedCount} resource entr${comparison.expectedCount === 1 ? "y" : "ies"}. 'uip solution resources refresh' reads that file, so the solution will resolve none of them. ${remedy}`);
       case "unreadable":
         return issue2(`bindings_v2.json could not be read as a bindings file. ${remedy}`);
+      case "entry-points-unreadable":
+        return issue2(`${comparison.reason ?? `${comparison.path} could not be read`}. The trigger bindings in bindings_v2.json take their entry point ids from that file, so they cannot be checked. Fix or remove ${comparison.path}, then run \`uip maestro case bindings sync\`.`);
       case "differs": {
         const {
           missing = [],
@@ -2289,1185 +2392,48 @@ Validating: ${absolutePath}
       }
     }
   }
-  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?.length ?? 0) > 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 duration: `count` is missing or zero. Escalations are measured against the duration, so none of them can fire. Check for the value sitting in an invented key such as `duration`.",
-          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"
-        });
-      }
+  async checkDeclaredVersion(parsed) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return [];
     }
-    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 declared = parsed.version;
+    if (declared === undefined || typeof declared === "string" && declared.trim() === "") {
+      return [];
     }
-    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(", ")}`,
+    const latest = await resolveCaseSchemaVersion();
+    const parts = parseCaseSchemaVersion(declared);
+    if (parts === null) {
+      return [
+        {
+          code: "CASE_MGMT_INVALID_VERSION",
+          path: "version",
+          message: `Schema version ${JSON.stringify(declared)} is not a version — expected "<major>.<minor>.<patch>", and the current schema is "${latest}".`,
           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(", ")}`,
+    if (parts.major < MIN_SUPPORTED_MAJOR) {
+      return [
+        {
+          code: "CASE_MGMT_INVALID_VERSION",
+          path: "version",
+          message: `Schema version "${String(declared)}" predates V${MIN_SUPPORTED_MAJOR} — this validator requires major version >= ${MIN_SUPPORTED_MAJOR}, and the current schema is "${latest}".`,
           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(", ")}`,
+    const latestParts = parseCaseSchemaVersion(latest);
+    if (latestParts !== null && compareCaseSchemaVersions(parts, latestParts) > 0) {
+      return [
+        {
+          code: "CASE_MGMT_VERSION_NEWER_THAN_SCHEMA",
+          path: "version",
+          message: `Schema version "${String(declared)}" is newer than "${latest}", the newest this CLI's @uipath/case-schema knows, so this CLI cannot validate it. Update the CLI; if it is already current, the @uipath/case-schema pin needs to move.`,
           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?.length ?? 0) > 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;
+    return [];
   }
   runTaskValidators(schema, profile = "full") {
     const issues = [];
@@ -3493,4 +2459,4 @@ export {
   CaseValidateService
 };
 
-//# debugId=CF6CF2FB8A5C033D64756E2164756E21
+//# debugId=38BA7511D4E039A064756E2164756E21