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

package/dist/strict-sdd-audit-8e2fh9jg.js

@@ -0,0 +1,2520 @@
+import {
+  isAnyTriggerNode,
+  isStageNode
+} from "./packager-tool-sv0d6wb6.js";
+import {
+  catchError
+} from "./packager-tool-kpcjnxd1.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/strict-sdd-audit.ts
+var isDigit = (ch) => ch >= "0" && ch <= "9";
+var isLowerLetter = (ch) => ch >= "a" && ch <= "z";
+var isUpperLetter = (ch) => ch >= "A" && ch <= "Z";
+var isLetter = (ch) => isLowerLetter(ch) || isUpperLetter(ch);
+var isWordChar = (ch) => isLetter(ch) || isDigit(ch) || ch === "_";
+var isSlugChar = (ch) => isDigit(ch) || isLowerLetter(ch) || ch === "-" || ch === "_";
+var readHeading = (line) => {
+  let level = 0;
+  while (level < line.length && line[level] === "#")
+    level += 1;
+  if (level === 0 || level > 6)
+    return;
+  const rest = line.slice(level);
+  if (!rest.startsWith(" ") && !rest.startsWith("\t"))
+    return;
+  return { level, title: rest.trim() };
+};
+var firstIndexOfEither = (text, a, b) => {
+  const first = text.indexOf(a);
+  const second = text.indexOf(b);
+  if (first === -1)
+    return second;
+  if (second === -1)
+    return first;
+  return Math.min(first, second);
+};
+var readStageHeading = (title) => {
+  const words = title.trim().split(" ").filter((w) => w !== "");
+  const at = words.findIndex((w) => w.toLowerCase().startsWith("stage"));
+  if (at === -1 || at > 1)
+    return;
+  let rest = words.slice(at).join(" ");
+  rest = rest.slice("stage".length);
+  const separator = firstIndexOfEither(rest, ":", ".");
+  if (separator === -1)
+    return;
+  const between = rest.slice(0, separator).trim();
+  if (between !== "" && ![...between].every(isDigit))
+    return;
+  const name = rest.slice(separator + 1).trim();
+  return name === "" ? undefined : name;
+};
+var readTaskHeading = (title) => {
+  const text = title.trim();
+  if (!text.toLowerCase().startsWith("task "))
+    return;
+  let rest = text.slice("task ".length).trimStart();
+  if (rest.length > 0 && rest[0] >= "A" && rest[0] <= "Z")
+    rest = rest.slice(1);
+  let at = 0;
+  while (at < rest.length && (isDigit(rest[at]) || rest[at] === "."))
+    at += 1;
+  if (at === 0)
+    return;
+  const marker = rest.slice(0, at);
+  let tail = rest.slice(at);
+  if (marker.endsWith("."))
+    tail = `.${tail}`;
+  tail = tail.trimStart();
+  if (!tail.startsWith(":") && !tail.startsWith("."))
+    return;
+  const name = tail.slice(1).trim();
+  return name === "" ? undefined : name;
+};
+var isSeparatorCell = (cell) => {
+  let body = cell;
+  if (body.startsWith(":"))
+    body = body.slice(1);
+  if (body.endsWith(":"))
+    body = body.slice(0, -1);
+  return body.length >= 2 && [...body].every((ch) => ch === "-");
+};
+var hasUnresolvedMarker = (text) => text.toLowerCase().includes("<unresolved");
+var withoutSectionNumber = (key) => {
+  const words = key.split(" ");
+  let at = 0;
+  if (words[at] === "section")
+    at += 1;
+  const looksNumbered = (word) => {
+    if (!word)
+      return false;
+    let i = 0;
+    if (isLowerLetter(word[i]))
+      i += 1;
+    const start = i;
+    while (i < word.length && isDigit(word[i]))
+      i += 1;
+    if (i === start)
+      return false;
+    if (i < word.length && isLowerLetter(word[i]))
+      i += 1;
+    return i === word.length;
+  };
+  if (!looksNumbered(words[at]))
+    return key;
+  at += 1;
+  while (looksNumbered(words[at]))
+    at += 1;
+  return words.slice(at).join(" ");
+};
+var TOPIC_WORDS = ["conditions", "variables", "triggers", "sla"];
+var withoutTrailingSlug = (text) => {
+  const trimmed = text.trimEnd();
+  if (!trimmed.endsWith(")"))
+    return text;
+  const open = trimmed.lastIndexOf("(");
+  if (open === -1)
+    return text;
+  let inner = trimmed.slice(open + 1, -1).trim();
+  if (inner.startsWith("`") && inner.endsWith("`") && inner.length >= 2) {
+    inner = inner.slice(1, -1);
+  }
+  if (inner === "" || ![...inner].every(isSlugChar))
+    return text;
+  return trimmed.slice(0, open).trimEnd();
+};
+var PLACEHOLDER_CELLS = ["", "-", "—", "–", "n/a", "na", "none", "tbd"];
+var DEFAULT_UNFILLED = new Set(["-", "—", "–", "n/a", "na", "tbd"]);
+var CASE_EXIT_HEADINGS = [
+  "Case Exit Conditions",
+  "Case Completion Conditions"
+];
+var CASE_TRIGGER_HEADINGS = ["Case Triggers", "Triggers"];
+var CASE_SLA_HEADINGS = ["Case-Level SLA Escalation Rules"];
+var CASE_METADATA_HEADINGS = ["Case Metadata"];
+var CASE_SLA_PROPERTY = "Case-Level SLA";
+var CASE_VARIABLE_HEADINGS = ["Case Variables"];
+var STAGE_ENTRY_HEADINGS = ["Stage Entry Conditions"];
+var STAGE_EXIT_HEADINGS = [
+  "Stage Exit Conditions",
+  "Stage Completion Conditions"
+];
+var STAGE_SLA_HEADINGS = ["Stage SLA"];
+var STAGE_CONDITIONAL_SLA_HEADINGS = [
+  "Stage Conditional SLA Rules",
+  "Stage Variable SLA Rules"
+];
+var CASE_CONDITIONAL_SLA_HEADINGS = [
+  "Variable SLA Rules",
+  "Case Conditional SLA Rules",
+  "Case-Level Conditional SLA Rules",
+  "Case Variable SLA Rules"
+];
+var STAGE_TASK_HEADINGS = ["Tasks"];
+var VARIABLE_GROUPS = ["inputs", "outputs", "inputOutputs"];
+var VARIABLE_PLACEMENT = new Map([
+  ["in", ["inputs", "inputOutputs"]],
+  ["out", ["outputs", "inputOutputs"]],
+  ["variable", ["inputOutputs"]]
+]);
+var DEFAULT_GROUP = new Map([
+  ["in", "inputs"],
+  ["out", "inputOutputs"],
+  ["variable", "inputOutputs"]
+]);
+var QUOTE_CHARS = new Set(["`", '"', "“", "”", "‘", "’", " "]);
+var trimQuotes = (text) => {
+  let start = 0;
+  let end = text.length;
+  while (start < end && QUOTE_CHARS.has(text[start]))
+    start += 1;
+  while (end > start && QUOTE_CHARS.has(text[end - 1]))
+    end -= 1;
+  return text.slice(start, end);
+};
+var normAnnotationless = (value) => {
+  const text = String(value ?? "").trim();
+  if (!text.endsWith(")"))
+    return norm(text);
+  const open = text.lastIndexOf("(");
+  return open === -1 ? norm(text) : norm(text.slice(0, open));
+};
+var norm = (value) => {
+  const text = trimQuotes(withoutTrailingSlug(String(value ?? "").trim()));
+  const words = [];
+  let word = "";
+  for (const ch of text.toLowerCase()) {
+    if (isLowerLetter(ch) || isDigit(ch))
+      word += ch;
+    else if (word !== "") {
+      words.push(word);
+      word = "";
+    }
+  }
+  if (word !== "")
+    words.push(word);
+  return words.join(" ");
+};
+var headingKey = (title) => withoutSectionNumber(norm(title));
+var headingIs = (title, accepted) => accepted.some((a) => headingKey(a) === headingKey(title));
+var topicOf = (title) => {
+  const key = headingKey(title);
+  const words = key.split(" ");
+  if (words.some((w) => w === "task" || w === "tasks"))
+    return "tasks";
+  const last = words.at(-1);
+  return TOPIC_WORDS.find((topic) => topic === last);
+};
+var isBlank = (cell) => PLACEHOLDER_CELLS.map(norm).includes(norm(cell));
+var sectionBlocks = (text) => {
+  const heads = [];
+  let offset = 0;
+  for (const line of text.split(`
+`)) {
+    const heading = readHeading(line);
+    if (heading) {
+      heads.push({
+        level: heading.level,
+        title: heading.title,
+        start: offset,
+        at: offset + line.length
+      });
+    }
+    offset += line.length + 1;
+  }
+  return heads.map((head, index) => {
+    let end = text.length;
+    for (const later of heads.slice(index + 1)) {
+      if (later.level <= head.level) {
+        end = later.start;
+        break;
+      }
+    }
+    return {
+      level: head.level,
+      title: head.title,
+      body: text.slice(head.at, end)
+    };
+  });
+};
+var splitRowCells = (inner) => {
+  const cells = [];
+  let current = "";
+  let fenced = false;
+  for (let at = 0;at < inner.length; at += 1) {
+    const ch = inner[at];
+    if (ch === "\\" && inner[at + 1] === "|") {
+      current += "|";
+      at += 1;
+      continue;
+    }
+    if (ch === "`") {
+      fenced = !fenced;
+      current += ch;
+      continue;
+    }
+    if (ch === "|" && !fenced) {
+      cells.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  cells.push(current.trim());
+  return cells;
+};
+var firstTable = (block) => {
+  let header = [];
+  const rows = [];
+  for (const line of block.split(`
+`)) {
+    const stripped = line.trim();
+    if (!stripped.startsWith("|")) {
+      if (header.length > 0 && rows.length > 0)
+        break;
+      continue;
+    }
+    let inner = stripped;
+    if (inner.startsWith("|"))
+      inner = inner.slice(1);
+    if (inner.endsWith("|"))
+      inner = inner.slice(0, -1);
+    const cells = splitRowCells(inner);
+    if (cells.length > 0 && cells.filter((c) => c !== "").every(isSeparatorCell)) {
+      continue;
+    }
+    if (header.length === 0)
+      header = cells;
+    else
+      rows.push(cells);
+  }
+  return { header, rows };
+};
+var columnIndex = (header, ...names) => {
+  const wanted = new Set(names.map(norm));
+  const found = header.findIndex((c) => wanted.has(norm(c)));
+  return found === -1 ? undefined : found;
+};
+var cellAt = (row, index) => index !== undefined && index < row.length ? row[index] : "";
+var INPUT_LABELS = ["Inputs", "Input Schema"];
+var OUTPUT_LABELS = ["Outputs", "Output Schema"];
+var afterAnyLabel = (block, labels) => afterBoldLabel(block, ...labels);
+var unwrapCodeSpan = (value) => {
+  const text = value.trim();
+  let fence = 0;
+  while (fence < text.length && text[fence] === "`")
+    fence += 1;
+  if (fence === 0 || text.length < fence * 2)
+    return text;
+  if (text.slice(text.length - fence) !== "`".repeat(fence))
+    return text;
+  return text.slice(fence, text.length - fence).trim();
+};
+var stripTicks = (value) => {
+  const span = /^(`+)([\s\S]*?)\1/.exec(value.trim());
+  return (span ? span[2] : value).trim();
+};
+var field = (block, label) => {
+  const wanted = label.toLowerCase();
+  for (const line of block.split(`
+`)) {
+    const text = line.trim();
+    if (!text.startsWith("**"))
+      continue;
+    const close = text.indexOf("**", 2);
+    if (close === -1)
+      continue;
+    let name = text.slice(2, close).trim().toLowerCase();
+    if (name.endsWith(":"))
+      name = name.slice(0, -1);
+    if (name !== wanted)
+      continue;
+    return text.slice(close + 2).trim();
+  }
+  return;
+};
+var declaresProse = (value) => value?.trim().startsWith("<") === false && !isBlank(value);
+var firstProseLabel = (block, ...labels) => labels.find((label) => declaresProse(field(block, label)));
+var noNameColumnNote = (title, wanted, header) => `section "${title}": the table has rows but no ${wanted.join("/")} ` + `column (header: ${header.join(" | ") || "<none>"}) — every row is ` + "skipped, so the section contributes nothing to audit";
+var capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var noCategoryColumnNote = (title, header) => `section "${title}": the table has rows but no Category column ` + `(header: ${header.join(" | ") || "<none>"}) — no row can be checked ` + "for `variables` group placement, so a formal argument missing half its " + "pair passes";
+var unrecognizedHeadingNote = (title, level) => `heading "${title}" (level ${level}) reads like an audited section but ` + "matches no accepted spelling — rename it to one of the canonical " + "headings, or the checks it feeds are skipped";
+var entryConditionBlocks = (block) => {
+  const blocks = [];
+  for (const sub of sectionBlocks(block)) {
+    if (norm(sub.title).startsWith(norm("Entry Condition"))) {
+      blocks.push(sub.body);
+    }
+  }
+  const lines = block.split(`
+`);
+  const isInlineLabel = (line) => line.trim().startsWith("**") && norm(line.replaceAll("*", "")).startsWith(norm("Entry Condition"));
+  const at = lines.findIndex(isInlineLabel);
+  if (at === -1)
+    return blocks;
+  const tail = [];
+  for (const line of lines.slice(at + 1)) {
+    const text = line.trim();
+    if (text.startsWith("**") || readHeading(text))
+      break;
+    tail.push(line);
+  }
+  blocks.push(tail.join(`
+`));
+  return blocks;
+};
+var detailEntryRows = (block) => entryConditionBlocks(block).reduce((most, text) => Math.max(most, firstTable(text).rows.length), 0);
+var afterBoldLabel = (block, ...labels) => {
+  const hits = [];
+  for (const label of labels) {
+    const opener = `**${label}`;
+    let at = block.indexOf(opener);
+    while (at !== -1) {
+      const from = at + opener.length;
+      if (!isWordChar(block.charAt(from)))
+        hits.push({ at, from });
+      at = block.indexOf(opener, from);
+    }
+  }
+  hits.sort((left, right) => left.at - right.at);
+  return hits.map(({ from }, index) => block.slice(from, hits[index + 1]?.at ?? block.length));
+};
+var isIdentifier = (text) => {
+  const head = text.charAt(0);
+  if (!isLetter(head) && head !== "_")
+    return false;
+  for (const ch of text.slice(1)) {
+    if (!isWordChar(ch))
+      return false;
+  }
+  return true;
+};
+var detailInputRows = (block) => {
+  const rowsOut = [];
+  for (const sub of afterAnyLabel(block, INPUT_LABELS)) {
+    const { header, rows } = firstTable(sub);
+    const nameAt = columnIndex(header, "Name", "Input", "Field");
+    const valueAt = columnIndex(header, "Binding / Value", "Binding", "Value");
+    if (nameAt === undefined || valueAt === undefined)
+      continue;
+    for (const row of rows) {
+      const name = stripTicks(cellAt(row, nameAt).trim());
+      const raw = stripTicks(cellAt(row, valueAt).trim());
+      if (!name || isBlank(name) || isBlank(raw))
+        continue;
+      rowsOut.push({ name, raw });
+    }
+  }
+  return rowsOut;
+};
+var isBinding = (raw) => raw.startsWith("=") || raw.startsWith("<-");
+var EMPTY_LITERAL = /^""\s*\(empty literal\)$/i;
+var detailLiteralInputs = (block) => detailInputRows(block).filter(({ raw }) => !isBinding(raw)).map(({ name, raw }) => ({
+  name,
+  value: EMPTY_LITERAL.test(raw) ? "" : raw
+}));
+var detailBoundInputs = (block) => detailInputRows(block).filter(({ raw }) => isBinding(raw)).map(({ name, raw }) => ({ name, binding: raw }));
+var detailExpressionInputs = (block) => {
+  const inputs = [];
+  for (const sub of afterAnyLabel(block, INPUT_LABELS)) {
+    const { header, rows } = firstTable(sub);
+    const nameAt = columnIndex(header, "Name", "Input", "Field");
+    const valueAt = columnIndex(header, "Binding / Value", "Binding", "Value");
+    if (nameAt === undefined || valueAt === undefined)
+      continue;
+    for (const row of rows) {
+      const name = stripTicks(cellAt(row, nameAt).trim());
+      const raw = unwrapCodeSpan(cellAt(row, valueAt));
+      if (!name || isBlank(name) || isBlank(raw))
+        continue;
+      if (!raw.startsWith("="))
+        continue;
+      inputs.push({ name, expression: raw });
+    }
+  }
+  return inputs;
+};
+var PRODUCER_ARROW = "<-";
+var XREF_OPEN = "$xref(";
+var SEGMENT_QUOTES = new Set(['"', "'", "`", "“", "”"]);
+var CLOSING_QUOTE = new Map([["“", "”"]]);
+var closesQuote = (ch, quote) => ch === (CLOSING_QUOTE.get(quote) ?? quote);
+var dottedSegments = (text) => {
+  const segments = [];
+  let current = "";
+  let quote;
+  for (const ch of text) {
+    if (quote !== undefined) {
+      if (closesQuote(ch, quote))
+        quote = undefined;
+      else
+        current += ch;
+      continue;
+    }
+    if (SEGMENT_QUOTES.has(ch)) {
+      quote = ch;
+      continue;
+    }
+    if (ch === ".") {
+      segments.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  segments.push(current.trim());
+  return segments.filter((segment) => segment !== "");
+};
+var callCloseIndex = (text, from) => {
+  let quote;
+  for (let at = from;at < text.length; at += 1) {
+    const ch = text[at];
+    if (quote !== undefined) {
+      if (closesQuote(ch, quote))
+        quote = undefined;
+      continue;
+    }
+    if (SEGMENT_QUOTES.has(ch)) {
+      quote = ch;
+      continue;
+    }
+    if (ch === ")")
+      return at;
+  }
+  return -1;
+};
+var splitCallArguments = (text) => {
+  const parts = [];
+  let current = "";
+  let quote;
+  for (const ch of text) {
+    if (quote !== undefined) {
+      current += ch;
+      if (closesQuote(ch, quote))
+        quote = undefined;
+      continue;
+    }
+    if (SEGMENT_QUOTES.has(ch)) {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ",") {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts;
+};
+var xrefArguments = (text) => {
+  const open = text.indexOf(XREF_OPEN);
+  if (open === -1)
+    return [];
+  const close = callCloseIndex(text, open);
+  if (close === -1)
+    return [];
+  return splitCallArguments(text.slice(open + XREF_OPEN.length, close)).map((part) => {
+    let value = part.trim();
+    while (value.length > 0 && SEGMENT_QUOTES.has(value[0])) {
+      value = value.slice(1);
+    }
+    while (value.length > 0 && SEGMENT_QUOTES.has(value.at(-1) ?? "")) {
+      value = value.slice(0, -1);
+    }
+    return value.trim();
+  }).filter((part) => part !== "");
+};
+var producerSegments = (raw) => {
+  if (raw.includes(XREF_OPEN))
+    return xrefArguments(raw);
+  if (raw.startsWith(PRODUCER_ARROW)) {
+    return dottedSegments(raw.slice(PRODUCER_ARROW.length).trim());
+  }
+  return [];
+};
+var readProducer = (raw) => {
+  const segments = producerSegments(raw);
+  if (segments.length !== 3)
+    return;
+  const [stage, task, output] = segments;
+  return stage && task && output ? { stage, task, output } : undefined;
+};
+var xrefProducers = (text) => {
+  const found = [];
+  const seen = new Set;
+  let cursor = 0;
+  while (cursor < text.length) {
+    const at = text.indexOf(XREF_OPEN, cursor);
+    if (at === -1)
+      break;
+    const close = callCloseIndex(text, at);
+    if (close === -1)
+      break;
+    const args = xrefArguments(text.slice(at, close + 1));
+    if (args.length === 3) {
+      const key = `${norm(args[0])}|${norm(args[1])}|${norm(args[2])}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        found.push({ stage: args[0], task: args[1], output: args[2] });
+      }
+    }
+    cursor = close + 1;
+  }
+  return found;
+};
+var detailProducerInputs = (block) => {
+  const inputs = [];
+  for (const sub of afterAnyLabel(block, INPUT_LABELS)) {
+    const { header, rows } = firstTable(sub);
+    const nameAt = columnIndex(header, "Name", "Input", "Field");
+    const valueAt = columnIndex(header, "Binding / Value", "Binding", "Value");
+    if (nameAt === undefined || valueAt === undefined)
+      continue;
+    for (const row of rows) {
+      const name = stripTicks(cellAt(row, nameAt).trim());
+      const raw = unwrapCodeSpan(cellAt(row, valueAt));
+      if (!name || isBlank(name) || isBlank(raw))
+        continue;
+      const producer = readProducer(raw);
+      if (producer !== undefined) {
+        inputs.push({
+          name,
+          producer,
+          direct: raw.trimStart().startsWith(PRODUCER_ARROW)
+        });
+      }
+    }
+  }
+  return inputs;
+};
+var detailOutputRows = (block) => {
+  const names = [];
+  for (const sub of afterAnyLabel(block, OUTPUT_LABELS)) {
+    const { header, rows } = firstTable(sub);
+    const nameAt = columnIndex(header, "Field", "Name", "Output");
+    if (nameAt === undefined)
+      continue;
+    for (const row of rows) {
+      const name = stripTicks(cellAt(row, nameAt).trim());
+      if (!name || isBlank(name))
+        continue;
+      if (!names.includes(name))
+        names.push(name);
+    }
+  }
+  return names;
+};
+var SLA_STATUS_AT_RISK = new Set(["at risk", "atrisk", "at risk warning"]);
+var SLA_STATUS_BREACH = new Set(["breached", "breach"]);
+var slaEscalationsOf = (block) => {
+  const { header, rows } = firstTable(block);
+  const atRiskAt = columnIndex(header, "At-Risk Action", "At Risk Action");
+  const breachAt = columnIndex(header, "Breach Action", "Breached Action");
+  const declaredColumn = (at) => at !== undefined && rows.some((row) => {
+    const cell = stripTicks(cellAt(row, at).trim());
+    return cell !== "" && !isBlank(cell);
+  });
+  let atRisk = declaredColumn(atRiskAt);
+  let breach = declaredColumn(breachAt);
+  const statusAt = columnIndex(header, "SLA Status", "Status");
+  const actionAt = columnIndex(header, "Action", "Escalation Action", "Response");
+  if (statusAt === undefined || actionAt === undefined) {
+    return { atRisk, breach };
+  }
+  for (const row of rows) {
+    const action = stripTicks(cellAt(row, actionAt).trim());
+    if (action === "" || isBlank(action))
+      continue;
+    const status = norm(stripTicks(cellAt(row, statusAt)));
+    if (SLA_STATUS_AT_RISK.has(status))
+      atRisk = true;
+    else if (SLA_STATUS_BREACH.has(status))
+      breach = true;
+  }
+  return { atRisk, breach };
+};
+var detailExtractRows = (block) => {
+  const rows = [];
+  for (const sub of afterAnyLabel(block, OUTPUT_LABELS)) {
+    const { header, rows: tableRows } = firstTable(sub);
+    const fieldAt = columnIndex(header, "Field", "Name", "Output");
+    const bindingAt = columnIndex(header, "Binding / Value", "Binding", "Value");
+    if (fieldAt === undefined || bindingAt === undefined)
+      continue;
+    for (const row of tableRows) {
+      const field2 = stripTicks(cellAt(row, fieldAt).trim());
+      const binding = unwrapCodeSpan(cellAt(row, bindingAt));
+      if (!field2 || isBlank(field2) || !binding.startsWith("->"))
+        continue;
+      const variable = binding.slice(2).trim();
+      if (!variable || isBlank(variable))
+        continue;
+      rows.push({ field: field2, variable });
+    }
+  }
+  return rows;
+};
+var detailCustomRows = (block) => {
+  const rows = [];
+  for (const sub of afterAnyLabel(block, OUTPUT_LABELS)) {
+    const { header, rows: tableRows } = firstTable(sub);
+    const bindingAt = columnIndex(header, "Binding / Value", "Binding", "Value");
+    if (bindingAt === undefined)
+      continue;
+    for (const row of tableRows) {
+      const binding = unwrapCodeSpan(cellAt(row, bindingAt));
+      const at = binding.indexOf("=");
+      if (at <= 0)
+        continue;
+      const variable = binding.slice(0, at).trim();
+      const expression = binding.slice(at + 1).trim();
+      if (!isIdentifier(variable))
+        continue;
+      if (!expression || isBlank(expression))
+        continue;
+      rows.push({ variable, expression });
+    }
+  }
+  return rows;
+};
+var timerFields = (block) => {
+  const declared = stripTicks(field(block, "Timer") ?? "");
+  if (!declared || isBlank(declared))
+    return {};
+  if (TIMER_VALUE_FIELDS.has(norm(declared).replaceAll(" ", ""))) {
+    const value2 = stripTicks(field(block, "Value") ?? "");
+    return {
+      timerType: declared,
+      ...value2 && !isBlank(value2) && { timerValue: value2 }
+    };
+  }
+  const configured = stripTicks(field(block, "Timer Configuration") ?? "");
+  const asType = TIMER_CONFIGURATION_TYPES.get(norm(configured));
+  if (asType === undefined)
+    return {};
+  const value = stripTicks(field(block, "Value") ?? "");
+  return {
+    timerType: asType,
+    ...value && !isBlank(value) && { timerValue: value }
+  };
+};
+var readTaskDetail = (block) => {
+  const identity = [
+    field(block, "Resource Identity"),
+    field(block, "Folder Path"),
+    field(block, "Connection ID"),
+    field(block, "Activity Type ID")
+  ].filter((value) => !!value && !isBlank(value));
+  return {
+    type: stripTicks(field(block, "Type") ?? ""),
+    resolvedResource: field(block, "Resolved Resource"),
+    identityResolved: identity.length > 0 && !identity.some(hasUnresolvedMarker),
+    folder: field(block, "Deployment Folder") ?? field(block, "Folder Path"),
+    proseLabel: firstProseLabel(block, "Description", "Design Rationale"),
+    entryRows: detailEntryRows(block),
+    entryConditions: entryConditionBlocks(block).flatMap(conditionRows),
+    expressionInputs: detailExpressionInputs(block),
+    producerInputs: detailProducerInputs(block),
+    outputRows: detailOutputRows(block),
+    literalInputs: detailLiteralInputs(block),
+    boundInputs: detailBoundInputs(block),
+    extractRows: detailExtractRows(block),
+    customRows: detailCustomRows(block),
+    ...timerFields(block)
+  };
+};
+var yesNoCell = (cell) => {
+  const value = norm(stripTicks(cell.trim()));
+  if (value === "yes" || value === "true")
+    return true;
+  if (value === "no" || value === "false")
+    return false;
+  return;
+};
+var conditionRows = (block) => {
+  const { header, rows } = firstTable(block);
+  const nameAt = columnIndex(header, "Display Name", "Name");
+  const ifAt = columnIndex(header, "IF", "Condition");
+  if (nameAt === undefined)
+    return [];
+  const whenAt = columnIndex(header, "WHEN", "When", "Rule");
+  const exitAt = columnIndex(header, "Exit Type");
+  const interruptAt = columnIndex(header, "Interrupting");
+  const marksAt = columnIndex(header, "Marks Stage Complete", "Marks");
+  const declared = (row, at) => {
+    if (at === undefined)
+      return "";
+    const text = unwrapCodeSpan(cellAt(row, at));
+    return isBlank(text) ? "" : text;
+  };
+  const conditions = [];
+  for (const row of rows) {
+    const displayName = unwrapCodeSpan(cellAt(row, nameAt));
+    if (!displayName || isBlank(displayName))
+      continue;
+    const raw = ifAt === undefined ? "" : unwrapCodeSpan(cellAt(row, ifAt));
+    const when = declared(row, whenAt);
+    const exitType = declared(row, exitAt);
+    conditions.push({
+      displayName,
+      ifExpression: raw !== "" && !isBlank(raw) ? raw : undefined,
+      ...ifAt !== undefined && (raw === "" || isBlank(raw)) && { ungated: true },
+      ...when !== "" && { when },
+      ...exitType !== "" && { exitType },
+      ...interruptAt !== undefined && {
+        interrupting: yesNoCell(cellAt(row, interruptAt))
+      },
+      ...marksAt !== undefined && {
+        marksComplete: yesNoCell(cellAt(row, marksAt))
+      }
+    });
+  }
+  return conditions;
+};
+var readTaskRows = (title, block, notes) => {
+  const { header, rows } = firstTable(block);
+  const wanted = ["Task Name", "Task", "Name"];
+  const nameAt = columnIndex(header, ...wanted);
+  if (rows.length > 0 && nameAt === undefined) {
+    notes.push(noNameColumnNote(title, wanted, header));
+  }
+  const typeAt = columnIndex(header, "Type", "Task Type");
+  const requiredAt = columnIndex(header, "Required");
+  const runOnceAt = columnIndex(header, "Run Only Once", "Run Once");
+  const tasks = [];
+  for (const row of rows) {
+    const taskName = cellAt(row, nameAt);
+    if (!taskName || isBlank(taskName))
+      continue;
+    tasks.push({
+      name: stripTicks(taskName.trim()),
+      type: stripTicks(cellAt(row, typeAt).trim()),
+      required: yesNoCell(cellAt(row, requiredAt)),
+      runOnlyOnce: yesNoCell(cellAt(row, runOnceAt)),
+      expressionInputs: [],
+      producerInputs: [],
+      outputRows: [],
+      literalInputs: [],
+      boundInputs: [],
+      entryConditions: [],
+      extractRows: [],
+      customRows: [],
+      identityResolved: false,
+      entryRows: 0
+    });
+  }
+  return tasks;
+};
+var applyStageSection = (stage, title, block, notes) => {
+  if (headingIs(title, STAGE_ENTRY_HEADINGS)) {
+    stage.entryRows = firstTable(block).rows.length;
+    stage.entryConditions = conditionRows(block);
+  } else if (headingIs(title, STAGE_EXIT_HEADINGS)) {
+    stage.exitRows = firstTable(block).rows.length;
+    stage.exitConditions = conditionRows(block);
+  } else if (headingIs(title, STAGE_CONDITIONAL_SLA_HEADINGS)) {
+    stage.conditionalSlas = conditionalSlaRows(block);
+  } else if (headingIs(title, STAGE_SLA_HEADINGS)) {
+    stage.hasSla = firstTable(block).rows.length > 0;
+    stage.slaEscalations = slaEscalationsOf(block);
+  } else if (headingIs(title, STAGE_TASK_HEADINGS)) {
+    stage.tasks.push(...readTaskRows(title, block, notes));
+  } else {
+    return false;
+  }
+  return true;
+};
+var conditionalSlaRows = (block) => {
+  const { header, rows } = firstTable(block);
+  const expressionAt = columnIndex(header, "Expression", "Condition");
+  const slaAt = columnIndex(header, "SLA", "Duration");
+  const unitAt = columnIndex(header, "Unit");
+  if (expressionAt === undefined || slaAt === undefined)
+    return [];
+  const found = [];
+  const nameAt = columnIndex(header, "Display Name", "Title");
+  for (const row of rows) {
+    const expression = (row[expressionAt] ?? "").trim();
+    if (expression === "" || expression.startsWith("<"))
+      continue;
+    const count = (row[slaAt] ?? "").trim();
+    const unit = unitAt === undefined ? "" : (row[unitAt] ?? "").trim();
+    const displayName = nameAt === undefined ? undefined : (row[nameAt] ?? "").trim();
+    found.push({
+      expression,
+      duration: unit === "" ? count : `${count} ${unit}`,
+      ...displayName !== undefined && displayName !== "" && { displayName }
+    });
+  }
+  return found;
+};
+var parseStage = (name, body, notes) => {
+  const stage = {
+    conditionalSlas: [],
+    name: name.trim(),
+    tasks: [],
+    entryConditions: [],
+    exitConditions: [],
+    entryRows: 0,
+    exitRows: 0,
+    hasSla: false,
+    slaEscalations: { atRisk: false, breach: false }
+  };
+  const details = new Map;
+  const annotated = [];
+  const stageNotes = [];
+  const lookalikes = [];
+  for (const { title, body: block, level } of sectionBlocks(body)) {
+    if (level === 4) {
+      if (applyStageSection(stage, title, block, stageNotes))
+        continue;
+      const topic = topicOf(title);
+      if (topic === "conditions" || topic === "sla" || topic === "tasks") {
+        lookalikes.push([title, topic]);
+      }
+      continue;
+    }
+    if (level !== 5)
+      continue;
+    const detailName = readTaskHeading(title);
+    if (detailName !== undefined) {
+      const detail = readTaskDetail(block);
+      details.set(norm(detailName), detail);
+      annotated.push({
+        loose: normAnnotationless(detailName),
+        detail
+      });
+    }
+  }
+  for (const task of stage.tasks) {
+    let detail = details.get(norm(task.name));
+    if (detail === undefined) {
+      const loose = normAnnotationless(task.name);
+      const hits = annotated.filter((entry) => entry.loose === loose);
+      if (hits.length === 1)
+        detail = hits[0].detail;
+    }
+    if (!detail)
+      continue;
+    task.expressionInputs = detail.expressionInputs;
+    task.producerInputs = detail.producerInputs;
+    task.outputRows = detail.outputRows;
+    task.literalInputs = detail.literalInputs;
+    task.boundInputs = detail.boundInputs;
+    task.extractRows = detail.extractRows;
+    task.customRows = detail.customRows;
+    task.resolvedResource = detail.resolvedResource;
+    task.identityResolved = detail.identityResolved;
+    task.folder = detail.folder;
+    task.proseLabel = detail.proseLabel;
+    task.entryRows = detail.entryRows;
+    task.entryConditions = detail.entryConditions;
+    task.timerType = detail.timerType;
+    task.timerValue = detail.timerValue;
+    if (!task.type && detail.type)
+      task.type = detail.type;
+  }
+  const empty = {
+    conditions: !(stage.entryRows && stage.exitRows),
+    sla: !stage.hasSla,
+    tasks: stage.tasks.length === 0
+  };
+  for (const [title, topic] of lookalikes) {
+    if (empty[topic])
+      stageNotes.push(unrecognizedHeadingNote(title, 4));
+  }
+  if (details.size > 0 && stage.tasks.length === 0 && stageNotes.length === 0) {
+    stageNotes.push(`${details.size} \`Task <n>.<m>:\` detail section(s) but no task ` + "row parsed — the `#### Tasks` table is missing or has no Task " + "Name column, so none of its tasks are audited");
+  }
+  notes.push(...stageNotes.map((note) => `stage "${stage.name}": ${note}`));
+  return stage;
+};
+var applyCaseSection = (sdd, title, body) => {
+  if (headingIs(title, CASE_EXIT_HEADINGS)) {
+    sdd.caseExitRows = firstTable(body).rows.length;
+    sdd.caseExitConditions = conditionRows(body);
+  } else if (headingIs(title, CASE_TRIGGER_HEADINGS)) {
+    sdd.triggers = firstTable(body).rows.length;
+  } else if (headingIs(title, CASE_CONDITIONAL_SLA_HEADINGS)) {
+    sdd.caseConditionalSlas = conditionalSlaRows(body);
+  } else if (headingIs(title, CASE_SLA_HEADINGS)) {
+    sdd.caseSla = firstTable(body).rows.length > 0;
+    sdd.caseSlaEscalations = slaEscalationsOf(body);
+  } else if (headingIs(title, CASE_METADATA_HEADINGS)) {
+    const { header, rows } = firstTable(body);
+    const propertyAt = columnIndex(header, "Property", "Field", "Name");
+    const valueAt = columnIndex(header, "Value");
+    if (propertyAt !== undefined && valueAt !== undefined) {
+      for (const row of rows) {
+        if (norm(cellAt(row, propertyAt)) !== norm(CASE_SLA_PROPERTY)) {
+          continue;
+        }
+        const value = stripTicks(cellAt(row, valueAt));
+        if (!isBlank(value))
+          sdd.caseSlaDuration = value;
+      }
+    }
+  } else if (headingIs(title, CASE_VARIABLE_HEADINGS)) {
+    sdd.sawVariableSection = true;
+    const { header, rows } = firstTable(body);
+    const wanted = ["Name", "Variable", "Variable Name"];
+    const nameAt = columnIndex(header, ...wanted);
+    const categoryAt = columnIndex(header, "Category");
+    const defaultAt = columnIndex(header, "Default");
+    if (rows.length > 0 && nameAt === undefined) {
+      sdd.parseNotes.push(noNameColumnNote(title, wanted, header));
+    } else if (rows.length > 0 && categoryAt === undefined) {
+      sdd.parseNotes.push(noCategoryColumnNote(title, header));
+    }
+    for (const row of rows) {
+      const name = cellAt(row, nameAt);
+      if (name && !isBlank(name)) {
+        sdd.variables.push(stripTicks(name.trim()));
+        const category = norm(cellAt(row, categoryAt));
+        if (VARIABLE_PLACEMENT.has(category)) {
+          sdd.variableCategories.set(norm(name), category);
+        }
+        const cell = cellAt(row, defaultAt).trim();
+        const declared = trimQuotes(stripTicks(cell));
+        if (cell !== "" && !DEFAULT_UNFILLED.has(declared.toLowerCase()) && !DEFAULT_UNFILLED.has(cell.toLowerCase())) {
+          sdd.variableDefaults.set(norm(name), declared);
+        }
+      }
+    }
+  } else {
+    return false;
+  }
+  return true;
+};
+var parseSdd = (text) => {
+  const sdd = {
+    stages: [],
+    caseExitConditions: [],
+    caseExitRows: 0,
+    triggers: 0,
+    variables: [],
+    sawVariableSection: false,
+    variableCategories: new Map,
+    variableDefaults: new Map,
+    caseSla: false,
+    caseSlaEscalations: { atRisk: false, breach: false },
+    caseConditionalSlas: [],
+    xrefOutputs: xrefProducers(text),
+    parseNotes: []
+  };
+  const lookalikes = [];
+  for (const { level, title, body } of sectionBlocks(text)) {
+    if (level !== 3)
+      continue;
+    if (applyCaseSection(sdd, title, body))
+      continue;
+    const stageName = readStageHeading(title);
+    if (stageName !== undefined) {
+      sdd.stages.push(parseStage(stageName, body, sdd.parseNotes));
+      continue;
+    }
+    const topic = topicOf(title);
+    if (topic === "conditions" || topic === "variables" || topic === "triggers" || topic === "sla") {
+      lookalikes.push([title, topic]);
+    }
+  }
+  const empty = {
+    conditions: !sdd.caseExitRows,
+    variables: sdd.variables.length === 0,
+    triggers: !sdd.triggers,
+    sla: !sdd.caseSla
+  };
+  for (const [title, topic] of lookalikes) {
+    if (empty[topic])
+      sdd.parseNotes.push(unrecognizedHeadingNote(title, 3));
+  }
+  return sdd;
+};
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var addressedByVar = (output) => output.custom === true;
+var bindingId = (expression) => {
+  if (typeof expression !== "string")
+    return;
+  const text = expression.trim();
+  const prefix = "=bindings.";
+  if (!text.startsWith(prefix))
+    return;
+  const id = text.slice(prefix.length);
+  const isWordChar2 = (ch) => isDigit(ch) || ch === "_" || isLowerLetter(ch.toLowerCase());
+  return id !== "" && [...id].every(isWordChar2) ? id : undefined;
+};
+var bindingDefault = (bindings, expression) => {
+  const id = bindingId(expression);
+  if (id === undefined)
+    return;
+  const binding = bindings.find((b) => b.id === id);
+  const value = binding?.default;
+  return typeof value === "string" ? value : undefined;
+};
+var readPlanTasks = (data, bindings) => {
+  const tasks = [];
+  for (const lane of asArray(data.tasks)) {
+    for (const task of asArray(lane)) {
+      const record = asRecord(task);
+      if (!record)
+        continue;
+      const taskData = asRecord(record.data) ?? {};
+      const name = (typeof record.displayName === "string" ? record.displayName : undefined) ?? (typeof record.label === "string" ? record.label : undefined) ?? bindingDefault(bindings, taskData.name);
+      tasks.push({
+        name,
+        id: typeof record.id === "string" ? record.id : undefined,
+        type: typeof record.type === "string" ? record.type : undefined,
+        isRequired: record.isRequired,
+        shouldRunOnlyOnce: record.shouldRunOnlyOnce,
+        description: record.description,
+        entry: asArray(record.entryConditions),
+        data: taskData
+      });
+    }
+  }
+  return tasks;
+};
+var readPlanVariables = (doc) => {
+  const variablesDoc = asRecord(doc.variables) ?? {};
+  const variables = [];
+  const variableGroups = {};
+  const variableEntries = {};
+  for (const group of VARIABLE_GROUPS) {
+    const names = [];
+    const entries = new Map;
+    for (const entry of asArray(variablesDoc[group])) {
+      const record = asRecord(entry);
+      if (record === undefined)
+        continue;
+      const name = record.name;
+      if (typeof name !== "string")
+        continue;
+      names.push(name);
+      if (!entries.has(norm(name)))
+        entries.set(norm(name), record);
+    }
+    variableGroups[group] = new Set(names.map(norm));
+    variableEntries[group] = entries;
+    variables.push(...names);
+  }
+  return { variables, variableGroups, variableEntries };
+};
+var parseCaseplan = (doc) => {
+  const bindings = asArray(doc.bindings).map(asRecord).filter((b) => b !== undefined);
+  const metadata = asRecord(doc.metadata) ?? {};
+  const plan = {
+    stages: [],
+    triggers: 0,
+    ...readPlanVariables(doc),
+    bindings,
+    caseExitConditions: asArray(metadata.caseExitRules),
+    caseSla: asArray(metadata.slaRules).length > 0,
+    caseSlaRules: asArray(metadata.slaRules)
+  };
+  for (const node of asArray(doc.nodes)) {
+    const record = asRecord(node);
+    if (!record)
+      continue;
+    const typed = record;
+    if (isAnyTriggerNode(typed)) {
+      plan.triggers += 1;
+      continue;
+    }
+    if (!isStageNode(typed))
+      continue;
+    const data = asRecord(record.data) ?? {};
+    plan.stages.push({
+      name: (typeof data.label === "string" ? data.label : undefined) ?? (typeof data.displayName === "string" ? data.displayName : undefined),
+      id: typeof record.id === "string" ? record.id : undefined,
+      tasks: readPlanTasks(data, bindings),
+      entry: asArray(data.entryConditions),
+      exit: asArray(data.exitConditions),
+      sla: asArray(data.slaRules)
+    });
+  }
+  return plan;
+};
+var resolveTasks = (sddTasks, planTasks) => {
+  const bound = sddTasks.map(() => {
+    return;
+  });
+  const taken = new Set;
+  const free = (predicate) => planTasks.map((t, i) => ({ t, i })).filter(({ t, i }) => !taken.has(i) && predicate(t)).map(({ i }) => i);
+  const bind = (row, index) => {
+    bound[row] = index;
+    taken.add(index);
+  };
+  sddTasks.forEach((task, row) => {
+    const hits = free((t) => (t.name ?? "") === task.name);
+    if (hits.length > 0)
+      bind(row, hits[0]);
+  });
+  const ambiguous = new Set;
+  sddTasks.forEach((task, row) => {
+    if (bound[row] !== undefined)
+      return;
+    const key = norm(task.name);
+    const hits = free((t) => norm(t.name) === key);
+    if (hits.length === 1)
+      bind(row, hits[0]);
+    else if (hits.length > 1)
+      ambiguous.add(row);
+  });
+  sddTasks.forEach((task, row) => {
+    if (bound[row] !== undefined || ambiguous.has(row))
+      return;
+    const loose = normAnnotationless(task.name);
+    const hits = free((t) => normAnnotationless(t.name) === loose);
+    if (hits.length === 1)
+      bind(row, hits[0]);
+  });
+  sddTasks.forEach((task, row) => {
+    if (bound[row] !== undefined || ambiguous.has(row))
+      return;
+    const key = `${norm(task.name)} `;
+    const hits = free((t) => norm(t.name).startsWith(key));
+    if (hits.length === 1)
+      bind(row, hits[0]);
+  });
+  return bound;
+};
+var ruleTotal = (conditions) => {
+  let total = 0;
+  for (const condition of conditions) {
+    for (const group of asArray(asRecord(condition)?.rules)) {
+      total += asArray(group).length;
+    }
+  }
+  return total;
+};
+var error = (code, path, message) => ({ code, path, message, severity: "error" });
+var warning = (code, path, message) => ({ code, path, message, severity: "warning" });
+var coverageFinding = (path, label, kind, rows, conditions) => {
+  if (!rows)
+    return [];
+  const total = ruleTotal(conditions);
+  if (total >= rows)
+    return [];
+  return [
+    error("STRICT_SDD_CONDITION_MISSING", path, total === 0 ? `${label}: the SDD declares ${rows} ${kind} condition row(s), the caseplan has no ${kind} rules.` : `${label}: the SDD declares ${rows} ${kind} condition row(s), the caseplan keeps ${total} ${kind} rule(s) — rows may group into fewer conditions, never into fewer rules.`)
+  ];
+};
+var OPEN_QUOTES = new Set(['"', "“", "‘", "'"]);
+var CLOSE_QUOTES = new Set(['"', "”", "’", "'"]);
+var quotedArgs = (argumentList) => {
+  const args = [];
+  let at = 0;
+  while (at < argumentList.length) {
+    if (!OPEN_QUOTES.has(argumentList[at])) {
+      at += 1;
+      continue;
+    }
+    const from = at + 1;
+    let end = from;
+    while (end < argumentList.length && !CLOSE_QUOTES.has(argumentList[end])) {
+      end += 1;
+    }
+    if (end >= argumentList.length)
+      break;
+    if (end > from)
+      args.push(argumentList.slice(from, end));
+    at = end + 1;
+  }
+  return args;
+};
+var findSlaCalls = (text) => {
+  const calls = [];
+  const name = "sla-status-change";
+  text.split(`
+`).forEach((line, index) => {
+    const lower = line.toLowerCase();
+    let found = lower.indexOf(name);
+    while (found !== -1) {
+      const after = found + name.length;
+      found = lower.indexOf(name, after);
+      let open = after;
+      while (open < line.length && (line[open] === " " || line[open] === "\t")) {
+        open += 1;
+      }
+      if (!line.startsWith("(", open))
+        continue;
+      const close = callCloseIndex(line, open);
+      if (close === -1)
+        continue;
+      const args = quotedArgs(line.slice(open + 1, close));
+      if (args.length > 0)
+        calls.push({ line: index + 1, args });
+    }
+  });
+  return calls;
+};
+var slaReferenceFindings = (text, source) => {
+  const findings = [];
+  for (const call of findSlaCalls(text)) {
+    const at = `${source}:${call.line}`;
+    if (call.args.length !== 2 && call.args.length !== 3) {
+      findings.push(error("STRICT_SDD_SLA_REFERENCE_ARITY", at, `sla-status-change needs 2 quoted args (breach) or 3 (at-risk); got ${call.args.length}.`));
+    }
+    if (call.args[0].trim().toLowerCase() === "case") {
+      findings.push(error("STRICT_SDD_SLA_REFERENCE_TARGET", at, 'sla-status-change target "Case" — the case-level target is the literal "root".'));
+    }
+  }
+  return findings;
+};
+var folderFindings = (binding, declared, path, label) => {
+  const actual = binding.default;
+  if (typeof actual !== "string" || isBlank(actual))
+    return [];
+  if (comparableFolder(actual) === comparableFolder(declared))
+    return [];
+  const kind = GUID.test(actual.trim()) ? "that is a folder key, not a folder path — the pair resolves by path, so a key resolves nowhere off the machine that wrote it" : "that is a different folder, so the resource resolves in the wrong scope or not at all";
+  return [
+    error("STRICT_SDD_BINDING_FOLDER_MISMATCH", path, `${label}: binding "${String(binding.id)}" defaults its folderPath to "${actual}", and the SDD declares "${declared}" for this task — ${kind}. Set the binding's default from the SDD row.`)
+  ];
+};
+var GUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var trimSlashes = (text) => {
+  let start = 0;
+  let end = text.length;
+  while (start < end && text[start] === "/") {
+    start += 1;
+  }
+  while (end > start && text[end - 1] === "/") {
+    end -= 1;
+  }
+  return text.slice(start, end);
+};
+var comparableFolder = (text) => trimSlashes(text.trim()).toLowerCase();
+var bindingFindings = (plan, task, path, label, declaredFolder) => {
+  const findings = [];
+  for (const attribute of ["name", "folderPath"]) {
+    const id = bindingId(task.data[attribute]);
+    if (id === undefined)
+      continue;
+    const binding = plan.bindings.find((b) => b.id === id);
+    if (!binding)
+      continue;
+    if (attribute === "folderPath" && declaredFolder !== undefined) {
+      findings.push(...folderFindings(binding, declaredFolder, path, label));
+    }
+    const key = binding.resourceKey;
+    if (typeof key === "string" && key !== "" && !key.split("/").at(-1)?.includes(".")) {
+      findings.push(error("STRICT_SDD_BINDING_RESOURCE_KEY", path, `${label}: binding "${String(binding.id)}" has a bare resourceKey "${key}" — it needs the \`.<entry name>\` leaf suffix.`));
+    }
+    if (task.type === "api-workflow" && !binding.resourceSubType) {
+      findings.push(error("STRICT_SDD_BINDING_RESOURCE_KEY", path, `${label}: api-workflow binding "${String(binding.id)}" is missing \`resourceSubType: "Api"\`.`));
+    }
+  }
+  return findings;
+};
+var parsesAsJson = (text) => catchError(() => JSON.parse(text))[0] === undefined;
+var sameLiteral = (declared, actual) => {
+  if (declared === actual)
+    return true;
+  const parse = (text) => catchError(() => JSON.parse(text))[1];
+  const canonical = (value) => {
+    if (Array.isArray(value)) {
+      return `[${value.map(canonical).join(",")}]`;
+    }
+    const record = asRecord(value);
+    if (record) {
+      return `{${Object.keys(record).sort((a2, b2) => a2.localeCompare(b2)).map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+  };
+  const a = parse(declared);
+  const b = parse(actual);
+  if (a === undefined && b === undefined) {
+    return trimQuotes(declared) === trimQuotes(actual);
+  }
+  if (a === undefined || b === undefined) {
+    const parsed = a ?? b;
+    const structural = Array.isArray(parsed) || asRecord(parsed) !== undefined;
+    return structural ? false : trimQuotes(declared) === trimQuotes(actual);
+  }
+  if (typeof a === "string" || typeof b === "string") {
+    const left = typeof a === "string" ? a : declared;
+    const right = typeof b === "string" ? b : actual;
+    if (left === right)
+      return true;
+  }
+  return canonical(a) === canonical(b);
+};
+var WHITESPACE = new Set([" ", "\t", `
+`, "\r"]);
+var withoutWhitespace = (text) => {
+  let out = "";
+  for (const ch of text) {
+    if (!WHITESPACE.has(ch))
+      out += ch;
+  }
+  return out;
+};
+var VARS_PREFIX = "vars.";
+var XREF_CALL_PREFIX = "$xref(";
+var VARIABLE_PLACEHOLDER = `${VARS_PREFIX}@`;
+var isReferenceChar = (ch) => ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9" || ch === "_";
+var withCollapsedReferences = (text) => {
+  let out = "";
+  let index = 0;
+  while (index < text.length) {
+    if (!text.startsWith(VARS_PREFIX, index)) {
+      out += text[index];
+      index += 1;
+      continue;
+    }
+    out += VARIABLE_PLACEHOLDER;
+    index += VARS_PREFIX.length;
+    if (text.startsWith(XREF_CALL_PREFIX, index)) {
+      const close = callCloseIndex(text, index);
+      index = close === -1 ? text.length : close + 1;
+      continue;
+    }
+    while (index < text.length && isReferenceChar(text[index])) {
+      index += 1;
+    }
+  }
+  return out;
+};
+var withoutJsPrefix = (text) => text.startsWith("=js:") ? `=${text.slice("=js:".length)}` : text;
+var withoutWrappingParens = (text) => {
+  let current = text;
+  for (;; ) {
+    if (!current.startsWith("(") || !current.endsWith(")"))
+      return current;
+    let depth = 0;
+    for (let index = 0;index < current.length; index += 1) {
+      const ch = current[index];
+      if (ch === "(")
+        depth += 1;
+      else if (ch === ")")
+        depth -= 1;
+      if (depth === 0 && index < current.length - 1)
+        return current;
+    }
+    current = current.slice(1, -1);
+  }
+};
+var normalizeExpression = (text) => {
+  const bare = withoutWhitespace(withoutJsPrefix(text.trim())).replaceAll("'", '"').toLowerCase();
+  const body = bare.startsWith("=") ? bare.slice(1) : bare;
+  const unwrapped = withoutWrappingParens(body);
+  return withCollapsedReferences(bare.startsWith("=") ? `=${unwrapped}` : unwrapped);
+};
+var wiringFindings = (task, found, path, label) => {
+  const findings = [];
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  for (const declared of task.expressionInputs) {
+    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    if (!input)
+      continue;
+    const actual = input.value;
+    if (typeof actual !== "string" || actual === "")
+      continue;
+    if (!actual.startsWith("="))
+      continue;
+    if (normalizeExpression(actual) === normalizeExpression(declared.expression)) {
+      continue;
+    }
+    findings.push(error("STRICT_SDD_INPUT_FORM_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" is wired differently from the SDD's Inputs row for it. Re-read that row: a dropped conversion (a bare reference where the SDD wraps it) passes the wrong type and nothing else reports it.`));
+  }
+  return findings;
+};
+var referenceTokensIn = (text) => {
+  const prefix = "vars.";
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    if (!text.startsWith(prefix, index)) {
+      index += 1;
+      continue;
+    }
+    index += prefix.length;
+    let token = "";
+    while (index < text.length && isReferenceToken(text[index])) {
+      token += text[index];
+      index += 1;
+    }
+    if (token !== "")
+      tokens.push(token);
+  }
+  return tokens;
+};
+var isReferenceToken = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+var planOutputFor = (plan, producer) => {
+  for (const stage of plan.stages) {
+    if (norm(stage.name) !== norm(producer.stage))
+      continue;
+    for (const planTask of stage.tasks) {
+      if (norm(planTask.name) !== norm(producer.task))
+        continue;
+      for (const entry of asArray(planTask.data.outputs)) {
+        const output = asRecord(entry);
+        if (output === undefined)
+          continue;
+        for (const label of [output.name, output.var]) {
+          if (typeof label === "string" && norm(label) === norm(producer.output)) {
+            return output;
+          }
+        }
+      }
+    }
+  }
+  return;
+};
+var planHasTask = (plan, producer) => plan.stages.some((stage) => norm(stage.name) === norm(producer.stage) && stage.tasks.some((planTask) => norm(planTask.name) === norm(producer.task)));
+var xrefOutputFindings = (sdd, plan) => {
+  const findings = [];
+  for (const producer of sdd.xrefOutputs) {
+    if (!planHasTask(plan, producer))
+      continue;
+    const output = planOutputFor(plan, producer);
+    const path = `nodes[${producer.stage}].data.tasks[${producer.task}].data.outputs`;
+    if (output === undefined) {
+      findings.push(error("STRICT_SDD_OUTPUT_ROW_MISSING", path, `${producer.task}: the SDD references "${producer.output}" as an output of this task, and the task exposes no output with that name. Every reference to it reads nothing.`));
+      continue;
+    }
+    if (addressedByVar(output))
+      continue;
+    const id = output.id;
+    if (typeof id !== "string" || id.trim() === "") {
+      findings.push(error("STRICT_SDD_OUTPUT_ROW_MISSING", `${path}[${producer.output}].id`, `${producer.task}: output "${producer.output}" is referenced by the SDD and carries no id. Nothing can address it, so the references resolve to nothing.`));
+    }
+  }
+  return findings;
+};
+var outputIds = (plan) => {
+  const ids = new Set;
+  for (const stage of plan.stages) {
+    for (const planTask of stage.tasks) {
+      for (const entry of asArray(planTask.data.outputs)) {
+        const id = asRecord(entry)?.id;
+        if (typeof id === "string" && id !== "")
+          ids.add(id);
+      }
+    }
+  }
+  return ids;
+};
+var producerIndex = (plan) => {
+  const index = new Map;
+  const ids = outputIds(plan);
+  for (const stage of plan.stages) {
+    for (const planTask of stage.tasks) {
+      for (const entry of asArray(planTask.data.outputs)) {
+        const output = asRecord(entry);
+        if (output === undefined)
+          continue;
+        const own = output.id;
+        const tokens = new Set;
+        for (const attribute of ["id", "name", "var"]) {
+          const value = output[attribute];
+          if (typeof value !== "string" || value === "")
+            continue;
+          if (attribute !== "id" && value !== own && ids.has(value)) {
+            continue;
+          }
+          tokens.add(value);
+        }
+        if (tokens.size === 0)
+          continue;
+        for (const label of [output.name, output.var]) {
+          if (typeof label !== "string" || label === "")
+            continue;
+          const key = `${norm(stage.name)}|${norm(planTask.name)}|${norm(label)}`;
+          const bucket = index.get(key);
+          if (bucket === undefined)
+            index.set(key, [tokens]);
+          else if (!bucket.includes(tokens))
+            bucket.push(tokens);
+        }
+      }
+    }
+  }
+  return index;
+};
+var AUDIT_CONNECTOR_TASK_TYPES = new Set([
+  "execute-connector-activity",
+  "wait-for-connector"
+]);
+var CONNECTOR_ENVELOPE_INPUTS = new Set([
+  "pathParameters",
+  "queryParameters",
+  "body"
+]);
+var resolveEnvelopeKey = (body, name) => {
+  const named = (record, part) => Object.entries(record).find(([key]) => norm(key) === norm(part));
+  const direct = named(body, name);
+  if (direct !== undefined)
+    return { value: direct[1] };
+  const parts = name.split(".").filter((part) => part !== "");
+  if (parts.length < 2)
+    return;
+  let current = body;
+  for (const part of parts) {
+    const record = asRecord(current);
+    if (record === undefined)
+      return;
+    const hit = named(record, part);
+    if (hit === undefined)
+      return;
+    current = hit[1];
+  }
+  return { value: current };
+};
+var carriedInput = (found, name) => {
+  const absent = { present: false, value: undefined, valueless: false };
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  const direct = inputs.find((i) => norm(i.name) === norm(name));
+  if (direct !== undefined) {
+    return {
+      present: true,
+      value: direct.value,
+      valueless: !("value" in direct)
+    };
+  }
+  if (typeof found.type !== "string" || !AUDIT_CONNECTOR_TASK_TYPES.has(found.type)) {
+    return absent;
+  }
+  for (const entry of inputs) {
+    const entryName = entry.name;
+    if (typeof entryName !== "string" || !CONNECTOR_ENVELOPE_INPUTS.has(entryName)) {
+      continue;
+    }
+    const body = asRecord(entry.body);
+    if (body === undefined)
+      continue;
+    const carried = resolveEnvelopeKey(body, name);
+    if (carried !== undefined) {
+      return { present: true, value: carried.value, valueless: false };
+    }
+  }
+  return absent;
+};
+var declaredInputNames = (task) => {
+  const names = [];
+  const add = (name) => {
+    if (!names.some((existing) => norm(existing) === norm(name))) {
+      names.push(name);
+    }
+  };
+  for (const entry of task.literalInputs)
+    add(entry.name);
+  for (const entry of task.expressionInputs)
+    add(entry.name);
+  for (const entry of task.producerInputs)
+    add(entry.name);
+  return names;
+};
+var boundInputNames = (task) => task.boundInputs.map((entry) => entry.name);
+var emptyLiteralInputNames = (task) => task.literalInputs.filter((entry) => isBlank(entry.value)).map((entry) => entry.name);
+var envelopeFindings = (task, found, path, label) => {
+  const findings = [];
+  const columns = [
+    {
+      declared: task.required,
+      actual: found.isRequired,
+      column: "Required",
+      field: "isRequired"
+    },
+    {
+      declared: task.runOnlyOnce,
+      actual: found.shouldRunOnlyOnce,
+      column: "Run Only Once",
+      field: "shouldRunOnlyOnce"
+    }
+  ];
+  for (const { declared, actual, column, field: field2 } of columns) {
+    if (declared === undefined)
+      continue;
+    if (typeof actual === "boolean" && actual === declared)
+      continue;
+    findings.push(error("STRICT_SDD_TASK_ENVELOPE_MISMATCH", `${path}.${field2}`, `${label}: the SDD Tasks table declares a "${column}" value for this task and its \`${field2}\` ${typeof actual === "boolean" ? "disagrees" : "is absent"}. Set it from that column.`));
+  }
+  return findings;
+};
+var emptyInputFindings = (task, found, path, label) => {
+  const declared = declaredInputNames(task);
+  if (declared.length === 0)
+    return [];
+  if (Object.keys(found.data).length === 0)
+    return [];
+  const bound = boundInputNames(task);
+  const emptyLiteral = emptyLiteralInputNames(task);
+  const findings = [];
+  const names = (list, name) => list.some((entry) => norm(entry) === norm(name));
+  for (const name of declared) {
+    const carried = carriedInput(found, name);
+    const value = carried.value;
+    const missing = !carried.present;
+    if (!missing && !carried.valueless && (typeof value !== "string" || value.trim() !== "")) {
+      continue;
+    }
+    if (!missing && (names(bound, name) || names(emptyLiteral, name))) {
+      continue;
+    }
+    const declares = names(emptyLiteral, name) ? "the empty literal" : "a value";
+    findings.push(error("STRICT_SDD_INPUT_EMPTY", `${path}.data.inputs[${name}]`, `${label}: the SDD Inputs row for "${name}" declares ${declares}, and the caseplan input ${missing ? "is absent" : carried.valueless ? "carries no `value` at all" : "is empty"}. Nothing reaches the task for it, and none of the value comparisons can run against an input that carries nothing. ${missing ? "The row exists, so the input has to exist too — add it, carrying that row's value." : carried.valueless ? "Its value has to live under `value` — data under `body` is the connector envelope, which does not apply to this task type." : "Re-read that row and set the input from it."}`));
+  }
+  return findings;
+};
+var comparableExpression = (text) => withoutWhitespace(text).replaceAll("'", '"');
+var resolveXrefExpression = (expression, index) => {
+  const marker = `${VARS_PREFIX}${XREF_OPEN}`;
+  const tokens = new Set;
+  let expected = "";
+  let cursor = 0;
+  while (cursor < expression.length) {
+    const at = expression.indexOf(marker, cursor);
+    if (at === -1) {
+      expected += expression.slice(cursor);
+      break;
+    }
+    expected += expression.slice(cursor, at);
+    const close = callCloseIndex(expression, at);
+    if (close === -1)
+      return;
+    const call = expression.slice(at + VARS_PREFIX.length, close + 1);
+    const args = xrefArguments(call);
+    if (args.length !== 3)
+      return;
+    const candidates = index.get(`${norm(args[0])}|${norm(args[1])}|${norm(args[2])}`);
+    if (candidates === undefined || candidates.length !== 1) {
+      return;
+    }
+    for (const token of candidates[0])
+      tokens.add(token);
+    expected += VARIABLE_PLACEHOLDER;
+    cursor = close + 1;
+  }
+  return { expected, tokens };
+};
+var ruleCarryingExpression = (condition) => {
+  for (const lane of asArray(asRecord(condition)?.rules)) {
+    for (const entry of asArray(lane)) {
+      const rule = asRecord(entry);
+      for (const key of ["conditionExpression", "expression"]) {
+        const value = rule?.[key];
+        if (typeof value === "string" && value.trim() !== "") {
+          return rule;
+        }
+      }
+    }
+  }
+  return;
+};
+var conditionExpressionOf = (condition) => {
+  for (const lane of asArray(asRecord(condition)?.rules)) {
+    for (const entry of asArray(lane)) {
+      const rule = asRecord(entry);
+      for (const key of ["conditionExpression", "expression"]) {
+        const value = rule?.[key];
+        if (typeof value === "string" && value.trim() !== "") {
+          return value;
+        }
+      }
+    }
+  }
+  return;
+};
+var predicateFinding = (row, condition, path, label) => {
+  if (row.when === undefined)
+    return [];
+  const { rule: declared } = whenRule(row.when);
+  if (!declared || isBlank(declared))
+    return [];
+  const carrier = ruleCarryingExpression(condition);
+  const actual = carrier?.rule;
+  if (typeof actual !== "string" || actual === "")
+    return [];
+  if (norm(actual) === norm(declared))
+    return [];
+  return [
+    error("STRICT_SDD_CONDITION_RULE_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row "${row.displayName}" declares WHEN \`${declared}\`, and the rule carrying that row's gate uses \`${actual}\`. The gate itself is right, so every expression check passes; a different predicate fires it at a different moment, which builds a transition the SDD never described.`)
+  ];
+};
+var conditionExpressionFindings = (declared, planConditions, plan, path, label) => {
+  const withMarkers = declared.filter((row) => row.ifExpression?.includes(XREF_OPEN) === true);
+  if (withMarkers.length === 0)
+    return [];
+  const findings = [];
+  const index = producerIndex(plan);
+  for (const row of withMarkers) {
+    const resolved = resolveXrefExpression(row.ifExpression ?? "", index);
+    if (resolved === undefined)
+      continue;
+    const expected = comparableExpression(resolved.expected);
+    const comparable = (actual2) => {
+      let normalised = actual2;
+      for (const token of resolved.tokens) {
+        normalised = normalised.replaceAll(`${VARS_PREFIX}${token}`, VARIABLE_PLACEHOLDER);
+      }
+      return comparableExpression(normalised);
+    };
+    const match = planConditions.find((condition) => norm(asRecord(condition)?.displayName) === norm(row.displayName));
+    const actual = match === undefined ? undefined : conditionExpressionOf(match);
+    if (actual !== undefined) {
+      if (comparable(actual) === expected) {
+        findings.push(...predicateFinding(row, match, path, label));
+        continue;
+      }
+      findings.push(error("STRICT_SDD_CONDITION_EXPRESSION_MISMATCH", `${path}[${row.displayName}].conditionExpression`, `${label}: the gate on "${row.displayName}" does not carry the expression its SDD row gives. SDD row: ${row.ifExpression} — which resolves to: ${[...resolved.tokens].join(" | ")} — caseplan: ${actual}. If the caseplan names something the row's reference does not resolve to, the gate reads a different value and opens on the wrong condition; that is not a formatting difference. A rewritten but equivalent form is also reported, because the row is preserved verbatim.`));
+      continue;
+    }
+    if (planConditions.some((condition) => {
+      const carried = conditionExpressionOf(condition);
+      return carried !== undefined && comparable(carried) === expected;
+    })) {
+      continue;
+    }
+    findings.push(error("STRICT_SDD_CONDITION_MISSING", `${path}[${row.displayName}]`, `${label}: no ${label.startsWith("case") ? "case exit" : "condition"} rule carries the route the SDD row "${row.displayName}" describes — its IF expression appears on no rule, under any Display Name. A generic rule with no expression in its slot keeps the row count whole and drops the route, so the count checks pass. Re-read that row and add the gate it describes.`));
+  }
+  return findings;
+};
+var expressionShapeFindings = (task, found, plan, path, label) => {
+  const withMarkers = task.expressionInputs.filter((entry) => entry.expression.includes(XREF_OPEN));
+  if (withMarkers.length === 0)
+    return [];
+  const findings = [];
+  const index = producerIndex(plan);
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  for (const declared of withMarkers) {
+    const resolved = resolveXrefExpression(declared.expression, index);
+    if (resolved === undefined)
+      continue;
+    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    const actual = input?.value;
+    if (typeof actual !== "string" || actual.trim() === "")
+      continue;
+    let normalisedActual = actual;
+    for (const token of resolved.tokens) {
+      normalisedActual = normalisedActual.replaceAll(`${VARS_PREFIX}${token}`, VARIABLE_PLACEHOLDER);
+    }
+    if (comparableExpression(normalisedActual) === comparableExpression(resolved.expected)) {
+      continue;
+    }
+    findings.push(warning("STRICT_SDD_EXPRESSION_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" does not carry the expression its SDD Inputs row gives, once that row's reference is resolved. The row's value is preserved exactly, so a rewritten but equivalent form counts as a difference. Re-read that row.`));
+  }
+  return findings;
+};
+var producerFindings = (task, found, plan, path, label) => {
+  if (task.producerInputs.length === 0)
+    return [];
+  const findings = [];
+  const index = producerIndex(plan);
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  for (const declared of task.producerInputs) {
+    const { stage, task: producerTask, output } = declared.producer;
+    const candidates = index.get(`${norm(stage)}|${norm(producerTask)}|${norm(output)}`);
+    if (candidates === undefined || candidates.length !== 1)
+      continue;
+    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    if (input === undefined)
+      continue;
+    const value = input.value;
+    if (typeof value !== "string" || value.trim() === "")
+      continue;
+    const accepted = candidates[0];
+    const tokens = referenceTokensIn(value);
+    if (tokens.some((token) => accepted.has(token))) {
+      if (!declared.direct)
+        continue;
+      if (!value.trimStart().startsWith("=js:"))
+        continue;
+      findings.push(error("STRICT_SDD_INPUT_FORM_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" reads the output its SDD row names, but wraps it in a JS expression. The row is a direct binding (\`<- "${stage}"."${producerTask}".${output}\`), so the plan form is the bare reference — \`=vars.<id>\` — not \`=js:\`. Passing the value through an expression is a different runtime path from binding it.`));
+      continue;
+    }
+    findings.push(error("STRICT_SDD_PRODUCER_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" is not wired to the output its SDD row names — "${output}" on task "${producerTask}" in "${stage}". It reads something else, so the task runs on data the SDD did not intend. Re-read that Inputs row and point the input at that output.`));
+  }
+  return findings;
+};
+var outputRowFindings = (task, found, path, label) => {
+  const findings = [];
+  const outputs = asArray(found.data.outputs).map(asRecord).filter((o) => o !== undefined);
+  for (const declared of task.outputRows) {
+    const match = outputs.find((o) => [o.name, o.var, o.source].some((candidate) => {
+      if (typeof candidate !== "string" || candidate === "") {
+        return false;
+      }
+      const bare = candidate.startsWith("=") ? candidate.slice(1) : candidate;
+      return norm(bare) === norm(declared) || norm(bare) === norm(declared.split(".").at(-1) ?? declared);
+    }));
+    if (match === undefined) {
+      findings.push(error("STRICT_SDD_OUTPUT_ROW_MISSING", `${path}.data.outputs`, `${label}: the SDD Outputs table declares "${declared}", and no output on the task carries it as its name, \`var\` or \`source\`. Nothing downstream can bind to it, so every reference to it is dead.`));
+      continue;
+    }
+    if (addressedByVar(match))
+      continue;
+    const id = match.id;
+    if (typeof id !== "string" || id.trim() === "") {
+      findings.push(error("STRICT_SDD_OUTPUT_ROW_MISSING", `${path}.data.outputs[${declared}].id`, `${label}: output "${declared}" carries no id. An output without one cannot be referenced, so the SDD row it satisfies is unfulfilled.`));
+    }
+  }
+  return findings;
+};
+var escalationFindings = (declared, rules, path, label) => {
+  if (!declared.atRisk && !declared.breach)
+    return [];
+  if (rules.length === 0)
+    return [];
+  const escalations = rules.map(asRecord).flatMap((rule) => asArray(rule?.escalationRule)).map(asRecord).filter((e) => e !== undefined);
+  const isKind = (escalation, kind) => {
+    const type = asRecord(escalation.triggerInfo)?.type;
+    if (typeof type !== "string")
+      return false;
+    const lowered = type.toLowerCase();
+    return kind === "at-risk" ? lowered.includes("at-risk") || lowered.includes("atrisk") : lowered.includes("breach");
+  };
+  const reaches = (escalation) => asArray(asRecord(escalation.action)?.recipients).length > 0;
+  const findings = [];
+  const report = (kind, consequence) => {
+    const matching = escalations.filter((e) => isKind(e, kind));
+    const noun = kind === "at-risk" ? "an At-Risk Action" : "a Breach Action";
+    if (matching.length === 0) {
+      findings.push(error("STRICT_SDD_SLA_ESCALATION_MISSING", path, `${label}: the SDD SLA table declares ${noun}, the SLA rules carry no ${kind} escalation. ${consequence}`));
+      return;
+    }
+    if (!matching.some(reaches)) {
+      findings.push(error("STRICT_SDD_SLA_ESCALATION_MISSING", path, `${label}: the SDD SLA table declares ${noun} and the ${kind} escalation exists, but it carries no recipient. ${consequence} Add the recipient the SDD names.`));
+    }
+  };
+  if (declared.atRisk) {
+    report("at-risk", "The duration is enforced and nobody is notified before it elapses.");
+  }
+  if (declared.breach) {
+    report("breach", "The SLA can elapse with nobody told.");
+  }
+  return findings;
+};
+var whenRule = (when) => {
+  const open = when.indexOf("(");
+  if (open === -1)
+    return { rule: when.trim(), selectors: [] };
+  const close = when.lastIndexOf(")");
+  return {
+    rule: when.slice(0, open).trim(),
+    selectors: close > open ? quotedArgs(when.slice(open + 1, close)) : []
+  };
+};
+var sameLabel = (a, b) => norm(a) === norm(b) || normAnnotationless(a) === normAnnotationless(b);
+var leadingSegment = (name) => {
+  for (const dash of [" - ", " – ", " — "]) {
+    const at = name.indexOf(dash);
+    if (at > 0)
+      return name.slice(0, at);
+  }
+  return name;
+};
+var selectorIds = (rule) => {
+  const ids = [];
+  for (const [key, value] of Object.entries(rule ?? {})) {
+    if (!isTargetKey(key))
+      continue;
+    if (typeof value === "string" && value.trim() !== "")
+      ids.push(value);
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (typeof entry === "string" && entry.trim() !== "") {
+          ids.push(entry);
+        }
+      }
+    }
+  }
+  return ids;
+};
+var isTargetKey = (key) => key.startsWith("selected") || key === "slaId";
+var hasSelector = (rule) => {
+  for (const [key, value] of Object.entries(rule ?? {})) {
+    if (!isTargetKey(key))
+      continue;
+    if (Array.isArray(value) && value.length > 0)
+      return true;
+    if (typeof value === "string" && value.trim() !== "")
+      return true;
+  }
+  return false;
+};
+var undeclaredGateFinding = (row, planRules, path, label, resolve) => {
+  if (row.ungated !== true || row.when === undefined)
+    return;
+  const { rule, selectors } = whenRule(row.when);
+  if (!rule || isBlank(rule))
+    return;
+  const belongsToRow = (candidate) => {
+    if (selectors.length === 0)
+      return !hasSelector(candidate);
+    if (!hasSelector(candidate))
+      return false;
+    if (resolve === undefined)
+      return false;
+    const pointsAt = selectorIds(candidate).map((id) => resolve.stage(id) ?? resolve.task(id)).filter((name) => name !== undefined);
+    if (pointsAt.length === 0)
+      return false;
+    return selectors.some((want) => {
+      const denotes = resolve.label(want);
+      return pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
+    });
+  };
+  const gated = planRules.filter((candidate) => {
+    if (norm(candidate?.rule) !== norm(rule))
+      return false;
+    if (!belongsToRow(candidate))
+      return false;
+    const expression = candidate?.conditionExpression;
+    return typeof expression === "string" && !isBlank(expression);
+  });
+  if (gated.length === 0)
+    return;
+  const expressions = [
+    ...new Set(gated.map((candidate) => String(candidate?.conditionExpression)).filter((expression) => expression !== ""))
+  ];
+  const on = selectors.length > 0 ? ` on "${selectors.join('", "')}"` : "";
+  return error("STRICT_SDD_CONDITION_EXPRESSION_UNDECLARED", `${path}[${row.displayName}].conditionExpression`, `${label}: the SDD row "${row.displayName}" declares WHEN \`${rule}\`${on} with no IF gate, and the caseplan's \`${rule}\` carries \`${expressions.join("`, `")}\`. A gate the SDD does not declare narrows the transition to one branch, so it fires where the row says it should fire every time. Remove the expression, or add the IF cell that justifies it.`);
+};
+var whenCellFinding = (row, planRules, path, label, resolve) => {
+  if (row.when === undefined)
+    return;
+  const { rule, selectors: wanted } = whenRule(row.when);
+  if (!rule || isBlank(rule))
+    return;
+  const matching = planRules.filter((r) => norm(r?.rule) === norm(rule));
+  if (matching.length === 0) {
+    return error("STRICT_SDD_CONDITION_RULE_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row "${row.displayName}" declares WHEN \`${rule}\`, no rule on it uses that predicate. A different predicate starts the task at a different moment. Re-read that row's WHEN cell.`);
+  }
+  if (wanted.length === 0)
+    return;
+  if (!matching.some(hasSelector)) {
+    return error("STRICT_SDD_CONDITION_SELECTOR_MISSING", `${path}[${row.displayName}].rule`, `${label}: the SDD row "${row.displayName}" declares WHEN \`${rule}\` on "${wanted.join('", "')}", and the caseplan's \`${rule}\` carries no target. The predicate then refers to nothing, so it never becomes true and the gate never opens. Set the rule's \`selected*\` field to the target the row names.`);
+  }
+  if (resolve === undefined)
+    return;
+  const pointsAt = matching.flatMap((candidate) => selectorIds(candidate)).map((id) => resolve.stage(id) ?? resolve.task(id)).filter((name) => name !== undefined);
+  if (pointsAt.length === 0)
+    return;
+  const missed = wanted.filter((want) => {
+    const denotes = resolve.label(want);
+    return !pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
+  });
+  if (missed.length === 0)
+    return;
+  return error("STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row "${row.displayName}" declares WHEN \`${rule}\` on "${missed.join('", "')}", and the caseplan's \`${rule}\` points at "${pointsAt.join('", "')}". A selector that resolves to the wrong target builds a transition the SDD never asked for and leaves the declared one absent, which no count or predicate check can see.`);
+};
+var conditionRuleFindings = (declared, planConditions, path, label, resolve) => {
+  if (declared.length === 0)
+    return [];
+  const planRules = planConditions.flatMap((condition) => asArray(asRecord(condition)?.rules).flatMap((group) => asArray(group).map(asRecord)));
+  if (planRules.length === 0)
+    return [];
+  return declared.flatMap((row) => [
+    whenCellFinding(row, planRules, path, label, resolve),
+    undeclaredGateFinding(row, planRules, path, label, resolve)
+  ]).filter((finding) => finding !== undefined);
+};
+var CONDITION_FLAGS = [
+  ["interrupting", "isInterrupting", "Interrupting"],
+  ["marksComplete", "marksStageComplete", "Marks Stage Complete"]
+];
+var conditionShapeFindings = (declared, planConditions, path, label) => {
+  const findings = [];
+  for (const row of declared) {
+    const match = planConditions.map(asRecord).find((c) => norm(c?.displayName) === norm(row.displayName));
+    if (match === undefined)
+      continue;
+    if (row.exitType !== undefined) {
+      const has = typeof match.type === "string" && match.type !== "";
+      if (!has || norm(match.type) !== norm(row.exitType)) {
+        findings.push(error("STRICT_SDD_CONDITION_EXIT_TYPE_MISMATCH", `${path}[${row.displayName}].type`, `${label}: the SDD row "${row.displayName}" declares Exit Type "${row.exitType}", the condition has ${has ? `"${String(match.type)}"` : "no `type` at all"}. The exit type decides where the case goes when the gate opens, so this ${has ? "sends it somewhere else" : "leaves it undecided — check for an invented key like `exitType` holding the value `type` should carry"}.`));
+      }
+    }
+    for (const [cell, field2, title] of CONDITION_FLAGS) {
+      const want = row[cell];
+      const got = typeof match[field2] === "boolean" ? match[field2] : false;
+      if (want === undefined)
+        continue;
+      if (want === got)
+        continue;
+      findings.push(error("STRICT_SDD_CONDITION_FLAG_MISMATCH", `${path}[${row.displayName}].${field2}`, `${label}: the SDD row "${row.displayName}" declares ${title}=${want ? "Yes" : "No"}, the condition has ${typeof match[field2] === "boolean" ? String(got) : "no such field, which the runtime reads as false"}.`));
+    }
+  }
+  return findings;
+};
+var TIMER_CONFIGURATION_TYPES = new Map([
+  ["duration", "timeDuration"],
+  ["date", "timeDate"],
+  ["cycle", "timeCycle"]
+]);
+var TIMER_VALUE_FIELDS = new Map([
+  ["timeduration", "timeDuration"],
+  ["timedate", "timeDate"],
+  ["timecycle", "timeCycle"]
+]);
+var timerFindings = (task, found, path, label) => {
+  if (task.timerType === undefined)
+    return [];
+  const findings = [];
+  const carriedType = found.data.timerType;
+  if (typeof carriedType === "string" && carriedType.trim() !== "") {
+    if (norm(carriedType) !== norm(task.timerType)) {
+      findings.push(error("STRICT_SDD_TIMER_TYPE_MISMATCH", `${path}.data.timerType`, `${label}: the SDD declares timer type "${task.timerType}", the caseplan has "${carriedType}". Re-read the **Timer:** line for this task.`));
+    }
+  }
+  if (task.timerValue === undefined)
+    return findings;
+  const key = TIMER_VALUE_FIELDS.get(norm(task.timerType).replaceAll(" ", ""));
+  const carried = key === undefined ? undefined : found.data[key];
+  if (typeof carried !== "string" || carried.trim() === "")
+    return findings;
+  if (norm(carried) === norm(task.timerValue))
+    return findings;
+  findings.push(error("STRICT_SDD_TIMER_VALUE_MISMATCH", `${path}.data.${key}`, `${label}: the timer runs for "${carried}" where the SDD's **Value:** line declares "${task.timerValue}". A timer copied from a sibling task waits the wrong length of time and nothing downstream can tell. Re-read the **Value:** line for this task.`));
+  return findings;
+};
+var literalDifference = (actual, declared) => {
+  if (actual === "")
+    return "carries an empty value";
+  if (actual.includes("`")) {
+    return "carries a value with a fence character (`) in it, so it is not the literal the SDD declares";
+  }
+  if (!parsesAsJson(actual) && parsesAsJson(declared)) {
+    return "does not match the literal the SDD declares, which is JSON where this value is not";
+  }
+  return "does not match the literal the SDD declares";
+};
+var missingLiteralFields = (declared, actual) => {
+  const [declaredError, declaredValue] = catchError(() => JSON.parse(declared));
+  const [actualError, actualValue] = catchError(() => JSON.parse(actual));
+  if (declaredError || actualError)
+    return;
+  const declaredRecord = asRecord(declaredValue);
+  const actualRecord = asRecord(actualValue);
+  if (declaredRecord === undefined || actualRecord === undefined) {
+    return;
+  }
+  const carried = new Set(Object.keys(actualRecord));
+  const declaredKeys = Object.keys(declaredRecord);
+  const missing = declaredKeys.filter((key) => !carried.has(key));
+  if (missing.length === 0)
+    return;
+  return {
+    declaredCount: declaredKeys.length,
+    actualCount: declaredKeys.length - missing.length,
+    firstMissing: missing[0]
+  };
+};
+var literalFindings = (task, found, path, label) => {
+  const findings = [];
+  for (const declared of task.literalInputs) {
+    const carried = carriedInput(found, declared.name);
+    if (!carried.present)
+      continue;
+    const actual = carried.value;
+    if (typeof actual !== "string")
+      continue;
+    if (actual.startsWith("=")) {
+      findings.push(error("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" carries an expression where the SDD's Inputs row declares a literal value. Re-read that row and set the literal it gives.`));
+      continue;
+    }
+    if (sameLiteral(declared.value, actual))
+      continue;
+    const truncated = missingLiteralFields(declared.value, actual);
+    if (truncated !== undefined) {
+      findings.push(error("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" carries ${truncated.actualCount} of the ${truncated.declaredCount} fields its SDD Inputs row declares — "${truncated.firstMissing}" is the first one absent. The row is the verbatim contract, so the task runs on data the SDD does not describe. Re-read that row and carry every field.`));
+      continue;
+    }
+    const difference = literalDifference(actual, declared.value);
+    findings.push(warning("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" ${difference}. Re-read the Inputs row for "${declared.name}" in the SDD and set the value from it. A literal that arrives truncated or rewritten runs with the wrong data.`));
+  }
+  return findings;
+};
+var PAYLOAD_SLOTS = ["body", "queryParameters", "pathParameters"];
+var usesSlotInputs = (found) => {
+  const names = asArray(found.data.inputs).map(asRecord).map((i) => norm(i?.name));
+  if (found.type === "wait-for-connector") {
+    return names.length === 1 && names[0] === norm("body");
+  }
+  return names.includes(norm("pathParameters")) || names.includes(norm("queryParameters"));
+};
+var carriesPayload = (inputs) => PAYLOAD_SLOTS.some((slot) => {
+  const input = inputs.find((i) => norm(i.name) === norm(slot));
+  if (typeof input?.body === "string")
+    return input.body !== "";
+  return Object.keys(asRecord(input?.body) ?? {}).length > 0;
+}) || inputs.some((i) => (i.type === "file" || i.target === "file") && typeof i.value === "string" && i.value !== "");
+var boundInputFindings = (task, found, path, label) => {
+  if (task.boundInputs.length === 0)
+    return [];
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  const findings = [];
+  const isConnector = AUDIT_CONNECTOR_TASK_TYPES.has(found.type ?? "") && usesSlotInputs(found);
+  let connectorRows = 0;
+  for (const declared of task.boundInputs) {
+    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    if (input) {
+      const valueless = !("value" in input);
+      if (!valueless && input.value !== "")
+        continue;
+      findings.push(error("STRICT_SDD_INPUT_UNBOUND", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" ${valueless ? "carries no `value` at all" : "carries an empty value"}. The SDD binds it to \`${declared.binding}\`, so the build has to resolve that reference into the slot. ${valueless ? "The runtime reads `value`, so data under any other key — `body` is the usual one — reaches it as nothing." : "Empty, the field reaches the runtime missing and the task faults on its first use."}`));
+      continue;
+    }
+    if (!isConnector)
+      continue;
+    connectorRows += 1;
+  }
+  if (connectorRows > 0 && !carriesPayload(inputs)) {
+    findings.push(error("STRICT_SDD_INPUT_UNBOUND", `${path}.data.inputs[body].body`, `${label}: the SDD binds ${connectorRows} input ${connectorRows === 1 ? "row" : "rows"} and the connector task carries no spliced payload: nothing in \`body\`, \`queryParameters\` or \`pathParameters\`, and no file parameter with a value. \`case spec\` returns that payload under \`Body\`, which lower-cases to \`body\` on the way in. Written to \`value\` instead it is dropped at packaging, and the activity runs with none of its fields.`));
+  }
+  return findings;
+};
+var extractFindings = (task, found, path, label) => {
+  if (task.extractRows.length === 0)
+    return [];
+  const outputs = asArray(found.data.outputs).map(asRecord).filter((o) => o !== undefined);
+  const findings = [];
+  for (const declared of task.extractRows) {
+    const wanted = `=${declared.field}`;
+    const present = outputs.some((o) => o.source === wanted && o.var === declared.variable);
+    if (present)
+      continue;
+    const carriesSource = outputs.filter((o) => o.source === wanted);
+    findings.push(error("STRICT_SDD_EXTRACT_MISSING", `${path}.data.outputs`, `${label}: no output writes "${declared.variable}". The SDD ` + `extracts \`${declared.field} -> ${declared.variable}\`, so ` + `the task needs an output with source "${wanted}" and var ` + `"${declared.variable}". ` + (carriesSource.length === 0 ? "The task carries no output with that source at all, " + "so the row was never written and anything reading " + "the variable sees null." : `The task does carry an output with that source, ` + `${carriesSource.map((o) => {
+      const named = (key, value) => typeof value === "string" && value.trim() !== "" ? `\`${key}\` "${value}"` : `no \`${key}\``;
+      return `${named("var", o.var)} and ${named("id", o.id)}`;
+    }).join(", ")}. The row is written and points at a ` + `variable the SDD never declared, so the repair is ` + `that \`var\`, not a second output. A collision ` + `suffix belongs on the \`id\`, which is what can ` + `clash; the \`var\` names the one case variable every ` + `such task writes.`)));
+  }
+  return findings;
+};
+var customOutputFindings = (task, found, path, label) => {
+  if (task.customRows.length === 0)
+    return [];
+  const outputs = asArray(found.data.outputs).map(asRecord).filter((o) => o !== undefined);
+  const findings = [];
+  for (const declared of task.customRows) {
+    const present = outputs.some((o) => o.custom === true && o.var === declared.variable);
+    if (present)
+      continue;
+    findings.push(error("STRICT_SDD_CUSTOM_OUTPUT_MISSING", `${path}.data.outputs`, `${label}: nothing sets "${declared.variable}". The SDD assigns it \`${declared.expression}\`, so the task needs an output with \`custom: true\` and var "${declared.variable}". Without it no element in the packed BPMN writes the variable and it keeps its default.`));
+  }
+  return findings;
+};
+var gatedSlaFindings = (rules, path, label) => {
+  if (rules.length === 0)
+    return [];
+  const expressions = rules.map((rule) => {
+    const expression = asRecord(rule)?.expression;
+    return typeof expression === "string" ? expression.trim() : "";
+  });
+  const isDefault = (expression) => expression === "" || norm(expression) === norm("=js:true");
+  if (expressions.some(isDefault))
+    return [];
+  return [
+    warning("STRICT_SDD_SLA_GATED_NEEDS_DEFAULT", path, `${label}: every SLA rule is gated by an expression and none is the \`=js:true\` default, so no SLA applies when no gate matches. Add a trailing unconditional rule if that is not intended.`)
+  ];
+};
+var compareTask = (plan, task, found, stagePath, label, selectors) => {
+  const issues = [];
+  const taskPath = `${stagePath}.data.tasks[${found.name ?? task.name}]`;
+  if (task.type && found.type && norm(task.type) !== norm(found.type)) {
+    issues.push(error("STRICT_SDD_TASK_TYPE_MISMATCH", `${taskPath}.type`, `${label}: the SDD declares type "${task.type}", the caseplan has "${found.type}".`));
+  }
+  if (task.proseLabel !== undefined) {
+    const description = typeof found.description === "string" ? found.description : "";
+    if (description.trim() === "") {
+      issues.push(warning("STRICT_SDD_TASK_DESCRIPTION_MISSING", `${taskPath}.description`, `${label}: the SDD writes a \`**${task.proseLabel}:**\` line for this task and the caseplan task carries no \`description\`. Studio Web shows that field on the task's General tab, so dropping it is how the reasoning stops reaching whoever opens the case. Copy that line into \`description\` word for word. This is a warning because the case still runs without it, so a \`Valid\` result does not mean the prose arrived.`));
+    }
+  }
+  issues.push(...coverageFinding(`${taskPath}.entryConditions`, label, "entry", task.entryRows, found.entry));
+  if (found.entry.length === 0) {
+    issues.push(error("STRICT_SDD_ENTRY_RULE_EMPTY", `${taskPath}.entryConditions`, `${label}: no entryConditions in the caseplan. The default profile only warns, but a task with no entry rule hangs \`case debug\` indefinitely.`));
+  } else if (ruleTotal(found.entry) === 0) {
+    issues.push(error("STRICT_SDD_ENTRY_RULE_EMPTY", `${taskPath}.entryConditions`, `${label}: entryConditions carry no rules.`));
+  }
+  const isPlaceholder = Object.keys(found.data).length === 0;
+  if (isPlaceholder && task.identityResolved) {
+    const resolved = task.resolvedResource ? ` to "${task.resolvedResource}"` : "";
+    issues.push(error("STRICT_SDD_PLACEHOLDER_RESOLVED", `${taskPath}.data`, `${label}: the caseplan has an empty \`data: {}\` (placeholder) but the SDD resolved the resource${resolved}.`));
+  } else if (isPlaceholder) {
+    issues.push(warning("STRICT_SDD_PLACEHOLDER_TASK", `${taskPath}.data`, `${label}: placeholder task (empty \`data\`) — the SDD leaves its resource unresolved.`));
+  }
+  issues.push(...conditionRuleFindings(task.entryConditions, found.entry, `${taskPath}.entryConditions`, label, selectors), ...envelopeFindings(task, found, taskPath, label));
+  if (isPlaceholder)
+    return issues;
+  issues.push(...bindingFindings(plan, found, taskPath, label, task.folder), ...literalFindings(task, found, taskPath, label), ...boundInputFindings(task, found, taskPath, label), ...timerFindings(task, found, taskPath, label), ...wiringFindings(task, found, taskPath, label), ...producerFindings(task, found, plan, taskPath, label), ...emptyInputFindings(task, found, taskPath, label), ...expressionShapeFindings(task, found, plan, taskPath, label), ...outputRowFindings(task, found, taskPath, label), ...extractFindings(task, found, taskPath, label), ...customOutputFindings(task, found, taskPath, label));
+  return issues;
+};
+var variablePlacementFindings = (sdd, plan, name, key) => {
+  const category = sdd.variableCategories.get(key);
+  const required = VARIABLE_PLACEMENT.get(category ?? "");
+  if (category === undefined || required === undefined)
+    return [];
+  const issues = [];
+  for (const group of required) {
+    if (plan.variableGroups[group].has(key))
+      continue;
+    const found = VARIABLE_GROUPS.filter((g) => plan.variableGroups[g].has(key));
+    issues.push(error("STRICT_SDD_VARIABLE_GROUP_MISSING", `variables.${group}[${name}]`, `Variable "${name}": the SDD Category=${capitalize(category)} needs an entry in caseplan variables.${group}[], found only in ${found.join(", ")}. \`validate\` accepts half the pair and the argument then drops out of entry-points.json.`));
+  }
+  return issues;
+};
+var variableDefaultFindings = (sdd, plan, name, key) => {
+  const declared = sdd.variableDefaults.get(key);
+  const category = sdd.variableCategories.get(key);
+  const group = DEFAULT_GROUP.get(category ?? "");
+  if (declared === undefined || group === undefined)
+    return [];
+  const entry = plan.variableEntries[group].get(key);
+  if (entry === undefined)
+    return [];
+  if (!("default" in entry)) {
+    return [
+      error("STRICT_SDD_VARIABLE_DEFAULT_MISSING", `variables.${group}[${name}].default`, `Variable "${name}": the SDD Default column gives it "${declared}" and caseplan variables.${group}[] carries no \`default\`. Packaging writes no attribute for it, so the slot starts with no value and a route that reads it before anything writes it sees undefined.`)
+    ];
+  }
+  const written = entry.default;
+  const asText = typeof written === "string" ? written : JSON.stringify(written);
+  if (asText === declared)
+    return [];
+  return [
+    error("STRICT_SDD_VARIABLE_DEFAULT_MISMATCH", `variables.${group}[${name}].default`, `Variable "${name}": the SDD Default column gives it "${declared}" and caseplan variables.${group}[] carries "${asText}". The slot starts at the written value, so every route that reads it before a task writes it reads the wrong one.`)
+  ];
+};
+var compareCaseLevel = (sdd, plan) => {
+  const issues = [
+    ...coverageFinding("metadata.caseExitRules", "case", "exit", sdd.caseExitRows, plan.caseExitConditions),
+    ...gatedSlaFindings(plan.caseSlaRules, "metadata.slaRules", "case"),
+    ...conditionalSlaFindings(sdd.caseConditionalSlas, plan.caseSlaRules, "metadata.slaRules", "case")
+  ];
+  if (sdd.caseSla && !plan.caseSla) {
+    issues.push(error("STRICT_SDD_SLA_MISSING", "metadata.slaRules", "case: the SDD declares Case-Level SLA Escalation Rules, the caseplan metadata.slaRules is empty."));
+  }
+  issues.push(...escalationFindings(sdd.caseSlaEscalations, plan.caseSlaRules, "metadata.slaRules", "case"), ...xrefOutputFindings(sdd, plan), ...conditionExpressionFindings(sdd.caseExitConditions, plan.caseExitConditions, plan, "metadata.caseExitRules", "case"));
+  issues.push(...slaDurationFindings(sdd, plan));
+  if (sdd.caseSla && plan.caseSlaRules.length > 1) {
+    issues.push(error("STRICT_SDD_SLA_EXTRA", "metadata.slaRules", `case: the SDD declares one case-level SLA and ${plan.caseSlaRules.length} SLA rules are present. Its escalations are the rows of that one table, so splitting them across rules leaves each rule with part of the SLA and the runtime applies whichever rule it reaches — the other escalations are lost. Carry one rule with every escalation the table declares.`));
+  }
+  if (sdd.triggers && plan.triggers < sdd.triggers) {
+    issues.push(error("STRICT_SDD_TRIGGER_MISSING", "nodes", plan.triggers === 0 ? `case: the SDD declares ${sdd.triggers} trigger(s), the caseplan has no trigger node.` : `case: the SDD declares ${sdd.triggers} trigger(s), the caseplan has ${plan.triggers}.`));
+  }
+  if (sdd.triggers && plan.triggers > sdd.triggers) {
+    issues.push(error("STRICT_SDD_TRIGGER_EXTRA", "nodes", `case: the SDD declares ${sdd.triggers} trigger(s), the caseplan has ${plan.triggers}. A trigger the SDD does not declare starts cases nobody asked for; remove it or add the row that justifies it.`));
+  }
+  const planVariables = new Set(plan.variables.map(norm));
+  for (const name of sdd.variables) {
+    const key = norm(name);
+    if (!planVariables.has(key)) {
+      issues.push(error("STRICT_SDD_VARIABLE_MISSING", `variables[${name}]`, `Variable "${name}" is declared in the SDD Case Variables table and absent from the caseplan.`));
+      continue;
+    }
+    issues.push(...variablePlacementFindings(sdd, plan, name, key), ...variableDefaultFindings(sdd, plan, name, key));
+  }
+  if (sdd.sawVariableSection) {
+    const declared = new Set(sdd.variables.map(norm));
+    for (const stage of sdd.stages) {
+      for (const task of stage.tasks) {
+        for (const row of task.extractRows)
+          declared.add(norm(row.variable));
+        for (const row of task.customRows)
+          declared.add(norm(row.variable));
+      }
+    }
+    const reported = new Set;
+    for (const name of plan.variables) {
+      const key = norm(name);
+      if (declared.has(key) || reported.has(key))
+        continue;
+      reported.add(key);
+      issues.push(error("STRICT_SDD_VARIABLE_EXTRA", `variables[${name}]`, `Variable "${name}" is in the caseplan and absent from the SDD Case Variables table. A case variable the SDD does not declare moves a value from task scope to case scope — it outlives the task, is visible to every stage, and nothing in the document says it should exist. Remove it and read the value where it is produced, or add the row that justifies it.`));
+    }
+  }
+  return issues;
+};
+var SLA_UNIT_CODES = new Map([
+  ["min", "min"],
+  ["mins", "min"],
+  ["minute", "min"],
+  ["minutes", "min"],
+  ["h", "h"],
+  ["hr", "h"],
+  ["hrs", "h"],
+  ["hour", "h"],
+  ["hours", "h"],
+  ["d", "d"],
+  ["day", "d"],
+  ["days", "d"],
+  ["w", "w"],
+  ["week", "w"],
+  ["weeks", "w"],
+  ["m", "m"],
+  ["mo", "m"],
+  ["month", "m"],
+  ["months", "m"]
+]);
+var AMBIGUOUS_SDD_UNITS = new Map([
+  ["m", ["min", "m"]]
+]);
+var acceptedUnitCodes = (cell) => {
+  const key = cell.trim().toLowerCase();
+  const ambiguous = AMBIGUOUS_SDD_UNITS.get(key);
+  if (ambiguous !== undefined)
+    return ambiguous;
+  const exact = SLA_UNIT_CODES.get(key);
+  return exact === undefined ? [] : [exact];
+};
+var parseDurationCell = (text) => {
+  const match = /^(\d+)\s*([a-z]+)$/i.exec(text.trim());
+  if (!match)
+    return;
+  const count = Number(match[1]);
+  if (!Number.isFinite(count))
+    return;
+  const units = acceptedUnitCodes(match[2]);
+  return units.length === 0 ? undefined : { count, units };
+};
+var conditionalSlaFindings = (declared, carried, path, label) => {
+  if (declared.length === 0)
+    return [];
+  const findings = [];
+  const rules = carried.map((entry) => asRecord(entry)).filter((entry) => entry !== undefined);
+  for (const row of declared) {
+    const wanted = comparableExpression(row.expression);
+    const match = rules.find((rule) => typeof rule.expression === "string" && comparableExpression(rule.expression) === wanted);
+    const title = row.displayName === undefined ? `\`${row.expression}\`` : `"${row.displayName}"`;
+    if (match === undefined) {
+      findings.push(error("STRICT_SDD_SLA_CONDITIONAL_MISSING", path, `${label}: the SDD declares a conditional SLA rule ${title} and no rule on this target carries that expression. The override is what applies the stricter duration when the condition holds, so without it every case takes the default and nothing reports a gap. Add the rule ahead of the trailing \`=js:true\` default.`));
+      continue;
+    }
+    const want = parseDurationCell(row.duration);
+    if (want === undefined)
+      continue;
+    const count = match.count;
+    const unit = match.unit;
+    const carriedUnit = typeof unit === "string" ? SLA_UNIT_CODES.get(unit.toLowerCase()) : undefined;
+    if (count === want.count && carriedUnit !== undefined && want.units.includes(carriedUnit)) {
+      continue;
+    }
+    findings.push(error("STRICT_SDD_SLA_CONDITIONAL_MISSING", path, `${label}: the conditional SLA rule ${title} carries ${typeof count === "number" && carriedUnit !== undefined ? `count ${String(count)} unit "${String(unit)}"` : "no usable `count`/`unit`"} where the SDD declares "${row.duration}". The duration is the whole point of the override, so a different one makes the condition decide nothing.`));
+  }
+  return findings;
+};
+var slaDurationFindings = (sdd, plan) => {
+  if (sdd.caseSlaDuration === undefined)
+    return [];
+  const declared = parseDurationCell(sdd.caseSlaDuration);
+  if (declared === undefined)
+    return [];
+  const findings = [];
+  plan.caseSlaRules.forEach((entry, index) => {
+    const rule = asRecord(entry);
+    if (rule === undefined)
+      return;
+    const label = typeof rule.displayName === "string" && rule.displayName !== "" ? rule.displayName : String(index);
+    const count = rule.count;
+    const unit = rule.unit;
+    const has = typeof count === "number" && Number.isFinite(count) && typeof unit === "string" && unit !== "";
+    const carried = has ? SLA_UNIT_CODES.get(String(unit).toLowerCase()) : undefined;
+    if (has && count === declared.count && carried !== undefined && declared.units.includes(carried)) {
+      return;
+    }
+    findings.push(error("STRICT_SDD_SLA_DURATION_MISMATCH", `metadata.slaRules[${label}]`, `case: the SDD declares a case-level SLA of "${sdd.caseSlaDuration}", and the rule carries ${has ? `count ${String(count)} unit "${String(unit)}"` : "no `count`/`unit` at all"}. The duration is what makes the SLA elapse, so ${has ? "a different one moves every escalation with it" : "without it the SLA never elapses and no escalation ever fires — check for the value sitting in an invented key such as `duration`"}.`));
+  });
+  return findings;
+};
+var compareStage = (plan, stage, planStage, selectors) => {
+  const stagePath = `nodes[${planStage.name ?? stage.name}]`;
+  const stageLabel = `stage "${stage.name}"`;
+  const issues = [
+    ...coverageFinding(`${stagePath}.data.entryConditions`, stageLabel, "entry", stage.entryRows, planStage.entry),
+    ...coverageFinding(`${stagePath}.data.exitConditions`, stageLabel, "exit", stage.exitRows, planStage.exit),
+    ...gatedSlaFindings(planStage.sla, `${stagePath}.data.slaRules`, stageLabel),
+    ...conditionalSlaFindings(stage.conditionalSlas, planStage.sla, `${stagePath}.data.slaRules`, stageLabel)
+  ];
+  if (stage.hasSla && planStage.sla.length === 0) {
+    issues.push(error("STRICT_SDD_SLA_MISSING", `${stagePath}.data.slaRules`, `${stageLabel}: the SDD declares a Stage SLA, the caseplan has no slaRules.`));
+  }
+  if (stage.hasSla && planStage.sla.length > 1) {
+    issues.push(error("STRICT_SDD_SLA_EXTRA", `${stagePath}.data.slaRules`, `${stageLabel}: the SDD declares one Stage SLA and ${planStage.sla.length} SLA rules are present. Its escalations belong to that one SLA, so splitting them across rules leaves each with part of it and the runtime applies whichever rule it reaches — the other escalations are lost. Carry one rule with every escalation the table declares.`));
+  }
+  issues.push(...conditionRuleFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, selectors), ...conditionRuleFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, selectors), ...conditionShapeFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel), ...conditionShapeFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel), ...conditionExpressionFindings(stage.entryConditions, planStage.entry, plan, `${stagePath}.data.entryConditions`, stageLabel), ...conditionExpressionFindings(stage.exitConditions, planStage.exit, plan, `${stagePath}.data.exitConditions`, stageLabel), ...escalationFindings(stage.slaEscalations, planStage.sla, `${stagePath}.data.slaRules`, stageLabel));
+  const bound = resolveTasks(stage.tasks, planStage.tasks);
+  stage.tasks.forEach((task, row) => {
+    const taskIndex = bound[row];
+    const label = `${stageLabel} task "${task.name}"`;
+    if (taskIndex === undefined) {
+      issues.push(error("STRICT_SDD_TASK_MISSING", `${stagePath}.data.tasks[${task.name}]`, `${label} is declared in the SDD and absent from the caseplan.`));
+      return;
+    }
+    issues.push(...compareTask(plan, task, planStage.tasks[taskIndex], stagePath, label, selectors));
+  });
+  planStage.tasks.forEach((extra, index) => {
+    if (bound.includes(index))
+      return;
+    issues.push(warning("STRICT_SDD_TASK_EXTRA", `${stagePath}.data.tasks[${extra.name ?? index}]`, `${stageLabel} task "${extra.name ?? index}" is in the caseplan with no matching SDD task row.`));
+  });
+  return issues;
+};
+var compare = (sdd, plan) => {
+  const issues = [];
+  const stageBound = new Set;
+  const pairs = [];
+  for (const stage of sdd.stages) {
+    const key = norm(stage.name);
+    let index = plan.stages.findIndex((candidate, at) => !stageBound.has(at) && norm(candidate.name) === key);
+    if (index === -1) {
+      const loose = normAnnotationless(stage.name);
+      const hits = plan.stages.map((candidate, at) => ({ candidate, at })).filter(({ candidate, at }) => !stageBound.has(at) && normAnnotationless(candidate.name) === loose);
+      if (hits.length === 1)
+        index = hits[0].at;
+    }
+    if (index === -1) {
+      issues.push(error("STRICT_SDD_STAGE_MISSING", `nodes[${stage.name}]`, `Stage "${stage.name}" is declared in the SDD and absent from the caseplan.`));
+      continue;
+    }
+    stageBound.add(index);
+    pairs.push({ stage, at: index });
+  }
+  const sddStageOfPlanId = new Map;
+  for (const { stage, at } of pairs) {
+    const id = plan.stages[at].id;
+    if (id !== undefined && id !== "")
+      sddStageOfPlanId.set(id, stage.name);
+  }
+  const selectors = {
+    stage: (id) => sddStageOfPlanId.get(id),
+    task: (id) => plan.stages.flatMap((s) => s.tasks).find((t) => t.id === id && t.name !== undefined)?.name,
+    label: (text) => {
+      const hits = sdd.stages.filter((candidate) => sameLabel(candidate.name, text) || norm(leadingSegment(candidate.name)) === norm(text));
+      return hits.length === 1 ? hits[0].name : undefined;
+    }
+  };
+  for (const { stage, at } of pairs) {
+    issues.push(...compareStage(plan, stage, plan.stages[at], selectors));
+  }
+  plan.stages.forEach((extra, index) => {
+    if (stageBound.has(index))
+      return;
+    issues.push(warning("STRICT_SDD_STAGE_EXTRA", `nodes[${extra.name ?? index}]`, `Stage "${extra.name ?? index}" is in the caseplan with no matching SDD stage.`));
+  });
+  issues.push(...compareCaseLevel(sdd, plan));
+  return issues;
+};
+var auditCaseplanAgainstSdd = (parsed, sddText, sddName) => {
+  const sdd = parseSdd(sddText);
+  const issues = sdd.parseNotes.map((note) => warning("STRICT_SDD_PARSE_NOTE", sddName, note));
+  if (sdd.stages.length === 0) {
+    issues.push(error("STRICT_SDD_PARSE_EMPTY", sddName, `No stages parsed from "${sddName}", so every completeness check would pass without checking anything. Stage headings must read \`### Stage <n>: <name>\`.`));
+    return issues;
+  }
+  issues.push(...compare(sdd, parseCaseplan(parsed)));
+  issues.push(...slaReferenceFindings(sddText, sddName));
+  return issues;
+};
+export {
+  auditCaseplanAgainstSdd
+};
+
+//# debugId=06CF0AAF35CEE5DC64756E2164756E21