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

package/dist/{connector-task-spec-pzfzmfr5.js → index-9f8naxbk.js}

@@ -1,73 +1,87 @@
 import {
-  nestDottedKeys
-} from "./packager-tool-1gwbq864.js";
-import {
-  lookupConnectorDisplayName,
-  lookupTypeCacheEntry
-} from "./packager-tool-qn3zkrrc.js";
-import"./packager-tool-ydyvtknp.js";
-import"./packager-tool-9sd483vs.js";
-import"./packager-tool-zgpsnxkd.js";
-import"./packager-tool-bfgdz1zh.js";
-import {
-  extractActivityFilterFields,
-  extractTriggerEventParameters,
-  extractTriggerFilterFields,
-  fetchConnectionInfo,
-  fetchConnectorMetadata,
-  fetchConnectorTriggerMetadata
-} from "./packager-tool-b1nw50ev.js";
-import"./packager-tool-ezds6t5e.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
 import {
-  assertActivityMetadataResolved,
+  getEventOperationObjects,
+  resourceFolderKeyFieldName,
+  ResourceFieldResolutionError2,
+  createSolutionResourceConfigurationsProvider,
   buildActivityEssentialConfiguration,
-  buildInputMetadata,
   configureActivityClient,
-  createSolutionResourceConfigurationsProvider,
+  assertActivityMetadataResolved,
   extractMultipartParameters,
-  findTriggerDesignAction,
-  getEventOperationObjects,
-  planResourceBindings,
+  inlineMultipartFileValues,
+  buildInputMetadata,
+  ConflictingDesignActionsError,
   resourcePickersRequestNeeds,
-  runTriggerDesignAction,
+  findTriggerDesignAction,
+  triggerEventParameters,
+  runTriggerDesignAction
+} from "./packager-tool-ccejfs0r.js";
+import"./packager-tool-q26hncjr.js";
+import"./packager-tool-dn9d4ywm.js";
+import"./packager-tool-z070caqq.js";
+import {
   storedActivityBindings,
-  triggerEventParameters
-} from "./packager-tool-wr12ndwk.js";
-import"./packager-tool-7hw344bt.js";
-import"./packager-tool-tqn0j6f9.js";
-import"./packager-tool-f8vwy92w.js";
+  planResourceBindings,
+  guardJsonString,
+  CONN_BINDING_ID_PLACEHOLDER,
+  FOLDER_BINDING_ID_PLACEHOLDER,
+  resourceBindingIdPlaceholder,
+  externalExecutionOf,
+  externalExecutionWarning
+} from "./packager-tool-h2ar8xf8.js";
+import"./packager-tool-17b466mr.js";
 import {
-  findSolutionFromCwd
-} from "./packager-tool-d8e2mrkq.js";
-import"./packager-tool-8ftat1vn.js";
-import"./packager-tool-pcvhcn2k.js";
-import"./packager-tool-sc961w0q.js";
-import"./packager-tool-6z1hsm2h.js";
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-sq931c23.js";
-import"./packager-tool-mknccck5.js";
+  findSolutionFromCwd2
+} from "./packager-tool-tgehy324.js";
+import"./packager-tool-3m8482sw.js";
 import {
-  TYPECACHE_ACTIVITY_INDEX_TYPES,
-  TYPECACHE_TRIGGER_INDEX_TYPES
-} from "./packager-tool-7nxppa3d.js";
-import"./packager-tool-aagnvyba.js";
-import"./packager-tool-mzf4gmph.js";
-import"./packager-tool-9kf3fqtr.js";
-import"./packager-tool-9e59z4d6.js";
-import"./packager-tool-yn33pw57.js";
-import"./packager-tool-0gctz400.js";
-import"./packager-tool-qa9gftnj.js";
-import"./packager-tool-yc4kw997.js";
+  extractTriggerEventParameters,
+  extractTriggerFilterFields,
+  extractActivityFilterFields,
+  fetchConnectorTriggerMetadata,
+  ConnectionConnectorMismatchError2,
+  assertConnectionConnector,
+  fetchConnectionInfo,
+  fetchConnectorMetadata2
+} from "./packager-tool-k0ar6cn7.js";
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
-import"./packager-tool-hdxtgckw.js";
-import"./packager-tool-1yh8g550.js";
+  genericObjectDiscoveryCommands
+} from "./packager-tool-q9fnx278.js";
+import {
+  v2ConfigurationVersionEntry
+} from "./packager-tool-68648y3j.js";
+// ../maestro-sdk/src/connector-spec/bpmn-element.ts
+var ELEMENT_TOKENS = {
+  id: "{{ID}}",
+  name: "{{NAME}}",
+  incomingEdge: "{{INCOMING_EDGE}}",
+  outgoingEdge: "{{OUTGOING_EDGE}}",
+  varId: "{{VAR_ID}}",
+  errorVarId: "{{ERROR_VAR_ID}}"
+};
+var VAR_TOKENS = {
+  response: ELEMENT_TOKENS.varId,
+  Error: ELEMENT_TOKENS.errorVarId
+};
+// ../maestro-sdk/src/connector-spec/option-labels.ts
+var OPTION_NAMES = {
+  inputDetails: "inputDetails",
+  skipCaseShape: "skipCaseShape",
+  objectNameOverride: "objectNameOverride",
+  solutionFolder: "solutionFolder"
+};
+function optionLabels(labels) {
+  return { ...OPTION_NAMES, ...labels };
+}
 
-// src/services/case-spec-input-validator.ts
+// ../maestro-sdk/src/connector-spec/input-validator.ts
 class InvalidInputDetailsError extends Error {
-  constructor(message) {
+  instructions;
+  constructor(message, instructions) {
     super(message);
+    this.instructions = instructions;
     this.name = "InvalidInputDetailsError";
   }
 }
@@ -83,11 +97,11 @@ var TRIGGER_VALID_KEYS = new Set([
   "pathParameters",
   "filter"
 ]);
-function validateActivityInputDetails(raw, isHttpRequest) {
+function validateActivityInputDetails(raw, isHttpRequest, label = optionLabels(undefined).inputDetails) {
   if (raw === undefined || raw === null)
     return {};
   if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new InvalidInputDetailsError("--input-details must be a JSON object");
+    throw new InvalidInputDetailsError(`${label} must be a JSON object`);
   }
   const config = raw;
   const errors = [];
@@ -98,42 +112,28 @@ function validateActivityInputDetails(raw, isHttpRequest) {
   if (unknownKeys.length > 0) {
     errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys for activity: ${[...ACTIVITY_VALID_KEYS].join(", ")}`);
   }
-  for (const key of [
+  errors.push(...objectFieldErrors(config, [
     "bodyParameters",
     "queryParameters",
     "pathParameters"
-  ]) {
-    const val = config[key];
-    if (val !== undefined && (typeof val !== "object" || val === null || Array.isArray(val))) {
-      errors.push(`${key} must be a JSON object`);
-    }
-  }
-  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
-    errors.push("filter must be a JSON object (FilterTree)");
-  }
-  if (config.filter !== undefined && typeof config.queryParameters === "object" && config.queryParameters !== null && !Array.isArray(config.queryParameters) && "where" in config.queryParameters) {
+  ]), ...filterErrors(config.filter));
+  if (config.filter !== undefined && isPlainObject(config.queryParameters) && "where" in config.queryParameters) {
     errors.push("queryParameters.where is derived from `filter` and cannot be set alongside it. " + 'Drop one of the two — prefer "filter" so Studio Web can re-render the filter widget.');
   }
-  if (isHttpRequest) {
-    if (config.bodyParameters !== undefined) {
-      errors.push("bodyParameters is not supported for synthetic HTTP request activities. " + "Pass body via --input-details.queryParameters or omit.");
-    }
-    if (config.filter !== undefined) {
-      errors.push("filter is not supported for synthetic HTTP request activities " + "(no curated filterable fields).");
-    }
-  }
+  if (isHttpRequest)
+    errors.push(...httpRequestErrors(config, label));
   if (errors.length > 0) {
-    throw new InvalidInputDetailsError(`Invalid --input-details:
+    throw new InvalidInputDetailsError(`Invalid ${label}:
   - ${errors.join(`
   - `)}`);
   }
   return config;
 }
-function validateTriggerInputDetails(raw) {
+function validateTriggerInputDetails(raw, label = optionLabels(undefined).inputDetails) {
   if (raw === undefined || raw === null)
     return {};
   if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new InvalidInputDetailsError("--input-details must be a JSON object");
+    throw new InvalidInputDetailsError(`${label} must be a JSON object`);
   }
   const config = raw;
   const errors = [];
@@ -154,11 +154,9 @@ function validateTriggerInputDetails(raw) {
       errors.push(`${key} must be a JSON object`);
     }
   }
-  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
-    errors.push("filter must be a JSON object (FilterTree)");
-  }
+  errors.push(...filterErrors(config.filter));
   if (errors.length > 0) {
-    throw new InvalidInputDetailsError(`Invalid --input-details:
+    throw new InvalidInputDetailsError(`Invalid ${label}:
   - ${errors.join(`
   - `)}`);
   }
@@ -184,13 +182,52 @@ function normalizeGroupOperator(value) {
     return 1;
   return value;
 }
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function objectFieldErrors(config, keys) {
+  return keys.filter((key) => config[key] !== undefined && !isPlainObject(config[key])).map((key) => `${key} must be a JSON object`);
+}
+function httpRequestErrors(config, label) {
+  const errors = [];
+  if (config.bodyParameters !== undefined) {
+    errors.push("bodyParameters is not supported for synthetic HTTP request activities. " + `Pass body via ${label}.queryParameters or omit.`);
+  }
+  if (config.filter !== undefined) {
+    errors.push("filter is not supported for synthetic HTTP request activities " + "(no curated filterable fields).");
+  }
+  return errors;
+}
+function filterErrors(filter) {
+  if (filter === undefined)
+    return [];
+  if (!isPlainObject(filter)) {
+    return ["filter must be a JSON object (FilterTree)"];
+  }
+  return Array.isArray(filter.filters) || Array.isArray(filter.groups) ? [] : [
+    'filter must be a FilterTree: {"groupOperator":"And","filters":[{"id":"<field>","operator":"<operator>","value":{...}}],"groups":[]}'
+  ];
+}
 
-// src/services/connector-task-spec.types.ts
-var CONN_BINDING_ID_PLACEHOLDER = "{{CONN_BINDING_ID}}";
-var FOLDER_BINDING_ID_PLACEHOLDER = "{{FOLDER_BINDING_ID}}";
-var resourceBindingIdPlaceholder = (field) => `{{RESOURCE_BINDING_ID:${field}}}`;
+// ../maestro-sdk/src/connector-spec/nest-dotted-keys.ts
+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.at(-1)] = value;
+  }
+  return result;
+}
 
-// src/services/trigger-scope-parameters.ts
+// ../maestro-sdk/src/connector-spec/trigger-scope-parameters.ts
 var isParam = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string";
 function extractTriggerScopeParameters(eventObject) {
   const raw = eventObject?.parameters;
@@ -220,34 +257,39 @@ function triggerScopeInputMetadata(details) {
   };
 }
 
-// src/services/connector-task-spec.ts
-async function fetchConnectorTaskSpec(type, activityTypeId, connectionId, opts = {}) {
+// ../maestro-sdk/src/connector-spec/connector-task-spec.ts
+async function fetchConnectorTaskSpec(type, activityTypeId, connectionId, opts) {
+  const labels = optionLabels(opts.optionLabels);
   if (opts.inputDetails !== undefined && opts.skipCaseShape === true) {
-    throw new InvalidInputDetailsError("--input-details has no effect when --skip-case-shape is set; remove one of the two flags.");
+    throw new InvalidInputDetailsError(`${labels.inputDetails} has no effect when ${labels.skipCaseShape} is set; remove one of the two.`);
   }
   if (type === "trigger" && opts.triggerKind === undefined) {
-    throw new Error("A trigger spec needs a trigger kind: 'start' for a case start trigger, 'wait-for' for a wait-for-connector task or rule.");
+    throw new Error("A trigger spec needs a trigger kind: 'start' or 'wait-for'.");
   }
   const diagnostics = {
     fetched: [],
     fallbacks: [],
     timestamp: new Date().toISOString()
   };
-  const typecache = await resolveTypeCacheEntry(type, activityTypeId);
+  const typecache = await resolveTypeCacheEntry(type, activityTypeId, opts.typeCache);
   diagnostics.fetched.push(`TypeCache(${typecache.source})`);
   const { connectorKey } = typecache.config;
   const objectName = opts.objectNameOverride ?? typecache.config.objectName;
   if (typecache.config.activityType === "Generic" && opts.objectNameOverride === undefined) {
-    throw new Error(`Generic ${type} (${activityTypeId}, "${typecache.entry.displayName}") requires --object-name. ` + `Discover available objects via:
-` + `  uip is resources list --connector-key ${connectorKey}
-` + `  uip is resources describe --connector-key ${connectorKey} --object-name <name>`);
+    throw new Error(`Generic ${type} (${activityTypeId}, "${typecache.entry.displayName}") requires ${labels.objectNameOverride}. ` + `Discover available objects via:
+` + genericObjectDiscoveryCommands(connectorKey, connectionId).map((command) => `  ${command}`).join(`
+`));
   }
-  const connection = await fetchConnectionContext(connectionId, diagnostics);
+  const connection = await fetchConnectionContext(connectionId, {
+    connectorKey,
+    activityTypeId,
+    displayName: typecache.entry.displayName
+  }, diagnostics);
   if (type === "activity") {
     if (!typecache.config.httpMethod) {
       throw new Error(`TypeCache entry ${activityTypeId} ("${typecache.entry.displayName}") has no httpMethod — not a connector activity. Verify the id is for a connector activity (Curated/Generic), not a non-connector activity (process/agent/etc.).`);
     }
-    const validatedDetails = validateActivityInputDetails(opts.inputDetails, isHttpRequestObject(objectName));
+    const validatedDetails = validateActivityInputDetails(opts.inputDetails, isHttpRequestObject(objectName), labels.inputDetails);
     const optsForActivity = {
       ...opts,
       inputDetails: validatedDetails
@@ -261,7 +303,7 @@ async function fetchConnectorTaskSpec(type, activityTypeId, connectionId, opts =
   if (!typecache.config.eventOperation) {
     throw new Error(`TypeCache entry ${activityTypeId} ("${typecache.entry.displayName}") has no eventOperation — not a connector trigger.`);
   }
-  const validatedTriggerDetails = validateTriggerInputDetails(opts.inputDetails);
+  const validatedTriggerDetails = validateTriggerInputDetails(opts.inputDetails, labels.inputDetails);
   const optsForTrigger = {
     ...opts,
     inputDetails: validatedTriggerDetails
@@ -272,12 +314,8 @@ async function fetchConnectorTaskSpec(type, activityTypeId, connectionId, opts =
     parsedConfig: typecache.config
   });
 }
-async function resolveTypeCacheEntry(type, activityTypeId) {
-  const sources = type === "activity" ? TYPECACHE_ACTIVITY_INDEX_TYPES : TYPECACHE_TRIGGER_INDEX_TYPES;
-  const [err, result] = await catchError(lookupTypeCacheEntry(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 ${type === "activity" ? "trigger" : "activity"}.`);
-  }
+async function resolveTypeCacheEntry(type, activityTypeId, typeCache) {
+  const result = await typeCache.lookupEntry(type, activityTypeId);
   return {
     source: result.source,
     entry: result.entry,
@@ -519,7 +557,8 @@ function buildActivityCaseShape(objectName, _pathParameters, _queryParameters, b
       inputs.push({
         name: param.name,
         type: "file",
-        target: "file"
+        target: "file",
+        ...param.value !== undefined && { value: param.value }
       });
     }
   }
@@ -544,16 +583,46 @@ function buildActivityContext(args) {
     });
   }
   entries.push({ name: "objectName", type: "string", value: args.objectName }, { name: "method", type: "string", value: args.httpMethod }, { name: "path", type: "string", value: args.path });
+  const external = args.externalExecution;
+  if (external?.eventType) {
+    entries.push({
+      name: "operation",
+      type: "string",
+      value: external.eventType
+    });
+  }
+  if (external?.eventMode) {
+    entries.push({
+      name: "eventMode",
+      type: "string",
+      value: external.eventMode
+    });
+  }
+  if (external) {
+    entries.push({
+      name: "executionType",
+      type: "string",
+      value: external.executionType
+    });
+  }
   const activityPropertyConfiguration = {};
   if (args.multipart && args.multipart.parameters.length > 0) {
     activityPropertyConfiguration.multipartParameters = args.multipart.parameters.map((p) => ({
       name: p.name,
-      dataType: p.dataType
+      dataType: p.dataType,
+      ...p.value !== undefined && { value: p.value }
     }));
   }
-  activityPropertyConfiguration.configuration = `=jsonString:${JSON.stringify(args.essentialConfiguration)}`;
+  activityPropertyConfiguration.configuration = guardJsonString(JSON.stringify(args.essentialConfiguration));
   activityPropertyConfiguration.uiPathActivityTypeId = args.uiPathActivityTypeId;
   activityPropertyConfiguration.errorState = { issues: [] };
+  if (external) {
+    Object.assign(activityPropertyConfiguration, {
+      ...external.eventType && { eventType: external.eventType },
+      ...external.eventMode && { eventMode: external.eventMode },
+      executionType: external.executionType
+    });
+  }
   const multipartParams = args.multipart?.parameters.map((p) => ({
     name: p.name,
     dataType: p.dataType
@@ -573,7 +642,7 @@ function buildActivityContext(args) {
       primaryKeyName: args.primaryKeyName
     }
   };
-  entries.push({ name: "metadata", type: "json", body: metadataBody });
+  entries.push({ name: "metadata", type: "json", body: metadataBody }, v2ConfigurationVersionEntry());
   return entries;
 }
 function buildTriggerContext(args) {
@@ -599,7 +668,7 @@ function buildTriggerContext(args) {
     objectName: args.objectName,
     eventType: args.eventOperation,
     eventMode: args.eventMode,
-    configuration: `=jsonString:${JSON.stringify(args.essentialConfiguration)}`,
+    configuration: guardJsonString(JSON.stringify(args.essentialConfiguration)),
     uiPathActivityTypeId: args.uiPathActivityTypeId,
     errorState: { issues: [] },
     ...args.filterExpression && args.filterExpression.length > 0 ? { filterExpression: args.filterExpression } : {}
@@ -617,7 +686,7 @@ function buildTriggerContext(args) {
     inputMetadata: args.inputMetadata ?? {},
     telemetryData
   };
-  entries.push({ name: "metadata", type: "json", body: metadataBody });
+  entries.push({ name: "metadata", type: "json", body: metadataBody }, v2ConfigurationVersionEntry());
   return entries;
 }
 function buildTriggerCaseShape(objectName, _eventParameters, responseFields, responseDisplayName) {
@@ -632,8 +701,8 @@ function buildTriggerCaseShape(objectName, _eventParameters, responseFields, res
   const outputs = buildOutputs(objectName, responseDisplayName, responseFields);
   return { inputs, outputs };
 }
-async function fetchConnectionContext(connectionId, diagnostics) {
-  const [err, info] = await catchError(fetchConnectionInfo(connectionId));
+async function fetchConnectionContext(connectionId, target, diagnostics) {
+  const [err, info] = await catchError2(fetchConnectionInfo(connectionId));
   if (err) {
     diagnostics.fallbacks.push({
       endpoint: "fetchConnectionInfo",
@@ -642,6 +711,7 @@ async function fetchConnectionContext(connectionId, diagnostics) {
     throw new Error(`Connection "${connectionId}" not found or inaccessible: ${err.message}`);
   }
   diagnostics.fetched.push("fetchConnectionInfo");
+  assertConnectionConnector(connectionId, info, target.connectorKey, `${target.activityTypeId} ("${String(target.displayName)}")`);
   return {
     context: {
       id: info.id,
@@ -729,11 +799,17 @@ function buildActivityPagination(verb, methodInfo) {
   const declared = methodInfo.pagination?.maxPageSize;
   return { maxPageSize: declared ? declared : 1000 };
 }
+function warnAboutExternalExecution(diagnostics, external, target) {
+  const warning = external && externalExecutionWarning(external, target);
+  if (warning) {
+    diagnostics.warnings = [...diagnostics.warnings ?? [], warning];
+  }
+}
 async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedConnection, diagnostics, opts, typecacheCtx) {
   if (isHttpRequestObject(objectName)) {
     return buildHttpActivitySpec(connectorKey, objectName, httpMethod, resolvedConnection, diagnostics, opts, typecacheCtx);
   }
-  const [metaErr, metadata] = await catchError(fetchActivityMetadata(connectorKey, objectName, resolvedConnection.context.id));
+  const [metaErr, metadata] = await catchError2(fetchActivityMetadata(connectorKey, objectName, resolvedConnection.context.id));
   if (metaErr) {
     diagnostics.fallbacks.push({
       endpoint: "fetchConnectorMetadata",
@@ -751,24 +827,24 @@ async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedC
   const params = methodInfo.parameters ?? [];
   const pathParameters = params.filter((p) => p.type === "path").map(parameterFromIS);
   const queryParameters = params.filter((p) => p.type === "query").map(parameterFromIS);
-  const multipart = buildMultipartSpec(params);
   const fields = collectFields(metadata);
   const bodyFields = filterFieldsByMethod(fields, httpMethod, "request");
   const responseFields = filterFieldsByMethod(fields, httpMethod, "response");
-  const filter = buildActivityFilter(metadata, httpMethod, verb);
+  const metadataFilter = buildActivityFilter(metadata, httpMethod, verb);
   const pagination = buildActivityPagination(verb, methodInfo);
   const references = collectReferences(connectorKey, resolvedConnection.context.id, [
     ...pathParameters.map((p) => ({ p, slot: "pathParameters" })),
     ...queryParameters.map((p) => ({ p, slot: "queryParameters" })),
     ...bodyFields.map((p) => ({ p, slot: "bodyFields" }))
   ]);
-  const inputDetails = opts.inputDetails;
+  const { multipart, inputDetails } = withMultipartFileValues(buildMultipartSpec(params), opts.inputDetails);
+  assertActivityParameters(inputDetails, params, connectorKey, objectName);
   let savedFilterTrees = null;
   let activityFilterParamName = null;
   if (inputDetails?.filter !== undefined) {
     const filterBuilderParam = (methodInfo.parameters ?? []).find((p) => p.design?.component === "FilterBuilder");
     if (!filterBuilderParam) {
-      throw new InvalidInputDetailsError(`Activity "${connectorKey}/${objectName}" does not declare a FilterBuilder parameter — server-side filtering is not supported by this operation. Drop "filter" from --input-details.`);
+      throw new InvalidInputDetailsError(`Activity "${connectorKey}/${objectName}" does not declare a FilterBuilder parameter — server-side filtering is not supported by this operation. Drop "filter" from ${optionLabels(opts.optionLabels).inputDetails}.`);
     }
     activityFilterParamName = filterBuilderParam.name;
     savedFilterTrees = {
@@ -789,15 +865,16 @@ async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedC
     fieldValues: authoredValues ?? null,
     solutionDir: authoredValues ? await solutionDirFor(opts) : null
   });
-  await assertPickersResolved(activityClient, authoredValues, resolvedResources);
+  await assertPickersResolved(activityClient, authoredValues, resolvedResources, optionLabels(opts.optionLabels));
   const { essentialConfiguration: essentialConfig } = activityClient.getEssentialConfiguration();
   assertActivityMetadataResolved(essentialConfig, resolvedConnection.context.id);
   const activityCeqlExpression = activityFilterParamName ? activityClient.getCompiledFilter(activityFilterParamName) : null;
+  const filter = withBuilderOperators(metadataFilter, "ceql", activityClient.getFilterFields());
   const essentialConfiguration = { essentialConfiguration: essentialConfig };
   const primaryKeyName = responseFields.filter((f) => f.primaryKey === true).map((f) => f.name).join(",");
   let caseShape;
   if (!opts.skipCaseShape) {
-    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    const connectorDisplayName = await opts.typeCache.lookupConnectorDisplayName(typecacheCtx.entry.packageId);
     caseShape = buildActivityCaseShape(objectName, pathParameters, queryParameters, bodyFields, responseFields, multipart);
     if (inputDetails) {
       applyActivityInputDetails(caseShape, inputDetails, {
@@ -805,6 +882,7 @@ async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedC
         ceqlExpression: activityCeqlExpression
       });
     }
+    const externalExecution = externalExecutionOf(metadata);
     caseShape.context = buildActivityContext({
       connectorKey,
       connectorName: resolvedConnection.connectorName,
@@ -821,8 +899,10 @@ async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedC
       multipart,
       maxPageSize: pagination?.maxPageSize,
       primaryKeyName,
-      essentialConfiguration
+      essentialConfiguration,
+      externalExecution
     });
+    warnAboutExternalExecution(diagnostics, externalExecution, `${connectorKey}/${objectName}`);
   }
   const resourceBindings = bindResolvedResources(caseShape, resolvedResources, activityClient);
   return {
@@ -877,7 +957,16 @@ async function withTriggerDesignAction(params) {
   if (!eventObject || Object.keys(fieldValues).length === 0) {
     return triggerMeta;
   }
-  const action = await findTriggerDesignAction(eventObject, fieldValues, params.target);
+  const [conflict, action] = await catchError2(findTriggerDesignAction(eventObject, fieldValues, params.target));
+  if (conflict instanceof ConflictingDesignActionsError) {
+    params.diagnostics.fallbacks.push({
+      endpoint: `triggerDesignAction.${conflict.actionNames.join(",")}`,
+      reason: `the authored values match more than one design action on '${conflict.fieldName}' [${conflict.actionNames.join(", ")}], so the spec cannot pick one and its fields are missing; Studio Web refuses these values too. Run 'uip is triggers describe <connector-key> <operation> <object-name> --connection-id <id> -f <field>=<value> --action <name>' to inspect one action's fields`
+    });
+    return triggerMeta;
+  }
+  if (conflict)
+    throw conflict;
   if (!action)
     return triggerMeta;
   const endpoint = `triggerDesignAction.${action.name}`;
@@ -886,7 +975,7 @@ async function withTriggerDesignAction(params) {
   if (unresolved.length > 0) {
     params.diagnostics.fallbacks.push({
       endpoint,
-      reason: `the picker [${unresolved.join(", ")}] did not resolve into a solution, so the fields it loads are missing; run inside a solution or pass --solution-folder, without --skip-case-shape`
+      reason: `the picker [${unresolved.join(", ")}] did not resolve into a solution, so the fields it loads are missing; run inside a solution or pass ${params.labels.solutionFolder}, without ${params.labels.skipCaseShape}`
     });
     return triggerMeta;
   }
@@ -894,7 +983,7 @@ async function withTriggerDesignAction(params) {
     r.field,
     { resourceKey: r.selection.key }
   ]));
-  const [error, designed] = await catchError(runTriggerDesignAction(undefined, params.connectionId, triggerMeta, action, fieldValues, solutionResources, createSolutionResourceConfigurationsProvider(params.solutionDir, new Map(resolvedResources.map((r) => [
+  const [error, designed] = await catchError2(runTriggerDesignAction(undefined, params.connectionId, triggerMeta, action, fieldValues, solutionResources, createSolutionResourceConfigurationsProvider(params.solutionDir, new Map(resolvedResources.map((r) => [
     r.selection.key,
     r.selection.name
   ])))));
@@ -905,9 +994,45 @@ async function withTriggerDesignAction(params) {
   return designed;
 }
 async function solutionDirFor(opts) {
-  return opts.solutionFolder ?? (await findSolutionFromCwd())?.solutionDir ?? null;
+  return opts.solutionFolder ?? (await findSolutionFromCwd2())?.solutionDir ?? null;
 }
-async function assertPickersResolved(client, values, resolved) {
+function assertActivityParameters(inputDetails, params, connectorKey, objectName) {
+  const pathBucket = parameterBucket("pathParameters", params, "path");
+  const queryBucket = parameterBucket("queryParameters", params, "query");
+  const target = `${connectorKey}/${objectName}`;
+  assertDeclaredParameters(inputDetails?.pathParameters, pathBucket, [queryBucket], target);
+  if (!isHttpRequestObject(objectName) && queryBucket.names.length > 0) {
+    assertDeclaredParameters(inputDetails?.queryParameters, queryBucket, [pathBucket], target);
+  }
+}
+var isPickerParam = (param) => param.design?.component === "Resources";
+function parameterBucket(key, params, type) {
+  const declared = params.filter((p) => p.type === type && p.name);
+  return {
+    key,
+    names: declared.map((p) => p.name),
+    pickers: declared.filter(isPickerParam).map((p) => p.name)
+  };
+}
+function assertDeclaredParameters(authored, bucket, others, target) {
+  const accepted = new Set([
+    ...bucket.names,
+    ...bucket.pickers.map(resourceFolderKeyFieldName)
+  ]);
+  const unknown = Object.keys(authored ?? {}).filter((name) => !accepted.has(name));
+  if (unknown.length === 0)
+    return;
+  const moves = others.flatMap((other) => {
+    const here = unknown.filter((name) => other.names.includes(name));
+    return here.length > 0 ? [`put ${here.join(", ")} under ${other.key}`] : [];
+  });
+  const moveText = moves.join("; ");
+  throw new InvalidInputDetailsError([
+    bucket.names.length === 0 ? `"${target}" declares no ${bucket.key}, but the authored ${bucket.key} sets ${unknown.join(", ")}.` : `"${target}" has no ${bucket.key} entry ${unknown.join(", ")}. Its ${bucket.key}: ${bucket.names.join(", ")}.`,
+    moveText !== "" && `${moveText[0].toUpperCase()}${moveText.slice(1)}.`
+  ].filter(Boolean).join(" "));
+}
+async function assertPickersResolved(client, values, resolved, labels) {
   if (!values)
     return;
   const unresolved = (await client.getResourceFields()).filter((f) => {
@@ -917,7 +1042,7 @@ async function assertPickersResolved(client, values, resolved) {
   if (unresolved.length === 0)
     return;
   const names = unresolved.map((f) => `'${f.name}' (${f.kind})`).join(", ");
-  throw new InvalidInputDetailsError(`${names} ${unresolved.length === 1 ? "is a resource picker" : "are resource pickers"} and must be referenced into the case's solution, but no solution was found from the current folder. Pass --solution-folder <path to the folder holding the .uipx>, or run from inside the solution.`);
+  throw new InvalidInputDetailsError(`${names} ${unresolved.length === 1 ? "is a resource picker" : "are resource pickers"} and must be referenced into the case's solution, but no solution was found from the current folder.`, `Pass ${labels.solutionFolder} <path to the folder holding the .uipx>, or run from inside the solution.`);
 }
 function authoredFieldValues(inputDetails) {
   if (!inputDetails)
@@ -1000,7 +1125,7 @@ async function buildHttpActivitySpec(connectorKey, objectName, httpMethod, resol
   const httpInputDetails = opts.inputDetails;
   let caseShape;
   if (!opts.skipCaseShape) {
-    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    const connectorDisplayName = await opts.typeCache.lookupConnectorDisplayName(typecacheCtx.entry.packageId);
     caseShape = buildActivityCaseShape(objectName, [], [], [], [], null);
     if (httpInputDetails) {
       applyActivityInputDetails(caseShape, httpInputDetails, {
@@ -1065,7 +1190,7 @@ async function buildHttpActivitySpec(connectorKey, objectName, httpMethod, resol
   };
 }
 async function fetchActivityMetadata(connectorKey, objectName, connectionId) {
-  return fetchConnectorMetadata(connectorKey, objectName, connectionId);
+  return fetchConnectorMetadata2(connectorKey, objectName, connectionId);
 }
 function extractMethodInfo(metadata, httpMethod) {
   const methodMap = metadata.metadata;
@@ -1077,7 +1202,7 @@ function listMethods(metadata) {
   return Object.keys(methodMap?.method ?? {});
 }
 async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolvedConnection, diagnostics, opts, typecacheCtx) {
-  const [metaErr, triggerMeta] = await catchError(fetchTriggerMetadata(connectorKey, objectName, eventOperation, resolvedConnection.context.id));
+  const [metaErr, triggerMeta] = await catchError2(fetchTriggerMetadata(connectorKey, objectName, eventOperation, resolvedConnection.context.id));
   if (metaErr) {
     diagnostics.fallbacks.push({
       endpoint: "fetchConnectorTriggerMetadata",
@@ -1089,7 +1214,7 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
   const elementInstanceId = resolvedConnection.context.elementInstanceId;
   let eventOpFlags = null;
   if (elementInstanceId !== null) {
-    const [flagsErr, flags] = await catchError(getEventOperationObjects(undefined, elementInstanceId, connectorKey, eventOperation));
+    const [flagsErr, flags] = await catchError2(getEventOperationObjects(undefined, elementInstanceId, connectorKey, eventOperation));
     if (flagsErr) {
       diagnostics.fallbacks.push({
         endpoint: "client-factory.getEventOperationObjects",
@@ -1118,6 +1243,15 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
   const queryParameters = scope.query.map(parameterFromIS);
   const pathParameters = scope.path.map(parameterFromIS);
   const triggerInputDetails = opts.inputDetails;
+  const scopeBuckets = [
+    parameterBucket("queryParameters", scope.query, "query"),
+    parameterBucket("pathParameters", scope.path, "path")
+  ];
+  if (eventOpFlags !== null) {
+    for (const bucket of scopeBuckets) {
+      assertDeclaredParameters(triggerInputDetails?.[bucket.key], bucket, scopeBuckets.filter((other) => other !== bucket), `${connectorKey}/${objectName} ${eventOperation}`);
+    }
+  }
   let triggerFilterTree = null;
   if (triggerInputDetails?.filter !== undefined) {
     triggerFilterTree = normalizeFilterTree(triggerInputDetails.filter);
@@ -1147,7 +1281,7 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
     fieldValues: pickerValues,
     solutionDir: resolvePickers ? await solutionDirFor(opts) : null
   });
-  await assertPickersResolved(triggerClient, resolvePickers ? pickerValues : undefined, resolvedResources);
+  await assertPickersResolved(triggerClient, resolvePickers ? pickerValues : undefined, resolvedResources, optionLabels(opts.optionLabels));
   const { essentialConfiguration: triggerEssentialConfig } = triggerClient.getEssentialConfiguration();
   assertActivityMetadataResolved(triggerEssentialConfig, resolvedConnection.context.id);
   const designedMeta = await withTriggerDesignAction({
@@ -1158,7 +1292,8 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
     solutionDir: resolvePickers ? await solutionDirFor(opts) : null,
     connectionId: resolvedConnection.context.id,
     target: { connectorKey, operation: eventOperation, objectName },
-    diagnostics
+    diagnostics,
+    labels: optionLabels(opts.optionLabels)
   });
   const fieldsMap = designedMeta.fields ?? {};
   const allFields = Object.values(fieldsMap);
@@ -1176,7 +1311,13 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
   const essentialConfiguration = {
     essentialConfiguration: triggerEssentialConfig
   };
-  const filter = filterFieldDefs.length > 0 ? { builder: "jmes", fields: filterFieldDefs } : undefined;
+  const filter = withBuilderOperators(filterFieldDefs.length > 0 ? { builder: "jmes", fields: filterFieldDefs } : undefined, "jmes", triggerClient.getFilterFields());
+  if (filter?.freeformOperators && filter.fields.length === 0 && responseFields.length === 0) {
+    diagnostics.warnings = [
+      ...diagnostics.warnings ?? [],
+      "the filter takes any field name and this trigger lists no payload fields, so a field name cannot be checked against the spec"
+    ];
+  }
   const byoaConnection = eventOpFlags?.byoaConnection ?? resolvedConnection.context.byoaConnection;
   resolvedConnection.context.byoaConnection = byoaConnection;
   const responseDisplayName = typecacheCtx.entry.displayName ?? objectDisplayName ?? "Response";
@@ -1186,7 +1327,7 @@ async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolv
     if (triggerInputDetails) {
       applyTriggerInputDetails(caseShape, triggerInputDetails, combinedFilterExpression);
     }
-    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    const connectorDisplayName = await opts.typeCache.lookupConnectorDisplayName(typecacheCtx.entry.packageId);
     caseShape.context = buildTriggerContext({
       connectorKey,
       connectorName: resolvedConnection.connectorName,
@@ -1363,6 +1504,21 @@ function buildActivityFilter(metadata, method, verb) {
   const filterFields = extractActivityFilterFields(metadata, method).map(toFilterFieldSpec);
   return filterFields.length > 0 ? { builder: "ceql", fields: filterFields } : undefined;
 }
+function withBuilderOperators(filter, builder, builderFields) {
+  const operatorsByName = new Map(builderFields.fields.map((f) => [f.name, f.operators]));
+  const fields = (filter?.fields ?? []).map((field) => {
+    const operators = operatorsByName.get(field.name);
+    return operators ? { ...field, operators: [...operators] } : field;
+  });
+  const { freeformOperators } = builderFields;
+  if (fields.length === 0 && freeformOperators === null)
+    return;
+  return {
+    builder: filter?.builder ?? builder,
+    fields,
+    ...freeformOperators === null ? {} : { freeformOperators: [...freeformOperators] }
+  };
+}
 function normalizeFilterType(raw) {
   switch ((raw ?? "").toLowerCase()) {
     case "number":
@@ -1394,6 +1550,26 @@ function parameterFromIS(p) {
   }
   return spec;
 }
+function withMultipartFileValues(multipart, inputDetails) {
+  if (multipart === null || inputDetails?.bodyParameters === undefined) {
+    return { multipart, inputDetails };
+  }
+  const { multipartParams, bodyParameters } = inlineMultipartFileValues(multipart.parameters, inputDetails.bodyParameters);
+  const unmoved = multipart.parameters.find((param) => param.dataType === "file" && bodyParameters?.[param.name] !== undefined);
+  if (unmoved) {
+    throw new InvalidInputDetailsError(`bodyParameters.${unmoved.name} takes a file variable as a string, e.g. "=js:vars.download".`);
+  }
+  return {
+    multipart: {
+      ...multipart,
+      parameters: multipart.parameters.map((param, index) => {
+        const value = multipartParams[index].value;
+        return value === undefined ? param : { ...param, value };
+      })
+    },
+    inputDetails: { ...inputDetails, bodyParameters }
+  };
+}
 function buildMultipartSpec(params) {
   const multiparts = extractMultipartParameters(params);
   if (multiparts.length === 0)
@@ -1455,12 +1631,12 @@ function extractElementVersion(rc) {
   return rc.elementVersion;
 }
 export {
-  applyActivityInputDetails,
-  applyTriggerInputDetails,
-  buildActivityContext,
-  buildResponseJsonSchema,
-  buildTriggerContext,
-  fetchConnectorTaskSpec
+  ConnectionConnectorMismatchError2 as ConnectionConnectorMismatchError,
+  InvalidInputDetailsError,
+  ResourceFieldResolutionError2 as ResourceFieldResolutionError,
+  UNSAFE_KEYS,
+  fetchConnectorTaskSpec,
+  nestDottedKeys
 };
 
-//# debugId=7B6C3F0AC1329CE164756E2164756E21
+//# debugId=E30D0AF4D91E22C864756E2164756E21