@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/{packager-tool-9bt3hs56.js → packager-tool-y57r93yz.js}

@@ -2,9 +2,16 @@ import {
   ledgerMissFor
 } from "./packager-tool-zk7ntkba.js";
 import {
-  isAnyTriggerNode,
-  isStageNode
-} from "./packager-tool-qmxmg1yv.js";
+  dedupedId,
+  exactKey,
+  indexKey,
+  lookupOutput,
+  modelKey,
+  stageSpellings
+} from "./packager-tool-20592jhn.js";
+import {
+  outputSourceFor
+} from "./packager-tool-bhhym40d.js";
 import {
   comparableFolder
 } from "./packager-tool-szn7gaaz.js";
@@ -12,21 +19,29 @@ import {
   cellAt,
   columnField,
   columnIndex,
+  fenceOf,
   field,
   firstTable,
   isBlank,
   isDigit,
   isLetter,
   isLowerLetter,
+  isSeparatorCell,
   namedValue,
   norm,
+  pipeTables,
+  splitRowCells,
   stripTicks,
   trimQuotes,
   withoutAnnotation
-} from "./packager-tool-gtzw8sw4.js";
+} from "./packager-tool-jexxh6qf.js";
+import {
+  isAnyTriggerNode,
+  isStageNode
+} from "./packager-tool-qmxmg1yv.js";
 import {
   catchError
-} from "./packager-tool-z1qbc0qf.js";
+} from "./packager-tool-wv85dhy2.js";
 
 // ../case-tool/src/services/sdd-normalizer.ts
 var readSddHeading = (line) => {
@@ -40,19 +55,6 @@ var readSddHeading = (line) => {
     return;
   return { level, title: rest.trim() };
 };
-var fenceOf = (line) => {
-  let at = 0;
-  while (at < 3 && line[at] === " ")
-    at += 1;
-  const ch = line[at];
-  if (ch !== "`" && ch !== "~")
-    return;
-  let run = 0;
-  while (line[at + run] === ch)
-    run += 1;
-  const bare = line.slice(at + run).trim() === "";
-  return run >= 3 ? { ch, run, bare } : undefined;
-};
 var readSddSections = (source) => {
   const headings = [];
   let offset = 0;
@@ -119,7 +121,11 @@ var afterBoldLabel = (block, ...labels) => {
     }
   }
   hits.sort((left, right) => left.at - right.at);
-  return hits.map(({ from }, index) => block.slice(from, hits[index + 1]?.at ?? block.length));
+  const nextLabelLine = (from) => {
+    const rest = block.slice(from).search(/\n[ \t]*\*\*[^\s*]/);
+    return rest === -1 ? block.length : from + rest + 1;
+  };
+  return hits.map(({ from }, index) => block.slice(from, Math.min(hits[index + 1]?.at ?? block.length, nextLabelLine(from))));
 };
 var unwrapCodeSpan = (value) => {
   const text = value.trim();
@@ -229,6 +235,7 @@ var SLA_RESPONSE_MAP_HEADINGS = ["SLA Response Map"];
 var CASE_METADATA_HEADINGS = ["Case Metadata"];
 var CASE_SLA_PROPERTY = "Case-Level SLA";
 var CASE_VARIABLE_HEADINGS = ["Case Variables"];
+var CANVAS_NOTE_HEADINGS = ["Canvas Notes", "Sticky Notes"];
 var STAGE_ENTRY_HEADINGS = ["Stage Entry Conditions"];
 var STAGE_EXIT_HEADINGS = [
   "Stage Exit Conditions",
@@ -457,6 +464,63 @@ var coverageFinding = (path, label, kind, rows, conditions) => {
   ];
 };
 
+// ../case-tool/src/services/strict-sdd-audit/task-io-tables.ts
+var INPUT_VALUE_COLUMNS = [
+  "Binding / Value",
+  "Binding",
+  "Value"
+];
+var INPUT_NAME_COLUMNS = ["Name", "Input", "Field"];
+var OUTPUT_NAME_COLUMNS = ["Field", "Name", "Output"];
+var inputNameColumn = (header) => columnIndex(header, ...INPUT_NAME_COLUMNS) ?? columnIndex(header, "Variable");
+var outputNameColumn = (header) => columnIndex(header, ...OUTPUT_NAME_COLUMNS) ?? columnIndex(header, "Variable");
+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 customRowsOf = (header, rows) => {
+  const bindingAt = columnIndex(header, ...INPUT_VALUE_COLUMNS);
+  if (bindingAt === undefined)
+    return [];
+  const found = [];
+  for (const row of rows) {
+    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;
+    const emptyLiteral = /^(""|'')$/.test(expression);
+    if (!emptyLiteral && (!expression || isBlank(expression)))
+      continue;
+    found.push({ variable, expression });
+  }
+  return found;
+};
+var unreadIoTables = (block) => {
+  const unread = [];
+  const check = (labels, readable, wants) => {
+    for (const label of labels)
+      for (const part of afterBoldLabel(block, label)) {
+        const { header, rows } = firstTable(part);
+        if (rows.length === 0 || readable(header, rows))
+          continue;
+        unread.push(`the **${label}** table (header: ${header.join(" | ")}) has ${rows.length} row(s) and no ${wants} column, so none of them reached the task`);
+      }
+  };
+  check(INPUT_LABELS, (header) => inputNameColumn(header) !== undefined && columnIndex(header, ...INPUT_VALUE_COLUMNS) !== undefined, `name (${[...INPUT_NAME_COLUMNS, "Variable"].join("/")}) or value (${INPUT_VALUE_COLUMNS.join("/")})`);
+  check(OUTPUT_LABELS, (header, rows) => outputNameColumn(header) !== undefined || customRowsOf(header, rows).length > 0, `name (${[...OUTPUT_NAME_COLUMNS, "Variable"].join("/")}) column or \`<variable> = <expression>\` row in a value`);
+  return unread;
+};
+
 // ../case-tool/src/services/strict-sdd-audit/producers.ts
 var PRODUCER_ARROW = "<-";
 var XREF_OPEN = "$xref(";
@@ -605,7 +669,7 @@ var xrefProducers = (document) => {
     const close = callCloseIndex(text, at);
     if (close === -1)
       break;
-    const args = xrefArguments(text.slice(at, close + 1));
+    const args = xrefArguments(text.slice(at, close + 1).replace(/\\(["'\\])/g, "$1"));
     if (args.length === 3) {
       const key = `${norm(args[0])}|${norm(args[1])}|${args[1].trim()}|${norm(args[2])}`;
       if (!seen.has(key)) {
@@ -621,8 +685,8 @@ 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");
+    const nameAt = inputNameColumn(header);
+    const valueAt = columnIndex(header, ...INPUT_VALUE_COLUMNS);
     if (nameAt === undefined || valueAt === undefined)
       continue;
     for (const row of rows) {
@@ -1213,6 +1277,58 @@ var resolveXrefExpression = (expression, index) => {
   }
   return { expected, tokens };
 };
+var expressionMatcher = (declared, index) => {
+  const resolved = declared.includes(XREF_OPEN) ? resolveXrefPositions(declared, index) : undefined;
+  if (resolved === undefined) {
+    const wanted = comparableExpression(declared);
+    return (actual) => comparableExpression(actual) === wanted;
+  }
+  const expected = comparableExpression(resolved.expected);
+  const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const placeholder = new RegExp(`${escapeRegExp(VARIABLE_PLACEHOLDER)}(\\d+)`, "g");
+  let pattern = "";
+  let cursor = 0;
+  for (const found of expected.matchAll(placeholder)) {
+    pattern += escapeRegExp(expected.slice(cursor, found.index));
+    const tokens = [...resolved.groups[Number(found[1])]].sort((left, right) => right.length - left.length).map(escapeRegExp);
+    pattern += `${escapeRegExp(VARS_PREFIX)}(?:${tokens.join("|")})(?![\\w$])`;
+    cursor = (found.index ?? 0) + found[0].length;
+  }
+  pattern += escapeRegExp(expected.slice(cursor));
+  const shape = new RegExp(`^${pattern}$`);
+  return (actual) => shape.test(comparableExpression(actual));
+};
+var resolveXrefPositions = (expression, index) => {
+  const marker = `${VARS_PREFIX}${XREF_OPEN}`;
+  const groups = [];
+  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 args = xrefArguments(expression.slice(at + VARS_PREFIX.length, close + 1));
+    if (args.length !== 3)
+      return;
+    const key = `${norm(args[0])}|${norm(args[1])}|${norm(args[2])}`;
+    const candidates = index.get(key);
+    if (candidates === undefined || candidates.length !== 1) {
+      return;
+    }
+    let position = groups.indexOf(candidates[0]);
+    if (position === -1)
+      position = groups.push(candidates[0]) - 1;
+    expected += `${VARIABLE_PLACEHOLDER}${position}`;
+    cursor = close + 1;
+  }
+  return { expected, groups };
+};
 var ruleCarryingExpression = (condition) => {
   for (const lane of asArray(asRecord(condition)?.rules)) {
     for (const entry of asArray(lane)) {
@@ -1434,11 +1550,303 @@ var escalationFindings = (declared, rules, path, label, mapped) => {
 };
 
 // ../case-tool/src/services/strict-sdd-audit/sdd-model.ts
+var CANVAS_NOTE_COLORS = [
+  "blue",
+  "green",
+  "yellow",
+  "pink",
+  "white"
+];
 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";
 
+// ../case-tool/src/services/sdd-convert/xrefs.ts
+var QUOTED = String.raw`(?:'((?:\\.|[^'\\])*)'|"((?:\\.|[^"\\])*)"|` + "`((?:\\\\.|[^`\\\\])*)`" + String.raw`|\u201c([^\u201d]*)\u201d)`;
+var XREF_CALL = new RegExp(String.raw`vars\.\$xref\(\s*${QUOTED}\s*,\s*${QUOTED}\s*,\s*${QUOTED}\s*\)`, "g");
+var argumentOf = (groups) => groups.find((value) => value !== undefined) ?? "";
+var unresolvedXrefDetail = (whole, found) => {
+  if (found === undefined) {
+    return `\`${whole}\` names an output this SDD does not declare, so the marker is left in place rather than pointed at a guess`;
+  }
+  const spellings = new Set(found.names);
+  const listed = [...spellings].map((name) => `\`${name}\``).join(", ");
+  if (spellings.size < found.names.length) {
+    return `\`${whole}\` names a task that ${found.names.length} tasks in that stage answer to (${listed}), so the marker is left in place rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
+  }
+  return `\`${whole}\` names its task in a spelling that ${found.names.length} tasks answer to (${listed}), so the marker is left in place rather than pointed at one of them — write the task's name as its heading spells it`;
+};
+var DOTTED_READ = /^\.[A-Za-z_$]/;
+var deferredOutputs = new WeakMap;
+var markDeferredOutputs = (index, ids) => {
+  deferredOutputs.set(index, ids);
+};
+var expandXrefs = (text, context) => text.replace(XREF_CALL, (whole, ...rest) => {
+  const offset = rest[rest.length - 2];
+  const captured = rest.slice(0, -2);
+  const stage = argumentOf(captured.slice(0, 4));
+  const task = argumentOf(captured.slice(4, 8));
+  const output = argumentOf(captured.slice(8, 12));
+  const found = lookupOutput(context.outputs, `${indexKey(stage)}|${indexKey(task)}|${indexKey(output)}`, task);
+  if (found !== undefined && "id" in found) {
+    if (deferredOutputs.get(context.outputs)?.has(found.id)) {
+      context.unresolved.push({
+        kind: "placeholder",
+        where: context.where,
+        detail: `\`${whole}\` reads an output of a task the resolved file defers, so \`vars.${found.id}\` resolves to nothing until that task is filled`
+      });
+    }
+    const after = text.slice(offset + whole.length);
+    return DOTTED_READ.test(after) ? `vars.${found.id}?` : `vars.${found.id}`;
+  }
+  context.unresolved.push({
+    kind: "producer-reference",
+    where: context.where,
+    detail: unresolvedXrefDetail(whole, found)
+  });
+  return whole;
+});
+var expandOutputMarkers = (output, context) => {
+  const expand = (value2) => typeof value2 === "string" && value2.includes("$xref") ? expandXrefs(value2, context) : value2;
+  const value = expand(output.value);
+  const source = expand(output.source);
+  return value === output.value && source === output.source ? output : { ...output, value, source };
+};
+
+// ../case-tool/src/services/sdd-convert/io.ts
+var taskMatcher = (model, taskName) => {
+  const mine = exactKey(taskName);
+  const folded = indexKey(taskName);
+  const filed = modelKey(taskName);
+  let unique = true;
+  let filedUnique = true;
+  for (const stage of model.stages) {
+    for (const other of stage.tasks) {
+      const name = exactKey(String(other.name ?? ""));
+      if (name === mine)
+        continue;
+      if (indexKey(name) === folded)
+        unique = false;
+      if (modelKey(name) === filed)
+        filedUnique = false;
+    }
+  }
+  return {
+    names: (spelled) => exactKey(spelled) === mine || unique && indexKey(spelled) === folded,
+    unique,
+    filedUnique
+  };
+};
+var declaredOutputs = (model, stageName, position, task) => {
+  const taskName = String(task.name ?? "");
+  const { names: own, slug, ordinal } = stageSpellings(stageName, position);
+  const names = [...own, ...slug === undefined ? [] : [slug], ordinal].map(indexKey);
+  const matcher = taskMatcher(model, taskName);
+  const mine = (producer) => names.includes(indexKey(producer.stage)) && matcher.names(producer.task);
+  const rows = (task.outputRows ?? []).map((row) => ({ row, aliases: [] }));
+  const sameOutput = (a, b) => indexKey(a) === indexKey(b) || (!a.includes(".") || !b.includes(".")) && indexKey(emittedName(a)) === indexKey(emittedName(b));
+  const dotted = (one) => [one.row, ...one.aliases].find((spelling) => spelling.includes("."));
+  const takes = (one, name) => {
+    if (!sameOutput(one.row, name))
+      return false;
+    if (!name.includes("."))
+      return true;
+    const held = dotted(one);
+    return held === undefined || indexKey(held) === indexKey(name);
+  };
+  const add = (name) => {
+    if (name === "")
+      return;
+    const found = rows.find((one) => takes(one, name));
+    if (found === undefined)
+      rows.push({ row: name, aliases: [] });
+    else if (found.row !== name && !found.aliases.includes(name)) {
+      found.aliases.push(name);
+    }
+  };
+  if (matcher.filedUnique) {
+    for (const name of model.resourceOutputs[modelKey(taskName)] ?? []) {
+      add(name);
+    }
+  }
+  for (const producer of model.xrefOutputs) {
+    if (mine(producer))
+      add(producer.output);
+  }
+  for (const stage of model.stages) {
+    for (const other of stage.tasks) {
+      for (const row of other.producerInputs ?? []) {
+        const producer = row.producer;
+        if (producer !== undefined && mine(producer)) {
+          add(producer.output);
+        }
+      }
+    }
+  }
+  return rows;
+};
+var emittedName = (row) => row.split(".").at(-1) ?? row;
+var OUTPUT_TYPES = new Map([
+  ["string", "string"],
+  ["object", "jsonSchema"],
+  ["json", "jsonSchema"],
+  ["jsonschema", "jsonSchema"]
+]);
+var readsOutput = (reference, row) => indexKey(reference) === indexKey(row) || !reference.includes(".") && indexKey(reference) === indexKey(emittedName(row));
+var outputTypeFor = (model, stageNames, taskName, output) => {
+  const matcher = taskMatcher(model, taskName);
+  for (const stage of model.stages) {
+    for (const task of stage.tasks) {
+      for (const row of task.producerInputs ?? []) {
+        const producer = row.producer;
+        if (producer === undefined || row.direct !== true || typeof row.type !== "string" || !stageNames.includes(indexKey(producer.stage)) || !matcher.names(producer.task) || !readsOutput(producer.output, output)) {
+          continue;
+        }
+        const mapped = OUTPUT_TYPES.get(row.type.trim().toLowerCase().replaceAll(" ", ""));
+        if (mapped !== undefined)
+          return mapped;
+      }
+    }
+  }
+  return;
+};
+var outputFor = (row, elementId, taken, type, taskType) => {
+  const leaf = row.split(".").at(-1) ?? row;
+  const base = leaf === "" ? leaf : `${leaf[0].toLowerCase()}${leaf.slice(1)}`;
+  const id = dedupedId(base, taken);
+  return {
+    name: leaf,
+    ...type !== undefined && { type },
+    id,
+    var: id,
+    value: id,
+    source: outputSourceFor(taskType, row),
+    target: `=${id}`,
+    elementId
+  };
+};
+var variableOutputType = (model, variable) => {
+  const declared = model.variableTypes[modelKey(variable)];
+  if (typeof declared !== "string" || declared.trim() === "") {
+    return;
+  }
+  const key = declared.trim().toLowerCase().replaceAll(" ", "");
+  return OUTPUT_TYPES.get(key) ?? "string";
+};
+var extractOutputFor = (row, elementId, taken, type, taskType) => {
+  const leaf = row.field.split(".").at(-1) ?? row.field;
+  const base = leaf === "" ? leaf : `${leaf[0].toLowerCase()}${leaf.slice(1)}`;
+  const id = dedupedId(base, taken);
+  return {
+    name: leaf,
+    ...type !== undefined && { type },
+    id,
+    var: row.variable,
+    value: row.variable,
+    source: outputSourceFor(taskType, row.field),
+    target: `=${id}`,
+    originalVar: id,
+    elementId
+  };
+};
+var customOutputFor = (row, type) => ({
+  name: row.variable,
+  ...type !== undefined && { type },
+  custom: true,
+  var: row.variable,
+  value: canonicalExpression(unquoteLiteral(row.expression)),
+  source: canonicalExpression(unquoteLiteral(row.expression)),
+  target: "",
+  body: "",
+  elementId: "root"
+});
+var canonicalExpression = (value) => value.startsWith("=metadata.") ? `=js:${value.slice(1)}` : value;
+var unquoteLiteral = (cell) => {
+  const text = cell.trim();
+  const quote = text[0];
+  if (quote !== '"' && quote !== "'")
+    return cell;
+  if (text.length < 2 || text[text.length - 1] !== quote)
+    return cell;
+  const inner = text.slice(1, -1);
+  for (let at = 0;at < inner.length; at += 1) {
+    if (inner[at] === "\\") {
+      at += 1;
+      continue;
+    }
+    if (inner[at] === quote)
+      return cell;
+  }
+  return inner.replaceAll(`\\${quote}`, quote);
+};
+var RANK_LITERAL = 1;
+var RANK_PRODUCER = 2;
+var RANK_EXPRESSION = 3;
+var unboundProducerDetail = (target, found) => {
+  if (found === undefined) {
+    return `the Inputs row reads an output (${target}) that no task in this SDD declares`;
+  }
+  const spellings = new Set(found.names);
+  const listed = [...spellings].map((task) => `"${task}"`).join(", ");
+  if (spellings.size < found.names.length) {
+    return `the Inputs row reads an output (${target}) of a task that ${found.names.length} tasks in that stage answer to (${listed}), so it is left unbound rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
+  }
+  return `the Inputs row reads an output (${target}) whose task spelling ${found.names.length} tasks answer to (${listed}), so it is left unbound rather than pointed at one of them`;
+};
+var inputsFor = (task, elementId, where, unresolved, outputs) => {
+  const ranked = new Map;
+  const offer = (name, rank, input) => {
+    const existing = ranked.get(name);
+    if (existing === undefined || rank > existing.rank) {
+      ranked.set(name, { rank, input });
+    }
+  };
+  for (const row of task.literalInputs ?? []) {
+    offer(String(row.name ?? ""), RANK_LITERAL, {
+      name: String(row.name ?? ""),
+      value: unquoteLiteral(String(row.value ?? "")),
+      elementId
+    });
+  }
+  for (const row of task.expressionInputs ?? []) {
+    offer(String(row.name ?? ""), RANK_EXPRESSION, {
+      name: String(row.name ?? ""),
+      value: canonicalExpression(expandXrefs(String(row.expression ?? row.value ?? ""), {
+        outputs,
+        where,
+        unresolved
+      })),
+      elementId
+    });
+  }
+  for (const row of task.producerInputs ?? []) {
+    const name = String(row.name ?? "");
+    const producer = row.producer;
+    const found = producer === undefined ? undefined : lookupOutput(outputs, `${indexKey(producer.stage)}|${indexKey(producer.task)}|${indexKey(producer.output)}`, producer.task);
+    if (found === undefined || !("id" in found)) {
+      const target = producer === undefined ? "unnamed producer" : `"${producer.stage}"."${producer.task}".${producer.output}`;
+      unresolved.push({
+        kind: "producer-reference",
+        where: `${where}.inputs[${name}]`,
+        detail: unboundProducerDetail(target, found)
+      });
+      continue;
+    }
+    const id = found.id;
+    offer(name, RANK_PRODUCER, {
+      name,
+      value: row.direct === false ? expandXrefs(String(row.value ?? `=js:vars.${id}`), {
+        outputs,
+        where,
+        unresolved
+      }) : `=vars.${id}`,
+      elementId
+    });
+  }
+  return [...ranked.values()].map((entry) => entry.input);
+};
+
 // ../case-tool/src/services/strict-sdd-audit/sla-durations.ts
 var SLA_UNIT_CODES = new Map([
   ["min", "min"],
@@ -1482,14 +1890,90 @@ var parseDurationCell = (text) => {
   const units = acceptedUnitCodes(match[2]);
   return units.length === 0 ? undefined : { count, units };
 };
-var conditionalSlaFindings = (declared, carried, path, label) => {
+var slaProducerIndex = (plan, stages, references) => {
+  const index = producerIndex(plan);
+  for (const stage of plan.stages) {
+    for (const task of stage.tasks) {
+      for (const entry of asArray(task.data.outputs)) {
+        const output = asRecord(entry);
+        const source = output?.source;
+        const name = output?.name;
+        if (typeof source !== "string" || !source.startsWith("=") || !source.includes(".") || typeof name !== "string") {
+          continue;
+        }
+        const prefix = `${norm(stage.name)}|${norm(task.name)}|`;
+        const own = index.get(`${prefix}${norm(name)}`)?.find((tokens) => tokens.has(String(output?.id ?? "")));
+        const row = `${prefix}${norm(source.slice(1))}`;
+        if (own !== undefined && !index.has(row)) {
+          index.set(row, [own]);
+        }
+      }
+    }
+  }
+  const entries = [...index.entries()];
+  const spelled = stages.flatMap((stage, at) => {
+    const { names, slug, ordinal } = stageSpellings(stage.name, at + 1);
+    const filed = names.map(norm).find((name) => entries.some(([key]) => key.startsWith(`${name}|`)));
+    return filed === undefined ? [] : [{ filed, names, slug, ordinal }];
+  });
+  const tiers = [
+    (one) => one.names,
+    (one) => one.slug === undefined ? [] : [one.slug],
+    (one) => [one.ordinal]
+  ];
+  for (const tier of tiers) {
+    for (const one of spelled) {
+      for (const alias of tier(one)) {
+        const prefix = norm(alias);
+        if (prefix === one.filed)
+          continue;
+        for (const [key, value] of entries) {
+          if (!key.startsWith(`${one.filed}|`))
+            continue;
+          const aliased = `${prefix}|${key.slice(one.filed.length + 1)}`;
+          if (!index.has(aliased))
+            index.set(aliased, value);
+        }
+      }
+    }
+  }
+  for (const { stage, task, output } of references) {
+    if (!output.includes("."))
+      continue;
+    const prefix = `${norm(stage)}|${norm(task)}|`;
+    const leaf = index.get(`${prefix}${norm(output.slice(output.lastIndexOf(".") + 1))}`);
+    const row = `${prefix}${norm(output)}`;
+    if (leaf?.length === 1 && !index.has(row))
+      index.set(row, leaf);
+  }
+  return index;
+};
+var slaReferences = (sdd) => [
+  ...sdd.xrefOutputs,
+  ...sdd.stages.flatMap((stage) => stage.tasks.flatMap((task) => task.producerInputs.map((input) => input.producer)))
+];
+var withoutConditional = (rules, declared, plan, stages, references) => {
+  const conditional = declared.filter((row) => !UNCONDITIONAL.test(row.expression.trim()));
+  if (conditional.length === 0)
+    return [...rules];
+  const index = slaProducerIndex(plan, stages, references);
+  const overrides = conditional.map((row) => expressionMatcher(canonicalExpression(row.expression.trim()), index));
+  return rules.filter((entry) => {
+    const rule = asRecord(entry);
+    const expression = rule?.expression;
+    return !(typeof expression === "string" && overrides.some((matches) => matches(expression)));
+  });
+};
+var UNCONDITIONAL = /^=js:\s*true\s*$/;
+var conditionalSlaFindings = (declared, carried, path, label, plan, stages, references) => {
   if (declared.length === 0)
     return [];
   const findings = [];
   const rules = carried.map((entry) => asRecord(entry)).filter((entry) => entry !== undefined);
+  const index = slaProducerIndex(plan, stages, references);
   for (const row of declared) {
-    const wanted = comparableExpression(row.expression);
-    const match = rules.find((rule) => typeof rule.expression === "string" && comparableExpression(rule.expression) === wanted);
+    const matches = expressionMatcher(canonicalExpression(row.expression.trim()), index);
+    const match = rules.find((rule) => typeof rule.expression === "string" && matches(rule.expression));
     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.`));
@@ -1515,7 +1999,7 @@ var slaDurationFindings = (sdd, plan) => {
   if (declared === undefined)
     return [];
   const findings = [];
-  plan.caseSlaRules.forEach((entry, index) => {
+  withoutConditional(plan.caseSlaRules, sdd.caseConditionalSlas, plan, sdd.stages, slaReferences(sdd)).forEach((entry, index) => {
     const rule = asRecord(entry);
     if (rule === undefined)
       return;
@@ -1705,7 +2189,7 @@ var extractFindings = (task, found, path, label) => {
   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 wanted = outputSourceFor(found.type, declared.field);
     const present = outputs.some((o) => o.source === wanted && o.var === declared.variable);
     if (present)
       continue;
@@ -1786,15 +2270,16 @@ 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")
+    ...conditionalSlaFindings(sdd.caseConditionalSlas, plan.caseSlaRules, "metadata.slaRules", "case", plan, sdd.stages, slaReferences(sdd))
   ];
   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", sdd.caseSlaResponses), ...xrefOutputFindings(sdd, plan), ...conditionExpressionFindings(sdd.caseExitConditions, plan.caseExitConditions, plan, "metadata.caseExitRules", "case"), ...conditionNameFindings(sdd.caseExitConditions, plan.caseExitConditions, "metadata.caseExitRules", "case", namesDeclaredOnce(sdd)));
   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.`));
+  const caseDefaults = withoutConditional(plan.caseSlaRules, sdd.caseConditionalSlas, plan, sdd.stages, slaReferences(sdd));
+  if (sdd.caseSla && caseDefaults.length > 1) {
+    issues.push(error("STRICT_SDD_SLA_EXTRA", "metadata.slaRules", `case: the SDD declares one case-level SLA and ${caseDefaults.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}.`));
@@ -1961,6 +2446,60 @@ var slaDurationOf = (block) => {
   return;
 };
 
+// ../case-tool/src/services/strict-sdd-audit/http-request-detail.ts
+var readHttpRequest = (block) => {
+  const read = (label) => {
+    const raw = field(block, label);
+    if (raw === undefined)
+      return;
+    const text = stripTicks(raw).trim();
+    if (text === "")
+      return;
+    if (/^[{["=]/.test(text))
+      return text;
+    return isBlank(text) ? undefined : text;
+  };
+  const request = {
+    method: read("Method"),
+    url: read("URL"),
+    headers: read("Headers"),
+    query: read("Query"),
+    body: read("Body")
+  };
+  const stated = Object.entries(request).filter(([, value]) => value !== undefined);
+  return stated.length === 0 ? undefined : Object.fromEntries(stated);
+};
+var httpFields = (block) => {
+  const http = readHttpRequest(block);
+  return http === undefined ? {} : { http };
+};
+
+// ../case-tool/src/services/strict-sdd-audit/resource-reference.ts
+var REFERENCE_LABELS = new Set([
+  "Action App Reference",
+  "Agent Reference",
+  "Process Reference",
+  "API Workflow Reference",
+  "Function Reference",
+  "Case Reference"
+].map(norm));
+var resourceReference = (block) => {
+  const cell = pipeTables(block).map((table) => firstTable(table)).flatMap(({ header, rows }) => [header, ...rows]).find((row) => REFERENCE_LABELS.has(norm(row[0] ?? "")))?.[1]?.trim();
+  if (cell === undefined || isBlank(cell))
+    return {};
+  const part = (key) => {
+    const found = new RegExp(`\\b${key}\\s+"([^"]*)"`, "i").exec(cell);
+    const value = found?.[1].trim();
+    return value === undefined || value === "" ? undefined : value;
+  };
+  const name = part("Name");
+  const folder = part("Folder");
+  return {
+    ...name !== undefined && { name },
+    ...folder !== undefined && { folder }
+  };
+};
+
 // ../case-tool/src/services/sdd-condition-cell.ts
 var STAGE_SELECTOR_RULES = new Set([
   "selected-stage-completed",
@@ -2061,22 +2600,12 @@ var entryConditionBlocks = (section) => {
   return blocks;
 };
 var detailEntryRows = (section) => entryConditionBlocks(section).reduce((most, text) => Math.max(most, firstTable(text).rows.length), 0);
-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");
+    const nameAt = inputNameColumn(header);
+    const valueAt = columnIndex(header, ...INPUT_VALUE_COLUMNS);
     if (nameAt === undefined || valueAt === undefined)
       continue;
     for (const row of rows) {
@@ -2100,8 +2629,8 @@ 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");
+    const nameAt = inputNameColumn(header);
+    const valueAt = columnIndex(header, ...INPUT_VALUE_COLUMNS);
     if (nameAt === undefined || valueAt === undefined)
       continue;
     for (const row of rows) {
@@ -2237,7 +2766,7 @@ 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");
+    const nameAt = outputNameColumn(header);
     if (nameAt === undefined)
       continue;
     for (const row of rows) {
@@ -2293,7 +2822,7 @@ 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 fieldAt = outputNameColumn(header);
     const bindingAt = columnIndex(header, "Binding / Value", "Binding", "Value");
     if (fieldAt === undefined || bindingAt === undefined)
       continue;
@@ -2310,30 +2839,10 @@ var detailExtractRows = (block) => {
   }
   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;
-      const emptyLiteral = /^(""|'')$/.test(expression);
-      if (!emptyLiteral && (!expression || isBlank(expression)))
-        continue;
-      rows.push({ variable, expression });
-    }
-  }
-  return rows;
-};
+var detailCustomRows = (block) => afterAnyLabel(block, OUTPUT_LABELS).flatMap((sub) => {
+  const { header, rows } = firstTable(sub);
+  return customRowsOf(header, rows);
+});
 var timerFields = (block) => {
   const declared = stripTicks(field(block, "Timer") ?? "");
   if (!declared || isBlank(declared))
@@ -2384,7 +2893,7 @@ var resourceNameOf = (block) => {
     if (name !== "" && !isBlank(name))
       return name;
   }
-  return;
+  return resourceReference(block).name;
 };
 var HTTP_METHODS = new Set([
   "GET",
@@ -2484,7 +2993,7 @@ var readTaskDetail = (section) => {
     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"),
+    folder: field(block, "Deployment Folder") ?? field(block, "Folder Path") ?? resourceReference(block).folder,
     ...(() => {
       const skip = namedValue(unwrapCodeSpan(field(block, "Skip Condition") ?? columnField(block, "Skip Condition") ?? ""));
       return skip === "" ? {} : { skipCondition: skip };
@@ -2511,7 +3020,9 @@ var readTaskDetail = (section) => {
     boundInputs: detailBoundInputs(block),
     extractRows: detailExtractRows(block),
     customRows: detailCustomRows(block),
-    ...timerFields(block)
+    unreadTables: unreadIoTables(block),
+    ...timerFields(block),
+    ...httpFields(block)
   };
 };
 var TIMER_CONFIGURATION_TYPES = new Map([
@@ -2779,7 +3290,7 @@ var conditionShapeFindings = (declared, planConditions, path, label) => {
 };
 
 // ../case-tool/src/services/strict-sdd-audit/compare-task.ts
-var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stageSpellings = [], once = new Set) => {
+var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stageSpellings2 = [], once = new Set) => {
   const issues = [];
   const taskPath = `${stagePath}.data.tasks[${found.name ?? task.name}]`;
   if (task.type && found.type && norm(task.type) !== norm(found.type)) {
@@ -2798,7 +3309,7 @@ var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stage
     issues.push(error("STRICT_SDD_ENTRY_RULE_EMPTY", `${taskPath}.entryConditions`, `${label}: entryConditions carry no rules.`));
   }
   const isPlaceholder = Object.keys(found.data).length === 0;
-  const miss = isPlaceholder ? ledgerMissFor(ledger, stageSpellings, task.name) : undefined;
+  const miss = isPlaceholder ? ledgerMissFor(ledger, stageSpellings2, task.name) : undefined;
   if (isPlaceholder && task.identityResolved && miss !== undefined) {
     issues.push(warning("STRICT_SDD_PLACEHOLDER_UNRESOLVABLE", `${taskPath}.data`, `${label}: placeholder task, and the run's registry ledger records no match for "${miss.query}"${miss.cacheFile ? ` in ${miss.cacheFile}` : ""} — so the placeholder is correct and the SDD names a resource this tenant does not have. Resolve it on a tenant that does, or leave the placeholder.`));
   } else if (isPlaceholder && task.identityResolved) {
@@ -2818,10 +3329,10 @@ var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stage
 };
 
 // ../case-tool/src/services/strict-sdd-audit/compare.ts
-var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, once = new Set) => {
+var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, once = new Set, sddStages = [stage], references = []) => {
   const stagePath = `nodes[${planStage.name ?? stage.name}]`;
   const ordinal = stagePosition === undefined ? undefined : `Stage ${stagePosition + 1}`;
-  const stageSpellings = [
+  const stageSpellings2 = [
     stage.name,
     ordinal,
     ordinal === undefined ? undefined : `${ordinal}: ${stage.name}`,
@@ -2832,13 +3343,14 @@ var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, on
     ...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)
+    ...conditionalSlaFindings(stage.conditionalSlas, planStage.sla, `${stagePath}.data.slaRules`, stageLabel, plan, sddStages, references)
   ];
   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.`));
+  const stageDefaults = withoutConditional(planStage.sla, stage.conditionalSlas, plan, sddStages, references);
+  if (stage.hasSla && stageDefaults.length > 1) {
+    issues.push(error("STRICT_SDD_SLA_EXTRA", `${stagePath}.data.slaRules`, `${stageLabel}: the SDD declares one Stage SLA and ${stageDefaults.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), ...conditionNameFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, once), ...conditionNameFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, once), ...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, stage.slaResponses));
   const bound = resolveTasks(stage.tasks, planStage.tasks);
@@ -2858,7 +3370,7 @@ var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, on
       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, ledger, stageSpellings, once));
+    issues.push(...compareTask(plan, task, planStage.tasks[taskIndex], stagePath, label, selectors, ledger, stageSpellings2, once));
   });
   planStage.tasks.forEach((extra, index) => {
     if (bound.includes(index))
@@ -2951,7 +3463,7 @@ var compare = (sdd, plan, ledger) => {
   };
   const once = namesDeclaredOnce(sdd);
   for (const { stage, at, sddIndex } of pairs) {
-    issues.push(...compareStage(plan, stage, plan.stages[at], selectors, ledger, sddIndex, once));
+    issues.push(...compareStage(plan, stage, plan.stages[at], selectors, ledger, sddIndex, once, sdd.stages, slaReferences(sdd)));
   }
   plan.stages.forEach((extra, index) => {
     if (stageBound.has(index))
@@ -2962,6 +3474,88 @@ var compare = (sdd, plan, ledger) => {
   return issues;
 };
 
+// ../case-tool/src/services/strict-sdd-audit/name-collisions.ts
+var nameCollisions = (declared) => {
+  const firstOf = new Map;
+  const found = [];
+  for (const one of declared) {
+    const { key } = one;
+    const first = firstOf.get(key);
+    if (first === undefined)
+      firstOf.set(key, one);
+    else
+      found.push({ key, first, second: one });
+  }
+  return found;
+};
+var describe = ({ key, first, second }) => first.name === second.name ? `"${first.name}" is declared twice, on lines ${first.line} and ${second.line}` : `"${first.name}" on line ${first.line} and "${second.name}" on line ${second.line} both read as "${key}"`;
+
+class SddNameCollisionError extends Error {
+  collisions;
+  constructor(collisions) {
+    super(`the Case Variables table declares variables the parser cannot tell apart: ${collisions.map(describe).join("; ")}. Each pair would merge into one variable with one Category, Type and Default. Rename one of each pair so the names differ by more than case, punctuation or a trailing (annotation).`);
+    this.collisions = collisions;
+    this.name = "SddNameCollisionError";
+  }
+}
+
+// ../case-tool/src/services/strict-sdd-audit/canvas-notes-read.ts
+var cellsOf = (line) => splitRowCells(line.trim().replace(/^\|/, "").replace(/\|$/, ""));
+var noteTable = (table) => {
+  const [head = "", ...rest] = table.split(`
+`).filter((line) => line.trim() !== "");
+  const separator = rest.length > 0 && cellsOf(rest[0]).every((cell) => cell === "" || isSeparatorCell(cell)) && cellsOf(rest[0]).some(isSeparatorCell);
+  return {
+    header: cellsOf(head),
+    rows: (separator ? rest.slice(1) : rest).map(cellsOf)
+  };
+};
+var readCanvasNotes = (sdd, title, body) => {
+  const { header, rows } = noteTable(body);
+  const wanted = ["Content", "Note", "Text"];
+  const contentAt = columnIndex(header, ...wanted);
+  const colorAt = columnIndex(header, "Color", "Colour");
+  if (contentAt === undefined) {
+    if (rows.length > 0) {
+      sdd.parseNotes.push(noNameColumnNote(title, wanted, header));
+    }
+    return;
+  }
+  const offered = new Set(CANVAS_NOTE_COLORS);
+  for (const [at, row] of rows.entries()) {
+    const content = cellAt(row, contentAt).trim();
+    if (content === "") {
+      sdd.parseNotes.push("canvas note row has no Content, so no note was written for it");
+      continue;
+    }
+    const stated = stripTicks(cellAt(row, colorAt)).trim();
+    const color = isBlank(stated) ? "" : stated.toLowerCase();
+    if (color !== "" && !offered.has(color)) {
+      sdd.parseNotes.push(`canvas note colour "${stated}" is not one the Case Designer offers (${CANVAS_NOTE_COLORS.join(", ")}); the note keeps the default colour`);
+    }
+    sdd.canvasNotes.push({
+      row: at + 1,
+      ...offered.has(color) && { color },
+      content
+    });
+  }
+};
+var readCanvasNotesSection = (sdd, section, seen) => {
+  const { title, body } = section;
+  const own = section.children.length > 0 ? body.slice(0, section.children[0].start - section.contentStart) : body;
+  const tables = pipeTables(own).filter((table) => noteTable(table).rows.some((row) => row.some((cell) => cell.trim() !== "")));
+  if (tables.length === 0)
+    return seen;
+  const later = seen ? tables.length : tables.length - 1;
+  if (later > 0) {
+    sdd.parseNotes.push(`section "${title}": ${later === 1 ? "a second Canvas Notes table is" : `${later} more Canvas Notes tables are`} not read, because each note is named by its row and two tables would name two notes alike; put every note in one table`);
+  }
+  if (seen)
+    return true;
+  readCanvasNotes(sdd, title, tables[0]);
+  return true;
+};
+
 // ../case-tool/src/services/strict-sdd-audit/sdd-stage.ts
 var readTaskRows = (title, block, notes) => {
   const { header, rows } = firstTable(block);
@@ -3038,7 +3632,7 @@ var conditionalSlaRows = (block) => {
   const found = [];
   const nameAt = columnIndex(header, "Display Name", "Title");
   for (const row of rows) {
-    const expression = (row[expressionAt] ?? "").trim();
+    const expression = unwrapCodeSpan(row[expressionAt] ?? "").trim();
     if (expression === "" || expression.startsWith("<"))
       continue;
     const count = (row[slaAt] ?? "").trim();
@@ -3148,6 +3742,7 @@ var parseStage = (name, section, notes) => {
     task.boundInputs = detail.boundInputs;
     task.extractRows = detail.extractRows;
     task.customRows = detail.customRows;
+    task.unreadTables = detail.unreadTables;
     task.resolvedResource = detail.resolvedResource;
     task.identityResolved = detail.identityResolved;
     task.folder = detail.folder;
@@ -3173,6 +3768,8 @@ var parseStage = (name, section, notes) => {
     task.timerValue = detail.timerValue;
     if (!task.type && detail.type)
       task.type = detail.type;
+    if (detail.http !== undefined && String(task.type ?? "").trim().toLowerCase() === "http-request")
+      task.http = detail.http;
   }
   const empty = {
     conditions: !(stage.entryRows && stage.exitRows),
@@ -3191,7 +3788,7 @@ var parseStage = (name, section, notes) => {
 };
 
 // ../case-tool/src/services/strict-sdd-audit/sdd-parse.ts
-var applyCaseSection = (sdd, title, body) => {
+var applyCaseSection = (sdd, title, body, headingLine, declaredNames) => {
   if (headingIs(title, CASE_EXIT_HEADINGS)) {
     const merged = addConditionTable(sdd.caseExitRows, sdd.caseExitConditions, body);
     sdd.caseExitRows = merged.rows;
@@ -3287,7 +3884,7 @@ var applyCaseSection = (sdd, title, body) => {
     }
   } else if (headingIs(title, CASE_VARIABLE_HEADINGS)) {
     sdd.sawVariableSection = true;
-    const { header, rows } = firstTable(body);
+    const { header, rows, rowLines } = firstTable(body);
     const wanted = ["Name", "Variable", "Variable Name"];
     const nameAt = columnIndex(header, ...wanted);
     const categoryAt = columnIndex(header, "Category");
@@ -3300,10 +3897,15 @@ var applyCaseSection = (sdd, title, body) => {
     } else if (rows.length > 0 && categoryAt === undefined) {
       sdd.parseNotes.push(noCategoryColumnNote(title, header));
     }
-    for (const row of rows) {
+    for (const [index, row] of rows.entries()) {
       const name = cellAt(row, nameAt);
       if (name && !isBlank(name)) {
         sdd.variables.push(stripTicks(name.trim()));
+        declaredNames.push({
+          name: stripTicks(name.trim()),
+          key: norm(name),
+          line: headingLine + rowLines[index]
+        });
         const declaredType = stripTicks(cellAt(row, typeAt).trim()).trim();
         if (declaredType !== "" && !isBlank(declaredType)) {
           sdd.variableTypes.set(norm(name), declaredType);
@@ -3404,6 +4006,16 @@ var applySlaResponses = (sdd) => {
       stage.slaResponses = merge(stage.slaResponses, atRisk, breach);
   }
 };
+var lineAt = (text, offset) => {
+  let line = 1;
+  for (let at = text.indexOf(`
+`);at !== -1 && at < offset; ) {
+    line += 1;
+    at = text.indexOf(`
+`, at + 1);
+  }
+  return line;
+};
 var parseSdd = (text) => {
   const document = normalizeSdd(text);
   const sdd = {
@@ -3426,14 +4038,22 @@ var parseSdd = (text) => {
     caseConditionalSlas: [],
     xrefOutputs: xrefProducers(document),
     resourceOutputs: resourceOutputsByTask(document),
+    canvasNotes: [],
     parseNotes: []
   };
   const lookalikes = [];
+  const declaredNames = [];
+  let sawCanvasNotes = false;
   for (const section of document.allSections) {
     const { level, title, body } = section;
+    if ((level === 2 || level === 3) && headingIs(title, CANVAS_NOTE_HEADINGS)) {
+      sawCanvasNotes = readCanvasNotesSection(sdd, section, sawCanvasNotes);
+      continue;
+    }
     if (level !== 3)
       continue;
-    if (applyCaseSection(sdd, title, body))
+    const headingLine = lineAt(text, section.start);
+    if (applyCaseSection(sdd, title, body, headingLine, declaredNames))
       continue;
     const stageName = readStageHeading(title);
     if (stageName !== undefined) {
@@ -3456,6 +4076,9 @@ var parseSdd = (text) => {
     if (empty[topic])
       sdd.parseNotes.push(unrecognizedHeadingNote(title, 3));
   }
+  const collisions = nameCollisions(declaredNames);
+  if (collisions.length > 0)
+    throw new SddNameCollisionError(collisions);
   return sdd;
 };
 
@@ -3522,6 +4145,7 @@ var parseSddToJson = (text) => {
     ...sdd.caseDescription !== undefined && {
       caseDescription: sdd.caseDescription
     },
+    ...sdd.canvasNotes.length > 0 && { canvasNotes: sdd.canvasNotes },
     intake: {
       caseExitRows: sdd.caseExitRows,
       sawVariableSection: sdd.sawVariableSection,
@@ -3530,7 +4154,14 @@ var parseSddToJson = (text) => {
   };
 };
 var auditCaseplanAgainstSdd = (parsed, sddText, sddName, ledger) => {
-  const sdd = parseSdd(sddText);
+  const [parseError, sdd] = catchError(() => parseSdd(sddText));
+  if (parseError instanceof SddNameCollisionError) {
+    return [
+      error("STRICT_SDD_NAME_COLLISION", sddName, `"${sddName}": ${parseError.message}`)
+    ];
+  }
+  if (parseError)
+    throw parseError;
   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>\`.`));
@@ -3540,6 +4171,6 @@ var auditCaseplanAgainstSdd = (parsed, sddText, sddName, ledger) => {
   issues.push(...slaReferenceFindings(sddText, sddName));
   return issues;
 };
-export { CASE_SLA_PROPERTY, VARIABLE_PLACEMENT, DEFAULT_GROUP, STAGE_SELECTOR_RULES, TASK_SELECTOR_RULES, parseIfCell, bodySchemaIn, parseSddToJson, auditCaseplanAgainstSdd };
+export { CASE_SLA_PROPERTY, VARIABLE_PLACEMENT, DEFAULT_GROUP, markDeferredOutputs, expandXrefs, expandOutputMarkers, declaredOutputs, outputTypeFor, outputFor, variableOutputType, extractOutputFor, customOutputFor, canonicalExpression, unquoteLiteral, inputsFor, STAGE_SELECTOR_RULES, TASK_SELECTOR_RULES, parseIfCell, bodySchemaIn, parseSddToJson, auditCaseplanAgainstSdd };
 
-//# debugId=0113344A654DDCE664756E2164756E21
+//# debugId=2CDB1F719150BEAA64756E2164756E21