@uipath/case-tool 1.202.0 → 1.203.0-preview.160

package/dist/{case-validate-service-xvxkr026.js → case-validate-service-e06varbt.js}

@@ -1,11 +1,17 @@
 import {
+  ACTIVITY_TYPE_ID_PATH,
+  BINDING_REFERENCE_PREFIX,
+  NAME_BOUND_TASK_TYPES,
+  RESOLVED_IDENTITY_KEYS,
+  activityTypeIdMessage,
+  contextEntries,
   contextEntry,
   missingContextKeys,
   readActivityTypeId
-} from "./packager-tool-ty1t2byf.js";
+} from "./packager-tool-d4sjk46c.js";
 import {
   validateIntSvcNode
-} from "./packager-tool-sk2b33km.js";
+} from "./packager-tool-b6368khs.js";
 import {
   loadCaseSchemaAsync
 } from "./packager-tool-p7jgrm5r.js";
@@ -17,17 +23,17 @@ import {
   VALID_STAGE_EXIT_RULE_TYPES,
   VALID_TASK_ENTRY_RULE_TYPES
 } from "./packager-tool-sv0d6wb6.js";
-import"./packager-tool-dqs5qy9s.js";
+import"./packager-tool-yrsrzz1a.js";
+import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
 import {
   catchError,
   logger
-} from "./packager-tool-4knkebkr.js";
+} from "./packager-tool-kpcjnxd1.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";
@@ -86,8 +92,13 @@ var connectorTaskValidator = {
     return issues;
   }
 };
+function namedEntry(entries, name) {
+  if (!Array.isArray(entries))
+    return;
+  return entries.find((entry) => entry.name === name);
+}
 function readContextValue(context, name) {
-  const entry = context.find((c) => c.name === name);
+  const entry = namedEntry(context, name);
   if (typeof entry?.value !== "string")
     return;
   return entry.value;
@@ -99,18 +110,20 @@ function resolveBindingRef(rawValue, bindings) {
   const match = BINDING_REF_PATTERN.exec(rawValue);
   if (!match)
     return rawValue;
+  if (!Array.isArray(bindings))
+    return;
   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 meta = namedEntry(context, "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 entry = namedEntry(inputs, name);
   const body = entry?.body;
   if (body && typeof body === "object" && !Array.isArray(body)) {
     return body;
@@ -267,6 +280,7 @@ 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"
@@ -277,6 +291,19 @@ var SERVICE_TYPE_BY_TASK = {
 };
 var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 var asArray = (value) => Array.isArray(value) ? value : [];
+var VARS_READS = [
+  /\bvars\.([A-Za-z_$][A-Za-z0-9_$]*)/g,
+  /\bvars\s*\[\s*["']([A-Za-z_$][A-Za-z0-9_$]*)["']\s*\]/g
+];
+var readsIdentifier = (expression, name) => {
+  for (const pattern of VARS_READS) {
+    for (const match of expression.matchAll(pattern)) {
+      if (match[1] === name)
+        return true;
+    }
+  }
+  return false;
+};
 var taskData = (task) => asRecord(task.data);
 var taskLabel = (task) => task.displayName ?? task.id ?? "task";
 var taskPath = (stageId, task) => `nodes[${stageId}].data.tasks[${task.id ?? "?"}]`;
@@ -286,7 +313,7 @@ var strictConnectorContextValidator = {
   validate: (task, ctx) => {
     const issues = [];
     const context = taskData(task)?.context;
-    const missing = missingContextKeys(context);
+    const missing = missingContextKeys(context, TRIGGER_TASK_TYPES.has(task.type ?? ""));
     if (missing.length > 0) {
       issues.push({
         code: "STRICT_CONNECTOR_CONTEXT_INCOMPLETE",
@@ -299,9 +326,9 @@ var strictConnectorContextValidator = {
       if (readActivityTypeId(context) === undefined) {
         issues.push({
           code: "STRICT_CONNECTOR_ACTIVITY_TYPE_ID",
-          path: `${taskPath(ctx.stageId, task)}.data.context[metadata].body.activityPropertyConfiguration.UiPathActivityTypeId`,
+          path: `${taskPath(ctx.stageId, task)}.data.context[metadata].${ACTIVITY_TYPE_ID_PATH}`,
           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."
+          message: activityTypeIdMessage(`task "${taskLabel(task)}"`, context, "The connection id alone does not tell the runtime " + "which activity to run, so the task deploys and " + "never binds.")
         });
       }
     }
@@ -324,15 +351,71 @@ var strictConnectorContextValidator = {
         message: `Connector task "${taskLabel(task)}" declares no ` + `serviceType; a "${task.type}" task must declare ` + `"${expectedServiceType}".`
       });
     }
+    const bodyInput = TRIGGER_TASK_TYPES.has(task.type ?? "") ? undefined : asArray(taskData(task)?.inputs).map((entry) => asRecord(entry)).find((entry) => entry?.name === "body");
+    if (bodyInput !== undefined && !bodyInput.target) {
+      issues.push({
+        code: "STRICT_CONNECTOR_BODY_TARGET",
+        path: `${taskPath(ctx.stageId, task)}.data.inputs[body].target`,
+        severity: "warning",
+        message: `Connector task "${taskLabel(task)}" has a "body" input ` + 'with no "target". The parser keeps an activity input ' + "only when its name, type, value and target are all " + "present, so this one is dropped and the request goes " + "out with no body at all. On a multipart activity that " + "leaves no parts to parse and Integration Services " + 'answers 400 "Unable to parse multipart body". Transcribe ' + "the input from `case spec`, which always names the target."
+      });
+    }
     return issues;
   }
 };
+var selfReadExpression = (output) => {
+  const target = output.var;
+  if (typeof target !== "string" || target === "")
+    return;
+  for (const candidate of [output.value, output.source]) {
+    if (typeof candidate !== "string")
+      continue;
+    if (!candidate.startsWith("="))
+      continue;
+    if (readsIdentifier(candidate, target))
+      return candidate;
+  }
+  return;
+};
+var forwardRead = (output, index, writtenAt) => {
+  for (const candidate of [output.value, output.source]) {
+    if (typeof candidate !== "string")
+      continue;
+    if (!candidate.startsWith("="))
+      continue;
+    for (const [name, at] of writtenAt) {
+      if (at > index && readsIdentifier(candidate, name))
+        return { name, expression: candidate };
+    }
+  }
+  return;
+};
+var customShapeProblems = (output) => {
+  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');
+  return problems;
+};
 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`;
+    const writtenAt = new Map;
+    asArray(taskData(task)?.outputs).forEach((entry, index) => {
+      const name = asRecord(entry)?.var;
+      if (typeof name === "string" && name !== "" && !writtenAt.has(name))
+        writtenAt.set(name, index);
+    });
     asArray(taskData(task)?.outputs).forEach((entry, index) => {
       const output = asRecord(entry);
       if (!output)
@@ -345,22 +428,24 @@ var strictOutputShapeValidator = {
         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.");
-        }
+      const type = output.type;
+      const variable = typeof output.var === "string" ? output.var : label;
+      if (typeof type !== "string" || type === "") {
+        report("STRICT_OUTPUT_TYPE_MISSING", `Output "${label}" carries no "type". The parser keeps ` + "an output only when name, type, source and var are " + `all present, so this one is dropped and "${variable}" ` + "is never written. Emit the type of the case variable " + "it writes.");
+      }
+      const selfRead = selfReadExpression(output);
+      if (selfRead !== undefined) {
+        report("STRICT_OUTPUT_SELF_REFERENCE", `Output "${label}" writes "${variable}" from an ` + `expression that reads it: ${selfRead}. Nothing on ` + "the task produces that name, so the expression sees " + "the variable's default. Point it at the output that " + "carries the value instead.");
+      }
+      const forward = forwardRead(output, index, writtenAt);
+      if (forward !== undefined) {
+        report("STRICT_OUTPUT_FORWARD_READ", `Output "${label}" reads "${forward.name}" in ` + `${forward.expression}, and an output later in this ` + "task writes that name. The engine evaluates outputs " + "in array order and writes each one before the next " + "is evaluated, so this reads the variable's default. " + `Move "${label}" after the output that writes ` + `"${forward.name}".`);
+      }
+      if (output.custom !== true)
         return;
+      const problems = customShapeProblems(output);
+      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 issues;
@@ -406,10 +491,49 @@ var strictInputReferenceValidator = {
     return issues;
   }
 };
+var BINDING_PREFIX = "=bindings.";
+var literalCatalogName = (task) => {
+  const value = taskData(task)?.actionCatalogName;
+  return typeof value === "string" && value !== "" && !value.startsWith(BINDING_PREFIX) ? value : undefined;
+};
+var strictActionCatalogValidator = {
+  id: "strict-action-catalog",
+  appliesTo: (task) => task.type === "action" && literalCatalogName(task) !== undefined,
+  validate: (task, ctx) => {
+    const name = literalCatalogName(task) ?? "";
+    return [
+      {
+        code: "STRICT_ACTION_CATALOG_NAMED",
+        path: `${taskPath(ctx.stageId, task)}.data.actionCatalogName`,
+        severity: "warning",
+        message: `Task "${taskLabel(task)}" names the action catalog ` + `"${name}". The name is resolved in the app's deployment ` + "folder, the one data.folderPath binds, and a name that " + "folder does not hold fails the task the moment it opens, " + `with "No task catalog exists with name ${name}". Confirm ` + "it with 'uip tasks catalogs list --folder-path " + "<app deployment folder> --output json', or omit the key " + "and the task is created with no catalog."
+      }
+    ];
+  }
+};
+var strictTaskElementIdValidator = {
+  id: "strict-task-element-id",
+  appliesTo: (task) => typeof task.elementId === "string" && task.elementId !== "" && typeof task.id === "string" && task.id !== "",
+  validate: (task, ctx) => {
+    const expected = `${ctx.stageId}-${task.id}`;
+    if (task.elementId === expected)
+      return [];
+    return [
+      {
+        code: "STRICT_TASK_ELEMENT_ID_STAGE_MISMATCH",
+        path: `${taskPath(ctx.stageId, task)}.elementId`,
+        severity: "error",
+        message: `Task "${taskLabel(task)}" carries elementId ` + `"${task.elementId}" while it sits in stage ` + `"${ctx.stageId}". A task's elementId is ` + "<stageId>-<taskId> for the stage that holds it, and " + "every writer derives it that way, so the stored prefix " + "is never read back and the task runs in the stage whose " + "data.tasks holds it. Set elementId to " + `"${expected}" if the placement is right, or move the ` + "task into the stage its elementId names if the prefix " + "is right."
+      }
+    ];
+  }
+};
 var strictTaskValidators = [
   strictConnectorContextValidator,
   strictOutputShapeValidator,
-  strictInputReferenceValidator
+  strictInputReferenceValidator,
+  strictActionCatalogValidator,
+  strictTaskElementIdValidator
 ];
 
 // src/services/case-validators/index.ts
@@ -600,6 +724,993 @@ var VALID_TRIGGER_SERVICE_TYPES = new Set([
   "Intsvc.EventTrigger",
   "Intsvc.TimerTrigger"
 ]);
+var AUTHORING_MARKER_LIMIT = 50;
+var XREF_MARKER = "$xref(";
+var PLANNING_NOTATION_PREFIXES = ["<-", "->"];
+var findXrefMarkers = (document) => {
+  const found = [];
+  const visit = (value, path) => {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return;
+    if (typeof value === "string") {
+      if (value.includes(XREF_MARKER))
+        found.push(path);
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        visit(entry, `${path}[${index}]`);
+      });
+      return;
+    }
+    if (value === null || typeof value !== "object")
+      return;
+    for (const [key, entry] of Object.entries(value)) {
+      visit(entry, path === "" ? key : `${path}.${key}`);
+    }
+  };
+  visit(document, "");
+  return found;
+};
+var TASK_SLOTS = ["inputs", "outputs"];
+var parsesAsJsonValue = (text) => catchError(() => JSON.parse(text))[0] === undefined;
+function* taskSlotEntries(nodes, slots = TASK_SLOTS) {
+  for (const node of nodes) {
+    const nodeId = typeof node.id === "string" ? node.id : "?";
+    const data = asRecordValue(node.data);
+    for (const lane of asArrayValue(data?.tasks)) {
+      for (const task of asArrayValue(lane)) {
+        const taskRecord = asRecordValue(task);
+        if (taskRecord === undefined)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        const taskData2 = asRecordValue(taskRecord.data);
+        for (const slot of slots) {
+          for (const [index, value] of asArrayValue(taskData2?.[slot]).entries()) {
+            const entry = asRecordValue(value);
+            const name = typeof entry?.name === "string" ? entry.name : `#${index}`;
+            yield {
+              task: taskRecord,
+              slot,
+              entry,
+              name,
+              path: `nodes[${nodeId}].data.tasks[${taskId}].data.${slot}[${name}]`
+            };
+          }
+        }
+      }
+    }
+  }
+}
+var findPlanningNotation = (nodes) => {
+  const found = [];
+  for (const { slot, entry, path } of taskSlotEntries(nodes)) {
+    const value = entry?.value;
+    if (typeof value !== "string")
+      continue;
+    const trimmed = value.trimStart();
+    if (!PLANNING_NOTATION_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+      continue;
+    }
+    found.push({ path, slot });
+  }
+  return found;
+};
+var findUnparseableJsonValues = (nodes) => {
+  const found = [];
+  for (const { entry, name, path } of taskSlotEntries(nodes)) {
+    const value = entry?.value;
+    if (typeof value !== "string")
+      continue;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+      continue;
+    if (parsesAsJsonValue(trimmed))
+      continue;
+    found.push({ path, name });
+  }
+  return found;
+};
+var CONNECTOR_TASK_TYPES3 = new Set([
+  "execute-connector-activity",
+  "wait-for-connector"
+]);
+var CONNECTOR_INPUT_ENVELOPE = new Set([
+  "pathParameters",
+  "queryParameters",
+  "body"
+]);
+var isFileChannel = (input) => input?.type === "file" || input?.target === "file";
+var envelopeDefect = (input, name) => {
+  const target = input.target;
+  if (typeof target === "string" && target.trim() !== "" && target.trim().toLowerCase() !== name.toLowerCase()) {
+    return "mistargeted";
+  }
+  const value = input.value;
+  if (typeof value !== "string") {
+    const parked = asRecordValue(value);
+    const body = asRecordValue(input.body);
+    const emptyBody = body === undefined || Object.keys(body).length === 0;
+    return parked !== undefined && Object.keys(parked).length > 0 && emptyBody ? "misplaced" : undefined;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "" || trimmed.startsWith("="))
+    return;
+  return "stringified";
+};
+var findConnectorInputDefects = (nodes) => {
+  const found = [];
+  for (const { task, entry: input, name, path } of taskSlotEntries(nodes, [
+    "inputs"
+  ])) {
+    const type = task.type;
+    if (typeof type !== "string" || !CONNECTOR_TASK_TYPES3.has(type)) {
+      continue;
+    }
+    if (typeof input?.name !== "string" || input.name === "")
+      continue;
+    if (isFileChannel(input))
+      continue;
+    if (!CONNECTOR_INPUT_ENVELOPE.has(name)) {
+      found.push({ path, name, kind: "flattened" });
+      continue;
+    }
+    const kind = envelopeDefect(input, name);
+    if (kind !== undefined) {
+      found.push({
+        path,
+        name,
+        kind,
+        ...kind === "mistargeted" && {
+          target: String(input.target)
+        }
+      });
+    }
+  }
+  return found;
+};
+var findReassignedOutputsWithoutOriginalVar = (parsed) => {
+  const found = [];
+  for (const { entry, name, 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;
+    const id = entry.id;
+    const variable = entry.var;
+    if (typeof id !== "string" || id === "" || typeof variable !== "string" || variable === "" || id === variable || id.toLowerCase() === variable.toLowerCase() || entry.custom === true || entry.renamed === true || entry.originalVar) {
+      continue;
+    }
+    if (entry.source === undefined && entry.target === undefined)
+      continue;
+    found.push({ path, name });
+  }
+  return found;
+};
+var findVarIdCaseMismatches = (parsed) => {
+  const found = [];
+  for (const { entry, name, path } of taskSlotEntries(asArrayValue(parsed.nodes).map(asRecordValue).filter((n) => n !== undefined), ["outputs"])) {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return found;
+    const id = entry?.id;
+    const variable = entry?.var;
+    if (typeof id !== "string" || id === "" || typeof variable !== "string" || variable === "" || id === variable || id.toLowerCase() !== variable.toLowerCase()) {
+      continue;
+    }
+    found.push({ path, name });
+  }
+  return found;
+};
+var findMisplacedEnvelopeBodies = (nodes) => {
+  const found = [];
+  for (const { task, entry: input, path } of taskSlotEntries(nodes, [
+    "inputs"
+  ])) {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return found;
+    const type = task.type;
+    if (typeof type !== "string" || CONNECTOR_TASK_TYPES3.has(type)) {
+      continue;
+    }
+    if (input === undefined)
+      continue;
+    if (typeof input.name !== "string" || input.name === "")
+      continue;
+    const body = asRecordValue(input.body);
+    if (body === undefined || Object.keys(body).length === 0)
+      continue;
+    const value = input.value;
+    found.push({
+      path,
+      name: input.name,
+      hasValue: typeof value === "string" ? value.trim() !== "" : value !== undefined
+    });
+  }
+  return found;
+};
+var findUnreachableSlaRules = (parsed) => {
+  const found = [];
+  const unconditional = (rule) => {
+    const expression = asRecordValue(rule)?.expression;
+    if (expression === undefined || expression === null)
+      return true;
+    if (typeof expression !== "string")
+      return false;
+    const trimmed = expression.trim();
+    return trimmed === "" || trimmed.replaceAll(" ", "") === "=js:true";
+  };
+  const check = (rules, path, holder) => {
+    const list = asArrayValue(rules);
+    for (let index = 0;index < list.length - 1; index += 1) {
+      if (!unconditional(list[index]))
+        continue;
+      found.push({
+        path: `${path}[${index}]`,
+        holder,
+        dead: list.length - index - 1
+      });
+      return;
+    }
+  };
+  check(asRecordValue(parsed.metadata)?.slaRules, "metadata.slaRules", "the case");
+  asArrayValue(parsed.nodes).forEach((node, index) => {
+    const data = asRecordValue(asRecordValue(node)?.data);
+    if (data === undefined)
+      return;
+    const label = data.label;
+    check(data.slaRules, `nodes[${index}].data.slaRules`, typeof label === "string" && label !== "" ? `stage "${label}"` : "this stage");
+  });
+  return found;
+};
+var findDuplicateSlaGates = (parsed) => {
+  const found = [];
+  const scan = (rules, path, scope) => {
+    const byExpression = new Map;
+    for (const entry of asArrayValue(rules)) {
+      const expression = asRecordValue(entry)?.expression;
+      if (typeof expression !== "string" || expression.trim() === "") {
+        continue;
+      }
+      byExpression.set(expression, (byExpression.get(expression) ?? 0) + 1);
+    }
+    for (const [expression, count] of byExpression) {
+      if (count < 2)
+        continue;
+      found.push({ path, scope, expression, count });
+    }
+  };
+  scan(asRecordValue(parsed.metadata)?.slaRules, "metadata.slaRules", "the case");
+  for (const node of asArrayValue(parsed.nodes)) {
+    const data = asRecordValue(asRecordValue(node)?.data);
+    if (data?.slaRules === undefined)
+      continue;
+    const label = typeof data.label === "string" ? data.label : typeof asRecordValue(node)?.id === "string" ? asRecordValue(node)?.id : "?";
+    scan(data.slaRules, `nodes[${label}].data.slaRules`, `stage "${label}"`);
+  }
+  return found;
+};
+var findSharedBindingKeys = (parsed) => {
+  const typesById = new Map;
+  const note = (id, type) => {
+    const seen = typesById.get(id) ?? new Set;
+    seen.add(type);
+    typesById.set(id, seen);
+  };
+  const walk = (value) => {
+    if (Array.isArray(value)) {
+      for (const entry of value)
+        walk(entry);
+      return;
+    }
+    const record = asRecordValue(value);
+    if (record === undefined)
+      return;
+    const type = record.type;
+    const data = asRecordValue(record.data);
+    if (typeof type === "string" && data !== undefined) {
+      for (const field of Object.values(data)) {
+        if (typeof field === "string" && field.startsWith("=bindings.")) {
+          note(field.slice("=bindings.".length), type);
+        }
+      }
+    }
+    for (const entry of Object.values(record))
+      walk(entry);
+  };
+  walk(parsed.nodes);
+  const byKey = new Map;
+  for (const entry of asArrayValue(parsed.bindings)) {
+    const binding = asRecordValue(entry);
+    if (binding?.propertyAttribute !== "name")
+      continue;
+    const key = binding.resourceKey;
+    const id = binding.id;
+    if (typeof key !== "string" || typeof id !== "string")
+      continue;
+    byKey.set(key, [...byKey.get(key) ?? [], id]);
+  }
+  const found = [];
+  for (const [key, ids] of byKey) {
+    if (ids.length < 2)
+      continue;
+    const types = new Set;
+    for (const id of ids) {
+      for (const type of typesById.get(id) ?? [])
+        types.add(type);
+    }
+    if (types.size < 2)
+      continue;
+    found.push({
+      key,
+      types: [...types].sort((left, right) => left.localeCompare(right)),
+      ids
+    });
+  }
+  return found;
+};
+var findOutputsWithoutId = (parsed) => {
+  const found = [];
+  for (const { entry, name, 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;
+    if (entry.custom === true)
+      continue;
+    const id = entry.id;
+    if (typeof id === "string" && id.trim() !== "")
+      continue;
+    found.push({ path, name });
+  }
+  return found;
+};
+var SOLUTION_FOLDER_KEY_PREFIX = "solution_folder.";
+var NAME_ATTRIBUTE = "name";
+var FOLDER_PATH_ATTRIBUTE = "folderPath";
+var findBindingKeyMismatches = (document) => {
+  const groups = new Map;
+  for (const entry of asArrayValue(document.bindings)) {
+    const binding = asRecordValue(entry);
+    const key = binding?.resourceKey;
+    const resource = binding?.resource;
+    const attribute = binding?.propertyAttribute;
+    if (typeof key !== "string" || key === "" || typeof resource !== "string" || typeof attribute !== "string") {
+      continue;
+    }
+    const groupKey = `${resource}\x00${key}`;
+    const group = groups.get(groupKey) ?? {};
+    const value = binding?.default;
+    if (typeof value === "string")
+      group[attribute] = value;
+    groups.set(groupKey, group);
+  }
+  const found = [];
+  for (const [groupKey, attributes] of groups) {
+    const [resource, key] = groupKey.split("\x00");
+    if (key.startsWith(SOLUTION_FOLDER_KEY_PREFIX))
+      continue;
+    const name = attributes[NAME_ATTRIBUTE];
+    const folderPath = attributes[FOLDER_PATH_ATTRIBUTE];
+    if (name === undefined || folderPath === undefined)
+      continue;
+    if (key !== `${folderPath}.${name}`)
+      found.push({ key, resource });
+  }
+  return found;
+};
+var IO_SLOT_KEYS = ["inputs", "outputs", "inputOutputs"];
+var PROSE_KEYS = new Set(["description", "rationale"]);
+var collectReferenceableIds = (document) => {
+  const ids = new Set;
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const entry of value)
+        visit(entry);
+      return;
+    }
+    const record = asRecordValue(value);
+    if (record === undefined)
+      return;
+    for (const key of IO_SLOT_KEYS) {
+      for (const entry of asArrayValue(record[key])) {
+        const slot = asRecordValue(entry);
+        for (const attribute of ["id", "name", "var"]) {
+          const value2 = slot?.[attribute];
+          if (typeof value2 === "string" && value2 !== "") {
+            ids.add(value2);
+          }
+        }
+      }
+    }
+    for (const entry of Object.values(record))
+      visit(entry);
+  };
+  visit(document);
+  return ids;
+};
+var REFERENCE_PREFIX = "vars.";
+var isReferenceIdChar = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+var referencesIn = (text) => {
+  const found = [];
+  let index = 0;
+  while (index < text.length) {
+    if (!text.startsWith(REFERENCE_PREFIX, index)) {
+      index += 1;
+      continue;
+    }
+    index += REFERENCE_PREFIX.length;
+    let id = "";
+    while (index < text.length && isReferenceIdChar(text[index])) {
+      id += text[index];
+      index += 1;
+    }
+    if (id !== "")
+      found.push(id);
+  }
+  return found;
+};
+var findUnboundReferences = (document, ids) => {
+  const found = [];
+  const reported = new Set;
+  const visit = (value, path) => {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return;
+    if (typeof value === "string") {
+      for (const id of referencesIn(value)) {
+        if (ids.has(id) || reported.has(`${path}:${id}`))
+          continue;
+        reported.add(`${path}:${id}`);
+        found.push({ path, id });
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        visit(entry, `${path}[${index}]`);
+      });
+      return;
+    }
+    const record = asRecordValue(value);
+    if (record === undefined)
+      return;
+    for (const [key, entry] of Object.entries(record)) {
+      if (PROSE_KEYS.has(key))
+        continue;
+      visit(entry, path === "" ? key : `${path}.${key}`);
+    }
+  };
+  visit(document, "");
+  return found;
+};
+var asRecordValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArrayValue = (value) => Array.isArray(value) ? value : [];
+var RULE_DISCRIMINATOR_LIMIT = 50;
+var labelOf = (record, fallback) => {
+  const data = asRecordValue(record?.data);
+  for (const candidate of [
+    record?.displayName,
+    data?.label,
+    data?.displayName,
+    data?.name,
+    record?.id
+  ]) {
+    if (typeof candidate === "string" && candidate.trim() !== "") {
+      return candidate;
+    }
+  }
+  return fallback;
+};
+var findSchemaTypeMismatches = (parsed, migrationError) => {
+  const opens = migrationError.indexOf("[");
+  if (opens === -1)
+    return [];
+  const [, frames] = catchError(() => JSON.parse(migrationError.slice(opens)));
+  const found = [];
+  for (const frame of asArrayValue(frames)) {
+    const issue2 = asRecordValue(frame);
+    if (issue2?.code !== "invalid_type")
+      continue;
+    const segments = asArrayValue(issue2.path);
+    const field = segments.at(-1);
+    if (typeof field !== "string")
+      continue;
+    const parts = [];
+    let node;
+    let task;
+    for (const [at, segment] of segments.entries()) {
+      if (segment === "nodes" && typeof segments[at + 1] === "number") {
+        node = asRecordValue(asArrayValue(parsed.nodes)[segments[at + 1]]);
+        parts.push(`nodes[${labelOf(node, String(segments[at + 1]))}]`);
+        continue;
+      }
+      if (segment === "tasks" && typeof segments[at + 1] === "number" && typeof segments[at + 2] === "number") {
+        const lane = asArrayValue(asRecordValue(node?.data)?.tasks)[segments[at + 1]];
+        task = asRecordValue(asArrayValue(lane)[segments[at + 2]]);
+        parts.push(`tasks[${labelOf(task, String(segments[at + 2]))}]`);
+        continue;
+      }
+      if (typeof segment === "number")
+        continue;
+      parts.push(String(segment));
+    }
+    const withArticle = (noun) => /^[aeiou]/i.test(noun) ? `an ${noun}` : `a ${noun}`;
+    const expected = withArticle(typeof issue2.expected === "string" ? issue2.expected : "another type");
+    const received = typeof issue2.message === "string" && issue2.message.includes("received ") ? issue2.message.slice(issue2.message.indexOf("received ") + 9) : "something else";
+    const where = task !== undefined ? ` on task "${labelOf(task, "?")}"` : node !== undefined ? ` on "${labelOf(node, "?")}"` : "";
+    found.push({
+      path: parts.join("."),
+      message: `\`${field}\`${where} must be ${expected}; ` + `it is ${withArticle(received)}. The schema reports this as a V20-to-V21 ` + "migration failure with a zod dump naming array indexes, on a " + "file whose version is not the problem — which is how a " + "repair lands on the wrong task."
+    });
+  }
+  return found;
+};
+var findConnectorTasksWithoutInputs = (nodes) => {
+  const found = [];
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    const stage = labelOf(node, "?");
+    for (const lane of asArrayValue(data.tasks)) {
+      for (const task of asArrayValue(lane)) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return found;
+        const record = asRecordValue(task);
+        const type = record?.type;
+        const taskData2 = asRecordValue(record?.data);
+        if (typeof type !== "string" || !CONNECTOR_TASK_TYPES3.has(type) || taskData2 === undefined) {
+          continue;
+        }
+        const context = taskData2.context;
+        if (contextEntries(context).length === 0)
+          continue;
+        if (missingContextKeys(context, type === "wait-for-connector").length > 0)
+          continue;
+        const inputs = taskData2.inputs;
+        if (inputs !== undefined && !Array.isArray(inputs))
+          continue;
+        if (Array.isArray(inputs) && inputs.length > 0)
+          continue;
+        const name = labelOf(record, type);
+        found.push({
+          path: `nodes[${stage}].data.tasks[${name}].data.inputs`,
+          name
+        });
+      }
+    }
+  }
+  return found;
+};
+var SLA_RULE_KEYS = new Set([
+  "id",
+  "displayName",
+  "expression",
+  "count",
+  "unit",
+  "escalationRule"
+]);
+var SLA_KEY_NEAR_MISS = new Map([
+  ["duration", "count` and `unit"],
+  ["name", "displayName"],
+  ["escalations", "escalationRule"],
+  ["slatype", "expression"]
+]);
+var findUnknownSlaKeys = (parsed, nodes) => {
+  const found = [];
+  const check = (rules, at) => {
+    asArrayValue(rules).forEach((entry, index) => {
+      const rule = asRecordValue(entry);
+      if (rule === undefined)
+        return;
+      const label = typeof rule.displayName === "string" && rule.displayName !== "" ? rule.displayName : String(index);
+      for (const key of Object.keys(rule)) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return;
+        if (SLA_RULE_KEYS.has(key))
+          continue;
+        const nearMiss = SLA_KEY_NEAR_MISS.get(key.toLowerCase());
+        found.push({
+          path: `${at}[${label}].${key}`,
+          key,
+          ...nearMiss !== undefined && { nearMiss }
+        });
+      }
+    });
+  };
+  check(asRecordValue(parsed.metadata)?.slaRules, "metadata.slaRules");
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    check(data.slaRules, `nodes[${labelOf(node, "?")}].data.slaRules`);
+  }
+  return found;
+};
+var findLiteralResourceBindings = (nodes) => {
+  const found = [];
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    const stage = labelOf(node, "?");
+    for (const lane of asArrayValue(data.tasks)) {
+      for (const task of asArrayValue(lane)) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return found;
+        const record = asRecordValue(task);
+        const type = record?.type;
+        const taskData2 = asRecordValue(record?.data);
+        if (typeof type !== "string" || !NAME_BOUND_TASK_TYPES.has(type) || taskData2 === undefined) {
+          continue;
+        }
+        if (RESOLVED_IDENTITY_KEYS.some((k) => (k in taskData2)))
+          continue;
+        const fields = ["name", "folderPath"].filter((field) => {
+          const value = taskData2[field];
+          return typeof value === "string" && value !== "" && !value.startsWith(BINDING_REFERENCE_PREFIX);
+        });
+        if (fields.length === 0)
+          continue;
+        const name = labelOf(record, type);
+        found.push({
+          path: `nodes[${stage}].data.tasks[${name}].data`,
+          name,
+          fields
+        });
+      }
+    }
+  }
+  return found;
+};
+var eachContext = (parsed, onContext, stop) => {
+  const visit = (value, path) => {
+    if (stop())
+      return;
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        visit(entry, `${path}[${index}]`);
+      });
+      return;
+    }
+    const record = asRecordValue(value);
+    if (record === undefined)
+      return;
+    const entries = contextEntries(record.context);
+    if (entries.length > 0)
+      onContext(entries, path);
+    for (const [name, child] of Object.entries(record)) {
+      if (name === "context")
+        continue;
+      visit(child, path === "" ? name : `${path}.${name}`);
+    }
+  };
+  visit(parsed.nodes, "nodes");
+  visit(parsed.edges, "edges");
+  visit(asRecordValue(parsed.metadata)?.caseExitRules, "metadata.caseExitRules");
+};
+var bindingsById = (parsed) => {
+  const map = new Map;
+  for (const entry of asArrayValue(parsed.bindings)) {
+    const record = asRecordValue(entry);
+    const id = record?.id;
+    if (record !== undefined && typeof id === "string" && id !== "") {
+      if (!map.has(id))
+        map.set(id, record);
+    }
+  }
+  return map;
+};
+var findConnectorResourceKeyMismatches = (parsed) => {
+  const bindings = bindingsById(parsed);
+  if (bindings.size === 0)
+    return [];
+  const found = [];
+  eachContext(parsed, (entries, path) => {
+    const named = (name) => entries.find((entry) => entry.name === name)?.value;
+    const key = named("resourceKey");
+    const connection = named("connection");
+    if (typeof key !== "string" || key === "" || typeof connection !== "string" || connection === "") {
+      return;
+    }
+    if (key.startsWith("=") || bindings.has(key))
+      return;
+    const id = connection.startsWith(BINDING_REFERENCE_PREFIX) ? connection.slice(BINDING_REFERENCE_PREFIX.length) : connection;
+    const binding = bindings.get(id);
+    if (binding === undefined)
+      return;
+    const accepted = [binding.resourceKey, binding.default].filter((candidate) => typeof candidate === "string" && candidate !== "");
+    if (accepted.length === 0 || accepted.includes(key))
+      return;
+    let elsewhere;
+    for (const [candidateId, candidate] of bindings) {
+      if (candidateId === id)
+        continue;
+      const resource = candidate.resource;
+      if (typeof resource !== "string" || resource.toLowerCase() !== "connection") {
+        continue;
+      }
+      if (candidate.resourceKey === key || candidate.default === key) {
+        elsewhere = candidateId;
+        break;
+      }
+    }
+    found.push({
+      path: `${path}.context[resourceKey]`,
+      value: key,
+      binding: id,
+      elsewhere
+    });
+  }, () => found.length >= AUTHORING_MARKER_LIMIT);
+  return found;
+};
+var findUnresolvedConnectorResourceKeys = (parsed) => {
+  const bindingIds = new Set(bindingsById(parsed).keys());
+  if (bindingIds.size === 0)
+    return [];
+  const found = [];
+  eachContext(parsed, (entries, path) => {
+    const key = entries.find((candidate) => candidate.name === "resourceKey")?.value;
+    if (typeof key === "string" && key !== "" && (bindingIds.has(key) || key.startsWith(BINDING_REFERENCE_PREFIX))) {
+      found.push({
+        path: `${path}.context[resourceKey]`,
+        value: key
+      });
+    }
+  }, () => found.length >= AUTHORING_MARKER_LIMIT);
+  return found;
+};
+var findDuplicateOutputIds = (parsed) => {
+  const found = [];
+  const owners = new Map;
+  const reported = new Set;
+  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 name = labelOf(taskRecord, "?");
+        for (const output of asArrayValue(taskData2.outputs)) {
+          const id = asRecordValue(output)?.id;
+          if (typeof id !== "string" || id === "")
+            continue;
+          const owner = `${stage}/${name}`;
+          const previous = owners.get(id);
+          if (previous === undefined) {
+            owners.set(id, owner);
+            continue;
+          }
+          if (reported.has(id))
+            continue;
+          reported.add(id);
+          found.push({
+            path: `nodes[${stage}].data.tasks[${name}].data.outputs[${id}]`,
+            id,
+            first: previous,
+            second: owner
+          });
+        }
+      }
+    }
+  }
+  return found;
+};
+var findDuplicateSlaIds = (parsed, nodes) => {
+  const holders = new Map;
+  const note = (rules, path, where) => {
+    asArrayValue(rules).forEach((entry, index) => {
+      const id = asRecordValue(entry)?.id;
+      if (typeof id !== "string" || id === "")
+        return;
+      holders.set(id, [
+        ...holders.get(id) ?? [],
+        { path: `${path}[${index}]`, where }
+      ]);
+    });
+  };
+  note(asRecordValue(parsed.metadata)?.slaRules, "metadata.slaRules", "the case level");
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    const stage = labelOf(node, "?");
+    note(data.slaRules, `nodes[${stage}].data.slaRules`, `"${stage}"`);
+  }
+  const found = [];
+  for (const [id, carried] of holders) {
+    if (carried.length < 2)
+      continue;
+    for (const [at, holder] of carried.entries()) {
+      if (found.length >= AUTHORING_MARKER_LIMIT)
+        return found;
+      const others = carried.filter((_, other) => other !== at);
+      found.push({
+        path: holder.path,
+        id,
+        sameHolder: others.filter((other) => other.where === holder.where).length,
+        otherHolders: [
+          ...new Set(others.filter((other) => other.where !== holder.where).map((other) => other.where))
+        ],
+        where: holder.where
+      });
+    }
+  }
+  return found;
+};
+var CONNECTOR_BINDING_ATTRIBUTES = new Set([
+  "connectionid",
+  "folderkey",
+  "connection"
+]);
+var CONNECTOR_BINDING_RESOURCES = new Set(["connection", "folder"]);
+var findIncompleteBindingPairs = (parsed) => {
+  const attributes = new Map;
+  for (const entry of asArrayValue(parsed.bindings)) {
+    const binding = asRecordValue(entry);
+    const key = binding?.resourceKey;
+    const attribute = binding?.propertyAttribute;
+    const resource = binding?.resource;
+    if (typeof key !== "string" || key === "")
+      continue;
+    if (typeof attribute !== "string" || attribute === "")
+      continue;
+    if (CONNECTOR_BINDING_ATTRIBUTES.has(attribute.toLowerCase()))
+      continue;
+    if (typeof resource === "string" && CONNECTOR_BINDING_RESOURCES.has(resource.toLowerCase())) {
+      continue;
+    }
+    const seen = attributes.get(key) ?? new Set;
+    seen.add(attribute);
+    attributes.set(key, seen);
+  }
+  const found = [];
+  for (const [key, seen] of attributes) {
+    if (found.length >= AUTHORING_MARKER_LIMIT)
+      return found;
+    const hasName = seen.has("name");
+    const hasFolder = seen.has("folderPath");
+    if (hasName && hasFolder)
+      continue;
+    found.push({
+      key,
+      present: [...seen].sort((a, b) => a.localeCompare(b)).join(", "),
+      missing: hasName ? "folderPath" : "name"
+    });
+  }
+  return found;
+};
+var findRecipientShapeDefects = (nodes) => {
+  const found = [];
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    const stage = labelOf(node, "?");
+    for (const lane of asArrayValue(data.tasks)) {
+      for (const task of asArrayValue(lane)) {
+        if (found.length >= AUTHORING_MARKER_LIMIT)
+          return found;
+        const record = asRecordValue(task);
+        const taskData2 = asRecordValue(record?.data);
+        const recipient = taskData2?.recipient;
+        if (recipient === undefined || recipient === null)
+          continue;
+        if (asRecordValue(recipient) !== undefined)
+          continue;
+        const name = labelOf(record, typeof record?.type === "string" ? record.type : "?");
+        found.push({
+          path: `nodes[${stage}].data.tasks[${name}].data.recipient`,
+          name,
+          actual: Array.isArray(recipient) ? "an array" : `a ${typeof recipient}`
+        });
+      }
+    }
+  }
+  return found;
+};
+var CONDITION_KEYS = {
+  entry: new Set(["id", "displayName", "rules", "isInterrupting"]),
+  exit: new Set([
+    "id",
+    "displayName",
+    "rules",
+    "type",
+    "exitToStageId",
+    "marksStageComplete"
+  ]),
+  caseExit: new Set(["id", "displayName", "rules", "marksCaseComplete"])
+};
+var CONDITION_EXPRESSION_KEY = "conditionExpression";
+var CONDITION_RULE_KEYS = new Set(["rule", "ruleType"]);
+var findUnknownConditionKeys = (nodes, metadata, options) => {
+  const found = [];
+  const check = (condition, allowed, path) => {
+    const record = asRecordValue(condition);
+    if (record === undefined)
+      return;
+    for (const key of Object.keys(record)) {
+      if (found.length >= AUTHORING_MARKER_LIMIT)
+        return;
+      if (allowed.has(key))
+        continue;
+      const lower = key.toLowerCase();
+      const nearMiss = [...allowed].find((candidate) => candidate.length >= 4 && candidate.toLowerCase() !== lower && lower.includes(candidate.toLowerCase()));
+      found.push({
+        path: `${path}.${key}`,
+        key,
+        ...nearMiss !== undefined && { nearMiss }
+      });
+    }
+  };
+  const named = (condition, at) => {
+    const record = asRecordValue(condition);
+    const label = record?.displayName ?? record?.id;
+    return typeof label === "string" && label !== "" ? label : String(at);
+  };
+  for (const node of nodes) {
+    const data = asRecordValue(node.data);
+    if (data === undefined)
+      continue;
+    const stage = labelOf(node, "?");
+    for (const [slot, allowed] of [
+      ["entryConditions", CONDITION_KEYS.entry],
+      ["exitConditions", CONDITION_KEYS.exit]
+    ]) {
+      asArrayValue(data[slot]).forEach((condition, at) => {
+        check(condition, allowed, `nodes[${stage}].data.${slot}[${named(condition, at)}]`);
+      });
+    }
+    for (const lane of options.includeTaskSlots ? asArrayValue(data.tasks) : []) {
+      for (const task of asArrayValue(lane)) {
+        const taskRecord = asRecordValue(task);
+        if (taskRecord === undefined)
+          continue;
+        const name = labelOf(taskRecord, "?");
+        asArrayValue(taskRecord.entryConditions).forEach((condition, at) => {
+          check(condition, CONDITION_KEYS.entry, `nodes[${stage}].data.tasks[${name}].entryConditions[${named(condition, at)}]`);
+        });
+      }
+    }
+  }
+  asArrayValue(metadata.caseExitRules).forEach((condition, at) => {
+    check(condition, CONDITION_KEYS.caseExit, `metadata.caseExitRules[${named(condition, at)}]`);
+  });
+  return found;
+};
+var findRuleTypeKeys = (document) => {
+  const found = [];
+  const visit = (value, path) => {
+    if (found.length >= RULE_DISCRIMINATOR_LIMIT)
+      return;
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        visit(entry, `${path}[${index}]`);
+      });
+      return;
+    }
+    if (value === null || typeof value !== "object")
+      return;
+    const record = value;
+    if (typeof record.ruleType === "string" && record.rule === undefined) {
+      found.push(path);
+      return;
+    }
+    for (const [key, entry] of Object.entries(record)) {
+      visit(entry, path === "" ? key : `${path}.${key}`);
+    }
+  };
+  visit(document, "");
+  return found;
+};
 
 class CaseValidateService {
   fs;
@@ -699,6 +1810,8 @@ Validating: ${absolutePath}
   }
   runSupplementalRules(parsed, profile) {
     const issues = [];
+    const taskContent = checksTaskContent(profile);
+    const slaContent = profile !== "skeleton";
     const name = parsed.name;
     if (typeof name !== "string" || name.trim() === "") {
       issues.push({
@@ -709,6 +1822,197 @@ Validating: ${absolutePath}
       });
     }
     const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+    for (const markerPath of findXrefMarkers(parsed)) {
+      issues.push({
+        code: "CASE_MGMT_XREF_UNRESOLVED",
+        path: markerPath,
+        severity: "error",
+        message: 'This value holds an unresolved "$xref(...)" authoring ' + "marker. Nothing expands it — packed and deployed it stays " + "a literal string, so whatever reads it never sees the id " + "it was standing in for. Replace it with the id or " + "expression it refers to."
+      });
+    }
+    for (const { path, slot } of taskContent ? findPlanningNotation(nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_PLANNING_NOTATION",
+        path,
+        severity: "error",
+        message: `This ${slot === "inputs" ? "input" : "output"} value ` + `starts with the SDD's planning notation ("<-" or "->"), ` + "which describes where a value comes from rather than " + "being a value. Replace it with the expression it " + 'describes — an "=vars.<id>" reference, an "=bindings.<id>" ' + "reference, or a literal."
+      });
+    }
+    for (const { path, name: name2 } of taskContent ? findUnparseableJsonValues(nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_VALUE_JSON_INVALID",
+        path,
+        severity: "error",
+        message: `Value of "${name2}" opens with "{" or "[" but is not ` + "valid JSON, so the runtime cannot read it as the " + "structure it announces. A truncated copy, or a markdown " + "fence character (`) picked up with the value, is the " + "usual cause."
+      });
+    }
+    for (const { path, name: name2, kind, target } of taskContent ? findConnectorInputDefects(nodes) : []) {
+      const CONNECTOR_INPUT_MESSAGES = {
+        flattened: `Connector input "${name2}" is not one of the three containers an Integration Service activity declares (pathParameters, queryParameters, body). A field spliced in at the top level is not passed: put it inside the container's \`body\` object.`,
+        stringified: `Connector input "${name2}" carries its payload as JSON text in \`value\`. The container takes a \`body\` object, so a serialised string is passed through as a string and the activity receives no fields.`,
+        misplaced: `Connector input "${name2}" carries its fields in \`value\` and has no \`body\`. A json container is read from \`body\` — \`value\` holds a scalar, and only for a string-typed entry — so the activity runs with this container empty. Move the object into \`body\`.`,
+        mistargeted: `Connector input "${name2}" targets \`${target ?? ""}\`. Every reader keys on the input's \`name\`, and the three containers are emitted with \`target\` equal to it, so this fills \`${name2}\` and leaves \`${target ?? ""}\` empty. Rename the entry to the container its fields belong to, or set \`target\` to match \`${name2}\`.`
+      };
+      const CONNECTOR_INPUT_CODES = {
+        flattened: "CASE_MGMT_CONNECTOR_INPUT_FLATTENED",
+        stringified: "CASE_MGMT_CONNECTOR_INPUT_STRINGIFIED",
+        misplaced: "CASE_MGMT_CONNECTOR_INPUT_VALUE_NOT_BODY",
+        mistargeted: "CASE_MGMT_CONNECTOR_INPUT_TARGET_MISMATCH"
+      };
+      issues.push({
+        code: CONNECTOR_INPUT_CODES[kind],
+        path,
+        severity: "error",
+        message: CONNECTOR_INPUT_MESSAGES[kind]
+      });
+    }
+    for (const { path, name: name2 } of taskContent ? findReassignedOutputsWithoutOriginalVar(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_OUTPUT_ORIGINAL_VAR_MISSING",
+        path,
+        severity: "error",
+        message: `Output "${name2}" writes to a variable other than its ` + "own id but carries no `originalVar`. That field is how " + "the designer recognises a reassigned output: without " + "it the output reads as a plain one and goes down the " + "path that allocates a fresh variable by name, so the " + "plan the designer opens is not the one written here. " + "Set `originalVar` to this output's own id."
+      });
+    }
+    for (const { path, name: name2 } of taskContent ? findVarIdCaseMismatches(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_OUTPUT_VAR_ID_CASE_MISMATCH",
+        path,
+        severity: "error",
+        message: `Output "${name2}" has an id and a var that differ only ` + "by casing. A renamed output keeps its own id on " + "purpose, but nothing renames a value to the same word " + "in a different case — so this is one name typed two " + "ways, and the case variable it declares carries a " + "spelling no reference written from the id will match. " + "Make the two agree."
+      });
+    }
+    for (const { path, name: name2, hasValue } of taskContent ? findMisplacedEnvelopeBodies(nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_INPUT_BODY_ON_PLAIN_TASK",
+        path,
+        severity: "error",
+        message: `Input "${name2}" carries its fields in \`body\`, which ` + "only a connector input has. This task type reads " + `\`value\`, so ${hasValue ? "the fields under `body` are ignored and the task runs on `value` alone" : "nothing reaches the task for it at all"}. ` + "Move the object into `value` — as a native object, or " + "JSON text if that is what the task expects."
+      });
+    }
+    for (const { path, holder, dead } of slaContent ? findUnreachableSlaRules(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_SLA_RULE_UNREACHABLE",
+        path,
+        severity: "error",
+        message: `This SLA rule on ${holder} is unconditional, and ` + `${dead} rule${dead === 1 ? "" : "s"} follow${dead === 1 ? "s" : ""} it. ` + "The first rule whose expression holds is the one that " + "applies, so everything after an unconditional rule is " + "dead — a conditional override written below the default " + "reads as configured and enforces the default instead. " + "Move the unconditional rule last."
+      });
+    }
+    for (const { path, scope, expression, count } of slaContent ? findDuplicateSlaGates(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_SLA_RULE_DUPLICATE",
+        path,
+        severity: "error",
+        message: `${count} SLA rules on ${scope} share the gate ` + `\`${expression}\`. The first rule whose expression holds ` + "is the one that applies, so every rule after it on the " + "same gate is unreachable — including any escalation only " + "it carries. One SLA split across two rules like this " + "looks complete rule by rule and enforces only the first."
+      });
+    }
+    for (const { key, types, ids } of taskContent ? findSharedBindingKeys(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_BINDING_KEY_SHARED",
+        path: `bindings[${ids.join(", ")}].resourceKey`,
+        severity: "error",
+        message: `${types.length} kinds of resource (${types.join(", ")}) ` + `resolve to one resourceKey "${key}". A resource is ` + 'addressed by folderPath + "." + name, so one key is one ' + "resource: 'uip solution resources refresh' will resolve a " + "single resource and bind it for all of them. Each " + "binding's `name` default has to be that resource's own " + "name, not the folder's."
+      });
+    }
+    for (const { path, id, sameHolder, otherHolders, where } of slaContent ? findDuplicateSlaIds(parsed, nodes) : []) {
+      const repeats = sameHolder > 0 ? `${sameHolder} other rule${sameHolder === 1 ? "" : "s"} in ${where}'s own \`slaRules\`` : "";
+      const elsewhere = otherHolders.length > 0 ? `${otherHolders.join(" and ")}` : "";
+      issues.push({
+        code: "CASE_MGMT_SLA_ID_DUPLICATE",
+        path,
+        severity: "error",
+        message: `SLA rule id "${id}" is also carried by ` + `${[repeats, elsewhere].filter((part) => part !== "").join(", and by ")}. ` + "`sla-status-change` entry " + "rules key on `slaId`, so anything referring to this id " + "is ambiguous — there is no way to say which SLA a " + "threshold or an escalation belongs to. Give each SLA " + "rule its own id."
+      });
+    }
+    for (const { path, key, nearMiss } of slaContent ? findUnknownSlaKeys(parsed, nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_SLA_RULE_UNKNOWN_KEY",
+        path,
+        severity: "error",
+        message: `\`${key}\` is not part of an SLA rule. ` + (nearMiss === undefined ? "The shape is closed, so the runtime never reads " + "this key and whatever it holds is lost." : `The key is \`${nearMiss}\` — move the value ` + "across. The schema neither migrates nor rejects " + `\`${key}\`, so the plan validates while the ` + "field the runtime reads is absent and the SLA " + "ends up with no value at all.")
+      });
+    }
+    for (const { key, present, missing } of taskContent ? findIncompleteBindingPairs(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_BINDING_PAIR_INCOMPLETE",
+        path: `bindings[${key}]`,
+        severity: "error",
+        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, name: name2, fields } of taskContent ? findLiteralResourceBindings(nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_RESOURCE_TASK_LITERAL_BINDING",
+        path,
+        severity: "error",
+        message: `Task "${name2}" names its resource with ` + `${fields.length === 1 ? "a literal" : "literals"}: ` + `${fields.join(" and ")}. A resource task's \`name\` and ` + `\`folderPath\` are \`${BINDING_REFERENCE_PREFIX}<id>\` ` + "references — the bindings array is what 'uip solution " + "resources refresh' resolves and what bindings_v2.json is " + "derived from, so a plain string names something the " + "solution never resolves and no binding exists for it. " + "Add the name/folderPath binding pair and point both " + "fields at it."
+      });
+    }
+    for (const { path, name: name2, actual } of taskContent ? findRecipientShapeDefects(nodes) : []) {
+      issues.push({
+        code: "CASE_MGMT_ACTION_RECIPIENT_SHAPE",
+        path,
+        severity: "error",
+        message: `Task "${name2}" writes \`recipient\` as ${actual}. The ` + 'shape is `{ "Type": <n>, "Value": "<who>" }` — a bare ' + "value carries no type, so the assignment resolves to " + "nobody and the task is created unassigned. Wrap it, " + "keeping the value."
+      });
+    }
+    for (const { path, value } of taskContent ? findUnresolvedConnectorResourceKeys(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_CONNECTOR_RESOURCE_KEY_UNRESOLVED",
+        path,
+        severity: "error",
+        message: `\`resourceKey\` is "${value}", which names a binding ` + "rather than a resource. It carries the *resolved* " + "connection key, so a reader looking for the connection " + "id here finds a name that means nothing to it and the " + "connector is unresolved — while every other check " + "passes, because the entry has a value and the sibling " + "`connection` reference resolves. Put the connection key " + "the binding resolves to here, not the binding's id."
+      });
+    }
+    for (const { path, value, binding, elsewhere } of taskContent ? findConnectorResourceKeyMismatches(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_CONNECTOR_RESOURCE_KEY_MISMATCH",
+        path,
+        severity: "error",
+        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) : []) {
+      issues.push({
+        code: "CASE_MGMT_CONNECTOR_INPUTS_EMPTY",
+        path,
+        severity: "error",
+        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, id, first, second } of taskContent ? findDuplicateOutputIds(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_OUTPUT_ID_DUPLICATE",
+        path,
+        severity: "error",
+        message: `Output id "${id}" is used by two tasks (${first} and ` + `${second}). An output id is the write target, so the ` + "second write lands on the first task's variable and one " + "of the two values is gone. Give each output its own id."
+      });
+    }
+    for (const { path, name: name2 } of taskContent ? findOutputsWithoutId(parsed) : []) {
+      issues.push({
+        code: "CASE_MGMT_OUTPUT_ID_MISSING",
+        path,
+        severity: "error",
+        message: `Output "${name2}" carries no id. The designer generates ` + "one for every output it writes, and without it nothing " + "can reference this output — every expression that reads " + "it resolves to nothing."
+      });
+    }
+    for (const { key, resource } of findBindingKeyMismatches(parsed)) {
+      issues.push({
+        code: "CASE_MGMT_BINDING_KEY_MISMATCH",
+        path: `bindings[${key}]`,
+        severity: "error",
+        message: `The resourceKey of this ${resource} binding does not ` + "match the folderPath and name its own entries declare. " + "The key addresses the resource in the solution, so a key " + "built from anything else resolves nothing at deploy " + "time. Rebuild it from this pair's own folderPath and " + "name defaults."
+      });
+    }
+    const referenceableIds = collectReferenceableIds(parsed);
+    for (const { path, id } of findUnboundReferences(parsed, referenceableIds)) {
+      issues.push({
+        code: "CASE_MGMT_REFERENCE_UNBOUND",
+        path,
+        severity: "error",
+        message: `"vars.${id}" resolves to nothing: no input or output ` + "in this case plan carries that id, name or var. " + "Whatever reads it gets no value at run time. Point it " + "at the entry that produces the data."
+      });
+    }
     const seen = new Set;
     const reported = new Set;
     for (const node of nodes) {
@@ -730,6 +2034,23 @@ Validating: ${absolutePath}
       issues.push(...this.checkEntryRuleSlots(nodes, {
         includeTaskSlots: checksTaskContent(profile)
       }));
+      for (const { path, key, nearMiss } of findUnknownConditionKeys(nodes, asRecordValue(parsed.metadata) ?? {}, { includeTaskSlots: checksTaskContent(profile) })) {
+        if (key === CONDITION_EXPRESSION_KEY) {
+          issues.push({
+            code: "CASE_MGMT_CONDITION_EXPR_HOISTED",
+            path,
+            severity: "error",
+            message: "`conditionExpression` sits on the condition " + "object. The scheduler reads it from a rule " + "inside `rules[][]`, so here it is ignored and " + "the condition fires **ungated** — which is " + "worse than not firing at all. Move it onto the " + "rule it is meant to guard."
+          });
+          continue;
+        }
+        issues.push({
+          code: "CASE_MGMT_CONDITION_UNKNOWN_KEY",
+          path,
+          severity: "error",
+          message: `\`${key}\` is not part of a condition. ` + (CONDITION_RULE_KEYS.has(key) ? "A rule lives inside `rules[][]`, not on the " + "condition: the condition carries the display " + "name and the flags, the inner array carries " + "the rules. Flattened here it is never " + "evaluated, and the condition reads as having " + "no rules at all." : nearMiss === undefined ? "The shape is closed, so the runtime never " + "reads this key and whatever it holds is lost." : `The key is \`${nearMiss}\` — rename it and ` + `keep the value. The schema neither migrates ` + `nor rejects \`${key}\`, so the plan ` + `validates while \`${nearMiss}\` reads as ` + `absent, which is how a condition ends up ` + `missing the field it was written to carry.`)
+        });
+      }
     }
     return issues;
   }
@@ -845,12 +2166,36 @@ Validating: ${absolutePath}
       });
     }
     if (diskResult.migrationError) {
-      issues.push({
-        code: "CASE_MGMT_MIGRATION_FAILED",
-        path: "(root)",
-        message: diskResult.migrationError,
-        severity: "error"
-      });
+      const ruleTypePaths = findRuleTypeKeys(parsed);
+      if (ruleTypePaths.length > 0) {
+        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.",
+            severity: "error"
+          });
+        }
+      } else {
+        const typeMismatches = findSchemaTypeMismatches(parsed, diskResult.migrationError);
+        if (typeMismatches.length > 0) {
+          for (const mismatch of typeMismatches) {
+            issues.push({
+              code: "CASE_MGMT_FIELD_TYPE_MISMATCH",
+              path: mismatch.path,
+              message: mismatch.message,
+              severity: "error"
+            });
+          }
+        } else {
+          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));
@@ -883,13 +2228,14 @@ Validating: ${absolutePath}
       issues.push(...this.runSupplementalRules(parsed, profile));
     }
     if (diskResult.valid && profile === "strict") {
-      const { runStrictCaseRules } = await import("./strict-case-rules-303vjvas.js");
+      const { runStrictCaseRules } = await import("./strict-case-rules-x6t0vb40.js");
       issues.push(...runStrictCaseRules(parsed));
+      issues.push(...await this.checkBindingsSidecar(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-qdmc9e1y.js");
+          const { auditCaseplanAgainstSdd } = await import("./strict-sdd-audit-8e2fh9jg.js");
           issues.push(...auditCaseplanAgainstSdd(parsed, sddText, this.fs.path.basename(sddPath)));
         } else {
           issues.push({
@@ -907,6 +2253,42 @@ Validating: ${absolutePath}
       issues
     };
   }
+  async checkBindingsSidecar(casePlanPath, parsed) {
+    const { compareCaseBindingsV2 } = await import("./case-bindings-service-1wxfghzd.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.`;
+    const issue2 = (message) => [
+      {
+        code: "STRICT_BINDINGS_SIDECAR_STALE",
+        path: this.fs.path.basename(comparison.path),
+        severity: "warning",
+        message
+      }
+    ];
+    switch (comparison.status) {
+      case "match":
+        return [];
+      case "absent":
+        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 "differs": {
+        const {
+          missing = [],
+          extra = [],
+          changed = []
+        } = comparison.difference ?? {};
+        const parts = [
+          missing.length > 0 && `missing: ${missing.join(", ")}`,
+          changed.length > 0 && `wrong: ${changed.join(", ")}`,
+          extra.length > 0 && `unexpected: ${extra.join(", ")}`
+        ].filter((part) => part !== false);
+        return issue2(`bindings_v2.json disagrees with the case plan's bindings (${parts.join("; ")}). An entry the consumer cannot key is skipped without an error. ${remedy}`);
+      }
+    }
+  }
   validateMetadata(schema, profile) {
     const issues = [];
     const metadata = schema.metadata ?? {};
@@ -974,13 +2356,13 @@ Validating: ${absolutePath}
     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 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 value is set",
+          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"
         });
       }
@@ -1582,7 +2964,7 @@ Validating: ${absolutePath}
     }
     const sla = stage.data.sla;
     if (sla) {
-      const hasEscalations = sla.escalationRule != null && sla.escalationRule.length > 0;
+      const hasEscalations = (sla.escalationRule?.length ?? 0) > 0;
       const hasValue = sla.count != null && sla.count > 0;
       if (hasEscalations && !hasValue) {
         issues.push({
@@ -2111,4 +3493,4 @@ export {
   CaseValidateService
 };
 
-//# debugId=73947324AD8898D364756E2164756E21
+//# debugId=CF6CF2FB8A5C033D64756E2164756E21