@uipath/case-tool 1.203.0-preview.203 → 1.204.0-preview.206

package/dist/case-bindings-service-c2mze9vj.js

@@ -0,0 +1,476 @@
+import {
+  byCodeUnit
+} from "./packager-tool-5qp9xza1.js";
+import {
+  catchError
+} from "./packager-tool-58kx79ta.js";
+import {
+  getFileSystem
+} from "./packager-tool-xdxr3ync.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/bindings-v2.ts
+var BINDINGS_V2_FILE_NAME = "bindings_v2.json";
+var BINDINGS_V2_VERSION = "2.0";
+var CONNECTION_ID_PROPERTY = "ConnectionId";
+var FOLDER_KEY_PROPERTY = "folderKey";
+var RESOURCE_BINDINGS_VERSION = "2.2";
+var sortBindingsV2Resources = (resources) => [...resources].sort((a, b) => byCodeUnit(a.resource, b.resource) || byCodeUnit(a.key, b.key));
+var serializeBindingsV2File = (resources) => {
+  const file = {
+    version: BINDINGS_V2_VERSION,
+    resources: sortBindingsV2Resources(resources)
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+};
+var readBindingsV2Resources = (raw) => {
+  const [error, parsed] = catchError(() => JSON.parse(raw));
+  if (error)
+    return;
+  if (parsed === null || typeof parsed !== "object")
+    return;
+  const resources = parsed.resources;
+  if (!Array.isArray(resources))
+    return;
+  return resources.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.key === "string");
+};
+var identity = (entry) => `${entry.resource}:${entry.key}`;
+var diffBindingsV2 = (expected, actual) => {
+  const expectedByKey = new Map(expected.map((e) => [identity(e), e]));
+  const actualByKey = new Map(actual.map((e) => [identity(e), e]));
+  const missing = [];
+  const changed = [];
+  for (const [key, entry] of expectedByKey) {
+    const found = actualByKey.get(key);
+    if (found === undefined) {
+      missing.push(entry.key);
+    } else if (JSON.stringify(found) !== JSON.stringify(entry)) {
+      changed.push(entry.key);
+    }
+  }
+  const extra = [...actualByKey.values()].filter((entry) => !expectedByKey.has(identity(entry))).map((entry) => entry.key);
+  const alphabetically = (left, right) => left.localeCompare(right);
+  return {
+    missing: missing.sort(alphabetically),
+    extra: extra.sort(alphabetically),
+    changed: changed.sort(alphabetically)
+  };
+};
+var hasBindingsV2Difference = (difference) => difference.missing.length > 0 || difference.extra.length > 0 || difference.changed.length > 0;
+
+// src/services/case-event-trigger-bindings.ts
+var ENTRY_POINTS_FILE_NAME = "entry-points.json";
+var EVENT_TRIGGER_SERVICE_TYPE = "Intsvc.EventTrigger";
+var TRIGGER_NODE_TYPES = new Set([
+  "uipath.case.trigger",
+  "case-management:Trigger"
+]);
+var PROPERTY_RESOURCE = "Property";
+var BINDING_REFERENCE_PREFIX = "=bindings.";
+var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var asString = (value) => typeof value === "string" && value !== "" ? value : undefined;
+var nonEmpty = (value) => {
+  const record = asRecord(value);
+  return record !== undefined && Object.keys(record).length > 0 ? record : undefined;
+};
+function entryPointIdsByNode(entryPoints) {
+  const ids = new Map;
+  const list = asRecord(entryPoints)?.entryPoints;
+  if (!Array.isArray(list))
+    return ids;
+  for (const item of list) {
+    const entry = asRecord(item);
+    const filePath = asString(entry?.filePath);
+    const uniqueId = asString(entry?.uniqueId);
+    const hash = filePath?.lastIndexOf("#") ?? -1;
+    if (filePath === undefined || uniqueId === undefined || hash < 0)
+      continue;
+    ids.set(filePath.slice(hash + 1), uniqueId);
+  }
+  return ids;
+}
+async function readEntryPointIds(casePlanPath) {
+  const fs = getFileSystem();
+  const path = fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), ENTRY_POINTS_FILE_NAME);
+  if (!await fs.exists(path))
+    return { ids: new Map };
+  const [readError, raw] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      error: `Could not read ${path}: ${readError?.message ?? "the file is no longer there"}`,
+      path
+    };
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(raw));
+  if (parseError) {
+    return {
+      error: `${path} is not valid JSON: ${parseError.message}`,
+      path
+    };
+  }
+  return { ids: entryPointIdsByNode(parsed) };
+}
+function readTrigger(node) {
+  const record = asRecord(node);
+  const nodeId = asString(record?.id);
+  if (nodeId === undefined || !TRIGGER_NODE_TYPES.has(String(record?.type)))
+    return;
+  const data = asRecord(record?.data);
+  const container = [asRecord(data?.inputs), asRecord(data?.uipath)].find((candidate) => candidate?.serviceType === EVENT_TRIGGER_SERVICE_TYPE);
+  if (container === undefined || !Array.isArray(container.context))
+    return;
+  const context = new Map;
+  for (const item of container.context) {
+    const entry = asRecord(item);
+    const name = asString(entry?.name);
+    if (name !== undefined)
+      context.set(name, entry?.value ?? entry?.body);
+  }
+  const bodyInput = Array.isArray(container.inputs) ? container.inputs.map(asRecord).find((input) => input?.name === "body") : undefined;
+  return {
+    nodeId,
+    activityName: asString(asRecord(data?.display)?.label) ?? asString(data?.label) ?? asString(context.get("operation")),
+    context,
+    body: asRecord(bodyInput?.body),
+    metadataBody: asRecord(context.get("metadata"))
+  };
+}
+function findConnectionBinding(trigger, bindings) {
+  const connections = bindings.filter((binding) => binding.resource === "Connection" && binding.propertyAttribute === CONNECTION_ID_PROPERTY);
+  const reference = asString(trigger.context.get("connection"));
+  if (reference?.startsWith(BINDING_REFERENCE_PREFIX)) {
+    const id = reference.slice(BINDING_REFERENCE_PREFIX.length);
+    const byId = connections.find((binding) => binding.id === id);
+    if (byId !== undefined)
+      return byId;
+  }
+  const resourceKey = asString(trigger.context.get("resourceKey"));
+  return connections.find((binding) => binding.resourceKey === resourceKey);
+}
+var optional = (key, value) => value === undefined ? {} : { [key]: value };
+function eventTriggerResource(trigger, connectionId, key, entryPointId) {
+  const apc = asRecord(trigger.metadataBody?.activityPropertyConfiguration);
+  const filterExpression = asString(apc?.filterExpression) ?? asString(asRecord(trigger.body?.filters)?.expression) ?? "";
+  const value = {
+    ConnectionId: { defaultValue: connectionId, isExpression: false }
+  };
+  if (entryPointId !== undefined) {
+    value.EntryPointUniqueId = {
+      defaultValue: entryPointId,
+      isExpression: false
+    };
+  }
+  return {
+    resource: "EventTrigger",
+    key,
+    id: `EventTrigger${key}`,
+    value,
+    metadata: {
+      UseConnectionService: "true",
+      ...optional("Connector", asString(trigger.context.get("connectorKey"))),
+      ...optional("ActivityName", trigger.activityName),
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      ...optional("ObjectName", objectName(trigger)),
+      ...optional("Operation", asString(trigger.context.get("operation"))),
+      FilterExpression: filterExpression
+    }
+  };
+}
+var objectName = (trigger) => asString(trigger.context.get("objectName")) ?? asString(asRecord(trigger.metadataBody?.activityPropertyConfiguration)?.objectName);
+function storedPropertyResources(trigger, parentResourceKey) {
+  const stored = trigger.metadataBody?.bindings;
+  if (!Array.isArray(stored) || stored.length === 0)
+    return;
+  return stored.flatMap((raw) => {
+    const entry = asRecord(raw);
+    if (typeof entry?.resource !== "string" || typeof entry.key !== "string")
+      return [];
+    const clone = structuredClone(entry);
+    clone.metadata = {
+      ...clone.metadata,
+      ...optional("ActivityName", trigger.activityName)
+    };
+    if (clone.resource === PROPERTY_RESOURCE) {
+      clone.id = `Property_${trigger.nodeId}`;
+      clone.metadata.ParentResourceKey = parentResourceKey;
+    }
+    return [clone];
+  });
+}
+function propertyResources(trigger, parentResourceKey) {
+  const stored = storedPropertyResources(trigger, parentResourceKey);
+  if (stored !== undefined)
+    return stored;
+  const parameters = nonEmpty(trigger.body?.queryParams) ?? nonEmpty(trigger.body?.parameters);
+  const operation = asString(trigger.context.get("operation"));
+  if (parameters === undefined || operation === undefined)
+    return [];
+  const value = {};
+  for (const [name, raw] of Object.entries(parameters)) {
+    value[name] = { defaultValue: String(raw), isExpression: false };
+  }
+  const names = Object.keys(parameters).join(",");
+  return [
+    {
+      resource: PROPERTY_RESOURCE,
+      key: operation,
+      id: `Property_${trigger.nodeId}`,
+      value,
+      metadata: {
+        TriggerCreateParameters: names,
+        DebugQueryParameters: names,
+        ...optional("ActivityName", trigger.activityName),
+        BindingsVersion: RESOURCE_BINDINGS_VERSION,
+        ...optional("ObjectName", objectName(trigger)),
+        ParentResourceKey: parentResourceKey
+      }
+    }
+  ];
+}
+function deriveEventTriggerResources(nodes, bindings, entryPointIds) {
+  if (!Array.isArray(nodes))
+    return [];
+  return nodes.flatMap((node) => {
+    const trigger = readTrigger(node);
+    if (trigger === undefined)
+      return [];
+    const binding = findConnectionBinding(trigger, bindings);
+    if (binding === undefined)
+      return [];
+    const connectionId = binding.default ?? binding.resourceKey;
+    const key = [connectionId, trigger.nodeId].filter(Boolean).join("_");
+    return [
+      eventTriggerResource(trigger, connectionId, key, entryPointIds.get(trigger.nodeId)),
+      ...propertyResources(trigger, `EventTrigger.${key}`)
+    ];
+  });
+}
+
+// src/services/case-bindings-service.ts
+var asBinding = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  return typeof record.id === "string" && typeof record.resource === "string" && typeof record.resourceKey === "string" && record.resourceKey !== "" && typeof record.propertyAttribute === "string" && (record.default === undefined || typeof record.default === "string") ? value : undefined;
+};
+var CONNECTION_RESOURCE = "Connection";
+var NAME_ATTRIBUTE = "name";
+var FOLDER_PATH_ATTRIBUTE = "folderPath";
+var SOLUTION_FOLDER_PREFIX = "solution_folder.";
+var SOLUTION_FOLDER_SENTINEL = "solution_folder";
+var BINDING_REFERENCE_PREFIX2 = "=bindings.";
+var CONNECTOR_KEY_ENTRY = "connectorKey";
+var CONNECTION_ENTRY = "connection";
+var readConnectorContext = (value) => {
+  if (!Array.isArray(value))
+    return;
+  const byName = new Map;
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+      return;
+    const { name, value: entryValue } = entry;
+    if (typeof name !== "string")
+      return;
+    if (typeof entryValue === "string")
+      byName.set(name, entryValue);
+  }
+  return byName.has(CONNECTOR_KEY_ENTRY) ? byName : undefined;
+};
+var ownLabel = (node) => {
+  const record = node;
+  for (const candidate of [
+    record.displayName,
+    record.display?.label,
+    record.label
+  ]) {
+    if (typeof candidate === "string" && candidate !== "")
+      return candidate;
+  }
+  return;
+};
+var collectConnectorKeys = (document) => {
+  const byBindingId = new Map;
+  const visit = (node, label) => {
+    if (Array.isArray(node)) {
+      const context = readConnectorContext(node);
+      const connection = context?.get(CONNECTION_ENTRY);
+      const connectorKey = context?.get(CONNECTOR_KEY_ENTRY);
+      const bindingId = connection?.startsWith(BINDING_REFERENCE_PREFIX2) ? connection.slice(BINDING_REFERENCE_PREFIX2.length) : undefined;
+      if (connectorKey !== undefined && bindingId !== undefined && !byBindingId.has(bindingId)) {
+        byBindingId.set(bindingId, {
+          connectorKey,
+          activityName: label
+        });
+      }
+      for (const item of node)
+        visit(item, label);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    const scoped = ownLabel(node) ?? label;
+    for (const value of Object.values(node))
+      visit(value, scoped);
+  };
+  visit(document, undefined);
+  return byBindingId;
+};
+var attributeDefault = (group, attribute) => group.find((binding) => binding.propertyAttribute === attribute)?.default;
+var connectionEntry = (group, connectorKeys) => {
+  const key = group[0].resourceKey;
+  const value = {
+    [CONNECTION_ID_PROPERTY]: {
+      defaultValue: attributeDefault(group, CONNECTION_ID_PROPERTY) ?? key
+    }
+  };
+  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined) {
+    value[FOLDER_KEY_PROPERTY] = { defaultValue: folderKey };
+  }
+  const use = group.map((binding) => connectorKeys.get(binding.id)).find((found) => found !== undefined);
+  const displayLabel = (group.find((binding) => binding.propertyAttribute === CONNECTION_ID_PROPERTY) ?? group[0]).name;
+  return {
+    resource: CONNECTION_RESOURCE,
+    key,
+    id: `${CONNECTION_RESOURCE}${key}`,
+    value,
+    metadata: {
+      ...use?.activityName !== undefined && {
+        ActivityName: use.activityName
+      },
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      ...typeof displayLabel === "string" && displayLabel !== "" && { DisplayLabel: displayLabel },
+      UseConnectionService: "true",
+      ...use !== undefined && { Connector: use.connectorKey }
+    }
+  };
+};
+var resourceEntry = (group) => {
+  const key = group[0].resourceKey;
+  const value = {};
+  const name = attributeDefault(group, NAME_ATTRIBUTE);
+  if (name !== undefined)
+    value.name = { defaultValue: name };
+  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
+  if (folderPath !== undefined) {
+    value.folderPath = { defaultValue: folderPath };
+  }
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  return {
+    resource: group[0].resource,
+    key,
+    value,
+    ...subType !== undefined && { metadata: { subType } }
+  };
+};
+var deriveCaseBindingsV2 = (document, entryPointIds = new Map) => {
+  const connectorKeys = collectConnectorKeys(document);
+  const groups = new Map;
+  const bindings = [];
+  for (const entry of Array.isArray(document.bindings) ? document.bindings : []) {
+    const binding = asBinding(entry);
+    if (binding === undefined)
+      continue;
+    bindings.push(binding);
+    const groupKey = `${binding.resource}:${binding.resourceKey}`;
+    const group = groups.get(groupKey);
+    if (group === undefined)
+      groups.set(groupKey, [binding]);
+    else
+      group.push(binding);
+  }
+  return [
+    ...[...groups.values()].map((group) => group[0].resource === CONNECTION_RESOURCE ? connectionEntry(group, connectorKeys) : resourceEntry(group)),
+    ...deriveEventTriggerResources(document.nodes, bindings, entryPointIds)
+  ];
+};
+var bindingsV2PathFor = (casePlanPath) => {
+  const fs = getFileSystem();
+  return fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), BINDINGS_V2_FILE_NAME);
+};
+var compareCaseBindingsV2 = async (casePlanPath, document) => {
+  const fs = getFileSystem();
+  const path = bindingsV2PathFor(casePlanPath);
+  const entryPoints = await readEntryPointIds(casePlanPath);
+  if ("error" in entryPoints) {
+    return {
+      status: "entry-points-unreadable",
+      path: entryPoints.path,
+      expectedCount: 0,
+      reason: entryPoints.error
+    };
+  }
+  const expected = deriveCaseBindingsV2(document, entryPoints.ids);
+  const expectedCount = expected.length;
+  if (!await fs.exists(path))
+    return { status: "absent", path, expectedCount };
+  const [readError, raw] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || raw == null)
+    return { status: "unreadable", path, expectedCount };
+  const actual = readBindingsV2Resources(raw);
+  if (actual === undefined)
+    return { status: "unreadable", path, expectedCount };
+  const difference = diffBindingsV2(expected, actual);
+  return hasBindingsV2Difference(difference) ? { status: "differs", path, expectedCount, difference } : { status: "match", path, expectedCount };
+};
+var syncCaseBindings = async (casePlanPath) => {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(casePlanPath);
+  if (!await fs.exists(resolved)) {
+    return {
+      ok: false,
+      message: `Case plan file not found: ${resolved}`,
+      instructions: "Pass the path to an existing caseplan JSON file, for example 'uip maestro case bindings sync case.json'."
+    };
+  }
+  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      ok: false,
+      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
+      instructions: `Verify read permissions on ${resolved}.`
+    };
+  }
+  const [parseError, document] = catchError(() => JSON.parse(raw));
+  if (parseError || document == null || typeof document !== "object" || Array.isArray(document)) {
+    return {
+      ok: false,
+      message: `Case plan is not valid JSON: ${parseError?.message ?? "not a JSON object"}`,
+      instructions: `Verify the contents of ${resolved}.`
+    };
+  }
+  const entryPoints = await readEntryPointIds(resolved);
+  if ("error" in entryPoints) {
+    return {
+      ok: false,
+      message: entryPoints.error,
+      instructions: `Fix or remove ${entryPoints.path}, then run \`uip maestro case bindings sync\` again.`
+    };
+  }
+  const resources = deriveCaseBindingsV2(document, entryPoints.ids);
+  const path = bindingsV2PathFor(resolved);
+  const [writeError] = await catchError(fs.writeFile(path, serializeBindingsV2File(resources)));
+  if (writeError) {
+    return {
+      ok: false,
+      message: `Failed to write bindings file: ${writeError.message}`,
+      instructions: `Verify write permissions on ${fs.path.dirname(path)}.`
+    };
+  }
+  return {
+    ok: true,
+    path,
+    resourceCount: resources.length,
+    connectionCount: resources.filter((entry) => entry.resource === CONNECTION_RESOURCE).length
+  };
+};
+export {
+  bindingsV2PathFor,
+  compareCaseBindingsV2,
+  deriveCaseBindingsV2,
+  syncCaseBindings
+};
+
+//# debugId=DF4BCD662409114064756E2164756E21

package/dist/{case-debug-studio-web-service-87j70jy4.js → case-debug-studio-web-service-cc0vj7md.js}

@@ -1,14 +1,11 @@
-import {
-  loadCaseSchemaAsync
-} from "./packager-tool-p7jgrm5r.js";
 import {
   buildSolutionPackageFromDir,
   uploadOrOverwriteSolution
-} from "./packager-tool-2ztfrdya.js";
+} from "./packager-tool-ggbvxvey.js";
 import {
   findSolutionFile,
   updateSolutionFile
-} from "./packager-tool-052kvydg.js";
+} from "./packager-tool-pm646ag4.js";
 import {
   CasePlanFileNames,
   buildCasePackageDescriptor,
@@ -18,17 +15,21 @@ import {
   misnamedEntryPointBpmn,
   normalizeEntryPointPath,
   resolveDeclaredFileName
-} from "./packager-tool-83qnybab.js";
+} from "./packager-tool-wj9d9mqe.js";
+import"./packager-tool-4rqd21wc.js";
 import"./packager-tool-b098y4a2.js";
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-cmwets3m.js";
 import {
   uploadAndDebugSolution
-} from "./packager-tool-adcaxdhs.js";
+} from "./packager-tool-paepfv5d.js";
 import {
   logger
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-debug-studio-web-service.ts
@@ -130,4 +131,4 @@ export {
   CaseDebugStudioWebService
 };
 
-//# debugId=BA02F2B9880B270D64756E2164756E21
+//# debugId=0DC6729E8C8F178464756E2164756E21

package/dist/case-described-io-service-cpe5h2ks.js

@@ -0,0 +1,132 @@
+import {
+  readIoRows
+} from "./packager-tool-8a9yqfq7.js";
+import {
+  NAME_BOUND_TASK_TYPES
+} from "./packager-tool-d7jjng8a.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/case-described-io-service.ts
+var RESOURCE_FIELDS = [
+  "type",
+  "subType",
+  "_jsonSchema",
+  "displayName",
+  "options",
+  "required"
+];
+var CLEARED_ON_REFRESH = [
+  "body",
+  "_jsonSchema",
+  "options",
+  "subType",
+  "required"
+];
+var AUTHORED_FIELDS = ["value", "source", "target"];
+var bodyOwner = (direction) => direction === "outputs" ? "resource" : "authored";
+var carriesValue = (value) => value !== undefined && value !== null && !(typeof value === "string" && value.trim() === "");
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var findTask = (document, taskId) => {
+  for (const rawNode of asArray(document.nodes)) {
+    const data = asRecord(asRecord(rawNode)?.data);
+    for (const lane of asArray(data?.tasks)) {
+      for (const rawTask of asArray(lane)) {
+        const task = asRecord(rawTask);
+        if (task?.id === taskId)
+          return task;
+      }
+    }
+  }
+  return;
+};
+var mergeRows = (existing, described, elementId, direction) => {
+  const byName = new Map;
+  for (const raw of described) {
+    const row = asRecord(raw);
+    if (row === undefined)
+      continue;
+    const name = row.name;
+    if (typeof name === "string" && name !== "")
+      byName.set(name, row);
+  }
+  const updated = [];
+  const rows = existing.map((raw) => {
+    const row = asRecord(raw);
+    const name = typeof row?.name === "string" ? row.name : "";
+    const source = byName.get(name);
+    if (row === undefined || source === undefined)
+      return raw;
+    updated.push(name);
+    const merged = { ...row };
+    for (const field of RESOURCE_FIELDS) {
+      if (source[field] !== undefined)
+        merged[field] = source[field];
+    }
+    if (bodyOwner(direction) === "resource") {
+      for (const field of CLEARED_ON_REFRESH) {
+        if (source[field] !== undefined)
+          merged[field] = source[field];
+        else
+          delete merged[field];
+      }
+    } else if (!carriesValue(merged.body) && carriesValue(source.body)) {
+      merged.body = source.body;
+    }
+    for (const field of AUTHORED_FIELDS) {
+      if (carriesValue(merged[field]))
+        continue;
+      if (!carriesValue(source[field]))
+        continue;
+      merged[field] = source[field];
+    }
+    merged.elementId = elementId;
+    return merged;
+  });
+  const unmatched = [...byName.keys()].filter((name) => !updated.includes(name));
+  return { rows, updated, unmatched };
+};
+var applyDescribedIo = (document, describeDocument, options) => {
+  const task = findTask(document, options.taskId);
+  if (task === undefined) {
+    return {
+      message: `No task with id "${options.taskId}" in this case plan`,
+      instructions: "Pass the task's `id` from `nodes[].data.tasks[][]`."
+    };
+  }
+  const taskType = typeof task.type === "string" ? task.type : "";
+  if (!NAME_BOUND_TASK_TYPES.has(taskType)) {
+    return {
+      message: `Task "${options.taskId}" is a \`${taskType || "(untyped)"}\` task, and \`--described\` writes a resource task's own contract`,
+      instructions: `A described result belongs on ${[...NAME_BOUND_TASK_TYPES].map((type) => `\`${type}\``).join(", ")}. For a connector task use \`--spec\` with a \`case spec\` result instead.`
+    };
+  }
+  const described = readIoRows(describeDocument);
+  if (described === undefined) {
+    return {
+      message: "This file carries no described inputs or outputs",
+      instructions: "Save the result of `uip maestro case tasks describe --type <type> --id <id> --output json` and pass that."
+    };
+  }
+  const data = asRecord(task.data) ?? {};
+  const elementId = typeof task.elementId === "string" && task.elementId !== "" ? task.elementId : options.taskId;
+  const inputs = mergeRows(asArray(data.inputs), described.inputs, elementId, "inputs");
+  const outputs = mergeRows(asArray(data.outputs), described.outputs, elementId, "outputs");
+  task.data = { ...data, inputs: inputs.rows, outputs: outputs.rows };
+  return {
+    document,
+    summary: {
+      taskId: options.taskId,
+      inputsUpdated: inputs.updated,
+      outputsUpdated: outputs.updated,
+      unmatched: [...inputs.unmatched, ...outputs.unmatched]
+    }
+  };
+};
+var isDescribedIoFailure = (value) => ("message" in value);
+export {
+  applyDescribedIo,
+  isDescribedIoFailure
+};
+
+//# debugId=68B2D7B3821D688864756E2164756E21

package/dist/{case-format-service-q345a2fd.js → case-format-service-qwyjyt0y.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-format-service.ts