@uipath/case-tool 1.205.0-preview.277 → 1.206.0-preview.279

package/dist/{packager-tool-scc247gk.js → packager-tool-32792w66.js}

@@ -1,31 +1,37 @@
 import {
-  fetchConnectorConnections,
-  lookupTypeCacheEntry
-} from "./packager-tool-xm3gr7d4.js";
-import {
-  addVarIdsToInputsOutputs,
-  buildErrorOutput
-} from "./packager-tool-ydyvtknp.js";
-import {
-  fetchConnectorMetadata
-} from "./packager-tool-g8nkdj5b.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
 import {
   ElementsApi,
-  assertActivityMetadataResolved,
-  buildInputMetadata,
   createApiClient,
   createConfiguredActivityClient,
-  extractMultipartParameters
-} from "./packager-tool-29br2cdx.js";
+  assertActivityMetadataResolved,
+  extractMultipartParameters,
+  buildInputMetadata
+} from "./packager-tool-4wn3b7qp.js";
+import {
+  guardJsonString
+} from "./packager-tool-h2ar8xf8.js";
+import {
+  lookupTypeCacheEntry2,
+  fetchConnectorConnections2
+} from "./packager-tool-nd312sma.js";
+import {
+  buildErrorOutput,
+  addVarIdsToInputsOutputs
+} from "./packager-tool-0w4fsdzv.js";
+import {
+  fetchConnectorMetadata2
+} from "./packager-tool-bpkkg4z2.js";
 import {
   createConnectorBindings
-} from "./packager-tool-sq931c23.js";
+} from "./packager-tool-e1tx5mqg.js";
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  v2ConfigurationVersionEntry
+} from "./packager-tool-68648y3j.js";
 
 // src/services/connector-enrichment-service.ts
-function parseEntryConfiguration(entry) {
+function parseEntryConfiguration2(entry) {
   if (!entry.configuration)
     return {};
   try {
@@ -35,15 +41,15 @@ function parseEntryConfiguration(entry) {
   }
 }
 async function fetchMetadataSafe(connectorKey, objectName, connectionId) {
-  const [err, result] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
+  const [err, result] = await catchError2(fetchConnectorMetadata2(connectorKey, objectName, connectionId));
   return err ? undefined : result;
 }
-async function resolveActivityOperation(connectorKey, displayName, operation) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function resolveActivityOperation2(connectorKey, displayName, operation) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return operation;
   }
-  const [fetchError, activities] = await catchError(api.getActivities({ elementKey: connectorKey }));
+  const [fetchError, activities] = await catchError2(api.getActivities({ elementKey: connectorKey }));
   if (fetchError) {
     return operation;
   }
@@ -52,9 +58,9 @@ async function resolveActivityOperation(connectorKey, displayName, operation) {
   }
   const list = activities;
   if (operation) {
-    const match2 = list.find((a) => a.operation === operation && !a.isTrigger);
-    if (match2) {
-      return match2.name;
+    const match = list.find((a) => a.operation === operation && !a.isTrigger);
+    if (match) {
+      return match.name;
     }
   }
   const match = list.find((a) => a.displayName === displayName && !a.isTrigger);
@@ -63,31 +69,31 @@ async function resolveActivityOperation(connectorKey, displayName, operation) {
   }
   return operation;
 }
-async function fetchObjectSwaggerPath(connectorKey, objectName) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function fetchObjectSwaggerPath2(connectorKey, objectName) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return;
   }
-  const [fetchError, swagger] = await catchError(api.getObjectSwagger({
+  const [fetchError, swagger] = await catchError2(api.getObjectSwagger({
     elementKey: connectorKey,
     objectName
   }));
   if (fetchError) {
     return;
   }
-  const [parseError, parsed] = catchError(() => typeof swagger === "string" ? JSON.parse(swagger) : swagger);
+  const [parseError, parsed] = catchError2(() => typeof swagger === "string" ? JSON.parse(swagger) : swagger);
   if (parseError || !parsed?.paths) {
     return;
   }
   const pathKeys = Object.keys(parsed.paths).filter((k) => k.startsWith("/"));
   return pathKeys[0];
 }
-async function fetchObjectMethodConfig(connectorKey, objectName, httpMethod) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function fetchObjectMethodConfig2(connectorKey, objectName, httpMethod) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return;
   }
-  const [fetchError, objects] = await catchError(api.getObjects({ elementKey: connectorKey }));
+  const [fetchError, objects] = await catchError2(api.getObjects({ elementKey: connectorKey }));
   if (fetchError) {
     return;
   }
@@ -104,7 +110,7 @@ async function fetchObjectMethodConfig(connectorKey, objectName, httpMethod) {
 }
 async function buildActivityPropertyConfig(params) {
   const { entry, uiPathActivityTypeId, connectionId } = params;
-  const instanceParameters = parseEntryConfiguration(entry);
+  const instanceParameters = parseEntryConfiguration2(entry);
   const activityClient = await createConfiguredActivityClient({
     instanceParameters,
     connectionId
@@ -115,7 +121,7 @@ async function buildActivityPropertyConfig(params) {
   const multipartParams = extractMultipartParameters(params.objectMethodConfig?.parameters ?? []);
   return {
     ...multipartParams.length > 0 ? { multipartParameters: multipartParams } : {},
-    configuration: `=jsonString:${JSON.stringify(essentialConfig)}`,
+    configuration: guardJsonString(JSON.stringify(essentialConfig)),
     uiPathActivityTypeId,
     errorState: { issues: [] }
   };
@@ -125,7 +131,7 @@ function buildInputMetadataFromParams(objectMethodConfig, resolvedOperation) {
   const multipartParams = extractMultipartParameters(params);
   return buildInputMetadata(multipartParams, resolvedOperation ?? "list") ?? undefined;
 }
-function extractFields(metadata) {
+function extractFields2(metadata) {
   if (metadata.fields) {
     return metadata.fields;
   }
@@ -135,36 +141,18 @@ function extractFields(metadata) {
   }
   return;
 }
-function normalizeFields(raw) {
+function normalizeFields2(raw) {
   if (Array.isArray(raw)) {
     return raw;
   }
   return Object.values(raw);
 }
-var UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-function nestDottedKeys(flat) {
-  const result = {};
-  for (const [key, value] of Object.entries(flat)) {
-    const parts = key.split(".");
-    if (parts.some((p) => UNSAFE_KEYS.has(p)))
-      continue;
-    let current = result;
-    for (let i = 0;i < parts.length - 1; i++) {
-      if (!Object.hasOwn(current, parts[i]) || typeof current[parts[i]] !== "object" || current[parts[i]] === null) {
-        current[parts[i]] = {};
-      }
-      current = current[parts[i]];
-    }
-    current[parts[parts.length - 1]] = value;
-  }
-  return result;
-}
-function mapISFieldsToInputOutputs(metadata, httpMethod) {
-  const rawFields = extractFields(metadata);
+function mapISFieldsToInputOutputs2(metadata, httpMethod) {
+  const rawFields = extractFields2(metadata);
   if (!rawFields) {
     return { inputs: [], outputs: [] };
   }
-  const fields = normalizeFields(rawFields);
+  const fields = normalizeFields2(rawFields);
   const method = httpMethod ?? "POST";
   const requestFields = [];
   const responseFields = [];
@@ -214,7 +202,7 @@ function mapISFieldsToInputOutputs(metadata, httpMethod) {
   outputs.push(buildErrorOutput());
   return { inputs, outputs };
 }
-function buildParameterInputs(objectMethodConfig, activityPropertyConfig) {
+function buildParameterInputs2(objectMethodConfig, activityPropertyConfig) {
   const inputs = [];
   inputs.push({
     name: "pathParameters",
@@ -269,7 +257,7 @@ function httpMethodToOperationType(method) {
       return "";
   }
 }
-function buildConnectorContext(params) {
+function buildConnectorContext2(params) {
   const {
     config,
     entry,
@@ -339,26 +327,22 @@ function buildConnectorContext(params) {
       primaryKeyName: ""
     }
   };
-  context.push({
-    name: "metadata",
-    type: "json",
-    body: metadataBody
-  });
+  context.push({ name: "metadata", type: "json", body: metadataBody }, v2ConfigurationVersionEntry());
   return context;
 }
-async function extractFieldDefinitions(connectorKey, objectName, httpMethod, prefetched) {
+async function extractFieldDefinitions2(connectorKey, objectName, httpMethod, prefetched) {
   const result = {};
   if (!objectName)
     return result;
   const method = httpMethod ?? "POST";
   const [metadata, methodConfig] = prefetched ? [prefetched.metadata, prefetched.methodConfig] : await Promise.all([
     fetchMetadataSafe(connectorKey, objectName),
-    fetchObjectMethodConfig(connectorKey, objectName, method)
+    fetchObjectMethodConfig2(connectorKey, objectName, method)
   ]);
   if (metadata) {
-    const rawFields = extractFields(metadata);
+    const rawFields = extractFields2(metadata);
     if (rawFields) {
-      const fields = normalizeFields(rawFields);
+      const fields = normalizeFields2(rawFields);
       const bodyDefs = {};
       for (const field of fields) {
         const mc = field.method?.[method];
@@ -414,7 +398,7 @@ async function extractFieldDefinitions(connectorKey, objectName, httpMethod, pre
   }
   return result;
 }
-async function enrichConnectorRegistryEntry(config, connectionId) {
+async function enrichConnectorRegistryEntry2(config, connectionId) {
   if (!config.objectName || !config.httpMethod) {
     return null;
   }
@@ -422,11 +406,11 @@ async function enrichConnectorRegistryEntry(config, connectionId) {
   if (!metadata) {
     return null;
   }
-  const rawFields = extractFields(metadata);
+  const rawFields = extractFields2(metadata);
   if (!rawFields) {
     return null;
   }
-  const fields = normalizeFields(rawFields);
+  const fields = normalizeFields2(rawFields);
   const method = config.httpMethod;
   const inputFields = [];
   const outputFields = [];
@@ -460,9 +444,9 @@ async function enrichConnectorRegistryEntry(config, connectionId) {
     outputDefinition: { fields: outputFields }
   };
 }
-async function enrichConnectorActivity(activityTypeId, connectionId, indexType = "typecache-activities") {
-  const { entry, config } = await lookupTypeCacheEntry(activityTypeId, indexType);
-  const resolvedOperation = await resolveActivityOperation(config.connectorKey, entry.displayName, config.operation);
+async function enrichConnectorActivity2(activityTypeId, connectionId, indexType = "typecache-activities") {
+  const { entry, config } = await lookupTypeCacheEntry2(activityTypeId, indexType);
+  const resolvedOperation = await resolveActivityOperation2(config.connectorKey, entry.displayName, config.operation);
   let inputs = [];
   let outputs = [];
   let objectSwaggerPath;
@@ -472,13 +456,13 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (config.objectName) {
     const [md, swaggerPath, mc] = await Promise.all([
       fetchMetadataSafe(config.connectorKey, config.objectName),
-      fetchObjectSwaggerPath(config.connectorKey, config.objectName),
-      fetchObjectMethodConfig(config.connectorKey, config.objectName, config.httpMethod)
+      fetchObjectSwaggerPath2(config.connectorKey, config.objectName),
+      fetchObjectMethodConfig2(config.connectorKey, config.objectName, config.httpMethod)
     ]);
     metadata = md ?? undefined;
     objectMethodConfig = mc ?? undefined;
     if (metadata) {
-      const io = mapISFieldsToInputOutputs(metadata, config.httpMethod);
+      const io = mapISFieldsToInputOutputs2(metadata, config.httpMethod);
       inputs = io.inputs;
       outputs = io.outputs;
       inputMetadata = buildInputMetadataFromParams(objectMethodConfig, resolvedOperation ?? config.operation);
@@ -496,10 +480,10 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (config.objectName) {
     inputs = [
       ...inputs,
-      ...buildParameterInputs(objectMethodConfig, activityPropertyConfig)
+      ...buildParameterInputs2(objectMethodConfig, activityPropertyConfig)
     ];
   }
-  const connections = await fetchConnectorConnections(config.connectorKey);
+  const connections = await fetchConnectorConnections2(config.connectorKey);
   const connection = connections.find((c) => c.id === connectionId);
   if (!connection) {
     throw new Error(`Connection "${connectionId}" not found for connector "${config.connectorKey}"`);
@@ -511,7 +495,7 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (folderKeyBinding) {
     bindings.push(folderKeyBinding);
   }
-  const context = buildConnectorContext({
+  const context = buildConnectorContext2({
     config,
     entry,
     connectionBindingId: connectionBinding.id,
@@ -541,6 +525,6 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   };
 }
 
-export { parseEntryConfiguration, resolveActivityOperation, fetchObjectSwaggerPath, fetchObjectMethodConfig, extractFields, normalizeFields, UNSAFE_KEYS, nestDottedKeys, mapISFieldsToInputOutputs, buildParameterInputs, buildConnectorContext, extractFieldDefinitions, enrichConnectorRegistryEntry, enrichConnectorActivity };
+export { parseEntryConfiguration2, resolveActivityOperation2, fetchObjectSwaggerPath2, fetchObjectMethodConfig2, extractFields2, normalizeFields2, mapISFieldsToInputOutputs2, buildParameterInputs2, buildConnectorContext2, extractFieldDefinitions2, enrichConnectorRegistryEntry2, enrichConnectorActivity2 };
 
-//# debugId=3B7A9B9E859645AF64756E2164756E21
+//# debugId=E98C74933F9F2C6D64756E2164756E21

package/dist/{packager-tool-nj4seavy.js → packager-tool-35c9npcy.js}

@@ -4,31 +4,46 @@ var VALID_TASK_ENTRY_RULE_TYPES = [
   "selected-tasks-completed",
   "wait-for-connector",
   "adhoc",
-  "runs-sequentially"
+  "runs-sequentially",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_ENTRY_RULE_TYPES = [
   "case-entered",
   "selected-stage-exited",
   "selected-stage-completed",
   "wait-for-connector",
-  "user-selected-stage"
+  "user-selected-stage",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_COMPLETION_RULE_TYPES = [
   "required-tasks-completed",
-  "wait-for-connector"
+  "selected-tasks-completed",
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_STAGE_EXIT_RULE_TYPES = [
   "selected-tasks-completed",
-  "wait-for-connector"
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_CASE_COMPLETION_RULE_TYPES = [
   "required-stages-completed",
-  "wait-for-connector"
+  "selected-stage-exited",
+  "selected-stage-completed",
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 var VALID_CASE_EXIT_RULE_TYPES = [
   "selected-stage-completed",
   "selected-stage-exited",
-  "wait-for-connector"
+  "wait-for-connector",
+  "sla-status-change",
+  "api-event"
 ];
 function buildRule(options) {
   const {
@@ -88,6 +103,10 @@ function buildRule(options) {
       return { rule: "user-selected-stage", id, conditionExpression };
     case "runs-sequentially":
       return { rule: "runs-sequentially", id, conditionExpression };
+    case "sla-status-change":
+      return { rule: "sla-status-change", id, conditionExpression };
+    case "api-event":
+      return { rule: "api-event", id, conditionExpression };
   }
 }
 function isStageNode(node) {
@@ -174,4 +193,4 @@ function remapBindingRefs(value, idRemap) {
 
 export { VALID_TASK_ENTRY_RULE_TYPES, VALID_STAGE_ENTRY_RULE_TYPES, VALID_STAGE_COMPLETION_RULE_TYPES, VALID_STAGE_EXIT_RULE_TYPES, VALID_CASE_COMPLETION_RULE_TYPES, VALID_CASE_EXIT_RULE_TYPES, buildRule, isStageNode, requireStageNode, requireTask, DEFAULT_TRIGGER_ID, DEFAULT_TRIGGER_LABEL, isAnyTriggerNode, findTriggerNodes, ensureRootBindings, findOrPushBinding, remapBindingRefs };
 
-//# debugId=E05AE20CC4D952F964756E2164756E21
+//# debugId=A877E69BF91D62B264756E2164756E21

package/dist/{packager-tool-r0x3qh59.js → packager-tool-388vyja1.js}

@@ -1,9 +1,185 @@
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  CASE_APP_VERSIONS_WITH_ROLES,
+  roleActionKeyOf,
+  caseStageLabels,
+  roleResourceKey,
+  CASE_ROLE_FIELDS,
+  caseRoleEntries,
+  readCaseRole,
+  readCaseRoles
+} from "./packager-tool-1wgav5ma.js";
 import {
-  __require
-} from "./packager-tool-1yh8g550.js";
+  resolvePersonas
+} from "./packager-tool-yh8mmj3p.js";
+import {
+  withoutTrailingSlug
+} from "./packager-tool-fcektt1g.js";
+import {
+  indexKey
+} from "./packager-tool-5w0gjcck.js";
+import {
+  prefixedId
+} from "./packager-tool-1h7abxw6.js";
+
+// src/services/sdd-convert/case-roles.ts
+var caseRolesFor = (model, index, unresolved) => {
+  for (const note of model.personaNotes ?? []) {
+    unresolved.push({
+      kind: "case-role",
+      where: "metadata.caseRoles",
+      detail: note
+    });
+  }
+  if (model.personas.length === 0)
+    return [];
+  const { roles, problems } = resolvePersonas(model.personas, (name) => index.stageIds.get(indexKey(withoutTrailingSlug(name))));
+  for (const problem of problems) {
+    unresolved.push({
+      kind: "case-role",
+      where: `metadata.caseRoles[${problem.persona}]`,
+      detail: problem.detail
+    });
+  }
+  return roles.map((role) => ({
+    id: prefixedId("role-", 10),
+    name: role.name,
+    description: role.description,
+    actions: role.actions,
+    scope: role.scope,
+    ...role.scope === "stages" && { stageIds: role.stageIds }
+  }));
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sameSet = (a, b) => a.length === b.length && new Set(a.map((x) => x.toLowerCase())).size === new Set([...a, ...b].map((x) => x.toLowerCase())).size;
+var describeRole = (role, stageLabels) => {
+  const keys = role.actions.map((action) => roleActionKeyOf(action) ?? action);
+  const grants = keys.length > 0 ? keys.join(", ") : "nothing";
+  const where = role.scope === "stages" ? stageLabels.length > 0 ? ` on ${stageLabels.map((label) => `"${label}"`).join(", ")}` : " on no stage this plan has" : "";
+  const description = role.description?.trim();
+  return `${role.scope} scope granting ${grants}${where}${description ? `, "${description}"` : ""}`;
+};
+var carryCaseRoles = (document, previous, unresolved, declaredNames = []) => {
+  if (!isRecord(document) || !isRecord(previous))
+    return 0;
+  const previousMetadata = isRecord(previous.metadata) ? previous.metadata : {};
+  const entries = previousEntries(previous, unresolved);
+  const previousVersion = asString(previousMetadata.caseAppVersion);
+  if (entries.length === 0 && previousVersion === undefined)
+    return 0;
+  const metadata = isRecord(document.metadata) ? document.metadata : {};
+  const stages = {
+    before: caseStageLabels(previous.nodes),
+    now: caseStageLabels(document.nodes)
+  };
+  const { roles, matched } = matchDeclaredRoles(readCaseRoles(document), entries, stages, unresolved);
+  const undeclared = entries.filter((entry) => !matched.has(entry));
+  const declared = new Set(declaredNames.map(roleResourceKey));
+  const carried = carryUndeclaredRoles(undeclared, stages, declared, unresolved);
+  roles.push(...carried);
+  const versions = caseAppVersions(previousMetadata, metadata, roles.length > 0);
+  if (versions.version !== undefined && roles.length > 0 && !CASE_APP_VERSIONS_WITH_ROLES.includes(versions.version)) {
+    unresolved.push({
+      kind: "case-role",
+      where: "metadata.caseAppVersion",
+      detail: `the plan runs the "${versions.version}" case app, which has no roles, so the ${roles.length} role(s) written are not honoured until the case is moved to the V2 app in the Case Designer. Kept as the plan had it`
+    });
+  }
+  const {
+    caseRoles: _roles,
+    caseAppVersion: _version,
+    caseAppCreatedVersion: _created,
+    ...rest
+  } = metadata;
+  document.metadata = {
+    ...rest,
+    ...versions.version !== undefined && {
+      caseAppVersion: versions.version
+    },
+    ...versions.createdVersion !== undefined && {
+      caseAppCreatedVersion: versions.createdVersion
+    },
+    ...roles.length > 0 && { caseRoles: roles }
+  };
+  return carried.length;
+};
+var asString = (value) => typeof value === "string" ? value : undefined;
+var roleItem = (name, detail) => ({
+  kind: "case-role",
+  where: `metadata.caseRoles[${name}]`,
+  detail
+});
+var previousEntries = (previous, unresolved) => caseRoleEntries(previous).flatMap((entry, at) => {
+  const role = readCaseRole(entry);
+  if (role === undefined) {
+    const name = isRecord(entry) && typeof entry.name === "string" && entry.name.trim() !== "" ? `"${entry.name}"` : `entry ${at + 1}`;
+    unresolved.push({
+      kind: "case-role",
+      where: `metadata.caseRoles[${at}]`,
+      detail: `the plan's role ${name} is not carried: it has no name, no scope or no actions list, so the schema does not read it as a role`
+    });
+    return [];
+  }
+  const extras = Object.fromEntries(Object.entries(entry).filter(([key]) => !CASE_ROLE_FIELDS.includes(key)));
+  return [{ role, extras }];
+});
+var labelsOf = (role, from) => (role.stageIds ?? []).flatMap((stageId) => {
+  const label = from.get(stageId);
+  return label === undefined ? [] : [label];
+});
+var sameRole = (before, role, beforeLabels, nowLabels) => before.scope === role.scope && sameSet(before.actions, role.actions) && sameSet(beforeLabels, nowLabels) && (before.description?.trim() ?? "") === (role.description?.trim() ?? "");
+var matchDeclaredRoles = (declared, entries, stages, unresolved) => {
+  const roles = [];
+  const matched = new Set;
+  for (const role of declared) {
+    const entry = entries.find((candidate) => !matched.has(candidate) && roleResourceKey(candidate.role.name) === roleResourceKey(role.name));
+    if (entry === undefined) {
+      roles.push(role);
+      continue;
+    }
+    matched.add(entry);
+    const { role: before, extras } = entry;
+    const beforeLabels = labelsOf(before, stages.before);
+    const nowLabels = labelsOf(role, stages.now);
+    if (!sameRole(before, role, beforeLabels, nowLabels)) {
+      unresolved.push(roleItem(role.name, `the plan had this role as ${describeRole(before, beforeLabels)}; the Personas row writes it as ${describeRole(role, nowLabels)}. The row is written. If the plan's was the one meant, edit the row`));
+    }
+    roles.push({
+      ...extras,
+      ...role,
+      id: before.id,
+      ...before.isDefault !== undefined && {
+        isDefault: before.isDefault
+      }
+    });
+  }
+  return { roles, matched };
+};
+var carryUndeclaredRoles = (undeclared, stages, declared, unresolved) => {
+  const idByLabel = new Map([...stages.now].map(([id, label]) => [label.toLowerCase(), id]));
+  return undeclared.flatMap(({ role: before, extras }) => {
+    const labels = labelsOf(before, stages.before);
+    const kept = labels.filter((label) => idByLabel.has(label.toLowerCase()));
+    if (before.scope === "stages" && kept.length === 0) {
+      unresolved.push(roleItem(before.name, `the plan's role is not carried: none of its stages${labels.length > 0 ? ` (${labels.map((label) => `"${label}"`).join(", ")})` : ""} is in this plan, so it could apply to nothing. Add it back in the Case Designer if it is still wanted`));
+      return [];
+    }
+    const role = {
+      ...extras,
+      ...before,
+      ...before.scope === "stages" && {
+        stageIds: kept.map((label) => idByLabel.get(label.toLowerCase()))
+      }
+    };
+    unresolved.push(roleItem(before.name, declared.has(roleResourceKey(before.name)) ? `kept from the plan as it was, ${describeRole(role, kept)}: its Personas row could not become a role (see the other items for it)` : `kept from the plan, which the Personas table does not declare: ${describeRole(role, kept)}. Add a row for it, or remove the role in the Case Designer`));
+    return [role];
+  });
+};
+var caseAppVersions = (previousMetadata, metadata, hasRoles) => {
+  const previousVersion = asString(previousMetadata.caseAppVersion);
+  const version = previousVersion ?? asString(metadata.caseAppVersion) ?? (hasRoles ? "v2" : undefined);
+  const createdVersion = previousVersion !== undefined ? asString(previousMetadata.caseAppCreatedVersion) : asString(previousMetadata.caseAppCreatedVersion) ?? asString(metadata.caseAppCreatedVersion) ?? (version !== undefined ? "v2" : undefined);
+  return { version, createdVersion };
+};
 
 // src/services/sdd-convert/canvas-note-match.ts
 var SIMILAR = 0.5;
@@ -30,9 +206,9 @@ var similarity = (a, b) => {
 var commonRun = (a, b) => {
   const length = a.map(() => new Array(b.length + 1).fill(0));
   length.push(new Array(b.length + 1).fill(0));
-  for (let i2 = a.length - 1;i2 >= 0; i2 -= 1)
-    for (let j2 = b.length - 1;j2 >= 0; j2 -= 1)
-      length[i2][j2] = a[i2] === b[j2] ? length[i2 + 1][j2 + 1] + 1 : Math.max(length[i2 + 1][j2], length[i2][j2 + 1]);
+  for (let i = a.length - 1;i >= 0; i -= 1)
+    for (let j = b.length - 1;j >= 0; j -= 1)
+      length[i][j] = a[i] === b[j] ? length[i + 1][j + 1] + 1 : Math.max(length[i + 1][j], length[i][j + 1]);
   const pairs = [];
   let i = 0;
   let j = 0;
@@ -281,27 +457,7 @@ var colorText = (note) => {
   const color = dataOf(note).color;
   return typeof color === "string" ? ` (${color})` : ` (${DEFAULT_COLOR}, the default)`;
 };
-var carryCanvasNotesFrom = async (document, out, unresolved) => {
-  const { getFileSystemAsync } = await import("./index-ngs0a2he.js");
-  const fs = await getFileSystemAsync();
-  if (!await fs.exists(out))
-    return 0;
-  const [readError, text] = await catchError(fs.readFile(out, "utf-8"));
-  if (readError || typeof text !== "string")
-    return {
-      error: `Could not read the plan at ${out} to keep its sticky notes: ${readError?.message ?? "it read as empty"}`
-    };
-  if (text.trim() === "")
-    return 0;
-  const json = text.replace(/^\uFEFF/, "");
-  const [parseError, previous] = await catchError(Promise.resolve().then(() => JSON.parse(json)));
-  if (parseError)
-    return {
-      error: `The plan at ${out} is not valid JSON, so its sticky notes cannot be kept: ${parseError.message}`
-    };
-  return carryCanvasNotes(document, previous, unresolved);
-};
 
-export { STICKY_NOTE_TYPE, sddNoteId, emitCanvasNotes, carryCanvasNotes, carryCanvasNotesFrom };
+export { caseRolesFor, carryCaseRoles, emitCanvasNotes, carryCanvasNotes };
 
-//# debugId=FDBC5FC638B6E79B64756E2164756E21
+//# debugId=114C68FEC6CAE42B64756E2164756E21