@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{sdd-convert-service-8jpew7vz.js → sdd-convert-service-ffbx00k6.js}

@@ -1,473 +1,95 @@
+import"./packager-tool-1wgav5ma.js";
+import"./packager-tool-yh8mmj3p.js";
 import {
-  canonicalVariableType,
-  gateKey
-} from "./packager-tool-k6jbedyc.js";
+  withoutTrailingSlug,
+  namedValue
+} from "./packager-tool-fcektt1g.js";
 import {
-  designerShapeConnectorTasks
-} from "./packager-tool-a17g0pj1.js";
+  emitBusinessEvents,
+  connectorInputs,
+  connectorContextFor,
+  parseWhen,
+  entryConditionFor,
+  caseExitRuleFor,
+  exitConditionFor
+} from "./packager-tool-vyavrbym.js";
+import {
+  markDeferredOutputs,
+  expandXrefs,
+  expandOutputMarkers,
+  declaredOutputs,
+  outputTypeFor,
+  outputFor,
+  variableOutputType,
+  rowOutputType,
+  unmappedOutputType,
+  extractOutputFor,
+  customOutputFor,
+  canonicalExpression,
+  inputsFor
+} from "./packager-tool-1nfdj0zm.js";
+import"./packager-tool-z070caqq.js";
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import"./packager-tool-h2ar8xf8.js";
+import {
+  NAME_BOUND_TASK_TYPES,
+  BINDING_REFERENCE_PREFIX
+} from "./packager-tool-nfhtwa72.js";
+import"./packager-tool-mk9fmzdy.js";
+import {
+  CONNECTOR_CALL_TASK_TYPES
+} from "./packager-tool-7x1tmb8a.js";
+import {
+  hasFixedOutputs,
+  fixedOutputName,
+  ERROR_OUTPUT_SCHEMA,
+  FILE_TYPE_JSON_SCHEMA,
+  BUSINESS_RULE_TASK_VERSION
+} from "./packager-tool-0w4fsdzv.js";
 import {
-  RECIPIENT_TYPES,
   SDD_TASK_TYPES,
   UNAUTHORABLE_TASK_TYPES,
-  bindingPairFor,
-  connectionPairFor
-} from "./packager-tool-4p11fvf4.js";
+  bindingPairFor
+} from "./packager-tool-b2q8m9pq.js";
 import {
-  CONNECTOR_TASK_TYPES
-} from "./packager-tool-93mdeqay.js";
+  CASE_SLA_PROPERTY,
+  VARIABLE_PLACEMENT2,
+  DEFAULT_GROUP2
+} from "./packager-tool-9ar5829n.js";
 import {
-  emitCanvasNotes
-} from "./packager-tool-r0x3qh59.js";
+  gateKey,
+  canonicalVariableType
+} from "./packager-tool-hcdnc420.js";
 import {
-  BINDING_REFERENCE_PREFIX,
-  NAME_BOUND_TASK_TYPES
-} from "./packager-tool-87y6xw3a.js";
+  designerShapeConnectorTasks2
+} from "./packager-tool-xd1wbvay.js";
 import {
-  CASE_SLA_PROPERTY,
-  DEFAULT_GROUP,
-  STAGE_SELECTOR_RULES,
-  TASK_SELECTOR_RULES,
-  VARIABLE_PLACEMENT,
-  canonicalExpression,
-  customOutputFor,
-  declaredOutputs,
-  expandOutputMarkers,
-  expandXrefs,
-  extractOutputFor,
-  inputsFor,
-  markDeferredOutputs,
-  outputFor,
-  outputTypeFor,
-  parseIfCell,
-  unquoteLiteral,
-  variableOutputType
-} from "./packager-tool-kyrm4e5m.js";
-import"./packager-tool-b250k6w4.js";
+  caseRolesFor,
+  emitCanvasNotes
+} from "./packager-tool-388vyja1.js";
 import {
   buildElementId,
-  claim,
-  claimOutput,
-  dedupedId,
-  everySpelling,
+  stageSpellings,
   indexKey,
   modelKey,
-  referenceSpellings,
-  scopedSlaKey,
-  stageSpellings
-} from "./packager-tool-9kvkzc05.js";
-import {
-  BUSINESS_RULE_TASK_VERSION,
-  FILE_TYPE_JSON_SCHEMA,
-  httpRequestOutputName
-} from "./packager-tool-ydyvtknp.js";
-import"./packager-tool-21qfsbxn.js";
-import {
-  namedValue,
-  withoutTrailingSlug
-} from "./packager-tool-9y1w2wds.js";
+  everySpelling,
+  claim,
+  dedupedId,
+  claimOutput,
+  scopedSlaKey
+} from "./packager-tool-5w0gjcck.js";
 import {
   buildMinimalCaseDocument
-} from "./packager-tool-v2kcgjbf.js";
+} from "./packager-tool-j6nfje7t.js";
 import {
   prefixedId
-} from "./packager-tool-mknccck5.js";
-import"./packager-tool-nj4seavy.js";
+} from "./packager-tool-1h7abxw6.js";
 import {
   byCodeUnit
-} from "./packager-tool-5qp9xza1.js";
-import {
-  catchError
-} from "./packager-tool-83v804p7.js";
-import"./packager-tool-hdxtgckw.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/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, so the rule is written with an empty `context` to fill before debug"
-      });
-      base.uipath = {
-        serviceType: WAIT_FOR_EVENT,
-        context: [],
-        inputs: [],
-        outputs: [],
-        bindings: []
-      };
-    } else {
-      const built = connectorContextFor(context.connector, context.where, context.connections, context.bindings, context.unresolved).filter((entry) => entry.name !== "operation" || context.connector?.operation !== undefined);
-      const missing = missingActivitySlots(built);
-      if (missing.length > 0) {
-        context.unresolved.push({
-          kind: "connector-context",
-          where: context.where,
-          detail: `the document names no ${missing.map((name) => `\`${name}\``).join(" or ")} for this \`wait-for-connector\` rule, so it is left out of the rule's \`context\`, to fill before debug`
-        });
-      }
-      base.uipath = {
-        serviceType: WAIT_FOR_EVENT,
-        context: built,
-        ...missing.length > 0 && {
-          inputs: [],
-          outputs: [],
-          bindings: []
-        }
-      };
-    }
-  }
-  return base;
-};
-var WAIT_FOR_EVENT = "Intsvc.WaitForEvent";
-var ACTIVITY_SLOTS = ["connectorKey", "operation"];
-var missingActivitySlots = (entries) => ACTIVITY_SLOTS.filter((name) => !entries.some((entry) => entry.name === name && typeof entry.value === "string" && entry.value !== ""));
-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]]
-  };
-};
+} from "./packager-tool-1c30ttpm.js";
+import"./packager-tool-68648y3j.js";
 
 // src/services/sdd-convert/metadata.ts
 var TIMER_VALUE_FIELDS = new Map([
@@ -784,7 +406,7 @@ var jsonSchemaBody = (name, type, model, unresolved) => {
     });
     return;
   }
-  const [error, parsed] = catchError(() => JSON.parse(declared));
+  const [error, parsed] = catchError2(() => JSON.parse(declared));
   if (error || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     unresolved.push({
       kind: "variable-body",
@@ -816,8 +438,8 @@ var caseVariablesFor = (model, triggers = [], unresolved = []) => {
       });
     }
     const category = declaredCategory ?? "variable";
-    const groups = VARIABLE_PLACEMENT.get(category) ?? ["inputOutputs"];
-    const carriesDefault = DEFAULT_GROUP.get(category) ?? "inputOutputs";
+    const groups = VARIABLE_PLACEMENT2.get(category) ?? ["inputOutputs"];
+    const carriesDefault = DEFAULT_GROUP2.get(category) ?? "inputOutputs";
     const type = variableTypeFor(name, model.variableTypes[key], unresolved);
     const body = jsonSchemaBody(name, type, model, unresolved);
     const fileBody = category === "in" && type === "file" ? FILE_TYPE_JSON_SCHEMA : undefined;
@@ -865,7 +487,7 @@ var caseVariablesFor = (model, triggers = [], unresolved = []) => {
 
 // src/services/sdd-convert/case-level.ts
 var finishCaseDocument = (document, model, index, unresolved) => {
-  const { planned, stageIds, taskIds, outputIds, bindings, connections } = index;
+  const { planned, stageIds, taskIds, outputIds, bindings } = index;
   let conditionCount = 0;
   const plans = triggerPlans(model);
   const emittedTriggers = [];
@@ -989,9 +611,17 @@ var finishCaseDocument = (document, model, index, unresolved) => {
     },
     ...model.directTaskOutputs === true && {
       caseDirectlyPassTaskOutputs: true
-    },
-    ...connections.size > 0 && { intsvcActivityConfig: "v2" }
+    }
   };
+  const caseRoles = caseRolesFor(model, index, unresolved);
+  if (caseRoles.length > 0) {
+    document.metadata = {
+      ...document.metadata,
+      caseAppVersion: "v2",
+      caseAppCreatedVersion: "v2",
+      caseRoles
+    };
+  }
   const entersOnCaseEntered = planned.some(({ stage }) => stage.entryConditions.some((condition) => {
     const when = String(condition.when ?? "");
     return parseWhen(when).rule === "case-entered";
@@ -1039,6 +669,7 @@ var finishCaseDocument = (document, model, index, unresolved) => {
     stages: stageIds,
     tasks: taskIds,
     taskNameConflicts: index.taskNameConflicts,
+    businessEvents: index.businessEvents,
     outputs: outputIds,
     unresolved
   })).filter((condition) => condition !== undefined);
@@ -1073,6 +704,273 @@ var finishCaseDocument = (document, model, index, unresolved) => {
   }
   return { conditionCount };
 };
+// src/services/sdd-convert/document-extraction-output-schema.json
+var document_extraction_output_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    ExtractionResult: {
+      type: "object",
+      properties: {
+        DocumentId: {
+          type: "string"
+        },
+        ResultsVersion: {
+          type: "integer"
+        },
+        ResultsDocument: {
+          type: "object",
+          properties: {
+            Bounds: {
+              type: "object",
+              properties: {
+                PageCount: {
+                  type: "integer"
+                },
+                PageRange: {
+                  type: "string"
+                }
+              }
+            },
+            Language: {
+              type: "string"
+            },
+            DocumentGroup: {
+              type: "string"
+            },
+            DocumentCategory: {
+              type: "string"
+            },
+            DocumentTypeId: {
+              type: "string"
+            },
+            DocumentTypeName: {
+              type: "string"
+            },
+            Fields: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  FieldId: {
+                    type: "string"
+                  },
+                  FieldName: {
+                    type: "string"
+                  },
+                  FieldType: {
+                    type: "string"
+                  },
+                  Value: {
+                    type: "string"
+                  },
+                  UnformattedValue: {
+                    type: "string"
+                  },
+                  Confidence: {
+                    type: "number"
+                  },
+                  IsMissing: {
+                    type: "boolean"
+                  }
+                }
+              }
+            },
+            Tables: {
+              type: "array",
+              items: {
+                type: "object"
+              }
+            }
+          }
+        },
+        ExtractorPayloads: {
+          type: "object"
+        },
+        BusinessrulesResults: {
+          type: "array",
+          items: {
+            type: "object"
+          }
+        }
+      }
+    },
+    Taxonomy: {
+      type: "object",
+      properties: {
+        DataContractVersion: {
+          type: "string"
+        },
+        DocumentTypes: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              DocumentTypeId: {
+                type: "string"
+              },
+              Group: {
+                type: "string"
+              },
+              Category: {
+                type: "string"
+              },
+              Name: {
+                type: "string"
+              },
+              OptionalUniqueIdentifier: {
+                type: "string"
+              },
+              TypeField: {
+                type: "object"
+              },
+              Fields: {
+                type: "array",
+                items: {
+                  type: "object"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/services/sdd-convert/document-extraction.ts
+var DOCUMENT_EXTRACTION_SERVICE_TYPE = "IXP.Extraction";
+var DATA_NAME = "Document extraction";
+var documentExtractionOutputs = (elementId, taken, reserved = new Set) => {
+  const mint = (base) => {
+    const id = dedupedId(base, new Set([...taken, ...reserved]));
+    taken.add(id);
+    return id;
+  };
+  const row = (name, displayName, source, schema) => {
+    const id = mint(name);
+    return {
+      name,
+      displayName,
+      type: "jsonSchema",
+      source,
+      _jsonSchema: structuredClone(schema),
+      id,
+      var: id,
+      value: id,
+      elementId,
+      body: structuredClone(schema)
+    };
+  };
+  return [
+    row("output", "Output", "=result", document_extraction_output_schema_default),
+    row("error", "Error", "=Error", ERROR_OUTPUT_SCHEMA)
+  ];
+};
+var INPUTS = [
+  { name: "fileRef", displayName: "File", type: "file", required: true },
+  { name: "pageRange", displayName: "Page range", type: "string" }
+];
+var spelling = (name) => name.toLowerCase().replace(/[^a-z]/g, "");
+var deploymentBinding = (deployment, resourceKey, bindings) => {
+  const found = bindings.find((one) => one.resource === "ixpDeployment" && one.default === deployment && (one.resourceKey ?? null) === resourceKey);
+  if (found !== undefined)
+    return String(found.id);
+  const ordinal = bindings.filter((one) => one.resource === "ixpDeployment").length + 1;
+  const id = `bIxp${ordinal}`;
+  bindings.push({
+    id,
+    name: "name",
+    type: "string",
+    resource: "ixpDeployment",
+    ...resourceKey !== null && { resourceKey },
+    default: deployment,
+    propertyAttribute: "name"
+  });
+  return id;
+};
+var documentExtractionData = (extraction, authored, outputs, context) => {
+  const { elementId, where, unresolved } = context;
+  const say = (detail) => {
+    unresolved.push({ kind: "resource-binding", where, detail });
+  };
+  const deployment = namedValue(extraction?.deployment);
+  const modelName = namedValue(extraction?.modelName);
+  const deploymentKey = namedValue(extraction?.deploymentKey);
+  const folderKey = namedValue(extraction?.folderKey);
+  const folderName = namedValue(context.folderName);
+  if (deployment === "") {
+    say("this `document-extraction` task names no `**IXP Deployment:**`, so nothing binds the deployment it runs; write the deployment's name as the solution lists it");
+  }
+  if (deploymentKey === "") {
+    say(`this \`document-extraction\` task states no \`**Deployment Key:**\`, the key of the IXP deployment's solution resource; \`uip solution resources add --source remote --kind IxpDeployment --name "${deployment === "" ? "<deployment-name>" : deployment}"\` adds it to the solution and returns it as \`Key\`, and \`uip solution resources list --kind IxpDeployment --source remote\` looks it up without changing anything`);
+  }
+  if (modelName === "") {
+    say("this `document-extraction` task states no `**Model Name:**`, the deployment's DeploymentName; `uip ixp deployments list <project-name>` gives it (with DeploymentTitle, the `**IXP Deployment:**`, and FolderKey), and `uip ixp projects list` names the project");
+  }
+  if (folderKey === "" || folderName === "") {
+    say(`this \`document-extraction\` task states no ${folderName === "" ? "`**Folder Path:**`" : "`**Folder Key:**`"}${folderKey === "" && folderName === "" ? " or `**Folder Key:**`" : ""} for the folder the deployment is deployed to; \`uip ixp deployments list <project-name>\` gives its FolderKey, and \`uip or folders list\` its path`);
+  }
+  const byName = new Map(authored.map((row) => [spelling(String(row.name ?? "")), row]));
+  const inputs = INPUTS.map((slot) => {
+    const row = byName.get(spelling(slot.name)) ?? byName.get(spelling(slot.displayName));
+    const id = prefixedId("v", 8);
+    return {
+      name: slot.name,
+      displayName: slot.displayName,
+      type: slot.type,
+      value: row === undefined ? "" : String(row.value ?? ""),
+      ...slot.required === true && { required: true },
+      id,
+      var: id,
+      elementId
+    };
+  });
+  const known = new Set(INPUTS.flatMap((slot) => [
+    spelling(slot.name),
+    spelling(slot.displayName)
+  ]));
+  for (const row of authored) {
+    const name = String(row.name ?? "");
+    if (!known.has(spelling(name))) {
+      unresolved.push({
+        kind: "task-io-table",
+        where,
+        detail: `a \`document-extraction\` task takes only \`fileRef\` (File) and \`pageRange\` (Page range), so the Inputs row "${name}" is not written`
+      });
+    }
+  }
+  if (inputs[0].value === "") {
+    unresolved.push({
+      kind: "task-io-table",
+      where,
+      detail: "this `document-extraction` task's `fileRef` input is empty, so it has no file to extract from; add an Inputs row `fileRef` reading the file, such as `=vars.invoiceFile`"
+    });
+  }
+  const resourceKey = deploymentKey === "" ? null : deploymentKey;
+  const nameValue = deployment === "" ? "" : `${BINDING_REFERENCE_PREFIX}${deploymentBinding(deployment, resourceKey, context.bindings)}`;
+  const entry = (name, value) => ({
+    name,
+    type: "string",
+    value
+  });
+  return {
+    name: DATA_NAME,
+    serviceType: DOCUMENT_EXTRACTION_SERVICE_TYPE,
+    context: [
+      entry("solutionResourceKey", resourceKey),
+      entry("name", nameValue),
+      entry("folderKey", folderKey === "" ? null : folderKey),
+      entry("folderName", folderName === "" ? null : folderName),
+      entry("modelName", modelName === "" ? null : modelName),
+      entry("modelDisplayName", deployment === "" ? null : deployment),
+      entry("digitizationMode", "fileUpload")
+    ],
+    inputs,
+    outputs,
+    version: "v2"
+  };
+};
 // src/services/sdd-convert/http-request-metadata.json
 var http_request_metadata_default = {
   activityPropertyConfiguration: {
@@ -1186,7 +1084,7 @@ var mint = (base, taken, reserved) => {
 var objectCell = (text) => {
   if (text === undefined)
     return {};
-  const [error, parsed] = catchError(() => JSON.parse(text));
+  const [error, parsed] = catchError2(() => JSON.parse(text));
   if (error)
     return { error: "is not JSON" };
   return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { value: parsed } : { error: "is not a JSON object" };
@@ -1194,7 +1092,7 @@ var objectCell = (text) => {
 var bodyValue = (text) => {
   if (text.startsWith("="))
     return { value: text };
-  const [error] = catchError(() => JSON.parse(text));
+  const [error] = catchError2(() => JSON.parse(text));
   return error ? { error: "is neither JSON nor an `=` expression" } : { value: `=js:( ${text})` };
 };
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH"]);
@@ -1399,10 +1297,47 @@ var httpRequestData = (http, connector, outputs, context) => {
   };
 };
 
+// src/services/sdd-convert/recipient.ts
+var RECIPIENT_TYPES = new Map([
+  ["email", 2],
+  ["expression", 3]
+]);
+var recipientFor = (recipient, where, unresolved, outputs) => {
+  if (recipient === undefined)
+    return;
+  const type = RECIPIENT_TYPES.get(recipient.kind);
+  if (type === undefined) {
+    unresolved.push({
+      kind: "task-recipient",
+      where,
+      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`
+    });
+    return;
+  }
+  if (type !== 3)
+    return { Type: type, Value: recipient.value };
+  if (!recipient.value.startsWith("=")) {
+    unresolved.push({
+      kind: "task-recipient",
+      where,
+      detail: `the Recipient row's Expression "${recipient.value}" is not an \`=\` expression; a \`Type 3\` recipient evaluates its value, so write it as \`Expression: =vars.<variable>\``
+    });
+    return;
+  }
+  return {
+    Type: type,
+    Value: canonicalExpression(expandXrefs(recipient.value, {
+      outputs,
+      where: `${where}.data.recipient`,
+      unresolved
+    }))
+  };
+};
+
 // 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;
+  return (NAME_BOUND_TASK_TYPES.has(type) || CONNECTOR_CALL_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;
@@ -1453,6 +1388,7 @@ var emitTask = (task, taskId, context) => {
     stages: stageIds,
     tasks: taskIds,
     taskNameConflicts: index.taskNameConflicts,
+    businessEvents: index.businessEvents,
     stageTasks,
     outputs: outputIds,
     slas: slaIds,
@@ -1501,15 +1437,7 @@ var emitTask = (task, taskId, context) => {
       where: `${taskWhere}.data`,
       detail
     });
-  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 recipient = recipientFor(task.recipient, taskWhere, unresolved, outputIds);
   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 ?? "");
@@ -1537,8 +1465,8 @@ var emitTask = (task, taskId, context) => {
       }
     }
   }
-  const connector = CONNECTOR_TASK_TYPES.has(type) && task.connector !== undefined ? task.connector : undefined;
-  if (CONNECTOR_TASK_TYPES.has(type) && connector === undefined) {
+  const connector = CONNECTOR_CALL_TASK_TYPES.has(type) && task.connector !== undefined ? task.connector : undefined;
+  if (CONNECTOR_CALL_TASK_TYPES.has(type) && connector === undefined) {
     unresolved.push({
       kind: "connector-connection",
       where: taskWhere,
@@ -1595,12 +1523,7 @@ var emitTask = (task, taskId, context) => {
       },
       ...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
-        }
-      },
+      ...recipient !== undefined && { recipient },
       ...timer
     }
   };
@@ -1614,6 +1537,16 @@ var emitTask = (task, taskId, context) => {
       outputs: outputIds
     });
   }
+  if (type === "document-extraction") {
+    const data = emitted.data;
+    emitted.data = documentExtractionData(task.extraction, data.inputs ?? [], data.outputs ?? [], {
+      elementId,
+      where: taskWhere,
+      folderName: folderPath,
+      bindings,
+      unresolved
+    });
+  }
   return { task: emitted, conditions };
 };
 var SHARES_WITH_SIBLING = "parallel-after-predecessor";
@@ -1635,11 +1568,11 @@ var taskSets = (tasks, declared) => {
       });
     }
     keyed.sort((a, b) => a.run - b.run || a.at - b.at);
-    const sets2 = new Map;
+    const sets = new Map;
     for (const one of keyed) {
-      sets2.set(one.key, [...sets2.get(one.key) ?? [], one.task]);
+      sets.set(one.key, [...sets.get(one.key) ?? [], one.task]);
     }
-    return { sets: [...sets2.values()], undeclared: [] };
+    return { sets: [...sets.values()], undeclared: [] };
   }
   const sets = [];
   const undeclaredSets = new Set;
@@ -1728,6 +1661,7 @@ var emitStages = (document, model, index, unresolved) => {
       stages: stageIds,
       tasks: taskIds,
       taskNameConflicts: index.taskNameConflicts,
+      businessEvents: index.businessEvents,
       stageTasks,
       outputs: outputIds,
       slas: slaIds,
@@ -1776,6 +1710,15 @@ var emitStages = (document, model, index, unresolved) => {
   return { taskCount, conditionCount };
 };
 
+// src/services/sdd-convert/fixed-outputs.ts
+var fixedOutputsFor = (taskType, elementId, taken, reserved) => {
+  if (taskType === "http-request")
+    return httpRequestOutputs(elementId, taken, reserved);
+  if (taskType === "document-extraction")
+    return documentExtractionOutputs(elementId, taken, reserved);
+  return [];
+};
+
 // src/services/sdd-convert/plan.ts
 var taskNameOf = (task) => typeof task.name === "string" ? task.name : "";
 var countByName = (entries) => {
@@ -1872,22 +1815,32 @@ var planCase = (model, unresolved) => {
         }
       };
       const extractByField = new Map;
+      const extractTypeByField = new Map;
+      const extractUnmappedByField = 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);
+          const { type, unmapped } = rowOutputType(entry.type);
+          if (type !== undefined)
+            extractTypeByField.set(field, type);
+          if (unmapped !== undefined) {
+            extractUnmappedByField.set(field, unmapped);
+          }
         }
       }
-      const httpOutputs = taskType === "http-request" ? httpRequestOutputs(buildElementId(stageId, taskId), takenOutputIds, new Set(model.variables)) : [];
-      const httpDeclared = taskType === "http-request" ? declaredOutputs(model, stage.name, position + 1, task) : [];
-      for (const output of httpOutputs) {
+      const fixed = hasFixedOutputs(taskType);
+      const fixedOutputs = fixedOutputsFor(taskType, buildElementId(stageId, taskId), takenOutputIds, new Set(model.variables));
+      const outputName = (field) => fixedOutputName(taskType, field);
+      const fixedDeclared = fixed ? declaredOutputs(model, stage.name, position + 1, task) : [];
+      for (const output of fixedOutputs) {
         const name = String(output.name).toLowerCase();
         const spellings = [
-          ...httpDeclared.flatMap(({ row, aliases }) => [row, ...aliases].filter((spelling2) => httpRequestOutputName(spelling2) === name)),
-          ...[...extractByField.keys()].filter((field) => httpRequestOutputName(field) === name)
+          ...fixedDeclared.flatMap(({ row, aliases }) => [row, ...aliases].filter((spelling) => outputName(spelling) === name)),
+          ...[...extractByField.keys()].filter((field) => outputName(field) === name)
         ];
-        const variable = [...extractByField].find(([field]) => httpRequestOutputName(field) === name)?.[1];
+        const variable = [...extractByField].find(([field]) => outputName(field) === name)?.[1];
         if (variable !== undefined) {
           output.var = variable;
           output.value = variable;
@@ -1901,26 +1854,38 @@ var planCase = (model, unresolved) => {
           ...variable === undefined ? [] : [variable]
         ]), output);
       }
-      if (taskType === "http-request") {
-        const offered = httpOutputs.map((output) => String(output.name));
+      if (fixed) {
+        const offered = fixedOutputs.map((output) => String(output.name));
         const authored = new Set([
           ...extractByField.values(),
           ...(task.customRows ?? []).map((entry) => String(entry.variable ?? ""))
         ].filter((name) => name !== "").map(indexKey));
-        const unnamed = new Set(httpDeclared.flatMap(({ row, aliases }) => [row, ...aliases]).filter((spelling2) => httpRequestOutputName(spelling2) === undefined && !authored.has(indexKey(spelling2))));
+        const unnamed = new Set(fixedDeclared.flatMap(({ row, aliases }) => [row, ...aliases]).filter((spelling) => outputName(spelling) === undefined && !authored.has(indexKey(spelling))));
         for (const row of unnamed) {
           unresolved.push({
             kind: "output-type",
             where: `nodes[${stage.name}].data.tasks[${taskName}].outputs[${row}]`,
-            detail: `an \`http-request\` task has the activity's own outputs only (${offered.join(", ")}), so the declared output "${row}" is not written; read the field it names from \`body\` instead`
+            detail: `an \`${taskType}\` task has the activity's own outputs only (${offered.join(", ")}), so the declared output "${row}" is not written; read the field it names from \`${taskType === "http-request" ? "body" : "output"}\` instead`
           });
         }
       }
-      for (const { row, aliases } of taskType === "http-request" ? [] : declaredOutputs(model, stage.name, position + 1, task)) {
-        const consumerType = [row, ...aliases].map((spelling2) => outputTypeFor(model, everySpelling(stage.name, position + 1), taskName, spelling2)).find((found) => found !== undefined);
+      const customVariables = new Set((task.customRows ?? []).map((entry) => String(entry.variable ?? "")).filter((name) => name !== ""));
+      const customTwinSpellings = new Map;
+      for (const { row, aliases } of fixed ? [] : declaredOutputs(model, stage.name, position + 1, task)) {
+        if (customVariables.has(row)) {
+          customTwinSpellings.set(row, aliases);
+          takenOutputIds.add(row);
+          takenOutputIds.add(`${row[0].toLowerCase()}${row.slice(1)}`);
+          own.set(row, {});
+          continue;
+        }
+        const consumerType = [row, ...aliases].map((spelling) => outputTypeFor(model, everySpelling(stage.name, position + 1), taskName, spelling)).find((found) => found !== undefined);
         const variable = extractByField.get(row);
-        const type = consumerType ?? (variable === undefined ? undefined : variableOutputType(model, variable));
-        if (type === undefined) {
+        const type = extractTypeByField.get(row) ?? consumerType ?? (variable === undefined ? undefined : variableOutputType(model, variable));
+        const unmapped = extractUnmappedByField.get(row);
+        if (unmapped !== undefined) {
+          unresolved.push(unmappedOutputType(`nodes[${stage.name}].data.tasks[${taskName}].outputs[${row}]`, unmapped, type));
+        } else if (type === undefined) {
           unresolved.push({
             kind: "output-type",
             where: `nodes[${stage.name}].data.tasks[${taskName}].outputs[${row}]`,
@@ -1943,19 +1908,29 @@ var planCase = (model, unresolved) => {
         };
         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
+        const cell = rowOutputType(entry.type);
+        const customType = cell.type ?? variableOutputType(model, row.variable);
+        if (cell.unmapped !== undefined) {
+          unresolved.push(unmappedOutputType(`nodes[${stage.name}].data.tasks[${taskName}].outputs[${row.variable}]`, cell.unmapped, customType));
+        }
+        const custom = customOutputFor(row, customType);
+        const twin = customTwinSpellings.get(row.variable);
+        own.set(twin === undefined ? `custom:${row.variable}` : row.variable, custom);
+        indexOutput(new Set([row.variable, ...twin ?? []]), {
+          ...custom,
+          id: row.variable
         });
       }
       outputsByTask.set(taskId, own);
       return { task, taskId };
     });
-    return { stage, stageId, tasks, stageSla, slaRules: [] };
+    return {
+      stage,
+      stageId,
+      tasks,
+      stageSla,
+      slaRules: []
+    };
   });
   const tasksPerName = countByName(tasksByExactName);
   reportRepeatedTaskNames(stagesByTaskName, unresolved);
@@ -1995,6 +1970,7 @@ var planCase = (model, unresolved) => {
     stageIds,
     taskIds,
     taskNameConflicts,
+    businessEvents: new Set((model.businessEvents ?? []).map((event) => event.name)),
     outputIds,
     outputsByTask,
     bindings,
@@ -2183,8 +2159,9 @@ var convertSddToCasePlan = (model, options) => {
   const { taskCount, conditionCount } = emitStages(document, model, index, unresolved);
   const caseLevel = finishCaseDocument(document, model, index, unresolved);
   uniquifyConditionNames(document);
-  designerShapeConnectorTasks(document);
+  designerShapeConnectorTasks2(document);
   emitCanvasNotes(document, model.canvasNotes);
+  emitBusinessEvents(document, model.businessEvents, unresolved);
   return {
     document,
     derived: {
@@ -2200,4 +2177,4 @@ export {
   convertSddToCasePlan
 };
 
-//# debugId=FCC3E2D1F580064164756E2164756E21
+//# debugId=E3082643D54EEB6464756E2164756E21