@uipath/flow-tool 1.202.1 → 1.203.0-preview.160

package/dist/{packager-tool-3bra2c4j.js → packager-tool-gctpkdzs.js}

@@ -1,6 +1,6 @@
 import {
   Path
-} from "./packager-tool-0d7tcvg1.js";
+} from "./packager-tool-b1xs6aty.js";
 
 // ../packager/packager-tool-flow/src/maestro-automate.ts
 var SENTINEL_FILE_NAME = ".maestro_automate";

package/dist/packager-tool-gdtpsdn7.js

@@ -0,0 +1,342 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-names.js
+var JsonSerializerNames = {
+  DefaultCaseInsensitive: "DefaultCaseInsensitive",
+  CaseInsensitive: "CaseInsensitive",
+  Indented: "Indented",
+  CamelCase: "CamelCase",
+  CaseInsensitiveIndented: "CaseInsensitiveIndented",
+  IndentedIgnoreNull: "IndentedIgnoreNull",
+  PreservePropertyNames: "PreservePropertyNames",
+  CamelCaseIndented: "CamelCaseIndented",
+  AllNames: [
+    "DefaultCaseInsensitive",
+    "CaseInsensitive",
+    "Indented",
+    "CamelCase",
+    "CaseInsensitiveIndented",
+    "IndentedIgnoreNull",
+    "PreservePropertyNames",
+    "CamelCaseIndented"
+  ]
+};
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer.js
+class JsonSerializer {
+  serialize(value) {
+    if (value == null)
+      return null;
+    let toSerialize = value;
+    if (this.options.ignoreNull)
+      toSerialize = this.removeNullValues(value);
+    if (this.options.camelCase && !this.options.preservePropertyNames)
+      toSerialize = this.toCamelCase(toSerialize);
+    if (this.options.enumCamelCase !== false)
+      toSerialize = this.convertEnumValuesToCamelCase(toSerialize);
+    const json = JSON.stringify(toSerialize, null, this.options.indented ? 2 : undefined);
+    return json;
+  }
+  async serializeAsync(stream, value, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const json = this.serialize(value);
+    if (json === null)
+      return;
+    const writer = stream.getWriter();
+    try {
+      const bytes = this.encoder.encode(json);
+      await writer.write(bytes);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  serializeToUtf8Bytes(value) {
+    const json = this.serialize(value);
+    if (json === null)
+      return new Uint8Array(0);
+    return this.encoder.encode(json);
+  }
+  deserialize(value) {
+    if (value == null || value === "")
+      return null;
+    try {
+      let cleanValue = value.charCodeAt(0) === 65279 ? value.slice(1) : value;
+      if (cleanValue.charCodeAt(cleanValue.length - 1) === 26)
+        cleanValue = cleanValue.slice(0, -1);
+      const parsed = JSON.parse(cleanValue);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  deserializeAsType(value, _type) {
+    return this.deserialize(value);
+  }
+  removeNullValues(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.removeNullValues(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj))
+        if (val != null)
+          result[key] = this.removeNullValues(val);
+      return result;
+    }
+    return obj;
+  }
+  toCamelCase(obj) {
+    if (obj == null)
+      return obj;
+    if (Array.isArray(obj))
+      return obj.map((item) => this.toCamelCase(item));
+    if (typeof obj == "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        const camelKey = key.charAt(0).toLowerCase() + key.slice(1);
+        result[camelKey] = this.toCamelCase(val);
+      }
+      return result;
+    }
+    return obj;
+  }
+  convertEnumValuesToCamelCase(obj, className) {
+    if (obj == null)
+      return obj;
+    if (typeof obj == "string")
+      return this.tryConvertEnumStringToCamelCase(obj, undefined, undefined);
+    if (Array.isArray(obj))
+      return obj.map((item) => this.convertEnumValuesToCamelCase(item, className));
+    if (typeof obj == "object") {
+      const result = {};
+      const currentClassName = obj.constructor?.name !== "Object" ? obj.constructor.name : className;
+      for (const [key, val] of Object.entries(obj))
+        if (typeof val == "string")
+          result[key] = this.tryConvertEnumStringToCamelCase(val, currentClassName, key);
+        else if (Array.isArray(val))
+          result[key] = val.map((item) => {
+            if (typeof item == "string")
+              return this.tryConvertEnumStringToCamelCase(item, currentClassName, key);
+            return this.convertEnumValuesToCamelCase(item, currentClassName);
+          });
+        else
+          result[key] = this.convertEnumValuesToCamelCase(val, currentClassName);
+      return result;
+    }
+    return obj;
+  }
+  tryConvertEnumStringToCamelCase(value, className, propertyName) {
+    if (this.camelCaseEnumProperties.size > 0) {
+      if (!propertyName || !this.isKnownCamelCaseEnum(className, propertyName))
+        return value;
+    } else if (propertyName && this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return value;
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(value))
+      return value.charAt(0).toLowerCase() + value.slice(1);
+    return value;
+  }
+  isKnownCamelCaseEnum(className, propertyName) {
+    if (this.isInPropertySet(this.pascalCaseEnumProperties, className, propertyName))
+      return false;
+    return this.isInPropertySet(this.camelCaseEnumProperties, className, propertyName);
+  }
+  isInPropertySet(propertySet, className, propertyName) {
+    if (className && propertySet.has(`${className}.${propertyName}`))
+      return true;
+    return propertySet.has(propertyName);
+  }
+  constructor(options = {}) {
+    this.isContextBased = false;
+    this.encoder = new TextEncoder;
+    this.options = options;
+    this.camelCaseEnumProperties = new Set(options.camelCaseEnumProperties ?? []);
+    this.pascalCaseEnumProperties = new Set(options.pascalCaseEnumProperties ?? []);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/pascal-case-enum-properties.js
+var CAMEL_CASE_ENUM_PROPERTIES = [
+  "scope",
+  "replaceOption",
+  "lookupStrategy",
+  "folderType"
+];
+var SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES = [
+  "propertyCategory"
+];
+var RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES = [
+  "ValidationState.errorSeverity",
+  "ValidationState.errorType",
+  "AddOrUpdateResourceToSolutionResponse.status",
+  "Overwrite.type",
+  "OverwriteValidationError.severity",
+  "ProjectResourceDescriptor.provisionType"
+];
+var PASCAL_CASE_ENUM_PROPERTIES = [
+  ...SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES,
+  ...RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES
+];
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/json-serializer-factory.js
+class JsonSerializerFactory {
+  get() {
+    return this.defaultSerializer;
+  }
+  getByName(name) {
+    if (!name)
+      return this.defaultSerializer;
+    let serializer = this.namedSerializers.get(name);
+    if (!serializer) {
+      serializer = this.createNamedSerializer(name);
+      this.namedSerializers.set(name, serializer);
+    }
+    return serializer;
+  }
+  initializePredefinedSerializers() {
+    for (const name of JsonSerializerNames.AllNames)
+      this.namedSerializers.set(name, this.createNamedSerializer(name));
+  }
+  createNamedSerializer(name) {
+    const options = this.createOptionsForName(name);
+    return new JsonSerializer(options);
+  }
+  createOptionsForName(name) {
+    const options = {
+      ...this.baseOptions
+    };
+    switch (name) {
+      case JsonSerializerNames.DefaultCaseInsensitive:
+        return {
+          caseInsensitive: true
+        };
+      case JsonSerializerNames.CaseInsensitive:
+        options.caseInsensitive = true;
+        break;
+      case JsonSerializerNames.Indented:
+        options.indented = true;
+        break;
+      case JsonSerializerNames.CamelCase:
+        options.camelCase = true;
+        break;
+      case JsonSerializerNames.CaseInsensitiveIndented:
+        options.caseInsensitive = true;
+        options.indented = true;
+        break;
+      case JsonSerializerNames.IndentedIgnoreNull:
+        options.indented = true;
+        options.ignoreNull = true;
+        break;
+      case JsonSerializerNames.PreservePropertyNames:
+        options.preservePropertyNames = true;
+        options.camelCase = false;
+        break;
+      case JsonSerializerNames.CamelCaseIndented:
+        options.indented = true;
+        options.camelCase = true;
+        options.ignoreNull = true;
+        break;
+      default:
+        break;
+    }
+    return options;
+  }
+  constructor(options) {
+    const defaults = {
+      camelCase: true,
+      enumCamelCase: true,
+      camelCaseEnumProperties: CAMEL_CASE_ENUM_PROPERTIES,
+      pascalCaseEnumProperties: PASCAL_CASE_ENUM_PROPERTIES
+    };
+    this.baseOptions = options ? {
+      ...defaults,
+      ...options
+    } : defaults;
+    this.defaultSerializer = new JsonSerializer(this.baseOptions);
+    this.namedSerializers = new Map;
+    this.initializePredefinedSerializers();
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/serializer-proxy.js
+class JsonSerializerProxy {
+  serialize(value) {
+    return this.jsonSerializer.serialize(value);
+  }
+  serializeAsync(stream, value, cancellationToken) {
+    return this.jsonSerializer.serializeAsync(stream, value, cancellationToken);
+  }
+  serializeToUtf8Bytes(value) {
+    return this.jsonSerializer.serializeToUtf8Bytes(value);
+  }
+  deserialize(value) {
+    return this.jsonSerializer.deserialize(value);
+  }
+  tryDeserializeObject(json) {
+    if (!json || json.trim() === "")
+      return null;
+    try {
+      return this.jsonSerializer.isContextBased ? this.jsonSerializer.deserialize(json) : this.caseInsensitiveSerializer.deserialize(json);
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return null;
+    }
+  }
+  tryDeserialize(value) {
+    if (!value || value.trim() === "")
+      return [
+        false,
+        null
+      ];
+    try {
+      const result = this.jsonSerializer.deserialize(value);
+      return [
+        true,
+        result
+      ];
+    } catch (ex) {
+      this.logger.info("Deserialization failed with exception.", ex);
+      return [
+        false,
+        null
+      ];
+    }
+  }
+  constructor(jsonSerializerFactory, loggerFactory) {
+    this.jsonSerializer = jsonSerializerFactory.get();
+    this.caseInsensitiveSerializer = jsonSerializerFactory.getByName(JsonSerializerNames.CaseInsensitive);
+    this.logger = loggerFactory.create("JsonSerializerProxy");
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/serialization/stream-serializer.js
+class StreamSerializer {
+  async serializeAsync(data, cancellationToken) {
+    cancellationToken?.throwIfAborted?.();
+    const serializer = this.jsonSerializerFactory.getByName(JsonSerializerNames.PreservePropertyNames);
+    const serializedContent = serializer.serialize(data);
+    const encoder = new TextEncoder;
+    const bytes = serializedContent ? encoder.encode(serializedContent) : new Uint8Array(0);
+    let streamClosed = false;
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+        streamClosed = true;
+      }
+    });
+    const disposeStream = this.disposeStream;
+    return {
+      stream,
+      dispose() {
+        if (disposeStream && !streamClosed)
+          stream.cancel().catch(() => {});
+      }
+    };
+  }
+  constructor(jsonSerializerFactory, disposeStream = true) {
+    this.jsonSerializerFactory = jsonSerializerFactory;
+    this.disposeStream = disposeStream;
+  }
+}
+export { JsonSerializerNames, JsonSerializer, CAMEL_CASE_ENUM_PROPERTIES, SHARED_CORE_ABSTRACTIONS_PASCAL_CASE_PROPERTIES, RESOURCE_BUILDER_PASCAL_CASE_PROPERTIES, PASCAL_CASE_ENUM_PROPERTIES, JsonSerializerFactory, JsonSerializerProxy, StreamSerializer };
+
+//# debugId=B9E68BD7718EF2DB64756E2164756E21

package/dist/{packager-tool-em5r6g6j.js → packager-tool-gpwec9sp.js}

@@ -1,23 +1,178 @@
 import {
   METADATA_IDENTIFIER,
   METADATA_PREFIX,
+  SELF_PREFIX,
   VARIABLE_PATH_IDENTIFIER_PATTERN,
   VARIABLE_PATH_PATTERN,
   VARIABLE_PATH_SELECTOR_PATTERN,
+  VARS_IDENTIFIER,
   VARS_PREFIX
-} from "./packager-tool-9bec251q.js";
-import {
-  init_esm_shims
-} from "./packager-tool-6ejqwbw9.js";
+} from "./packager-tool-vqcnvaae.js";
 import {
   FLAT_SEP,
+  JS_EXPRESSION_PREFIX,
   JobAttachmentSchema,
+  decodeLiteral,
   isAgentNodeType,
   isExpressionValue,
-  stripAutoDerivedFieldBindings
-} from "./packager-tool-m5qfverj.js";
+  isJobAttachmentRef,
+  stripAutoDerivedFieldBindings,
+  templateInterpolationBody
+} from "./packager-tool-fvm2dddf.js";
+import {
+  init_esm_shims
+} from "./packager-tool-6ejqwbw9.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/chunk-KO2EQXDL.js
+// ../../node_modules/@uipath/flow-converter/dist/chunk-KX2HWNFV.js
+init_esm_shims();
+var ITERATOR_FIELDS = [
+  { member: "currentItem", field: "item", type: "any" },
+  { member: "currentIteration", field: "loopCounter", type: "number" }
+];
+init_esm_shims();
+var VARS_REGEX = new RegExp(`\\${VARS_PREFIX}\\b`, "g");
+var METADATA_REGEX = new RegExp(`\\${METADATA_PREFIX}\\b`, "g");
+var SELF_REGEX = new RegExp(`\\${SELF_PREFIX}\\b`, "g");
+var SCRIPT_TASK_NODE_TYPES = ["core.action.script"];
+var DATA_TRANSFORM_NODE_TYPES = [
+  "core.action.transform",
+  "core.action.transform.filter",
+  "core.action.transform.map",
+  "core.action.transform.group-by"
+];
+function isScriptBodyPath(nodeType, path) {
+  if (!nodeType)
+    return false;
+  if (SCRIPT_TASK_NODE_TYPES.includes(nodeType)) {
+    return path.length === 2 && path[0] === "inputs" && path[1] === "script";
+  }
+  if (DATA_TRANSFORM_NODE_TYPES.includes(nodeType)) {
+    return path.length === 5 && path[0] === "inputs" && path[1] === "operations" && typeof path[2] === "number" && path[3] === "config" && path[4] === "script";
+  }
+  return false;
+}
+function unwrapScriptBody(value) {
+  let body;
+  if (isExpressionValue(value)) {
+    body = value.expression;
+  } else if (typeof value === "string") {
+    body = value;
+  } else {
+    return "";
+  }
+  while (body.startsWith(JS_EXPRESSION_PREFIX)) {
+    body = body.slice(JS_EXPRESSION_PREFIX.length);
+  }
+  return body;
+}
+function transformScriptBody(value, nodeId) {
+  if (typeof value !== "string" && !isExpressionValue(value))
+    return value;
+  return unwrapScriptBody(value).replace(VARS_REGEX, VARS_IDENTIFIER).replace(METADATA_REGEX, METADATA_IDENTIFIER).replace(SELF_REGEX, `${VARS_IDENTIFIER}.${nodeId}`);
+}
+function serializeTemplateInterpolations(expr) {
+  if (!expr || expr.startsWith(JS_EXPRESSION_PREFIX) || expr.startsWith("="))
+    return expr;
+  const body = templateInterpolationBody(expr);
+  return body === undefined ? expr : `${JS_EXPRESSION_PREFIX}\`${body}\``;
+}
+function transformExpression(expr, nodeId) {
+  if (!expr)
+    return expr;
+  expr = serializeTemplateInterpolations(expr);
+  expr = expr.replace(VARS_REGEX, VARS_IDENTIFIER).replace(METADATA_REGEX, METADATA_IDENTIFIER).replace(SELF_REGEX, `${VARS_IDENTIFIER}.${nodeId}`);
+  if (expr.startsWith(JS_EXPRESSION_PREFIX)) {
+    expr = `${JS_EXPRESSION_PREFIX}${parenthesizeObjectLiteral(expr.slice(JS_EXPRESSION_PREFIX.length))}`;
+  }
+  return expr;
+}
+function parenthesizeObjectLiteral(body) {
+  const trimmed = body.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") ? `(${trimmed})` : body;
+}
+function literalToJsExpressionBody(ev) {
+  const literal = ev.expression;
+  if (!literal)
+    return "";
+  switch (ev.fieldType) {
+    case "number":
+    case "boolean":
+    case "null":
+    case "array":
+      return literal;
+    case "object":
+      return `(${literal})`;
+    default:
+      return literal;
+  }
+}
+function serializeExpressionValueAsMappingSource(ev, nodeId) {
+  if (ev.type === "jsExpression" || ev.fieldType === "string") {
+    const out = serializeExpressionValue(ev, nodeId);
+    return typeof out === "string" ? out : `${JS_EXPRESSION_PREFIX}${String(out)}`;
+  }
+  return `${JS_EXPRESSION_PREFIX}${literalToJsExpressionBody(ev)}`;
+}
+function serializeExpressionValue(ev, nodeId) {
+  if (ev.type === "jsExpression") {
+    let body = ev.expression;
+    while (body.startsWith(JS_EXPRESSION_PREFIX)) {
+      body = body.slice(JS_EXPRESSION_PREFIX.length);
+    }
+    const transformed = body.replace(VARS_REGEX, VARS_IDENTIFIER).replace(METADATA_REGEX, METADATA_IDENTIFIER).replace(SELF_REGEX, `${VARS_IDENTIFIER}.${nodeId}`);
+    return `${JS_EXPRESSION_PREFIX}${parenthesizeObjectLiteral(transformed)}`;
+  }
+  if (ev.fieldType === "string") {
+    return transformExpression(ev.expression, nodeId);
+  }
+  return decodeLiteral(ev);
+}
+function serializeExpressionsInPlace(obj, nodeId, nodeType, path = []) {
+  if (obj == null || typeof obj !== "object")
+    return;
+  if (Array.isArray(obj)) {
+    for (let i = 0;i < obj.length; i++) {
+      const val = obj[i];
+      path.push(i);
+      if (isScriptBodyPath(nodeType, path)) {
+        obj[i] = transformScriptBody(val, nodeId);
+      } else if (isExpressionValue(val)) {
+        obj[i] = serializeExpressionValue(val, nodeId);
+      } else if (typeof val === "string") {
+        obj[i] = transformExpression(val, nodeId);
+      } else {
+        serializeExpressionsInPlace(val, nodeId, nodeType, path);
+      }
+      path.pop();
+    }
+    return;
+  }
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    const val = record[key];
+    path.push(key);
+    if (isScriptBodyPath(nodeType, path)) {
+      record[key] = transformScriptBody(val, nodeId);
+    } else if (isExpressionValue(val)) {
+      record[key] = serializeExpressionValue(val, nodeId);
+    } else if (typeof val === "string") {
+      record[key] = transformExpression(val, nodeId);
+    } else {
+      serializeExpressionsInPlace(val, nodeId, nodeType, path);
+    }
+    path.pop();
+  }
+}
+function transformNodeExpressions(node) {
+  if (!node.data)
+    return;
+  serializeExpressionsInPlace(node.data, node.id, node.type ?? node.data.type);
+}
+function transformEdgeExpression(edge) {
+  if (!edge.data)
+    return;
+  serializeExpressionsInPlace(edge.data, edge.preExpansionNodeId ?? edge.source);
+}
 init_esm_shims();
 var DEFAULT_AGENT_INPUT_ENCODING = "flat";
 init_esm_shims();
@@ -111,9 +266,6 @@ init_esm_shims();
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
-var UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-var isUnsafeKey = (key) => UNSAFE_PROPERTY_KEYS.has(key);
-init_esm_shims();
 function isLabeledWrapper(val) {
   return val != null && typeof val === "object" && !Array.isArray(val) && !isExpressionValue(val) && "value" in val;
 }
@@ -131,6 +283,38 @@ init_esm_shims();
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
+init_esm_shims();
+var MODES = /* @__PURE__ */ new Set(["text-builder", "variable", "prompt"]);
+var asString = (raw) => typeof raw === "string" ? raw : "";
+var isValueSourceValue = (raw) => !!raw && typeof raw === "object" && !Array.isArray(raw) && MODES.has(raw.mode);
+function readValueSource(raw, options = {}) {
+  const { defaultMode = "prompt", legacyString = "items" } = options;
+  const empty = { mode: defaultMode, textValue: "", promptValue: "", argumentPath: "", items: [] };
+  if (isValueSourceValue(raw)) {
+    const v = raw;
+    return {
+      mode: v.mode,
+      textValue: asString(v.textValue),
+      promptValue: asString(v.promptValue),
+      argumentPath: asString(v.argumentPath),
+      items: Array.isArray(v.items) ? v.items : []
+    };
+  }
+  if (Array.isArray(raw))
+    return raw.length === 0 ? empty : { ...empty, mode: "text-builder", items: raw };
+  if (typeof raw === "string" && raw !== "") {
+    return legacyString === "promptValue" ? { ...empty, mode: "prompt", promptValue: raw } : { ...empty, mode: "text-builder", items: [raw] };
+  }
+  return empty;
+}
+function bindingSources(value) {
+  if (value.mode === "text-builder")
+    return value.items;
+  if (value.mode === "variable" && value.argumentPath)
+    return [value.argumentPath];
+  return [];
+}
+var ANALYZE_FILES_INPUT_DESCRIPTION = "Combined file attachments for Analyze Files tool";
 var MUSTACHE_SOURCE_TOKEN_REGEX = new RegExp(String.raw`\{\{\s*\$(vars|metadata)\.(${VARIABLE_PATH_PATTERN})\s*\}\}`, "g");
 var RAW_SOURCE_TOKEN_REGEX = new RegExp(String.raw`(?<!\w)\$(vars|metadata)\.(${VARIABLE_PATH_PATTERN})`, "g");
 var MUSTACHE_INPUT_TOKEN_REGEX = new RegExp(String.raw`\{\{\s*\$agent\.(${VARIABLE_PATH_IDENTIFIER_PATTERN})(${VARIABLE_PATH_SELECTOR_PATTERN})\s*\}\}`, "g");
@@ -456,10 +640,7 @@ function scanSourceRefsDeep(values, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
     visit(value);
   return Array.from(seen.values());
 }
-var LOOP_MEMBER_TO_ITERATOR_FIELD = {
-  currentItem: { field: "item", type: "any" },
-  currentIteration: { field: "loopCounter", type: "number" }
-};
+var LOOP_MEMBER_TO_ITERATOR_FIELD = new Map(ITERATOR_FIELDS.map((f) => [f.member, f]));
 function tryBuildLoopBinding(ref, ancestorLoopInfo) {
   if (ref.prefix !== VARS_PREFIX)
     return;
@@ -481,7 +662,7 @@ function tryBuildLoopBinding(ref, ancestorLoopInfo) {
     binding = `${info.collectionExpr}${suffix}`;
     type = "array";
   } else {
-    const mapping = LOOP_MEMBER_TO_ITERATOR_FIELD[member];
+    const mapping = LOOP_MEMBER_TO_ITERATOR_FIELD.get(member);
     if (!mapping)
       return;
     binding = `=iterator[${info.index}].${mapping.field}${suffix}`;
@@ -563,7 +744,7 @@ function collectInlineAgentInputsFromAgent(agent) {
   if (!properties)
     return { refs, variables };
   const emitLeaf = (flatName, prop) => {
-    const type = prop?.$ref?.endsWith("/job-attachment") ? "file" : prop?.type || "string";
+    const type = isJobAttachmentRef(prop) ? "file" : prop?.type || "string";
     if (isSyntheticAgentInputId(flatName)) {
       variables.push({ id: flatName, type, binding: "", description: prop?.description ?? "" });
       return;
@@ -617,7 +798,13 @@ function collectArtifactDescendants(rootId, edges) {
   return out;
 }
 var ANALYZEFILES_NODE_TYPE = "uipath.agent.resource.tool.builtin.analyzefiles";
-function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+function isArrayTypedRef(ref, resolveSourceType, ancestorLoopInfo) {
+  const loopEntry = ancestorLoopInfo ? tryBuildLoopBinding(ref, ancestorLoopInfo) : undefined;
+  if (loopEntry)
+    return loopEntry.type === "array";
+  return resolveSourceType?.(ref) === "array";
+}
+function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING, resolveSourceType, ancestorLoopInfo) {
   let descendants = collectArtifactDescendants(agentId, edges);
   if (descendants.size === 0) {
     descendants = new Set(edges.filter((e) => e.source === agentId).map((e) => e.target));
@@ -632,8 +819,9 @@ function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding
     if (nodeType !== ANALYZEFILES_NODE_TYPE)
       continue;
     const nodeInputs = node.data?.inputs ?? node.inputs;
-    const rawItems = nodeInputs?.itemsDescription;
-    if (!Array.isArray(rawItems) || rawItems.length < 1)
+    const attachments = readValueSource(nodeInputs?.itemsDescription);
+    const rawItems = bindingSources(attachments);
+    if (rawItems.length < 1)
       continue;
     const fileBindings = [];
     for (const item of rawItems) {
@@ -643,7 +831,7 @@ function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding
       const refs = extractSourceRefs(text, encoding);
       for (const ref of refs) {
         supersededVarIds.add(ref.flatName);
-        fileBindings.push(`$vars.${ref.path}`);
+        fileBindings.push(isArrayTypedRef(ref, resolveSourceType, ancestorLoopInfo) ? `...$vars.${ref.path}` : `$vars.${ref.path}`);
       }
     }
     if (fileBindings.length === 0)
@@ -657,7 +845,7 @@ function mergeAnalyzeFilesInputs(variables, agentId, nodesById, edges, encoding
       id: syntheticId,
       type: "array",
       binding: `=[${fileBindings.join(", ")}]`,
-      description: "Combined file attachments for Analyze Files tool",
+      description: ANALYZE_FILES_INPUT_DESCRIPTION,
       schema: {
         type: "array",
         items: { $ref: "#/definitions/job-attachment" },
@@ -691,9 +879,9 @@ function mergeCompositeConnectorInputs(variables, agentId, nodesById, edges) {
   }
   return synthetic.length === 0 ? variables : [...variables, ...synthetic];
 }
-function deriveMergedAgentInputVariables(rawVariables, agentId, nodes, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING) {
+function deriveMergedAgentInputVariables(rawVariables, agentId, nodes, edges, encoding = DEFAULT_AGENT_INPUT_ENCODING, resolveSourceType) {
   const nodesById = new Map(nodes.map((n) => [n.id, n]));
-  const withFiles = mergeAnalyzeFilesInputs(rawVariables, agentId, nodesById, edges, encoding);
+  const withFiles = mergeAnalyzeFilesInputs(rawVariables, agentId, nodesById, edges, encoding, resolveSourceType);
   return mergeCompositeConnectorInputs(withFiles, agentId, nodesById, edges);
 }
 function preDeriveAgentInputDefinitions(nodes, edges, options = {}) {
@@ -716,7 +904,7 @@ function preDeriveAgentInputDefinitions(nodes, edges, options = {}) {
       ancestorLoops.forEach((loop, idx) => ancestorLoopInfo.set(loop.id, { index: idx, collectionExpr: loop.collectionExpr }));
     }
     const { variables } = scanAgentClusterRefs(agent, nodesById, edges, resolveSourceType, ancestorLoopInfo, pruneUnreferenced, encoding);
-    const withFiles = mergeAnalyzeFilesInputs(variables, agent.id, nodesById, edges, encoding);
+    const withFiles = mergeAnalyzeFilesInputs(variables, agent.id, nodesById, edges, encoding, resolveSourceType, ancestorLoopInfo);
     const mergedVariables = mergeCompositeConnectorInputs(withFiles, agent.id, nodesById, edges);
     if (!agent.data.inputs)
       agent.data.inputs = {};
@@ -731,6 +919,9 @@ function toJsExpression(binding) {
     return binding;
   if (binding.startsWith("="))
     return `=js:${binding.slice(1)}`;
+  const template = serializeTemplateInterpolations(binding);
+  if (template !== binding)
+    return template;
   return `=js:${binding}`;
 }
 function bindingExprBody(binding) {
@@ -887,6 +1078,6 @@ function rewriteStringsDeep(value, fn) {
   return value;
 }
 
-export { DEFAULT_AGENT_INPUT_ENCODING, SCHEMA_CONTAINER_MARKER, getContainerChildProps, extractAgentInputName, isCompositeConnectorValue, compositeConnectorInputKey, isSyntheticAgentInputId, collectCompositeConnectorInputs, isUnsafeKey, encodeFlatName, decodeFlatName, rewriteInputTokensToSource, UnresolvedAgentInputTypeError, AmbiguousAgentInputRootError, detectAmbiguousAgentInputRoot, buildAgentInputTypeResolver, canPruneAgentInputs, deriveAgentInputVariables, scanSourceRefsDeep, collectInlineAgentClusterInputs, collectInlineAgentInputsFromAgent, collectArtifactDescendants, mergeCompositeConnectorInputs, deriveMergedAgentInputVariables, preDeriveAgentInputDefinitions, buildDerivedInputDefinition, rewriteStringsDeep };
+export { ITERATOR_FIELDS, SCRIPT_TASK_NODE_TYPES, DATA_TRANSFORM_NODE_TYPES, unwrapScriptBody, serializeTemplateInterpolations, transformExpression, serializeExpressionValueAsMappingSource, serializeExpressionValue, transformNodeExpressions, transformEdgeExpression, DEFAULT_AGENT_INPUT_ENCODING, SCHEMA_CONTAINER_MARKER, getContainerChildProps, CONNECTOR_PARAM_BUCKET_KEYS, extractAgentInputName, isCompositeConnectorValue, compositeConnectorInputKey, isSyntheticAgentInputId, collectCompositeConnectorInputs, encodeFlatName, decodeFlatName, rewriteInputTokensToSource, UnresolvedAgentInputTypeError, AmbiguousAgentInputRootError, detectAmbiguousAgentInputRoot, buildAgentInputTypeResolver, canPruneAgentInputs, deriveAgentInputVariables, scanSourceRefsDeep, collectInlineAgentClusterInputs, collectInlineAgentInputsFromAgent, collectArtifactDescendants, mergeCompositeConnectorInputs, deriveMergedAgentInputVariables, preDeriveAgentInputDefinitions, buildDerivedInputDefinition, rewriteStringsDeep };
 
-//# debugId=0A4CAA6186A401FE64756E2164756E21
+//# debugId=678BEB3000A25CC964756E2164756E21