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

package/dist/sdd-convert-service-gp9733qv.js

@@ -0,0 +1,1962 @@
+import {
+  CONNECTOR_TASK_TYPES
+} from "./packager-tool-dthjwajc.js";
+import {
+  BINDING_REFERENCE_PREFIX,
+  NAME_BOUND_TASK_TYPES
+} from "./packager-tool-d7jjng8a.js";
+import {
+  FILE_TYPE_JSON_SCHEMA
+} from "./packager-tool-xkgq5fkf.js";
+import {
+  CASE_SLA_PROPERTY,
+  DEFAULT_GROUP,
+  STAGE_SELECTOR_RULES,
+  TASK_SELECTOR_RULES,
+  VARIABLE_PLACEMENT,
+  parseIfCell
+} from "./packager-tool-4e56rmwe.js";
+import"./packager-tool-b250k6w4.js";
+import"./packager-tool-21qfsbxn.js";
+import {
+  namedValue,
+  withoutTrailingSlug
+} from "./packager-tool-f78ntj5g.js";
+import {
+  buildMinimalCaseDocument
+} from "./packager-tool-xcd87qyx.js";
+import {
+  prefixedId
+} from "./packager-tool-mknccck5.js";
+import"./packager-tool-nj4seavy.js";
+import {
+  byCodeUnit
+} from "./packager-tool-5qp9xza1.js";
+import {
+  catchError
+} from "./packager-tool-58kx79ta.js";
+import"./packager-tool-xdxr3ync.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/exit-condition-types.ts
+var EXIT_CONDITION_TYPES = new Set([
+  "exit-only",
+  "wait-for-user",
+  "return-to-origin"
+]);
+
+// src/services/sdd-convert/ids.ts
+var buildElementId = (stageId, taskId) => `${stageId}-${taskId}`;
+var SLUG_SUFFIX = /^(.*?)\s*\(\s*([^()]+?)\s*\)\s*$/;
+var stageSpellings = (text, position) => {
+  const plain = text.replaceAll("`", "").trim();
+  const names = [plain];
+  const found = SLUG_SUFFIX.exec(plain);
+  const bare = found?.[1].trim() ?? "";
+  const slug = found?.[2].trim() ?? "";
+  if (bare !== "" && bare !== plain)
+    names.push(bare);
+  return {
+    names,
+    ...slug !== "" && { slug },
+    ordinal: `stage ${position}`
+  };
+};
+var referenceSpellings = (text) => {
+  const { names, slug } = stageSpellings(text, 0);
+  return slug === undefined ? names : [...names, slug];
+};
+var indexKey = (name) => name.replaceAll("`", "").trim().toLowerCase();
+var everySpelling = (name, position) => {
+  const { names, slug, ordinal } = stageSpellings(name, position);
+  return [...names, ...slug === undefined ? [] : [slug], ordinal].map(indexKey);
+};
+var claim = (index, key, id) => {
+  if (!index.has(key))
+    index.set(key, id);
+};
+var dedupedId = (base, taken) => {
+  let id = base;
+  let suffix = 2;
+  while (taken.has(id)) {
+    id = `${base}${suffix}`;
+    suffix += 1;
+  }
+  taken.add(id);
+  return id;
+};
+var exactKey = (name) => name.replaceAll("`", "").trim();
+var claimOutput = (index, key, task, id) => {
+  const byTask = index.get(key) ?? new Map;
+  index.set(key, byTask);
+  if (!byTask.has(exactKey(task)))
+    byTask.set(exactKey(task), id);
+};
+var lookupOutput = (index, key, task) => {
+  const byTask = index.get(key);
+  if (byTask === undefined)
+    return;
+  const tasksNamed = (name, claim2) => typeof claim2 === "number" ? Array.from({ length: claim2 }, () => name) : [name];
+  const exact = byTask.get(exactKey(task));
+  if (exact !== undefined) {
+    return typeof exact === "number" ? { names: tasksNamed(exactKey(task), exact) } : { id: exact };
+  }
+  const [onlyName, only] = [...byTask.entries()][0] ?? [];
+  if (byTask.size === 1 && onlyName !== undefined && typeof only === "string") {
+    return { id: only };
+  }
+  return {
+    names: [...byTask].flatMap(([name, claim2]) => tasksNamed(name, claim2))
+  };
+};
+var scopedSlaKey = (scope, title) => `${scope}\x00${title}`;
+
+// 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 };
+};
+
+// src/services/sdd-convert/io.ts
+var taskMatcher = (model, taskName) => {
+  const mine = exactKey(taskName);
+  const folded = indexKey(taskName);
+  let unique = true;
+  for (const stage of model.stages) {
+    for (const other of stage.tasks) {
+      const name = exactKey(String(other.name ?? ""));
+      if (name !== mine && indexKey(name) === folded)
+        unique = false;
+    }
+  }
+  return {
+    names: (spelled) => exactKey(spelled) === mine || unique && indexKey(spelled) === folded,
+    unique
+  };
+};
+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 ?? []];
+  const add = (name) => {
+    if (name !== "" && !rows.includes(name))
+      rows.push(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);
+        }
+      }
+    }
+  }
+  if (matcher.unique) {
+    for (const name of model.resourceOutputs[indexKey(taskName)] ?? []) {
+      add(name);
+    }
+  }
+  return rows;
+};
+var OUTPUT_TYPES = new Map([
+  ["string", "string"],
+  ["object", "jsonSchema"],
+  ["json", "jsonSchema"],
+  ["jsonschema", "jsonSchema"]
+]);
+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) || indexKey(producer.output) !== indexKey(output)) {
+          continue;
+        }
+        const mapped = OUTPUT_TYPES.get(row.type.trim().toLowerCase().replaceAll(" ", ""));
+        if (mapped !== undefined)
+          return mapped;
+      }
+    }
+  }
+  return;
+};
+var outputFor = (row, elementId, taken, type) => {
+  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: `=${row}`,
+    target: `=${id}`,
+    elementId
+  };
+};
+var variableOutputType = (model, variable) => {
+  const declared = model.variableTypes[indexKey(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) => {
+  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: `=${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);
+};
+
+// src/services/sdd-convert/resources.ts
+var SDD_TASK_TYPES = new Set([
+  ...NAME_BOUND_TASK_TYPES,
+  ...CONNECTOR_TASK_TYPES,
+  "wait-for-timer"
+]);
+var UNAUTHORABLE_TASK_TYPES = new Set([
+  "business-rule",
+  "document-extraction",
+  "external-agent",
+  "external-workflow",
+  "flow-process",
+  "http-request",
+  "script"
+]);
+var RESOURCE_KINDS = new Map([
+  ["agent", { resource: "process", subType: "Agent" }],
+  ["process", { resource: "process", subType: "ProcessOrchestration" }],
+  ["api-workflow", { resource: "process", subType: "Api" }],
+  ["case-management", { resource: "process", subType: "CaseManagement" }],
+  ["function", { resource: "process", subType: "Function" }],
+  ["rpa", { resource: "process" }],
+  ["action", { resource: "app" }]
+]);
+var bindingPairFor = (resourceName, folderPath, type, ordinal) => {
+  const resourceKey = `${folderPath}.${resourceName}`;
+  const kind = RESOURCE_KINDS.get(type) ?? { resource: "process" };
+  const shared = {
+    type: "string",
+    resource: kind.resource,
+    ...kind.subType !== undefined && { resourceSubType: kind.subType },
+    resourceKey
+  };
+  const nameId = `bN${ordinal}`;
+  const folderId = `bF${ordinal}`;
+  return {
+    nameId,
+    folderId,
+    name: {
+      id: nameId,
+      name: "name",
+      ...shared,
+      default: resourceName,
+      propertyAttribute: "name"
+    },
+    folder: {
+      id: folderId,
+      name: "folderPath",
+      ...shared,
+      default: folderPath,
+      propertyAttribute: "folderPath"
+    }
+  };
+};
+var RECIPIENT_TYPES = new Map([["email", 2]]);
+var connectionPairFor = (connectionId, ordinal) => {
+  const shared = {
+    type: "string",
+    resource: "Connection",
+    resourceKey: connectionId
+  };
+  const connectionRef = `bOC${ordinal}`;
+  const folderRef = `bOF${ordinal}`;
+  return {
+    connectionRef,
+    folderRef,
+    connection: {
+      id: connectionRef,
+      name: "connection",
+      ...shared,
+      propertyAttribute: "ConnectionId"
+    },
+    folder: {
+      id: folderRef,
+      name: "folderKey",
+      ...shared,
+      propertyAttribute: "folderKey"
+    }
+  };
+};
+
+// src/services/sdd-convert/connector.ts
+var connectorInputs = (inputs, connector, elementId, where, unresolved) => {
+  if (connector === undefined)
+    return inputs;
+  if (inputs.length === 0) {
+    if (String(connector.serviceType ?? "") !== "Intsvc.WaitForEvent") {
+      return inputs;
+    }
+    const id = prefixedId("v", 8);
+    return [
+      { name: "body", type: "json", value: "", id, var: id, elementId }
+    ];
+  }
+  if (connector.method === undefined) {
+    unresolved.push({
+      kind: "connector-context",
+      where,
+      detail: `${inputs.length} connector input(s) stay flat: the document states no method for this activity, so which of pathParameters/queryParameters/body each belongs in is not decidable from it`
+    });
+    return inputs;
+  }
+  const bodies = new Map;
+  const kept = [];
+  for (const input of inputs) {
+    const field = String(input.name ?? "");
+    const container = containerFor(field, connector);
+    if (container === undefined) {
+      kept.push(input);
+      continue;
+    }
+    const body = bodies.get(container) ?? {};
+    body[field] = unquoteLiteral(String(input.value ?? ""));
+    bodies.set(container, body);
+  }
+  if (bodies.size === 0)
+    return kept;
+  if (!bodies.has("pathParameters"))
+    bodies.set("pathParameters", {});
+  const containers = [];
+  for (const name of ["pathParameters", "queryParameters", "body"]) {
+    const body = bodies.get(name);
+    if (body === undefined)
+      continue;
+    const id = prefixedId("v", 8);
+    containers.push({
+      name,
+      type: "json",
+      target: name,
+      body,
+      id,
+      var: id,
+      elementId
+    });
+  }
+  return [...containers, ...kept];
+};
+var connectorContextFor = (connector, where, connections, bindings, unresolved) => {
+  const entry = (name, value) => typeof value === "string" && value !== "" ? [{ name, type: "string", value }] : [];
+  const connectionId = String(connector.connectionId ?? "");
+  const context = [
+    ...entry("connectorKey", connector.connectorKey),
+    ...entry("resourceKey", connectionId),
+    ...entry("objectName", connector.objectName),
+    ...entry("operation", connector.operation ?? connector.method),
+    ...entry("method", connector.method),
+    ...entry("path", connector.path)
+  ];
+  if (connectionId !== "") {
+    let ref = connections.get(connectionId);
+    if (ref === undefined) {
+      const pair = connectionPairFor(connectionId, connections.size + 1);
+      bindings.push(pair.connection, pair.folder);
+      ref = pair.connectionRef;
+      connections.set(connectionId, ref);
+    }
+    context.push({
+      name: "connection",
+      type: "string",
+      value: `${BINDING_REFERENCE_PREFIX}${ref}`
+    });
+  } else {
+    unresolved.push({
+      kind: "connector-connection",
+      where,
+      detail: "the document names no connection id, so nothing can be bound for this activity"
+    });
+  }
+  const activityTypeId = String(connector.activityTypeId ?? "");
+  if (activityTypeId !== "") {
+    context.push({
+      name: "metadata",
+      type: "json",
+      body: {
+        activityPropertyConfiguration: {
+          uiPathActivityTypeId: activityTypeId
+        }
+      }
+    });
+  }
+  unresolved.push({
+    kind: "connector-context",
+    where,
+    detail: `\`folderKey\` binds the folder's GUID and \`metadata.activityPropertyConfiguration.configuration\` carries the connector version and instance parameters; the document states a folder path and no schema, so ${activityTypeId === "" ? "those and the activity type id" : "both"} come from \`case spec\` against a tenant`
+  });
+  return context;
+};
+var QUERY_METHODS = new Set(["GET", "HEAD", "DELETE", "OPTIONS"]);
+var containerFor = (field, connector) => {
+  const method = String(connector?.method ?? "").toUpperCase();
+  if (method === "")
+    return;
+  const path = String(connector?.path ?? "");
+  if (path.includes(`{${field}}`))
+    return "pathParameters";
+  return QUERY_METHODS.has(method) ? "queryParameters" : "body";
+};
+
+// src/services/sdd-convert/rules.ts
+var RULE_VOCABULARY = new Set([
+  "wait-for-connector",
+  "case-entered",
+  "selected-stage-completed",
+  "selected-stage-exited",
+  "selected-tasks-completed",
+  "current-stage-entered",
+  "adhoc",
+  "required-stages-completed",
+  "required-tasks-completed",
+  "user-selected-stage",
+  "runs-sequentially",
+  "sla-status-change",
+  "api-event"
+]);
+var parseWhen = (cell) => {
+  const text = cell.replaceAll("`", "").trim();
+  const bare = /^([a-z-]+)/i.exec(text);
+  const rule = bare ? bare[1] : "";
+  const open = text.indexOf("(");
+  if (rule === "" || open === -1)
+    return { rule, argumentList: [] };
+  let depth = 0;
+  let close = -1;
+  for (let at = open;at < text.length; at += 1) {
+    if (text[at] === "(")
+      depth += 1;
+    else if (text[at] === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        close = at;
+        break;
+      }
+    }
+  }
+  const inner = text.slice(open + 1, close === -1 ? undefined : close);
+  const quoted = [...inner.matchAll(/"([^"]*)"/g)].map((match) => match[1].trim());
+  if (quoted.length > 0) {
+    return { rule, argumentList: quoted.filter((one) => one !== "") };
+  }
+  const plain = inner.split("(")[0].trim();
+  return { rule, argumentList: plain === "" ? [] : [plain] };
+};
+var resolveStage = (argument, stages) => {
+  for (const variant of referenceSpellings(argument)) {
+    const found = stages.get(indexKey(variant));
+    if (found !== undefined)
+      return found;
+  }
+  const prefix = indexKey(argument);
+  const matches = [...stages.entries()].filter(([name]) => name.startsWith(prefix) && /^[\s\-:_]/.test(name.slice(prefix.length)));
+  return matches.length === 1 ? matches[0][1] : undefined;
+};
+var ruleFor = (condition, idPrefix, context) => {
+  const whenCell = typeof condition.when === "string" ? condition.when : "";
+  const { rule, argumentList } = parseWhen(whenCell);
+  const parsedIf = parseIfCell(typeof condition.ifExpression === "string" ? condition.ifExpression : "");
+  const ifExpression = parsedIf.expression;
+  if (!RULE_VOCABULARY.has(rule)) {
+    context.unresolved.push({
+      kind: "condition-rule",
+      where: context.where,
+      detail: whenCell === "" ? "the condition row names no WHEN rule, so the condition is left out" : `the WHEN cell "${whenCell}" is not one of the rules the plan accepts, so the condition is left out`
+    });
+    return;
+  }
+  const base = { id: prefixedId(`${idPrefix}r`, 6), rule };
+  if (ifExpression !== "" && ifExpression !== "—") {
+    base.conditionExpression = canonicalExpression(expandXrefs(ifExpression, context));
+  }
+  const argument = argumentList[0];
+  const selectorMiss = (what, named) => {
+    context.unresolved.push({
+      kind: "selector-target",
+      where: context.where,
+      detail: `\`${rule}\` selects ${named === undefined ? `no ${what}` : `a ${what} named "${named}", which this SDD does not declare`}`
+    });
+  };
+  if (STAGE_SELECTOR_RULES.has(rule)) {
+    const wanted = parsedIf.stage ?? argument;
+    const id = wanted === undefined ? undefined : resolveStage(wanted, context.stages);
+    if (id === undefined)
+      selectorMiss("stage", parsedIf.stage ?? argument);
+    else
+      base.selectedStageIds = [id];
+  } else if (TASK_SELECTOR_RULES.has(rule)) {
+    const named = parsedIf.tasks === undefined ? argumentList : parsedIf.tasks.split(",").map((one) => one.trim());
+    const ids = [];
+    for (const name of named) {
+      const exact = context.tasks.get(name);
+      const folded = exact === undefined ? context.taskNameConflicts?.get(indexKey(name)) : undefined;
+      const id = exact ?? (folded === undefined ? context.tasks.get(indexKey(name)) : undefined);
+      if (id !== undefined && context.stageTasks?.has(id) === false) {
+        context.unresolved.push({
+          kind: "selector-target",
+          where: context.where,
+          detail: `\`${rule}\` selects a task named "${name}", which is in another stage. A stage's rules and its tasks' rules select only that stage's own tasks, so name one of them`
+        });
+        continue;
+      }
+      if (id !== undefined) {
+        ids.push(id);
+        continue;
+      }
+      if (folded === undefined) {
+        selectorMiss("task", name);
+        continue;
+      }
+      const shared = new Set(folded).size < folded.length;
+      if (shared) {
+        context.unresolved.push({
+          kind: "selector-target",
+          where: context.where,
+          detail: `\`${rule}\` selects a task named "${name}", and ${folded.length} tasks answer to it (${[
+            ...new Set(folded)
+          ].map((one) => `"${one}"`).join(", ")}). Task names are unique across the case, so rename all but one and point the selector at the one it means`
+        });
+        continue;
+      }
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `\`${rule}\` selects a task named "${name}", which matches none of this SDD's task names exactly and more than one when case and surrounding space are ignored (${folded.map((one) => `"${one}"`).join(", ")}) — task names are compared exactly, so the selector has to spell one of them`
+      });
+    }
+    if (ids.length === 0 && named.length === 0) {
+      selectorMiss("task");
+    }
+    if (ids.length > 0)
+      base.selectedTasksIds = ids;
+  } else if (rule === "sla-status-change") {
+    const title = argumentList.at(-1);
+    const found = title === undefined ? undefined : context.slas?.get(indexKey(title));
+    if (found === undefined) {
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `\`sla-status-change\` selects ${title === undefined ? "no SLA" : `an SLA named "${title}", which neither the case nor any stage in this SDD declares`}`
+      });
+    } else {
+      if (argumentList.length < 2) {
+        base.slaId = found.id;
+      } else {
+        const named = argumentList[0];
+        const scope = indexKey(named) === "root" ? "root" : resolveStage(named, context.stages);
+        if (scope === undefined) {
+          selectorMiss("stage", named);
+          base.slaId = found.id;
+        } else {
+          const own = context.slas?.get(scopedSlaKey(scope, indexKey(title ?? "")));
+          if (own !== undefined) {
+            base.slaId = own.id;
+          } else {
+            context.unresolved.push({
+              kind: "selector-target",
+              where: context.where,
+              detail: `\`sla-status-change\` names the SLA "${title}" in ${scope === "root" ? "the case" : `stage "${named}"`}, and that SLA belongs to ${found.stageId === "root" ? "the case" : "another stage"}, so the rule is left without an \`slaId\` rather than watching an SLA it was not written for`
+            });
+          }
+        }
+      }
+    }
+  } else if (rule === "wait-for-connector") {
+    if (context.connector === undefined || context.connections === undefined || context.bindings === undefined) {
+      context.unresolved.push({
+        kind: "connector-connection",
+        where: context.where,
+        detail: "a `wait-for-connector` rule needs its activity's context, and no `**Connector Rule Detail:**` accompanies this stage's entry table"
+      });
+    } else {
+      base.uipath = {
+        ...context.connector.serviceType !== undefined && {
+          serviceType: context.connector.serviceType
+        },
+        context: connectorContextFor(context.connector, context.where, context.connections, context.bindings, context.unresolved)
+      };
+    }
+  }
+  return base;
+};
+var displayNameOf = (condition) => {
+  const name = String(condition.displayName ?? "").trim();
+  return name === "" ? {} : { displayName: name };
+};
+var entryConditionFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    isInterrupting: condition.interrupting === true,
+    rules: [[rule]]
+  };
+};
+var caseExitRuleFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    marksCaseComplete: condition.marksComplete === true,
+    rules: [[rule]]
+  };
+};
+var exitConditionFor = (condition, context) => {
+  const rule = ruleFor(condition, "Rule_", context);
+  if (rule === undefined)
+    return;
+  const declaredExit = typeof condition.exitType === "string" && condition.exitType !== "" ? condition.exitType.trim() : undefined;
+  const exitType = declaredExit !== undefined && EXIT_CONDITION_TYPES.has(declaredExit) ? declaredExit : undefined;
+  if (declaredExit !== undefined && exitType === undefined) {
+    context.unresolved.push({
+      kind: "case-exit",
+      where: `${context.where}.type`,
+      detail: `the exit type "${declaredExit}" is none of ${[...EXIT_CONDITION_TYPES].map((type) => `\`${type}\``).join(", ")}, so no type is written — the rule still exits, and whichever of those three the document meant has to be chosen`
+    });
+  }
+  const exitTo = typeof condition.exitToStage === "string" ? condition.exitToStage : "";
+  let exitToStageId;
+  if (exitTo !== "") {
+    exitToStageId = resolveStage(exitTo, context.stages);
+    if (exitToStageId === undefined) {
+      context.unresolved.push({
+        kind: "selector-target",
+        where: context.where,
+        detail: `the Exit-To Stage cell names "${exitTo}", which this SDD does not declare as a stage, so the exit routes nowhere`
+      });
+    }
+  }
+  return {
+    id: prefixedId("Condition_", 6),
+    ...displayNameOf(condition),
+    ...exitType !== undefined && { type: exitType },
+    ...exitToStageId !== undefined && { exitToStageId },
+    marksStageComplete: condition.marksComplete === true,
+    rules: [[rule]]
+  };
+};
+
+// src/services/sdd-convert/metadata.ts
+var TIMER_VALUE_FIELDS = new Map([
+  ["timeduration", "timeDuration"],
+  ["timedate", "timeDate"],
+  ["timecycle", "timeCycle"]
+]);
+var timerData = (task) => {
+  const declared = task.timerType;
+  if (declared === undefined || declared.trim() === "")
+    return {};
+  const key = TIMER_VALUE_FIELDS.get(declared.trim().toLowerCase().replaceAll(" ", ""));
+  if (key === undefined)
+    return {};
+  return {
+    timerType: key,
+    ...task.timerValue !== undefined && task.timerValue.trim() !== "" && { [key]: task.timerValue.trim() }
+  };
+};
+var SLA_DURATION = /^(\d+)\s*([a-z]+)$/i;
+var SLA_UNITS = new Map([
+  ["min", "min"],
+  ["mins", "min"],
+  ["minute", "min"],
+  ["minutes", "min"],
+  ["h", "h"],
+  ["hr", "h"],
+  ["hrs", "h"],
+  ["hour", "h"],
+  ["hours", "h"],
+  ["d", "d"],
+  ["day", "d"],
+  ["days", "d"],
+  ["w", "w"],
+  ["wk", "w"],
+  ["wks", "w"],
+  ["week", "w"],
+  ["weeks", "w"],
+  ["m", "m"],
+  ["mo", "m"],
+  ["month", "m"],
+  ["months", "m"]
+]);
+var slaRuleFor = (displayName, duration, rows, where, unresolved, asked = {}) => {
+  const parts = SLA_DURATION.exec(duration.trim());
+  if (parts === null)
+    return;
+  const unit = SLA_UNITS.get(parts[2].toLowerCase());
+  if (unit === undefined)
+    return;
+  const escalations = rows.map((row) => {
+    const recipients = row.recipients.map((one) => {
+      if (one.kind === "user") {
+        return { scope: "User", target: one.value, value: one.value };
+      }
+      unresolved.push({
+        kind: "sla-recipient",
+        where,
+        detail: `the ${row.label} threshold notifies the group "${one.value}", and the plan addresses a group by the tenant's id — the document carries only the name, so the target is left as a marker`
+      });
+      return {
+        scope: "UserGroup",
+        target: `<UNRESOLVED: group-uuid for "${one.value}">`,
+        value: one.value
+      };
+    });
+    return {
+      id: prefixedId("esc_", 6),
+      displayName: `${row.label} notification`,
+      action: {
+        type: "notification",
+        recipients
+      },
+      triggerInfo: {
+        type: row.status,
+        ...row.percentage !== undefined && {
+          atRiskPercentage: row.percentage
+        }
+      }
+    };
+  });
+  const owed = [
+    {
+      status: "at-risk",
+      table: asked.table?.atRisk === true,
+      map: asked.map?.atRisk === true,
+      fromTable: "the SLA table declares an At-Risk action",
+      fromMap: "the SLA Response Map gives this SLA an At-Risk response",
+      needs: "an at-risk escalation"
+    },
+    {
+      status: "sla-breached",
+      table: asked.table?.breach === true,
+      map: asked.map?.breach === true,
+      fromTable: "the SLA table declares a Breach action that notifies",
+      fromMap: "the SLA Response Map gives this SLA a notify-only Breached response",
+      needs: "a breach escalation"
+    }
+  ];
+  for (const { status, table, map, fromTable, fromMap, needs } of owed) {
+    if (!table && !map)
+      continue;
+    const covered = rows.some((row) => row.status === status && row.recipients.length > 0);
+    if (covered)
+      continue;
+    const source = table ? fromTable : fromMap;
+    const gap = table ? "the cell names no one it notifies" : "no SLA table row names who it notifies; the planner writes that recipient in prose, in the Design Rationale or the map row's Rationale";
+    unresolved.push({
+      kind: "sla-recipient",
+      where,
+      detail: `${source}, which needs ${needs}, and ${gap}, so the escalation is left out`
+    });
+  }
+  return {
+    id: prefixedId("sla_", 6),
+    displayName,
+    expression: "=js:true",
+    count: Number(parts[1]),
+    unit,
+    ...escalations.length > 0 && { escalationRule: escalations }
+  };
+};
+
+// src/services/sdd-convert/triggers.ts
+var MANUAL_TRIGGERS = new Set(["manual", "none", "n/a", "na"]);
+var TRIGGER_SERVICE_TYPES = new Map([
+  ["timer", "timer"],
+  ["intsvc.timertrigger", "timer"],
+  ["intsvc.eventtrigger", "Intsvc.EventTrigger"]
+]);
+var TRIGGER_TIMER_FIELD = "timeCycle";
+var triggerTimer = (configuration) => {
+  const stated = (configuration ?? "").trim();
+  if (stated === "")
+    return;
+  const match = /^([A-Za-z]+)\s*[:=]?\s*(?:"([^"]+)"|\u201c([^\u201d]+)\u201d|'([^']+)'|([^\s,;:=][^\s,;]*))/.exec(stated);
+  const field = match === null ? undefined : TIMER_VALUE_FIELDS.get(match[1].toLowerCase());
+  if (match === null || field === undefined)
+    return { rejected: stated };
+  if (field !== TRIGGER_TIMER_FIELD)
+    return { rejected: stated };
+  const value = match[2] ?? match[3] ?? match[4] ?? match[5] ?? "";
+  if (value === "")
+    return { rejected: stated };
+  return { timerType: field, timeCycle: value };
+};
+var triggerPlans = (model) => (model.triggerRows ?? []).flatMap((row, position) => {
+  const declared = row.type.trim();
+  const rejected = [];
+  const label = row.displayName ?? `Trigger ${position + 1}`;
+  if (declared === "") {
+    return [
+      {
+        serviceType: "None",
+        row,
+        label,
+        rejected,
+        typeMissing: true
+      }
+    ];
+  }
+  const key = indexKey(declared);
+  if (MANUAL_TRIGGERS.has(key)) {
+    return [{ serviceType: "None", row, label, rejected }];
+  }
+  const serviceType = TRIGGER_SERVICE_TYPES.get(key);
+  if (serviceType === undefined) {
+    rejected.push(declared);
+    return [{ serviceType: "None", row, label, rejected }];
+  }
+  if (serviceType !== "timer") {
+    return [{ serviceType, row, label, rejected }];
+  }
+  const timer = triggerTimer(row.configuration);
+  if (timer !== undefined && "rejected" in timer) {
+    return [
+      {
+        serviceType,
+        row,
+        label,
+        rejected,
+        timerRejected: timer.rejected
+      }
+    ];
+  }
+  return [{ serviceType, row, label, ...timer, rejected }];
+});
+
+// src/services/sdd-convert/variables.ts
+var boundTriggerFor = (declared, triggers) => {
+  if (triggers.length === 0)
+    return { ambiguous: "the document declares no trigger" };
+  if (triggers.length === 1)
+    return { id: triggers[0].id };
+  const named = (declared ?? "").trim();
+  if (named !== "") {
+    const match = triggers.find((t) => t.tNumber !== undefined && indexKey(t.tNumber) === indexKey(named));
+    return match === undefined ? { ambiguous: `no trigger row carries the id "${named}"` } : { id: match.id };
+  }
+  const callable = triggers.filter((t) => t.serviceType !== "timer");
+  if (callable.length === 1)
+    return { id: callable[0].id };
+  return {
+    ambiguous: callable.length === 0 ? "every declared trigger is a timer, so none of them is the one a caller starts the case through" : `${callable.length} of the declared triggers are non-timer, so which one a blank \`sourceTriggers\` means is not stated`
+  };
+};
+var jsonSchemaBody = (name, type, model, unresolved) => {
+  if (type !== "jsonSchema")
+    return;
+  const declared = model.variableBodies?.[indexKey(name)];
+  if (declared === undefined || declared.trim() === "") {
+    unresolved.push({
+      kind: "variable-body",
+      where: `variables[${name}].body`,
+      detail: `"${name}" is a \`jsonSchema\` variable and its row states no \`Body schema:\` — the packager reads \`body ?? _jsonSchema\` to build the entry point's schema for it, so with neither the variable packages as an empty property and a caller has no shape to fill`
+    });
+    return;
+  }
+  const [error, parsed] = catchError(() => JSON.parse(declared));
+  if (error || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    unresolved.push({
+      kind: "variable-body",
+      where: `variables[${name}].body`,
+      detail: `"${name}" states a \`Body schema:\` that is not a JSON object (${JSON.stringify(declared.slice(0, 60))}), so it is left off rather than guessed at — the packager reads it straight through into the entry point's schema`
+    });
+    return;
+  }
+  return parsed;
+};
+var caseVariablesFor = (model, triggers = [], unresolved = []) => {
+  const buckets = { inputs: [], outputs: [], inputOutputs: [], bridges: new Map };
+  const categorised = model.variables.filter((name) => model.variableCategories[indexKey(name)] !== undefined).length;
+  if (model.variables.length > 0 && categorised === 0) {
+    unresolved.push({
+      kind: "variable-category",
+      where: "variables",
+      detail: `the \`### Case Variables\` table declares ${model.variables.length} variable(s) and no Category column, so none can be placed: each becomes a pure-state \`Variable\` on the case root, and any row the document means as \`In\` or \`Out\` loses the formal argument slot that a caller writes to`
+    });
+  }
+  for (const name of model.variables) {
+    const key = indexKey(name);
+    const declaredCategory = model.variableCategories[key];
+    if (declaredCategory === undefined && categorised > 0) {
+      unresolved.push({
+        kind: "variable-category",
+        where: `variables[${name}]`,
+        detail: `"${name}" has no Category where other rows in this table do, so it is placed as a pure-state \`Variable\` on the case root — if the document means it as \`In\` or \`Out\` it loses its formal argument slot`
+      });
+    }
+    const category = declaredCategory ?? "variable";
+    const groups = VARIABLE_PLACEMENT.get(category) ?? ["inputOutputs"];
+    const carriesDefault = DEFAULT_GROUP.get(category) ?? "inputOutputs";
+    const type = model.variableTypes[key] ?? "string";
+    const body = jsonSchemaBody(name, type, model, unresolved);
+    const fileBody = category === "in" && type === "file" ? FILE_TYPE_JSON_SCHEMA : undefined;
+    const declared = model.variableDefaults[key] ?? "";
+    const bound = category === "in" ? boundTriggerFor(model.variableSourceTriggers?.[key], triggers) : undefined;
+    if (bound !== undefined && "ambiguous" in bound) {
+      unresolved.push({
+        kind: "in-arg-trigger",
+        where: `variables.inputs[${name}].elementId`,
+        detail: `the \`In\` argument "${name}" attaches to a trigger — its formal slot, its companion and the bridge that copies the caller's value all live on that node — and ${bound.ambiguous}, so it is left on the case root where \`=vars.${name}\` reads nothing at run time`
+      });
+    }
+    const elementId = bound !== undefined && "id" in bound ? bound.id : "root";
+    let formalId;
+    for (const group of groups) {
+      const formal = group !== "inputOutputs";
+      const id = formal ? prefixedId("v", 8) : name;
+      if (formal && category === "in")
+        formalId = id;
+      buckets[group].push({
+        id,
+        name,
+        ...body !== undefined && { body, _jsonSchema: body },
+        ...fileBody !== undefined && { body: fileBody },
+        ...formal && { var: name },
+        type,
+        ...group === carriesDefault && { default: declared },
+        ...category === "variable" && { custom: true },
+        elementId
+      });
+    }
+    if (formalId !== undefined && elementId !== "root") {
+      const list = buckets.bridges.get(elementId) ?? [];
+      list.push({
+        name,
+        type,
+        source: `=vars.${formalId}`,
+        var: name
+      });
+      buckets.bridges.set(elementId, list);
+    }
+  }
+  return buckets;
+};
+
+// src/services/sdd-convert/case-level.ts
+var finishCaseDocument = (document, model, index, unresolved) => {
+  const { planned, stageIds, taskIds, outputIds, bindings, connections } = index;
+  let conditionCount = 0;
+  const plans = triggerPlans(model);
+  const emittedTriggers = [];
+  const scaffolded = document.nodes.find((node) => node.data?.inputs !== undefined);
+  if (plans.length === 0) {
+    unresolved.push({
+      kind: "trigger-type",
+      where: "nodes[trigger 1].data.inputs.serviceType",
+      detail: "the document declares no trigger, so the plan carries the scaffolded manual trigger (`serviceType: None`) — state the case's start in a `### Case Triggers` table (`| Trigger | Type |` with `manual`, `Intsvc.EventTrigger` or `timer`) if it starts any other way"
+    });
+  }
+  for (const [position, plan] of plans.entries()) {
+    if (plan.typeMissing === true) {
+      unresolved.push({
+        kind: "trigger-type",
+        where: `nodes[trigger ${position + 1}].data.inputs.serviceType`,
+        detail: `the Case Triggers row "${plan.label}" states no type, so this trigger carries \`serviceType: None\` — the manual start — which is a guess at what the row meant; state one of the three tokens the case schema names (None, Intsvc.EventTrigger, timer)`
+      });
+    }
+    for (const declared of plan.rejected) {
+      unresolved.push({
+        kind: "trigger-type",
+        where: `nodes[trigger ${position + 1}].data.inputs.serviceType`,
+        detail: `the Case Triggers table declares "${declared}", which is not one of the three tokens the case schema names (None, Intsvc.EventTrigger, timer) — emitting it verbatim would classify the trigger as a connector with no event definition, so it is left as declared in the document and not written to the plan`
+      });
+    }
+    const inputs = { serviceType: plan.serviceType };
+    if (plan.serviceType === "timer") {
+      if (plan.timeCycle === undefined) {
+        unresolved.push({
+          kind: "trigger-timer",
+          where: `nodes[trigger ${position + 1}].data.inputs.timeCycle`,
+          detail: `a timer trigger needs its interval, which the Case Triggers table states in its Configuration cell as \`timeCycle: <ISO 8601 repeating interval>\` or \`timeCycle "<interval>"\` — this row states ${plan.timerRejected === undefined ? "none" : `"${plan.timerRejected}", which names no interval this trigger can carry`}`
+        });
+      } else {
+        inputs.timerType = plan.timerType;
+        inputs.timeCycle = plan.timeCycle;
+      }
+    } else if (plan.serviceType !== "None") {
+      const eventSource = plan.row?.source;
+      if (eventSource !== undefined && eventSource !== "") {
+        inputs.context = [
+          { name: "objectName", type: "string", value: eventSource }
+        ];
+      }
+      unresolved.push({
+        kind: "connector-context",
+        where: `nodes[trigger ${position + 1}].data.inputs.context`,
+        detail: `a "${plan.serviceType}" trigger needs its connection, connector key, event mode and filter, which come from \`case spec\` against a tenant — the document names ${eventSource === undefined || eventSource === "" ? "no source object either" : `only the source object "${eventSource}"`}`
+      });
+    }
+    if (position === 0 && scaffolded !== undefined) {
+      const data = scaffolded.data;
+      data.inputs = inputs;
+      emittedTriggers.push({
+        id: String(scaffolded.id),
+        ...plan.row?.id !== undefined && { tNumber: plan.row.id },
+        serviceType: plan.serviceType
+      });
+      if (plan.row?.displayName !== undefined) {
+        data.display = { label: plan.row.displayName };
+      }
+      continue;
+    }
+    const appendedId = prefixedId("trigger_", 6);
+    emittedTriggers.push({
+      id: appendedId,
+      ...plan.row?.id !== undefined && { tNumber: plan.row.id },
+      serviceType: plan.serviceType
+    });
+    document.nodes.push({
+      id: appendedId,
+      type: "uipath.case.trigger",
+      data: {
+        parentElement: { id: "root", type: "case-management:root" },
+        typeVersion: "1.0.0",
+        display: { label: plan.label },
+        inputs
+      }
+    });
+  }
+  if (bindings.length > 0)
+    document.bindings = bindings;
+  const declaredType = model.caseIdentifierType;
+  const identifierType = declaredType === "constant" || declaredType === "external" ? declaredType : undefined;
+  if (declaredType !== undefined && identifierType === undefined) {
+    unresolved.push({
+      kind: "case-identifier",
+      where: "metadata.caseIdentifierType",
+      detail: `the Case Metadata table declares a case identifier of type "${declaredType}", and the case schema names two — \`constant\` and \`external\` — so the field is left off rather than written as a value nothing accepts`
+    });
+  }
+  const identifier = identifierType === "external" ? model.caseIdentifierSource : model.caseIdentifierPrefix;
+  if (identifierType === "external" && model.caseIdentifierSource === undefined) {
+    unresolved.push({
+      kind: "case-identifier",
+      where: "metadata.caseIdentifier",
+      detail: "the Case Metadata table declares an `external` case identifier and states no `Source:` clause for it, so the plan is left with no identifier at all rather than a constant every instance would share"
+    });
+  }
+  if (identifierType === "constant" && model.caseIdentifierPrefix === undefined) {
+    unresolved.push({
+      kind: "case-identifier",
+      where: "metadata.caseIdentifier",
+      detail: "the Case Metadata table declares a `constant` case identifier and states no `Prefix:` clause for it, so the plan carries no identifier — name it in the same cell (`Type: constant. Prefix: ABC`)"
+    });
+  }
+  const seeded = { ...document.metadata };
+  if (declaredType !== undefined) {
+    delete seeded.caseIdentifier;
+    delete seeded.caseIdentifierType;
+  }
+  document.metadata = {
+    ...seeded,
+    ...identifierType !== undefined && identifier !== undefined && { caseIdentifier: identifier },
+    ...identifierType !== undefined && {
+      caseIdentifierType: identifierType
+    },
+    ...model.caseAppEnabled !== undefined && {
+      caseAppEnabled: model.caseAppEnabled
+    },
+    ...model.directTaskOutputs === true && {
+      caseDirectlyPassTaskOutputs: true
+    },
+    ...connections.size > 0 && { intsvcActivityConfig: "v2" }
+  };
+  const entersOnCaseEntered = planned.some(({ stage }) => stage.entryConditions.some((condition) => {
+    const when = String(condition.when ?? "");
+    return parseWhen(when).rule === "case-entered";
+  }));
+  if (!entersOnCaseEntered && planned.length > 0) {
+    unresolved.push({
+      kind: "case-entry",
+      where: "nodes[].data.entryConditions",
+      detail: "no stage declares a `case-entered` entry condition, so nothing makes a first stage eligible and the case never starts"
+    });
+  }
+  const slaRules = index.caseSla === undefined ? [] : [index.caseSla];
+  if (slaRules.length > 0) {
+    document.metadata = { ...document.metadata, slaRules };
+  } else if (model.caseSla === true || /\d/.test(String(model.caseSlaDuration ?? ""))) {
+    const stated = String(model.caseSlaDuration ?? "").trim();
+    unresolved.push({
+      kind: "case-sla",
+      where: "metadata.slaRules",
+      detail: `this SDD declares a case SLA but no rule could be emitted from it: the duration cell is ${stated === "" ? "absent" : `\`${stated}\`, which gives no count and unit`}. Any conditional rules or escalations it declares outside a recognised SLA heading are not carried either — a combined rule table under a heading like \`SLA Escalation\`, or a condition written as prose rather than an expression, is left for authoring rather than guessed at`
+    });
+  }
+  const caseVariables = caseVariablesFor(model, emittedTriggers, unresolved);
+  for (const [triggerId, bridges] of caseVariables.bridges) {
+    const node = document.nodes.find((one) => one.id === triggerId);
+    if (node === undefined)
+      continue;
+    const data = node.data;
+    const inputs = data.inputs ?? {};
+    inputs.outputs = [
+      ...inputs.outputs ?? [],
+      ...bridges
+    ];
+    data.inputs = inputs;
+  }
+  const variableCount = caseVariables.inputs.length + caseVariables.outputs.length + caseVariables.inputOutputs.length;
+  if (variableCount > 0) {
+    const { bridges: _bridges, ...variableGroups } = caseVariables;
+    document.variables = { ...document.variables, ...variableGroups };
+  }
+  const caseExitRules = model.caseExitConditions.map((condition) => caseExitRuleFor(condition, {
+    where: "metadata.caseExitRules",
+    stages: stageIds,
+    tasks: taskIds,
+    taskNameConflicts: index.taskNameConflicts,
+    outputs: outputIds,
+    unresolved
+  })).filter((condition) => condition !== undefined);
+  if (caseExitRules.length > 0) {
+    document.metadata = { ...document.metadata, caseExitRules };
+    conditionCount += caseExitRules.length;
+  }
+  if (!caseExitRules.some((rule) => rule.marksCaseComplete === true) && planned.length > 0) {
+    unresolved.push({
+      kind: "case-exit",
+      where: "metadata.caseExitRules",
+      detail: model.caseExitConditions.length === 0 ? "the document declares no Case Exit Conditions, so nothing marks the case complete" : "no Case Exit Conditions row answers yes under Marks Case Complete, so nothing marks the case complete"
+    });
+  }
+  if (planned.length === 0) {
+    unresolved.push({
+      kind: "stages",
+      where: "nodes",
+      detail: "the document declares no stages, so the plan has a trigger and nothing to run"
+    });
+  }
+  const userSelected = planned.filter(({ stage }) => stage.entryConditions.some((condition) => parseWhen(String(condition.when ?? "")).rule === "user-selected-stage"));
+  if (userSelected.length > 0) {
+    const handsOver = planned.some(({ stage }) => stage.exitConditions.some((condition) => String(condition.exitType ?? "").trim().toLowerCase() === "wait-for-user"));
+    if (!handsOver) {
+      unresolved.push({
+        kind: "stage-handoff",
+        where: `nodes[${userSelected[0].stage.name}].data.entryConditions`,
+        detail: "a `user-selected-stage` entry rule needs some other stage to hand over to the user — an exit condition with Exit Type `wait-for-user` — and this document declares none"
+      });
+    }
+  }
+  return { conditionCount };
+};
+
+// src/services/sdd-convert/emit.ts
+var isDeferredTask = (resolved, stageName, task) => {
+  const type = typeof task.type === "string" ? task.type : "";
+  return (NAME_BOUND_TASK_TYPES.has(type) || CONNECTOR_TASK_TYPES.has(type)) && resolved?.deferred?.has(`${stageName}\x01${String(task.name ?? "")}`) === true;
+};
+var emitTask = (task, taskId, context) => {
+  const { stage, stageId, index, unresolved, stageTasks } = context;
+  const {
+    stageIds,
+    taskIds,
+    outputIds,
+    outputsByTask,
+    bindings,
+    bindingsByKey,
+    connections,
+    slaIds
+  } = index;
+  const where = `nodes[${stage.name}]`;
+  let conditions = 0;
+  const elementId = buildElementId(stageId, taskId);
+  const type = typeof task.type === "string" ? task.type : "";
+  const taskWhere = `${where}.data.tasks[${String(task.name ?? "")}]`;
+  const timer = timerData(task);
+  if (type === "wait-for-timer") {
+    const valueField = timer.timerType === undefined ? undefined : timer[String(timer.timerType)];
+    if (timer.timerType === undefined) {
+      unresolved.push({
+        kind: "trigger-timer",
+        where: `${taskWhere}.data`,
+        detail: "this `wait-for-timer` task declares no timer type the schema names (`timeDuration`, `timeDate` or `timeCycle`), so it emits with no timer fields and `validate` reports `TIMER_TASK_MISSING_TIMER_TYPE`"
+      });
+    } else if (valueField === undefined || String(valueField) === "") {
+      unresolved.push({
+        kind: "trigger-timer",
+        where: `${taskWhere}.data`,
+        detail: `this \`wait-for-timer\` task declares \`${String(timer.timerType)}\` and no value, so \`validate\` reports \`TIMER_TASK_MISSING_VALUE\``
+      });
+    }
+  }
+  if (type === "" || !SDD_TASK_TYPES.has(type)) {
+    unresolved.push({
+      kind: "task-type",
+      where: taskWhere,
+      detail: type === "" ? "the Tasks table row names no type, so the task cannot be emitted with one" : UNAUTHORABLE_TASK_TYPES.has(type) ? `the Tasks table row declares the type "${type}", a caseplan task type an SDD may not declare. Author this task in Studio Web.` : `the Tasks table row declares the type "${type}", which is not one of the ${SDD_TASK_TYPES.size} an SDD may use (${[
+        ...SDD_TASK_TYPES
+      ].sort(byCodeUnit).join(", ")}) — the task is left out rather than emitted with a type nothing resolves`
+    });
+    return { conditions: 0 };
+  }
+  const entryConditionsOf = () => (task.entryConditions ?? []).map((condition) => entryConditionFor(condition, {
+    where: `${taskWhere}.entryConditions`,
+    stages: stageIds,
+    tasks: taskIds,
+    taskNameConflicts: index.taskNameConflicts,
+    stageTasks,
+    outputs: outputIds,
+    slas: slaIds,
+    unresolved
+  })).filter((condition) => condition !== undefined);
+  const skip = typeof task.skipCondition === "string" && task.skipCondition !== "" ? canonicalExpression(expandXrefs(task.skipCondition, {
+    outputs: outputIds,
+    where: `${taskWhere}.skipCondition`,
+    unresolved
+  })) : undefined;
+  if (isDeferredTask(index.resolved, stage.name, task)) {
+    const placeholderConditions = entryConditionsOf();
+    unresolved.push({
+      kind: "placeholder",
+      where: taskWhere,
+      detail: `the resolved file defers this "${type}" task's resource, so it is emitted as a placeholder with an empty \`data\`; resolve it, then fill the task with \`uip maestro case tasks describe\` and \`uip maestro case splice\``
+    });
+    if (placeholderConditions.length === 0) {
+      unresolved.push({
+        kind: "task-entry-condition",
+        where: taskWhere,
+        detail: "no entry condition could be read for this task; a task with no entry rules never becomes eligible, and `case debug` waits on it forever"
+      });
+    }
+    return {
+      task: {
+        id: taskId,
+        type,
+        displayName: String(task.name ?? ""),
+        ...task.prose !== undefined && { description: task.prose },
+        elementId,
+        ...placeholderConditions.length > 0 && {
+          entryConditions: placeholderConditions
+        },
+        isRequired: task.required !== false,
+        shouldRunOnlyOnce: task.runOnlyOnce === true,
+        ...skip !== undefined && { skipCondition: skip },
+        data: {}
+      },
+      conditions: placeholderConditions.length
+    };
+  }
+  const recipient = task.recipient;
+  const recipientType = recipient === undefined ? undefined : RECIPIENT_TYPES.get(recipient.kind);
+  if (recipient !== undefined && recipientType === undefined) {
+    unresolved.push({
+      kind: "task-recipient",
+      where: taskWhere,
+      detail: `the Recipient row names a "${recipient.kind}" recipient, and the plan's numeric \`Type\` code for that kind is not one this command knows`
+    });
+  }
+  const settled = index.resolved?.byTask.get(`${stage.name}\x01${String(task.name ?? "")}`);
+  const resourceName = namedValue(task.resourceName) || (settled?.name ?? "");
+  const folderPath = namedValue(task.folder) || (settled?.folder ?? "");
+  let bound;
+  if (NAME_BOUND_TASK_TYPES.has(type)) {
+    if (resourceName === "" || folderPath === "") {
+      unresolved.push({
+        kind: "resource-binding",
+        where: taskWhere,
+        detail: `a "${type}" task runs a tenant resource, and ${index.resolved === undefined ? `this SDD names ${resourceName === "" && folderPath === "" ? "neither the resource nor its folder" : resourceName === "" ? "no resource (only the folder)" : "no folder (only the resource)"}` : `neither this SDD nor the resolved file supplies ${resourceName === "" && folderPath === "" ? "the resource or its folder" : resourceName === "" ? "the resource (only the folder is named)" : "its folder (only the resource is named)"}`}, so its name/folderPath pair cannot be bound${index.resolved === undefined ? " — `sdd resolve` can supply a missing folder, and `sdd convert --resolved` reads it" : ""}`
+      });
+    } else {
+      const key = JSON.stringify([type, folderPath, resourceName]);
+      const existing = bindingsByKey.get(key);
+      if (existing !== undefined)
+        bound = existing;
+      else {
+        const pair = bindingPairFor(resourceName, folderPath, type, bindingsByKey.size + 1);
+        bindings.push(pair.name, pair.folder);
+        bound = {
+          nameId: pair.nameId,
+          folderId: pair.folderId
+        };
+        bindingsByKey.set(key, bound);
+      }
+    }
+  }
+  const connector = CONNECTOR_TASK_TYPES.has(type) && task.connector !== undefined ? task.connector : undefined;
+  if (CONNECTOR_TASK_TYPES.has(type) && connector === undefined) {
+    unresolved.push({
+      kind: "connector-connection",
+      where: taskWhere,
+      detail: `a "${type}" task needs a connection and the activity's context, and this SDD declares neither`
+    });
+  }
+  let connectorContext;
+  if (connector !== undefined) {
+    connectorContext = connectorContextFor(connector, taskWhere, connections, bindings, unresolved);
+  }
+  const taskConditions = entryConditionsOf();
+  conditions += taskConditions.length;
+  if (taskConditions.length === 0) {
+    unresolved.push({
+      kind: "task-entry-condition",
+      where: taskWhere,
+      detail: "no entry condition could be read for this task; a task with no entry rules never becomes eligible, and `case debug` waits on it forever"
+    });
+  }
+  const emitted = {
+    id: taskId,
+    ...type !== "" && { type },
+    displayName: String(task.name ?? ""),
+    ...task.prose !== undefined && { description: task.prose },
+    elementId,
+    ...taskConditions.length > 0 && {
+      entryConditions: taskConditions
+    },
+    isRequired: task.required !== false,
+    shouldRunOnlyOnce: task.runOnlyOnce === true,
+    ...skip !== undefined && { skipCondition: skip },
+    data: {
+      ...bound !== undefined && {
+        name: `${BINDING_REFERENCE_PREFIX}${bound.nameId}`,
+        folderPath: `${BINDING_REFERENCE_PREFIX}${bound.folderId}`
+      },
+      ...connector?.serviceType !== undefined && {
+        serviceType: connector.serviceType
+      },
+      ...connectorContext !== undefined && {
+        context: connectorContext
+      },
+      inputs: connectorInputs(inputsFor(task, elementId, taskWhere, unresolved, outputIds), connector, elementId, taskWhere, unresolved),
+      outputs: [...outputsByTask.get(taskId)?.values() ?? []].map((output) => expandOutputMarkers(output, {
+        outputs: outputIds,
+        where: taskWhere,
+        unresolved
+      })),
+      ...type === "action" && task.taskTitle !== undefined && {
+        taskTitle: task.taskTitle
+      },
+      ...type === "action" && task.priority !== undefined && { priority: task.priority },
+      ...type === "action" && task.labels !== undefined && { labels: task.labels },
+      ...recipientType !== undefined && recipient !== undefined && {
+        recipient: {
+          Type: recipientType,
+          Value: recipient.value
+        }
+      },
+      ...timer
+    }
+  };
+  return { task: emitted, conditions };
+};
+var SHARES_WITH_SIBLING = "parallel-after-predecessor";
+var taskSets = (tasks, declared) => {
+  if (declared.some((one) => one.index !== undefined)) {
+    const indexes = declared.map((one) => one.index).filter((index) => index !== undefined);
+    const before = Math.min(...indexes) - 1;
+    const keyed = [];
+    let run = before;
+    for (const [position, task] of tasks.entries()) {
+      const index = declared[position]?.index;
+      if (index !== undefined)
+        run = index;
+      keyed.push({
+        run,
+        at: index === undefined ? position + 1 : 0,
+        key: index === undefined ? `at:${position}` : `set:${index}`,
+        task
+      });
+    }
+    keyed.sort((a, b) => a.run - b.run || a.at - b.at);
+    const sets2 = new Map;
+    for (const one of keyed) {
+      sets2.set(one.key, [...sets2.get(one.key) ?? [], one.task]);
+    }
+    return { sets: [...sets2.values()], undeclared: [] };
+  }
+  const sets = [];
+  const undeclaredSets = new Set;
+  let previous;
+  for (const [position, task] of tasks.entries()) {
+    const mode = declared[position]?.mode;
+    const last = sets.at(-1);
+    const shares = mode !== undefined && indexKey(mode) === SHARES_WITH_SIBLING && previous !== undefined && indexKey(previous) === SHARES_WITH_SIBLING;
+    const undeclared = mode === undefined && !startsOnItsOwnRule(task);
+    if (last !== undefined && (shares || undeclared && undeclaredSets.has(last))) {
+      last.push(task);
+    } else {
+      sets.push([task]);
+      if (undeclared)
+        undeclaredSets.add(sets[sets.length - 1]);
+    }
+    previous = mode;
+  }
+  return {
+    sets,
+    undeclared: sets.filter((set) => set.length > 1 && undeclaredSets.has(set))
+  };
+};
+var startsOnItsOwnRule = (task) => {
+  const conditions = task.entryConditions ?? [];
+  return conditions.length > 0 && !conditions.some((condition) => (condition.rules ?? []).some((set) => set.some((rule) => rule.rule === "runs-sequentially")));
+};
+var emitStages = (document, model, index, unresolved) => {
+  const {
+    planned,
+    stageIds,
+    taskIds,
+    outputIds,
+    outputsByTask,
+    bindings,
+    bindingsByKey,
+    connections,
+    slaIds
+  } = index;
+  let taskCount = 0;
+  let conditionCount = 0;
+  for (const { stage, stageId, tasks: plannedTasks, stageSla } of planned) {
+    const where = `nodes[${stage.name}]`;
+    const tasks = [];
+    const declared = [];
+    const stageTasks = new Set(plannedTasks.map(({ taskId }) => taskId));
+    for (const { task, taskId } of plannedTasks) {
+      const emitted = emitTask(task, taskId, {
+        stage,
+        stageId,
+        model,
+        index,
+        unresolved,
+        stageTasks
+      });
+      conditionCount += emitted.conditions;
+      if (emitted.task === undefined)
+        continue;
+      declared.push({
+        ...typeof task.activationMode === "string" && {
+          mode: task.activationMode
+        },
+        ...typeof task.taskSet === "number" && {
+          index: task.taskSet
+        }
+      });
+      tasks.push(emitted.task);
+      taskCount += 1;
+    }
+    const context = (kind) => ({
+      where: `${where}.data.${kind}`,
+      stages: stageIds,
+      tasks: taskIds,
+      taskNameConflicts: index.taskNameConflicts,
+      stageTasks,
+      outputs: outputIds,
+      slas: slaIds,
+      unresolved,
+      ...kind === "entryConditions" && stage.entryConnector !== undefined && {
+        connector: stage.entryConnector,
+        connections,
+        bindings
+      }
+    });
+    const entryConditions = stage.entryConditions.map((condition) => entryConditionFor(condition, context("entryConditions"))).filter((condition) => condition !== undefined);
+    const exitConditions = stage.exitConditions.map((condition) => exitConditionFor(condition, context("exitConditions"))).filter((condition) => condition !== undefined);
+    conditionCount += entryConditions.length + exitConditions.length;
+    const { sets, undeclared } = taskSets(tasks, declared);
+    for (const set of undeclared) {
+      unresolved.push({
+        kind: "task-grouping",
+        where: `${where}.data.tasks`,
+        detail: `this stage declares no Activation Mode or Task set for ${set.map((task) => `"${String(task.displayName)}"`).join(", ")}, so they share one set and run as parallel siblings; if the document means a strict chain, give each its own set`
+      });
+    }
+    document.nodes.push({
+      id: stageId,
+      type: "case-management:Stage",
+      data: {
+        ...stage.kind === "secondary" && {
+          stageType: "secondary"
+        },
+        label: withoutTrailingSlug(stage.name),
+        ...stage.description !== undefined && {
+          description: stage.description
+        },
+        ...stage.required !== undefined && {
+          isRequired: stage.required
+        },
+        parentElement: { id: "root", type: "case-management:root" },
+        isInvalidDropTarget: false,
+        isPendingParent: false,
+        ...stageSla !== undefined && { slaRules: [stageSla] },
+        tasks: sets,
+        entryConditions,
+        exitConditions
+      }
+    });
+  }
+  return { taskCount, conditionCount };
+};
+
+// src/services/sdd-convert/plan.ts
+var taskNameOf = (task) => typeof task.name === "string" ? task.name : "";
+var countByName = (entries) => {
+  const counts = new Map;
+  for (const [name] of entries) {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return counts;
+};
+var reportRepeatedTaskNames = (stagesByTaskName, unresolved) => {
+  for (const [name, stages] of stagesByTaskName) {
+    if (stages.length < 2 || name === "")
+      continue;
+    const stageNames = [...new Set(stages)].map((one) => `"${one}"`).join(", ");
+    unresolved.push({
+      kind: "task-name",
+      where: `nodes[${stages[0]}].data.tasks[${name}]`,
+      detail: `${stages.length} tasks are named "${name}" (in ${stageNames}). Task names are unique across the case, so rename all but one`
+    });
+  }
+};
+var planCase = (model, unresolved) => {
+  const stageIds = new Map;
+  const taskIds = new Map;
+  const outputIds = new Map;
+  const takenOutputIds = new Set;
+  const tasksByExactName = [];
+  const stagesByTaskName = new Map;
+  const tasksByFolded = new Map;
+  const stagesBySlug = [];
+  const stagesByOrdinal = [];
+  const outputsBySlug = [];
+  const outputsByOrdinal = [];
+  const outputsByTask = new Map;
+  const bindings = [];
+  const bindingsByKey = new Map;
+  const connections = new Map;
+  const slaIds = new Map;
+  const planned = model.stages.map((stage, position) => {
+    const stageId = prefixedId("Stage_");
+    const stageSla = slaRuleFor(String(stage.slaTitle ?? `${stage.name} SLA`), String(stage.slaDuration ?? ""), stage.slaEscalationRows ?? [], `nodes[${stage.name}].data.sla`, unresolved, { table: stage.slaEscalations, map: stage.slaResponses });
+    if (stageSla !== undefined) {
+      const entry = { id: String(stageSla.id), stageId };
+      const title = indexKey(String(stageSla.displayName));
+      slaIds.set(title, entry);
+      slaIds.set(scopedSlaKey(stageId, title), entry);
+    } else if (stage.hasSla === true || /\d/.test(String(stage.slaDuration ?? ""))) {
+      const stated = String(stage.slaDuration ?? "").trim();
+      unresolved.push({
+        kind: "case-sla",
+        where: `nodes[${stage.name}].data.slaRules`,
+        detail: `this stage declares an SLA and no rule could be emitted from it: the duration cell is ${stated === "" ? "absent, so the escalation rows have no duration to be a percentage of" : `\`${stated}\`, which gives no count and a unit the case schema names (min, h, d, w, m, and the spellings that map to them)`}. The stage's SLA title, duration and escalation rows are all dropped together, so authoring the duration is what carries them`
+      });
+    }
+    const spelling = stageSpellings(stage.name, position + 1);
+    for (const name of spelling.names) {
+      claim(stageIds, indexKey(name), stageId);
+    }
+    if (spelling.slug !== undefined) {
+      stagesBySlug.push([indexKey(spelling.slug), stageId]);
+    }
+    stagesByOrdinal.push([indexKey(spelling.ordinal), stageId]);
+    const namesInStage = stage.tasks.map(taskNameOf);
+    const tasksInStage = new Map;
+    for (const name of namesInStage) {
+      tasksInStage.set(name, (tasksInStage.get(name) ?? 0) + 1);
+    }
+    const tasks = stage.tasks.map((task) => {
+      const taskId = prefixedId("t", 8);
+      const taskName = taskNameOf(task);
+      tasksByExactName.push([taskName, taskId]);
+      stagesByTaskName.set(taskName, [
+        ...stagesByTaskName.get(taskName) ?? [],
+        stage.name
+      ]);
+      const folded = tasksByFolded.get(indexKey(taskName)) ?? new Map;
+      folded.set(taskName, taskId);
+      tasksByFolded.set(indexKey(taskName), folded);
+      const own = new Map;
+      const indexOutput = (labels, output) => {
+        const sharing = tasksInStage.get(taskName) ?? 1;
+        const claimed = sharing > 1 ? sharing : String(output.id);
+        for (const label of labels) {
+          const suffix = `${indexKey(taskName)}|${indexKey(label)}`;
+          for (const name of spelling.names) {
+            claimOutput(outputIds, `${indexKey(name)}|${suffix}`, taskName, claimed);
+          }
+          if (spelling.slug !== undefined) {
+            outputsBySlug.push([
+              `${indexKey(spelling.slug)}|${suffix}`,
+              taskName,
+              claimed
+            ]);
+          }
+          outputsByOrdinal.push([
+            `${indexKey(spelling.ordinal)}|${suffix}`,
+            taskName,
+            claimed
+          ]);
+        }
+      };
+      const extractByField = new Map;
+      for (const entry of task.extractRows ?? []) {
+        const field = String(entry.field ?? "");
+        const variable = String(entry.variable ?? "");
+        if (field !== "" && variable !== "") {
+          extractByField.set(field, variable);
+        }
+      }
+      for (const row of declaredOutputs(model, stage.name, position + 1, task)) {
+        const consumerType = outputTypeFor(model, everySpelling(stage.name, position + 1), taskName, row);
+        const variable = extractByField.get(row);
+        const type = consumerType ?? (variable === undefined ? undefined : variableOutputType(model, variable));
+        if (type === undefined) {
+          unresolved.push({
+            kind: "output-type",
+            where: `nodes[${stage.name}].data.tasks[${taskName}].outputs[${row}]`,
+            detail: "no row in this SDD types this output; its shape comes from the resolved resource's own schema, which needs a tenant — `uip maestro case tasks describe --type <type> --id <id>` returns it, and `uip maestro case splice <plan> --task-id <taskId> --described <that result>` writes it in"
+          });
+        }
+        const output = variable === undefined ? outputFor(row, buildElementId(stageId, taskId), takenOutputIds, type) : extractOutputFor({ field: row, variable }, buildElementId(stageId, taskId), takenOutputIds, type);
+        own.set(row, output);
+        indexOutput(new Set([
+          row,
+          String(output.name),
+          ...variable === undefined ? [] : [variable]
+        ]), output);
+      }
+      for (const entry of task.customRows ?? []) {
+        const row = {
+          variable: String(entry.variable ?? ""),
+          expression: String(entry.expression ?? "")
+        };
+        if (row.variable === "")
+          continue;
+        const custom = customOutputFor(row, variableOutputType(model, row.variable));
+        const declared = own.get(row.variable);
+        const output = declared === undefined ? custom : { ...custom, id: declared.id };
+        own.set(declared === undefined ? `custom:${row.variable}` : row.variable, output);
+        indexOutput(new Set([row.variable]), {
+          ...output,
+          id: output.id ?? row.variable
+        });
+      }
+      outputsByTask.set(taskId, own);
+      return { task, taskId };
+    });
+    return { stage, stageId, tasks, stageSla };
+  });
+  const tasksPerName = countByName(tasksByExactName);
+  reportRepeatedTaskNames(stagesByTaskName, unresolved);
+  const taskNameConflicts = new Map;
+  for (const [key, byName] of tasksByFolded) {
+    const names = [...byName.keys()].flatMap((name) => Array.from({ length: tasksPerName.get(name) ?? 1 }, () => name));
+    if (names.length === 1) {
+      const only = [...byName.values()][0];
+      if (only !== undefined)
+        taskIds.set(key, only);
+    } else {
+      taskNameConflicts.set(key, names);
+    }
+  }
+  for (const [name, id] of tasksByExactName) {
+    if (tasksPerName.get(name) === 1)
+      taskIds.set(name, id);
+  }
+  const caseSla = slaRuleFor(model.caseSlaTitle ?? CASE_SLA_PROPERTY, String(model.caseSlaDuration ?? ""), model.caseSlaEscalationRows, "metadata.slaRules", unresolved, { table: model.caseSlaEscalations, map: model.caseSlaResponses });
+  if (caseSla !== undefined) {
+    const key = indexKey(String(caseSla.displayName));
+    const entry = { id: String(caseSla.id), stageId: "root" };
+    if (!slaIds.has(key))
+      slaIds.set(key, entry);
+    slaIds.set(scopedSlaKey("root", key), entry);
+  }
+  for (const [key, id] of stagesBySlug)
+    claim(stageIds, key, id);
+  for (const [key, id] of stagesByOrdinal)
+    claim(stageIds, key, id);
+  for (const [key, task, id] of outputsBySlug)
+    claimOutput(outputIds, key, task, id);
+  for (const [key, task, id] of outputsByOrdinal)
+    claimOutput(outputIds, key, task, id);
+  return {
+    planned,
+    stageIds,
+    taskIds,
+    taskNameConflicts,
+    outputIds,
+    outputsByTask,
+    bindings,
+    bindingsByKey,
+    connections,
+    slaIds,
+    ...caseSla !== undefined && { caseSla }
+  };
+};
+
+// src/services/sdd-convert/rule-names.ts
+var asArray = (value) => Array.isArray(value) ? value : [];
+var asRow = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var uniquifyConditionNames = (document) => {
+  const owned = [];
+  const collect = (conditions, owner) => {
+    for (const entry of asArray(conditions)) {
+      const condition = asRow(entry);
+      if (condition === undefined)
+        continue;
+      const name = condition.displayName;
+      if (typeof name !== "string" || name.trim() === "")
+        continue;
+      owned.push({ condition, owner });
+    }
+  };
+  for (const node of asArray(document.nodes)) {
+    const data = asRow(asRow(node)?.data);
+    if (data === undefined)
+      continue;
+    const stage = typeof data.label === "string" ? data.label : "";
+    collect(data.entryConditions, stage);
+    collect(data.exitConditions, stage);
+    for (const lane of asArray(data.tasks)) {
+      for (const entry of asArray(lane)) {
+        const task = asRow(entry);
+        const name = typeof task?.displayName === "string" ? task.displayName : "";
+        collect(task?.entryConditions, name === "" ? stage : name);
+      }
+    }
+  }
+  collect(asRow(document.metadata)?.caseExitRules, "case");
+  const taken = new Set;
+  const seen = new Set;
+  for (const { condition } of owned) {
+    taken.add(String(condition.displayName).trim());
+  }
+  let renamed = 0;
+  for (const { condition, owner } of owned) {
+    const name = String(condition.displayName).trim();
+    if (!seen.has(name)) {
+      seen.add(name);
+      continue;
+    }
+    const base = owner === "" ? name : `${name} (${owner})`;
+    let candidate = base;
+    for (let n = 2;taken.has(candidate); n += 1) {
+      candidate = `${base} ${n}`;
+    }
+    taken.add(candidate);
+    seen.add(candidate);
+    condition.displayName = candidate;
+    renamed += 1;
+  }
+  return renamed;
+};
+
+// src/services/sdd-convert-service.ts
+var convertSddToCasePlan = (model, options) => {
+  const document = buildMinimalCaseDocument({
+    name: options.name,
+    schemaVersion: options.schemaVersion,
+    ...options.description !== undefined && {
+      description: options.description
+    }
+  });
+  const unresolved = [];
+  const index = planCase(model, unresolved);
+  if (options.resolved !== undefined)
+    index.resolved = options.resolved;
+  const placeholderOutputs = new Set;
+  for (const planned of index.planned) {
+    for (const { task, taskId } of planned.tasks) {
+      if (!isDeferredTask(index.resolved, planned.stage.name, task)) {
+        continue;
+      }
+      for (const output of index.outputsByTask.get(taskId)?.values() ?? []) {
+        const id = output.id ?? output.var;
+        if (typeof id === "string")
+          placeholderOutputs.add(id);
+      }
+    }
+  }
+  markDeferredOutputs(index.outputIds, placeholderOutputs);
+  const { taskCount, conditionCount } = emitStages(document, model, index, unresolved);
+  const caseLevel = finishCaseDocument(document, model, index, unresolved);
+  uniquifyConditionNames(document);
+  return {
+    document,
+    derived: {
+      stages: model.stages.length,
+      tasks: taskCount,
+      conditions: conditionCount + caseLevel.conditionCount,
+      variables: model.variables.length
+    },
+    unresolved
+  };
+};
+export {
+  convertSddToCasePlan
+};
+
+//# debugId=39653583D0D6907964756E2164756E21