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

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

@@ -0,0 +1,430 @@
+import {
+  BINDINGS_V2_FILE_NAME,
+  CONNECTION_ID_PROPERTY,
+  FOLDER_KEY_PROPERTY,
+  RESOURCE_BINDINGS_VERSION,
+  deriveEventTriggerResources,
+  diffBindingsV2,
+  hasBindingsV2Difference,
+  readBindingsV2Resources,
+  readEntryPointIds,
+  serializeBindingsV2File
+} from "./packager-tool-wekqkmgn.js";
+import"./packager-tool-5qp9xza1.js";
+import {
+  catchError
+} from "./packager-tool-83v804p7.js";
+import {
+  getFileSystem
+} from "./packager-tool-hdxtgckw.js";
+import"./packager-tool-1yh8g550.js";
+
+// 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 IMPLICIT_CONNECTION = "ImplicitConnection";
+var DROPPED_RESOURCES = new Set([
+  "connection",
+  "eventtrigger"
+]);
+var bindingIdentity = (resource, key) => `${resource.toLowerCase()}:${key}`;
+var NAME_ATTRIBUTE = "name";
+var FOLDER_PATH_ATTRIBUTE = "folderPath";
+var SOLUTION_FOLDER_PREFIX = "solution_folder.";
+var SOLUTION_FOLDER_SENTINEL = "solution_folder";
+var BINDING_REFERENCE_PREFIX = "=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 walkLabelled = (document, visit) => {
+  const walk = (node, label) => {
+    visit(node, label);
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item, label);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    const scoped = ownLabel(node) ?? label;
+    for (const value of Object.values(node))
+      walk(value, scoped);
+  };
+  walk(document, undefined);
+};
+var httpTargetConnector = (node) => {
+  if (node === null || typeof node !== "object" || Array.isArray(node))
+    return;
+  const task = node;
+  if (task.type !== "http-request" || !Array.isArray(task.data?.inputs))
+    return;
+  for (const input of task.data.inputs) {
+    const body = input?.body;
+    if (input.name === "body" && typeof body?.targetConnector === "string" && body.targetConnector !== "") {
+      return body.targetConnector;
+    }
+  }
+  return;
+};
+var collectConnectorKeys = (document) => {
+  const byBindingId = new Map;
+  walkLabelled(document, (node, label) => {
+    const target = httpTargetConnector(node);
+    if (target !== undefined) {
+      const context = readConnectorContext(node.data?.context);
+      const connection = context?.get(CONNECTION_ENTRY);
+      if (connection?.startsWith(BINDING_REFERENCE_PREFIX)) {
+        const bindingId = connection.slice(BINDING_REFERENCE_PREFIX.length);
+        if (!byBindingId.has(bindingId)) {
+          byBindingId.set(bindingId, {
+            connectorKey: target,
+            activityName: ownLabel(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_PREFIX) ? connection.slice(BINDING_REFERENCE_PREFIX.length) : undefined;
+      if (connectorKey !== undefined && bindingId !== undefined && !byBindingId.has(bindingId)) {
+        byBindingId.set(bindingId, {
+          connectorKey,
+          activityName: label
+        });
+      }
+    }
+  });
+  return byBindingId;
+};
+var attributeDefault = (group, attribute) => group.find((binding) => binding.propertyAttribute === attribute)?.default;
+var connectionEntry = (group, connectorKeys) => {
+  const key = group[0].resourceKey;
+  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;
+  const value = {
+    [CONNECTION_ID_PROPERTY]: {
+      defaultValue: attributeDefault(group, CONNECTION_ID_PROPERTY) ?? key,
+      isExpression: false,
+      ...typeof displayLabel === "string" && displayLabel !== "" && { displayName: displayLabel }
+    }
+  };
+  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined) {
+    value[FOLDER_KEY_PROPERTY] = { defaultValue: folderKey };
+  }
+  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 SLOT_DISPLAY_NAMES = {
+  app: { name: "App name", folderPath: "Folder path" },
+  process: { name: "Process name", folderPath: "Folder path" }
+};
+var designerResourceEntry = (group, labels, names) => {
+  const key = group[0].resourceKey;
+  const resource = group[0].resource;
+  const value = {};
+  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
+  if (folderPath !== undefined) {
+    value.folderPath = {
+      defaultValue: folderPath,
+      isExpression: false,
+      displayName: names.folderPath
+    };
+  }
+  const name = attributeDefault(group, NAME_ATTRIBUTE);
+  if (name !== undefined) {
+    value.name = {
+      defaultValue: name,
+      isExpression: false,
+      displayName: names.name
+    };
+  }
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  const activityName = group.map((binding) => labels.get(binding.id)).find((found) => found !== undefined);
+  return {
+    resource,
+    key,
+    id: `${resource}${key}`,
+    value,
+    metadata: {
+      ...activityName !== undefined && { ActivityName: activityName },
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      DisplayLabel: NAME_ATTRIBUTE,
+      SolutionsSupport: "true",
+      ...subType !== undefined && { subType }
+    }
+  };
+};
+var collectBindingLabels = (document) => {
+  const found = new Map;
+  walkLabelled(document.nodes ?? [], (node, label) => {
+    if (typeof node !== "string" || label === undefined || !node.startsWith(BINDING_REFERENCE_PREFIX)) {
+      return;
+    }
+    const id = node.slice(BINDING_REFERENCE_PREFIX.length);
+    if (!found.has(id))
+      found.set(id, label);
+  });
+  return found;
+};
+var resourceEntry = (group, labels = new Map) => {
+  const names = SLOT_DISPLAY_NAMES[group[0].resource];
+  if (names !== undefined)
+    return designerResourceEntry(group, labels, names);
+  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 folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined)
+    value.folderKey = { defaultValue: folderKey };
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  return {
+    resource: group[0].resource,
+    key,
+    value,
+    metadata: {
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      ...subType !== undefined && { subType }
+    }
+  };
+};
+var asStoredResource = (entry) => {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    return;
+  }
+  const record = entry;
+  const resource = typeof record.resource === "string" ? record.resource : "";
+  if (resource === "" || typeof record.key !== "string" || DROPPED_RESOURCES.has(resource.toLowerCase())) {
+    return;
+  }
+  const value = {};
+  for (const [name, slot] of Object.entries(record.value ?? {})) {
+    const defaultValue = slot?.defaultValue;
+    if (typeof defaultValue === "string")
+      value[name] = { defaultValue };
+  }
+  const metadata = {};
+  for (const [name, meta] of Object.entries(record.metadata ?? {})) {
+    if (typeof meta === "string")
+      metadata[name] = meta;
+  }
+  return {
+    resource,
+    key: record.key,
+    value,
+    ...Object.keys(metadata).length > 0 && { metadata }
+  };
+};
+var storedBindingResources = (document) => {
+  const found = new Map;
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node)
+        visit(item);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    const record = node;
+    const body = record.body;
+    if (record.name === "metadata" && Array.isArray(body?.bindings)) {
+      for (const entry of body.bindings) {
+        const resource = asStoredResource(entry);
+        if (resource === undefined)
+          continue;
+        const id = bindingIdentity(resource.resource, resource.key);
+        if (found.has(id))
+          continue;
+        found.set(id, resource);
+      }
+    }
+    for (const value of Object.values(record))
+      visit(value);
+  };
+  visit(document);
+  return found;
+};
+var withActivityMetadata = (derived, fromActivity) => {
+  return {
+    ...derived,
+    metadata: { ...fromActivity.metadata, ...derived.metadata }
+  };
+};
+var deriveCaseBindingsV2 = (document, entryPointIds = new Map) => {
+  const connectorKeys = collectConnectorKeys(document);
+  const labels = collectBindingLabels(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;
+    if (binding.resource === CONNECTION_RESOURCE && binding.resourceKey === IMPLICIT_CONNECTION) {
+      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);
+  }
+  const stored = storedBindingResources(document);
+  const derived = [...groups.values()].map((group) => {
+    const entry = group[0].resource === CONNECTION_RESOURCE ? connectionEntry(group, connectorKeys) : resourceEntry(group, labels);
+    const fromActivity = stored.get(bindingIdentity(entry.resource, entry.key));
+    return fromActivity === undefined ? entry : withActivityMetadata(entry, fromActivity);
+  });
+  const identity = (entry) => bindingIdentity(entry.resource, entry.key);
+  const merged = new Set(derived.map(identity));
+  const triggerEntries = deriveEventTriggerResources(document.nodes, bindings, entryPointIds).filter((entry) => !merged.has(identity(entry)));
+  for (const entry of triggerEntries)
+    merged.add(identity(entry));
+  return [
+    ...derived,
+    ...triggerEntries,
+    ...[...stored.values()].filter((entry) => !merged.has(identity(entry)))
+  ];
+};
+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=D8F7722320D6B53E64756E2164756E21

package/dist/case-debug-solution-projects-h3w2nx0a.js

@@ -0,0 +1,34 @@
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/case-debug-solution-projects.ts
+var caseSolutionProjects = async (solutionDir, uploaded, solutionId) => {
+  const { readSolutionAt } = await import("./index-332n0kxj.js");
+  const context = await readSolutionAt(solutionDir);
+  if (context === null)
+    return [];
+  const { readLocalResourcesForType } = await import("./localSolutionDiscovery-yyx234ak.js");
+  const rules = await readLocalResourcesForType(context, "businessRule");
+  const descriptors = [];
+  for (const rule of rules) {
+    if (rule.name === undefined)
+      continue;
+    const project = uploaded.find((one) => one.name === rule.name);
+    if (project === undefined)
+      continue;
+    descriptors.push({
+      name: rule.name,
+      projectId: project.id,
+      projectType: "BusinessRules",
+      entryPoint: "",
+      solutionId
+    });
+  }
+  return descriptors;
+};
+export {
+  caseSolutionProjects
+};
+
+//# debugId=06F6D5FADB7525A664756E2164756E21

package/dist/{case-debug-studio-web-service-xxfesw4v.js → case-debug-studio-web-service-3mkrtaet.js}

@@ -1,11 +1,11 @@
 import {
   buildSolutionPackageFromDir,
   uploadOrOverwriteSolution
-} from "./packager-tool-mr149jsw.js";
+} from "./packager-tool-k5cpxdm4.js";
 import {
   findSolutionFile,
   updateSolutionFile
-} from "./packager-tool-yfm83bzd.js";
+} from "./packager-tool-67vy1fz3.js";
 import {
   CasePlanFileNames,
   buildCasePackageDescriptor,
@@ -15,22 +15,24 @@ import {
   misnamedEntryPointBpmn,
   normalizeEntryPointPath,
   resolveDeclaredFileName
-} from "./packager-tool-wj9d9mqe.js";
-import"./packager-tool-4rqd21wc.js";
+} from "./packager-tool-e15kqpyh.js";
+import"./packager-tool-yn7r7zq2.js";
 import"./packager-tool-b098y4a2.js";
 import {
   loadCaseSchemaAsync
-} from "./packager-tool-cmwets3m.js";
+} from "./packager-tool-zf8f9pmm.js";
 import {
   uploadAndDebugSolution
-} from "./packager-tool-64rg5ekd.js";
+} from "./packager-tool-9e59z4d6.js";
 import {
   logger
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
-import"./packager-tool-1yh8g550.js";
+} from "./packager-tool-hdxtgckw.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
 
 // src/services/case-debug-studio-web-service.ts
 class CaseDebugStudioWebService {
@@ -120,6 +122,10 @@ class CaseDebugStudioWebService {
       projectName,
       entryPoint,
       projectType: "CaseManagement",
+      buildSolutionProjects: async (uploadedProjects, solutionId) => {
+        const { caseSolutionProjects } = await import("./case-debug-solution-projects-h3w2nx0a.js");
+        return caseSolutionProjects(solutionDir, uploadedProjects, solutionId);
+      },
       apiConfig,
       organizationName: config.organizationName,
       callbacks,
@@ -131,4 +137,4 @@ export {
   CaseDebugStudioWebService
 };
 
-//# debugId=0DC6729E8C8F178464756E2164756E21
+//# debugId=8BE54087EF22636364756E2164756E21

package/dist/{case-described-io-service-14hdnqcc.js → case-described-io-service-dx1f4nxe.js}

@@ -1,9 +1,15 @@
+import {
+  NAME_BOUND_TASK_TYPES
+} from "./packager-tool-87y6xw3a.js";
 import {
   readIoRows
-} from "./packager-tool-8a9yqfq7.js";
+} from "./packager-tool-1yfw674x.js";
 import {
-  NAME_BOUND_TASK_TYPES
-} from "./packager-tool-00y70spr.js";
+  RESULT_OUTPUT_SOURCE,
+  outputSourceFor
+} from "./packager-tool-ydyvtknp.js";
+import"./packager-tool-83v804p7.js";
+import"./packager-tool-hdxtgckw.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-described-io-service.ts
@@ -40,7 +46,11 @@ var findTask = (document, taskId) => {
   }
   return;
 };
-var mergeRows = (existing, described, elementId, direction) => {
+var readsAnotherValue = (row, name, taskType) => {
+  const wanted = outputSourceFor(taskType, name);
+  return wanted === RESULT_OUTPUT_SOURCE && carriesValue(row.source) && row.source !== wanted;
+};
+var mergeRows = (existing, described, elementId, direction, taskType) => {
   const byName = new Map;
   for (const raw of described) {
     const row = asRecord(raw);
@@ -51,12 +61,17 @@ var mergeRows = (existing, described, elementId, direction) => {
       byName.set(name, row);
   }
   const updated = [];
+  const passed = new Set;
   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;
+    if (direction === "outputs" && readsAnotherValue(row, name, taskType)) {
+      passed.add(name);
+      return raw;
+    }
     updated.push(name);
     const merged = { ...row };
     for (const field of RESOURCE_FIELDS) {
@@ -83,8 +98,13 @@ var mergeRows = (existing, described, elementId, direction) => {
     merged.elementId = elementId;
     return merged;
   });
-  const unmatched = [...byName.keys()].filter((name) => !updated.includes(name));
-  return { rows, updated, unmatched };
+  const missed = [...byName.keys()].filter((name) => !updated.includes(name));
+  return {
+    rows,
+    updated,
+    unmatched: missed.filter((name) => !passed.has(name)),
+    skipped: missed.filter((name) => passed.has(name))
+  };
 };
 var applyDescribedIo = (document, describeDocument, options) => {
   const task = findTask(document, options.taskId);
@@ -110,16 +130,22 @@ var applyDescribedIo = (document, describeDocument, options) => {
   }
   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 };
+  const inputs = mergeRows(asArray(data.inputs), described.inputs, elementId, "inputs", taskType);
+  const outputs = mergeRows(asArray(data.outputs), described.outputs, elementId, "outputs", taskType);
+  task.data = {
+    ...data,
+    ...described.version !== undefined && { version: described.version },
+    inputs: inputs.rows,
+    outputs: outputs.rows
+  };
   return {
     document,
     summary: {
       taskId: options.taskId,
       inputsUpdated: inputs.updated,
       outputsUpdated: outputs.updated,
-      unmatched: [...inputs.unmatched, ...outputs.unmatched]
+      unmatched: [...inputs.unmatched, ...outputs.unmatched],
+      skipped: outputs.skipped
     }
   };
 };
@@ -129,4 +155,4 @@ export {
   isDescribedIoFailure
 };
 
-//# debugId=68B2D7B3821D688864756E2164756E21
+//# debugId=324999381E52025864756E2164756E21

package/dist/case-event-trigger-bindings-g9ftnm4x.js

@@ -0,0 +1,16 @@
+import {
+  deriveEventTriggerResources,
+  entryPointIdsByNode,
+  readEntryPointIds
+} from "./packager-tool-wekqkmgn.js";
+import"./packager-tool-5qp9xza1.js";
+import"./packager-tool-83v804p7.js";
+import"./packager-tool-hdxtgckw.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  deriveEventTriggerResources,
+  entryPointIdsByNode,
+  readEntryPointIds
+};
+
+//# debugId=39F48E02A7313B2764756E2164756E21

package/dist/{case-format-service-yb48785t.js → case-format-service-6aew6tqc.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
+} from "./packager-tool-hdxtgckw.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-format-service.ts

package/dist/{case-pack-service-9185h6ez.js → case-pack-service-pqq8wnfd.js}

@@ -6,26 +6,26 @@ import {
   findCasePlanFileName,
   misnamedEntryPointBpmn,
   resolveDeclaredFileName
-} from "./packager-tool-wj9d9mqe.js";
+} from "./packager-tool-e15kqpyh.js";
 import {
   NugetPackager,
   ensureProjectId
-} from "./packager-tool-4rqd21wc.js";
+} from "./packager-tool-yn7r7zq2.js";
 import"./packager-tool-b098y4a2.js";
 import {
   VALID_PACKAGE_NAME_REGEX
-} from "./packager-tool-vepqrsse.js";
+} from "./packager-tool-9kf3fqtr.js";
 import {
   loadCaseSchemaAsync
-} from "./packager-tool-cmwets3m.js";
+} from "./packager-tool-zf8f9pmm.js";
 import {
   catchError,
   logger,
   mapPackageMetadataOptions
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
+} from "./packager-tool-hdxtgckw.js";
 import"./packager-tool-1yh8g550.js";
 
 // src/services/case-pack-service.ts