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

package/dist/{packager-tool-kdhey8gz.js → packager-tool-e02jkmrq.js}

@@ -1,9 +1,17 @@
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
 import {
-  getFileSystem
-} from "./packager-tool-hdxtgckw.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  resolvePackagedMainEntry,
+  readProjectMainFile,
+  readOperateMain
+} from "./packager-tool-snesn0bt.js";
+import {
+  casePlanDefaults2
+} from "./packager-tool-4avchhz8.js";
 
 // src/services/localSolutionDiscovery.ts
 var LOCAL_RESOURCE_TYPES = new Set([
@@ -32,16 +40,16 @@ var PROCESS_SUBDIR = ["resources", "solution_folder", "process"];
 function isUnder(parent, child) {
   if (child === parent)
     return true;
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const rel = fs.path.relative(parent, child);
   return rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel);
 }
 async function parseEnrichmentFile(filePath) {
-  const fs = getFileSystem();
-  const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+  const fs = getFileSystem2();
+  const [readErr, content] = await catchError2(fs.readFile(filePath, "utf-8"));
   if (readErr || !content)
     return null;
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  const [parseErr, parsed] = catchError2(() => JSON.parse(content));
   if (parseErr || !parsed.resource?.projectKey)
     return null;
   const r = parsed.resource;
@@ -57,16 +65,16 @@ async function parseEnrichmentFile(filePath) {
     }
   ];
 }
-async function loadResourceEnrichmentMap(solutionDir) {
-  const fs = getFileSystem();
+async function loadResourceEnrichmentMap2(solutionDir) {
+  const fs = getFileSystem2();
   const map = new Map;
   const processDir = fs.path.join(solutionDir, ...PROCESS_SUBDIR);
-  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  const [dirErr, typeDirs] = await catchError2(fs.readdir(processDir));
   if (dirErr || !Array.isArray(typeDirs))
     return map;
   for (const typeDir of typeDirs) {
     const typePath = fs.path.join(processDir, typeDir);
-    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    const [filesErr, files] = await catchError2(fs.readdir(typePath));
     if (filesErr || !Array.isArray(files))
       continue;
     for (const file of files) {
@@ -80,29 +88,33 @@ async function loadResourceEnrichmentMap(solutionDir) {
   return map;
 }
 async function readProjectName(projectDir) {
-  const fs = getFileSystem();
-  const [err, content] = await catchError(fs.readFile(fs.path.join(projectDir, "project.uiproj"), "utf-8"));
+  const fs = getFileSystem2();
+  const [err, content] = await catchError2(fs.readFile(fs.path.join(projectDir, "project.uiproj"), "utf-8"));
   if (!err && content) {
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const [parseErr, parsed] = catchError2(() => JSON.parse(content));
     if (!parseErr && parsed.Name)
       return parsed.Name;
   }
   return fs.path.basename(projectDir);
 }
 async function readEntryPointIO(projectDir) {
-  const fs = getFileSystem();
-  const candidates = [
-    fs.path.join(projectDir, "entry-points.json"),
-    fs.path.join(projectDir, "content", "entry-points.json")
-  ];
-  for (const filePath of candidates) {
-    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+  const fs = getFileSystem2();
+  const mainFile = await readProjectMainFile(fs, projectDir);
+  const candidates = [projectDir, fs.path.join(projectDir, "content")];
+  for (const dir of candidates) {
+    const filePath = fs.path.join(dir, "entry-points.json");
+    const [err, content] = await catchError2(fs.readFile(filePath, "utf-8"));
     if (err || !content)
       continue;
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const [parseErr, parsed] = catchError2(() => JSON.parse(content));
     if (parseErr || !parsed.entryPoints?.length)
       continue;
-    const ep = parsed.entryPoints[0];
+    const [, withPlanDefaults] = await catchError2(casePlanDefaults2(fs, dir));
+    const entries = parsed.entryPoints;
+    const [, defaulted] = catchError2(() => withPlanDefaults?.(entries));
+    const ep = resolvePackagedMainEntry(defaulted ?? entries, await readOperateMain(fs, dir), mainFile);
+    if (!ep)
+      continue;
     return {
       inputs: ep.input ?? ep.InputArguments,
       outputs: ep.output ?? ep.OutputArguments
@@ -110,11 +122,11 @@ async function readEntryPointIO(projectDir) {
   }
   return {};
 }
-async function readLocalResourcesForType(ctx, resourceType, enrichment) {
+async function readLocalResourcesForType2(ctx, resourceType, enrichment) {
   if (!LOCAL_RESOURCE_TYPES.has(resourceType))
     return [];
-  const fs = getFileSystem();
-  const enrichmentMap = enrichment ?? await loadResourceEnrichmentMap(ctx.solutionDir);
+  const fs = getFileSystem2();
+  const enrichmentMap = enrichment ?? await loadResourceEnrichmentMap2(ctx.solutionDir);
   const entries = [];
   for (const project of ctx.projects) {
     if (!project.Id || !project.Type)
@@ -148,6 +160,6 @@ async function readLocalResourcesForType(ctx, resourceType, enrichment) {
   return entries;
 }
 
-export { loadResourceEnrichmentMap, readLocalResourcesForType };
+export { loadResourceEnrichmentMap2, readLocalResourcesForType2 };
 
-//# debugId=44DA57B437646B6C64756E2164756E21
+//# debugId=DEEA168D8D2E465264756E2164756E21

package/dist/{packager-tool-sq931c23.js → packager-tool-e1tx5mqg.js}

@@ -1,6 +1,6 @@
 import {
   prefixedId
-} from "./packager-tool-mknccck5.js";
+} from "./packager-tool-1h7abxw6.js";
 
 // src/utils/binding-builder.ts
 function createBinding(propertyAttribute, defaultValue, resource, resourceKey) {

package/dist/{packager-tool-qn3zkrrc.js → packager-tool-ehjw672b.js}

@@ -1,24 +1,26 @@
 import {
-  loadResourceIndex
-} from "./packager-tool-9sd483vs.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
 import {
   ConnectorsApi,
   createApiClient
-} from "./packager-tool-wr12ndwk.js";
+} from "./packager-tool-ccejfs0r.js";
 import {
+  TYPECACHE_ACTIVITY_INDEX_TYPES,
+  TYPECACHE_TRIGGER_INDEX_TYPES,
   TYPECACHE_PACKAGE_INDEX_TYPES
-} from "./packager-tool-7nxppa3d.js";
+} from "./packager-tool-jv5byaww.js";
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  loadResourceIndex
+} from "./packager-tool-vs7gqa4r.js";
 
 // src/services/connector-lookup-service.ts
-async function lookupTypeCacheEntry(uiPathActivityTypeId, type) {
+async function lookupTypeCacheEntry2(uiPathActivityTypeId, type) {
   const types = typeof type === "string" ? [type] : type;
   let entry;
   let matchedType = types[0];
   for (const candidate of types) {
-    const [loadError, entries] = await catchError(loadResourceIndex(candidate));
+    const [loadError, entries] = await catchError2(loadResourceIndex(candidate));
     if (loadError) {
       if (types.length === 1)
         throw loadError;
@@ -34,7 +36,7 @@ async function lookupTypeCacheEntry(uiPathActivityTypeId, type) {
   if (!entry) {
     throw new Error(`No entry found in ${types.join(", ")} with uiPathActivityTypeId: ${uiPathActivityTypeId}`);
   }
-  const [parseError, config] = catchError(() => JSON.parse(entry.configuration));
+  const [parseError, config] = catchError2(() => JSON.parse(entry.configuration));
   if (parseError) {
     throw new Error(`Failed to parse configuration for "${entry.displayName}" in ${matchedType}: ${parseError.message}`);
   }
@@ -47,7 +49,7 @@ async function lookupConnectorDisplayName(packageId) {
   if (typeof packageId !== "number")
     return null;
   for (const indexType of TYPECACHE_PACKAGE_INDEX_TYPES) {
-    const [err, packages] = await catchError(loadResourceIndex(indexType));
+    const [err, packages] = await catchError2(loadResourceIndex(indexType));
     if (err)
       continue;
     const pkg = packages.find((p) => p.id === packageId);
@@ -56,12 +58,27 @@ async function lookupConnectorDisplayName(packageId) {
   }
   return null;
 }
-async function fetchConnectorConnections(connectorKey) {
-  const [apiError, api] = await catchError(createApiClient(ConnectorsApi));
+var caseTypeCacheSource2 = {
+  async lookupEntry(kind, activityTypeId) {
+    const sources = kind === "activity" ? TYPECACHE_ACTIVITY_INDEX_TYPES : TYPECACHE_TRIGGER_INDEX_TYPES;
+    const [err, result] = await catchError2(lookupTypeCacheEntry2(activityTypeId, sources));
+    if (err) {
+      throw new Error(`No TypeCache entry found in ${sources.join(", ")} for uiPathActivityTypeId "${activityTypeId}". ` + `If the id is correct, run 'uip maestro case registry pull' to refresh the local cache. ` + `If you're looking up the other kind, pass --type ${kind === "activity" ? "trigger" : "activity"}.`);
+    }
+    return {
+      source: result.source,
+      entry: result.entry,
+      config: { ...result.config }
+    };
+  },
+  lookupConnectorDisplayName
+};
+async function fetchConnectorConnections2(connectorKey) {
+  const [apiError, api] = await catchError2(createApiClient(ConnectorsApi));
   if (apiError) {
     throw new Error(`Failed to create Integration Service client: ${apiError.message}`);
   }
-  const [fetchError, connections] = await catchError(api.apiV1ConnectorsKeyOrIdConnectionsGet({
+  const [fetchError, connections] = await catchError2(api.apiV1ConnectorsKeyOrIdConnectionsGet({
     keyOrId: connectorKey,
     allFolders: true,
     folderDefaults: true
@@ -72,6 +89,6 @@ async function fetchConnectorConnections(connectorKey) {
   return connections;
 }
 
-export { lookupTypeCacheEntry, lookupConnectorDisplayName, fetchConnectorConnections };
+export { lookupTypeCacheEntry2, caseTypeCacheSource2, fetchConnectorConnections2 };
 
-//# debugId=CEB0F783A7A1FFBD64756E2164756E21
+//# debugId=0DE36F85D9934EA164756E2164756E21

package/dist/packager-tool-gy4yjqhf.js

@@ -0,0 +1,178 @@
+import {
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  eventTriggerResourceKey,
+  buildEventTriggerResource,
+  packageStoredBinding,
+  buildParameterPropertyResource
+} from "./packager-tool-h2ar8xf8.js";
+import {
+  CONNECTION_ID_PROPERTY2
+} from "./packager-tool-kz7zz79p.js";
+
+// 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 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 entryPointIdsByNode2(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;
+    const node = filePath.slice(hash + 1);
+    if (!ids.has(node))
+      ids.set(node, uniqueId);
+  }
+  return ids;
+}
+async function readEntryPointIds2(casePlanPath) {
+  const fs = getFileSystem2();
+  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 catchError2(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] = catchError2(() => JSON.parse(raw));
+  if (parseError) {
+    return {
+      error: `${path} is not valid JSON: ${parseError.message}`,
+      path
+    };
+  }
+  return { ids: entryPointIdsByNode2(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_PROPERTY2);
+  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);
+}
+function eventTriggerResource(trigger, connectionId, entryPointId) {
+  const apc = asRecord(trigger.metadataBody?.activityPropertyConfiguration);
+  return buildEventTriggerResource({
+    connectionKey: connectionId,
+    nodeId: trigger.nodeId,
+    entryPointId,
+    connector: asString(trigger.context.get("connectorKey")),
+    activityName: trigger.activityName,
+    objectName: objectName(trigger),
+    operation: asString(trigger.context.get("operation")),
+    filterExpression: asString(apc?.filterExpression) ?? asString(asRecord(trigger.body?.filters)?.expression)
+  });
+}
+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 [];
+    return [
+      packageStoredBinding(entry, {
+        nodeId: trigger.nodeId,
+        activityName: trigger.activityName,
+        parentResourceKey
+      })
+    ];
+  });
+}
+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 [];
+  return [
+    buildParameterPropertyResource({
+      key: operation,
+      nodeId: trigger.nodeId,
+      parameters,
+      activityName: trigger.activityName,
+      objectName: objectName(trigger),
+      parentResourceKey
+    })
+  ];
+}
+function deriveEventTriggerResources2(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 = eventTriggerResourceKey(connectionId, trigger.nodeId);
+    return [
+      eventTriggerResource(trigger, connectionId, entryPointIds.get(trigger.nodeId)),
+      ...propertyResources(trigger, `EventTrigger.${key}`)
+    ];
+  });
+}
+
+export { entryPointIdsByNode2, readEntryPointIds2, deriveEventTriggerResources2 };
+
+//# debugId=DE6B26E58776F4C864756E2164756E21

package/dist/packager-tool-h2ar8xf8.js

@@ -0,0 +1,222 @@
+// ../integrationservice-sdk/src/dap/bindings-v2.ts
+var BINDINGS_VERSION = "2.2";
+var JSON_STRING_PREFIX = "=jsonString:";
+var guardJsonString = (json) => `${JSON_STRING_PREFIX}${json}`;
+var stripJsonStringGuard = (value) => value.startsWith(JSON_STRING_PREFIX) ? value.slice(JSON_STRING_PREFIX.length) : value;
+function mapStringsDeep(value, map) {
+  if (typeof value === "string")
+    return map(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => mapStringsDeep(entry, map));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      mapStringsDeep(entry, map)
+    ]));
+  }
+  return value;
+}
+var restoreJsonStringsDeep = (value) => mapStringsDeep(value, stripJsonStringGuard);
+var CONN_BINDING_ID_PLACEHOLDER = "{{CONN_BINDING_ID}}";
+var FOLDER_BINDING_ID_PLACEHOLDER = "{{FOLDER_BINDING_ID}}";
+var RESOURCE_BINDING_ID_PREFIX = "{{RESOURCE_BINDING_ID:";
+var resourceBindingIdPlaceholder = (field) => `${RESOURCE_BINDING_ID_PREFIX}${field}}}`;
+var optional = (key, value) => value ? { [key]: value } : {};
+var eventTriggerResourceKey = (connectionKey, nodeId) => [connectionKey, nodeId].filter(Boolean).join("_");
+function buildEventTriggerResource(spec) {
+  const key = eventTriggerResourceKey(spec.connectionKey, spec.nodeId);
+  return {
+    resource: "EventTrigger",
+    key,
+    id: `EventTrigger${key}`,
+    value: {
+      ConnectionId: {
+        defaultValue: spec.connectionKey,
+        isExpression: false
+      },
+      ...spec.entryPointId && {
+        EntryPointUniqueId: {
+          defaultValue: spec.entryPointId,
+          isExpression: false
+        }
+      }
+    },
+    metadata: {
+      UseConnectionService: "true",
+      ...optional("Connector", spec.connector),
+      ...optional("ActivityName", spec.activityName),
+      BindingsVersion: BINDINGS_VERSION,
+      ...optional("ObjectName", spec.objectName),
+      ...optional("Operation", spec.operation),
+      FilterExpression: spec.filterExpression ?? ""
+    }
+  };
+}
+function packageStoredBinding(row, owner) {
+  const clone = restoreJsonStringsDeep(structuredClone(row));
+  const metadata = {
+    ...isRecord(clone.metadata) ? clone.metadata : {},
+    ...optional("ActivityName", owner.activityName)
+  };
+  clone.metadata = metadata;
+  if (clone.resource === "Property") {
+    clone.id = `Property_${owner.nodeId}`;
+    if (owner.operation && owner.parentResourceKey && clone.key === owner.operation) {
+      clone.key = `${owner.operation}_${owner.parentResourceKey}`;
+    }
+    metadata.ParentResourceKey = owner.parentResourceKey;
+  }
+  return clone;
+}
+function buildParameterPropertyResource(spec) {
+  const names = Object.keys(spec.parameters).join(",");
+  return {
+    resource: "Property",
+    key: spec.key,
+    id: `Property_${spec.nodeId}`,
+    value: Object.fromEntries(Object.entries(spec.parameters).map(([name, raw]) => [
+      name,
+      { defaultValue: String(raw), isExpression: false }
+    ])),
+    metadata: {
+      TriggerCreateParameters: names,
+      DebugQueryParameters: names,
+      ...optional("ActivityName", spec.activityName),
+      BindingsVersion: BINDINGS_VERSION,
+      ...optional("ObjectName", spec.objectName),
+      ParentResourceKey: spec.parentResourceKey
+    }
+  };
+}
+function upsertResourceBinding(bindings, row, mintId) {
+  const existing = bindings.find((binding) => binding.resource === row.resource && binding.resourceKey === row.resourceKey && binding.propertyAttribute === row.propertyAttribute);
+  if (existing) {
+    if (typeof existing.id !== "string" || existing.id === "") {
+      existing.id = mintId();
+    }
+    existing.name = row.name;
+    existing.default = row.default;
+    return { binding: existing, created: false };
+  }
+  const binding = {
+    id: mintId(),
+    name: row.name,
+    type: "string",
+    resource: row.resource,
+    resourceKey: row.resourceKey,
+    ...row.default ? { default: row.default } : {},
+    propertyAttribute: row.propertyAttribute
+  };
+  return { binding, created: true };
+}
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+// ../integrationservice-sdk/src/dap/activity-bindings.ts
+var DROPPED_RESOURCES = ["connection", "eventtrigger"];
+var isResourceType = (resource, types) => types.includes((resource ?? "").toLowerCase());
+function storedActivityBindings(bindings) {
+  return bindings.filter((binding) => !isResourceType(binding.resource, DROPPED_RESOURCES));
+}
+function planResourceBindings(stored, resolved) {
+  const plans = [];
+  for (const { field, companion, selection } of resolved) {
+    const entry = stored.find((binding) => binding.key?.toLowerCase() === selection.key.toLowerCase() && !isResourceType(binding.resource, ["property"]));
+    if (entry === undefined)
+      continue;
+    const displayName = entry.value?.name?.displayName ?? field;
+    const rows = [
+      {
+        field,
+        propertyAttribute: "name",
+        name: displayName,
+        default: selection.name
+      }
+    ];
+    if (entry.value?.folderKey && selection.folderKey) {
+      rows.push({
+        field: companion,
+        propertyAttribute: "folderKey",
+        name: `${displayName} folder`,
+        default: selection.folderKey
+      });
+    }
+    plans.push({
+      resource: entry.resource,
+      resourceKey: selection.key,
+      rows
+    });
+  }
+  return plans;
+}
+
+// ../integrationservice-sdk/src/dap/external-execution.ts
+function externalExecutionOf(metadata) {
+  if (typeof metadata !== "object" || metadata === null)
+    return;
+  const record = metadata;
+  const executionType = record.executionType;
+  if (typeof executionType !== "string" || executionType === "") {
+    return;
+  }
+  if (executionType !== "async" && executionType !== "hybrid") {
+    return { executionType };
+  }
+  const events = record.metadata?.events;
+  const eventMode = Array.isArray(events?.eventMode) ? String(events.eventMode[0] ?? "") : undefined;
+  const source = eventMode === "webhooks" ? events?.webhook : eventMode === "polling" ? events?.polling : undefined;
+  const eventTypes = source?.eventTypes;
+  return {
+    executionType,
+    ...eventMode && { eventMode },
+    ...eventTypes?.[0]?.operation && {
+      eventType: eventTypes[0].operation
+    }
+  };
+}
+function externalExecutionWarning(external, target) {
+  const { executionType, eventType } = external;
+  if (executionType === "sync" || eventType)
+    return;
+  return executionType === "async" || executionType === "hybrid" ? `"${target}" runs ${executionType}, but its metadata names no event it answers with, so the node has nothing to wait on and may never finish.` : `"${target}" has execution type "${executionType}", which is neither sync nor async, so it is saved as is and may not run.`;
+}
+var EXTERNAL_SERVICE_TYPES = {
+  agent: {
+    sync: "Intsvc.SyncAgentExecution",
+    async: "Intsvc.AsyncAgentExecution"
+  },
+  workflow: {
+    sync: "Intsvc.SyncWorkflowExecution",
+    async: "Intsvc.AsyncWorkflowExecution"
+  }
+};
+function externalServiceType(kind, executionType) {
+  const mode = executionType === "hybrid" ? "async" : executionType;
+  return mode === "sync" || mode === "async" ? EXTERNAL_SERVICE_TYPES[kind][mode] : undefined;
+}
+
+// ../integrationservice-sdk/src/dap/managed-http.ts
+var MANAGED_HTTP_METHODS = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+var MANAGED_HTTP_KEYS = new Set([
+  "authentication",
+  "method",
+  "url",
+  "connectionId",
+  "folderKey",
+  "targetConnector",
+  "headers",
+  "query",
+  "body"
+]);
+
+export { storedActivityBindings, planResourceBindings, BINDINGS_VERSION, guardJsonString, stripJsonStringGuard, mapStringsDeep, CONN_BINDING_ID_PLACEHOLDER, FOLDER_BINDING_ID_PLACEHOLDER, RESOURCE_BINDING_ID_PREFIX, resourceBindingIdPlaceholder, eventTriggerResourceKey, buildEventTriggerResource, packageStoredBinding, buildParameterPropertyResource, upsertResourceBinding, externalExecutionOf, externalExecutionWarning, EXTERNAL_SERVICE_TYPES, externalServiceType };
+
+//# debugId=55B5A01E97B21A5664756E2164756E21

package/dist/{packager-tool-v2kcgjbf.js → packager-tool-j6nfje7t.js}

@@ -1,10 +1,10 @@
 import {
   prefixedId
-} from "./packager-tool-mknccck5.js";
+} from "./packager-tool-1h7abxw6.js";
 import {
   DEFAULT_TRIGGER_ID,
   DEFAULT_TRIGGER_LABEL
-} from "./packager-tool-nj4seavy.js";
+} from "./packager-tool-35c9npcy.js";
 
 // src/utils/case-document.ts
 function buildMinimalCaseDocument(options) {
@@ -21,7 +21,8 @@ function buildMinimalCaseDocument(options) {
       caseIdentifier: options.caseIdentifier ?? options.name,
       caseAppEnabled: options.caseAppEnabled ?? false,
       caseIdentifierType: options.identifierType ?? "constant",
-      publishVersion: 2
+      publishVersion: 2,
+      intsvcActivityConfig: "v2"
     },
     nodes: [
       {
@@ -40,4 +41,4 @@ function buildMinimalCaseDocument(options) {
 
 export { buildMinimalCaseDocument };
 
-//# debugId=F5C6C653548DE78B64756E2164756E21
+//# debugId=BD5AEFBF8DD3701064756E2164756E21