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

package/dist/strict-sdd-audit-qdmc9e1y.js

@@ -1,1024 +0,0 @@
-import {
-  isAnyTriggerNode,
-  isStageNode
-} from "./packager-tool-sv0d6wb6.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 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_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_TASK_HEADINGS = ["Tasks"];
-var VARIABLE_GROUPS = ["inputs", "outputs", "inputOutputs"];
-var VARIABLE_PLACEMENT = new Map([
-  ["in", ["inputs", "inputOutputs"]],
-  ["out", ["outputs", "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 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 = inner.split("|").map((c) => c.trim());
-    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 stripTicks = (value) => {
-  let text = value;
-  if (text.startsWith("`"))
-    text = text.slice(1);
-  if (text.endsWith("`"))
-    text = text.slice(0, -1);
-  return text;
-};
-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 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 detailEntryRows = (block) => {
-  let rows = 0;
-  for (const sub of sectionBlocks(block)) {
-    if (norm(sub.title).startsWith(norm("Entry Condition"))) {
-      rows = firstTable(sub.body).rows.length;
-    }
-  }
-  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 rows;
-  const tail = [];
-  for (const line of lines.slice(at + 1)) {
-    const text = line.trim();
-    if (text.startsWith("**") || readHeading(text))
-      break;
-    tail.push(line);
-  }
-  return Math.max(rows, firstTable(tail.join(`
-`)).rows.length);
-};
-var afterBoldLabel = (block, label) => {
-  const opener = `**${label}`;
-  const hits = [];
-  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);
-  }
-  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 detailLiteralInputs = (block) => {
-  const inputs = [];
-  for (const sub of afterBoldLabel(block, "Inputs")) {
-    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;
-      if (raw.startsWith("=") || raw.startsWith("<-"))
-        continue;
-      inputs.push({ name, value: raw });
-    }
-  }
-  return inputs;
-};
-var detailExtractRows = (block) => {
-  const rows = [];
-  for (const sub of afterBoldLabel(block, "Outputs")) {
-    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 = stripTicks(cellAt(row, bindingAt).trim());
-      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 afterBoldLabel(block, "Outputs")) {
-    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 = stripTicks(cellAt(row, bindingAt).trim());
-      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 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),
-    entryRows: detailEntryRows(block),
-    literalInputs: detailLiteralInputs(block),
-    extractRows: detailExtractRows(block),
-    customRows: detailCustomRows(block)
-  };
-};
-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 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()),
-      literalInputs: [],
-      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;
-  } else if (headingIs(title, STAGE_EXIT_HEADINGS)) {
-    stage.exitRows = firstTable(block).rows.length;
-  } else if (headingIs(title, STAGE_SLA_HEADINGS)) {
-    stage.hasSla = firstTable(block).rows.length > 0;
-  } else if (headingIs(title, STAGE_TASK_HEADINGS)) {
-    stage.tasks.push(...readTaskRows(title, block, notes));
-  } else {
-    return false;
-  }
-  return true;
-};
-var parseStage = (name, body, notes) => {
-  const stage = {
-    name: name.trim(),
-    tasks: [],
-    entryRows: 0,
-    exitRows: 0,
-    hasSla: false
-  };
-  const details = new Map;
-  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) {
-      details.set(norm(detailName), readTaskDetail(block));
-    }
-  }
-  for (const task of stage.tasks) {
-    const detail = details.get(norm(task.name));
-    if (!detail)
-      continue;
-    task.literalInputs = detail.literalInputs;
-    task.extractRows = detail.extractRows;
-    task.customRows = detail.customRows;
-    task.resolvedResource = detail.resolvedResource;
-    task.identityResolved = detail.identityResolved;
-    task.entryRows = detail.entryRows;
-    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;
-  } else if (headingIs(title, CASE_TRIGGER_HEADINGS)) {
-    sdd.triggers = firstTable(body).rows.length;
-  } else if (headingIs(title, CASE_SLA_HEADINGS)) {
-    sdd.caseSla = firstTable(body).rows.length > 0;
-  } else if (headingIs(title, CASE_VARIABLE_HEADINGS)) {
-    const { header, rows } = firstTable(body);
-    const wanted = ["Name", "Variable", "Variable Name"];
-    const nameAt = columnIndex(header, ...wanted);
-    const categoryAt = columnIndex(header, "Category");
-    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);
-        }
-      }
-    }
-  } else {
-    return false;
-  }
-  return true;
-};
-var parseSdd = (text) => {
-  const sdd = {
-    stages: [],
-    caseExitRows: 0,
-    triggers: 0,
-    variables: [],
-    variableCategories: new Map,
-    caseSla: false,
-    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 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,
-        type: typeof record.type === "string" ? record.type : undefined,
-        entry: asArray(record.entryConditions),
-        data: taskData
-      });
-    }
-  }
-  return tasks;
-};
-var readPlanVariables = (doc) => {
-  const variablesDoc = asRecord(doc.variables) ?? {};
-  const variables = [];
-  const variableGroups = {};
-  for (const group of VARIABLE_GROUPS) {
-    const names = [];
-    for (const entry of asArray(variablesDoc[group])) {
-      const name = asRecord(entry)?.name;
-      if (typeof name === "string")
-        names.push(name);
-    }
-    variableGroups[group] = new Set(names.map(norm));
-    variables.push(...names);
-  }
-  return { variables, variableGroups };
-};
-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),
-      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 = line.indexOf(")", 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 bindingFindings = (plan, task, path, label) => {
-  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;
-    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 sameLiteral = (declared, actual) => {
-  if (declared === actual)
-    return true;
-  const parse = (text) => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return;
-    }
-  };
-  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);
-  }
-  return canonical(a) === canonical(b);
-};
-var literalFindings = (task, found, path, label) => {
-  const findings = [];
-  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
-  for (const declared of task.literalInputs) {
-    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
-    if (!input)
-      continue;
-    const actual = input.value;
-    if (typeof actual !== "string" || actual.startsWith("="))
-      continue;
-    if (sameLiteral(declared.value, actual))
-      continue;
-    const carried = actual === "" ? "an empty value" : `"${actual}"`;
-    findings.push(warning("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" carries ${carried}, the SDD declares "${declared.value}". A literal that arrives truncated or rewritten runs with the wrong data.`));
-  }
-  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;
-    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}". Without it the variable is never ` + "written and anything reading it sees null."));
-  }
-  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) => {
-  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}".`));
-  }
-  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(...bindingFindings(plan, found, taskPath, label), ...literalFindings(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 compareCaseLevel = (sdd, plan) => {
-  const issues = [
-    ...coverageFinding("metadata.caseExitRules", "case", "exit", sdd.caseExitRows, plan.caseExitConditions),
-    ...gatedSlaFindings(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."));
-  }
-  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}.`));
-  }
-  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));
-  }
-  return issues;
-};
-var compareStage = (plan, stage, planStage) => {
-  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)
-  ];
-  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.`));
-  }
-  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));
-  });
-  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;
-  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);
-    issues.push(...compareStage(plan, stage, plan.stages[index]));
-  }
-  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=8E454AD3E138C86064756E2164756E21