@uipath/maestro-tool 1.202.1 → 1.202.2-preview.167

package/dist/{packager-tool-m5qfverj.js → packager-tool-e8td7b01.js}

@@ -1,6 +1,6 @@
 import {
   VALIDATION_NAMESPACE
-} from "./packager-tool-e0p2zsyc.js";
+} from "./packager-tool-p79yh9ww.js";
 import {
   __commonJS,
   __export,
@@ -23043,7 +23043,410 @@ function date4(params) {
 
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
-// ../../node_modules/@uipath/flow-schema/dist/chunk-E6I5CCCH.js
+// ../../node_modules/@uipath/flow-schema/dist/chunk-GWRTD4DY.js
+var JS_EXPRESSION_PREFIX = "=js:";
+var expressionFieldTypeSchema = exports_external.enum(["string", "number", "boolean", "object", "array", "null"]);
+var expressionModeSchema = exports_external.enum(["literal", "jsExpression"]);
+var expressionValueSchema = exports_external.object({
+  type: expressionModeSchema,
+  expression: exports_external.string(),
+  fieldType: expressionFieldTypeSchema
+}).strict();
+var expressionLikeSchema = exports_external.union([exports_external.string(), expressionValueSchema]);
+function isExpressionValue(v) {
+  return expressionValueSchema.safeParse(v).success;
+}
+function isEmptyExpressionValue(ev) {
+  return ev.expression.trim() === "";
+}
+function inferFieldType(value) {
+  if (Array.isArray(value))
+    return "array";
+  if (value === null)
+    return "null";
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === "object")
+    return t;
+  return "string";
+}
+function encodeLiteral(raw, fieldType) {
+  switch (fieldType) {
+    case "string":
+      if (typeof raw === "string")
+        return raw;
+      if (raw == null)
+        return "";
+      if (typeof raw === "object") {
+        try {
+          return JSON.stringify(raw);
+        } catch {
+          return String(raw);
+        }
+      }
+      return String(raw);
+    case "number":
+    case "boolean":
+      return raw == null ? "" : String(raw);
+    case "null":
+      return "null";
+    case "object":
+    case "array":
+      return JSON.stringify(raw ?? null);
+  }
+}
+function decodeLiteral(ev) {
+  if (ev.type === "jsExpression")
+    return ev.expression;
+  switch (ev.fieldType) {
+    case "string":
+      return ev.expression;
+    case "number":
+      return ev.expression === "" ? undefined : Number(ev.expression);
+    case "boolean":
+      return ev.expression === "" ? undefined : ev.expression === "true";
+    case "null":
+      return null;
+    case "object":
+    case "array":
+      if (ev.expression === "")
+        return;
+      try {
+        return JSON.parse(ev.expression);
+      } catch {
+        return;
+      }
+  }
+}
+function coerceToExpressionValue(value, fieldType) {
+  if (isExpressionValue(value))
+    return value;
+  const resolvedFieldType = fieldType ?? inferFieldType(value);
+  if (typeof value === "string") {
+    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
+      return {
+        type: "jsExpression",
+        expression: value.slice(JS_EXPRESSION_PREFIX.length),
+        fieldType: resolvedFieldType
+      };
+    }
+    return { type: "literal", expression: value, fieldType: resolvedFieldType };
+  }
+  return { type: "literal", expression: encodeLiteral(value, resolvedFieldType), fieldType: resolvedFieldType };
+}
+function getJsExpressionBody(value) {
+  if (isExpressionValue(value)) {
+    return value.type === "jsExpression" ? value.expression : undefined;
+  }
+  if (typeof value === "string" && value.startsWith(JS_EXPRESSION_PREFIX)) {
+    return value.slice(JS_EXPRESSION_PREFIX.length);
+  }
+  return;
+}
+function expectedTypeToFieldType(expectedType) {
+  switch (expectedType) {
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    case "array":
+      return "array";
+    case "null":
+      return "null";
+    case "string":
+    case "text":
+    default:
+      return "string";
+  }
+}
+function jsonSchemaTypeToFieldType(raw) {
+  if (Array.isArray(raw)) {
+    for (const t of raw) {
+      const mapped = jsonSchemaTypeToFieldType(t);
+      if (mapped)
+        return mapped;
+    }
+    return;
+  }
+  if (typeof raw !== "string")
+    return;
+  switch (raw) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "object":
+    case "array":
+    case "null":
+      return raw;
+    case "integer":
+      return "number";
+    default:
+      return;
+  }
+}
+function coerceInputsViaSchema(value, schema) {
+  if (isExpressionValue(value))
+    return value;
+  if (Array.isArray(value)) {
+    if (schema?.items) {
+      for (let i = 0;i < value.length; i++) {
+        value[i] = coerceInputsViaSchema(value[i], schema.items);
+      }
+    }
+    return value;
+  }
+  if (value !== null && typeof value === "object") {
+    if (schema?.properties) {
+      const props = schema.properties;
+      for (const [k, v] of Object.entries(value)) {
+        value[k] = coerceInputsViaSchema(v, props[k]);
+      }
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
+      return coerceToExpressionValue(value, jsonSchemaTypeToFieldType(schema?.type));
+    }
+    if (hasMustacheInterpolation(value)) {
+      return {
+        type: "literal",
+        expression: value,
+        fieldType: jsonSchemaTypeToFieldType(schema?.type) ?? "string"
+      };
+    }
+  }
+  return value;
+}
+function hasMustacheInterpolation(s) {
+  const stripped = s.replace(/\\\{/g, "").replace(/\\\}/g, "");
+  return /\{\{[^{}]+\}\}/.test(stripped);
+}
+var ESCAPED_MUSTACHE_PLACEHOLDER = "__FLOW_ESCAPED_MUSTACHE__";
+var ESCAPED_MUSTACHE_REGEX = /\\\{\{/g;
+var hasMustache = (value) => {
+  if (!value)
+    return false;
+  const open = value.indexOf("{{");
+  return open !== -1 && value.indexOf("}}", open + 2) !== -1;
+};
+var parseMustacheSegments = (value) => {
+  if (!value)
+    return { segments: [], tail: "" };
+  const segments = [];
+  let pos = 0;
+  while (pos < value.length) {
+    const openIdx = value.indexOf("{{", pos);
+    if (openIdx === -1)
+      break;
+    const closeIdx = value.indexOf("}}", openIdx + 2);
+    if (closeIdx === -1)
+      break;
+    segments.push({
+      staticText: value.slice(pos, openIdx),
+      expression: value.slice(openIdx + 2, closeIdx).trim()
+    });
+    pos = closeIdx + 2;
+  }
+  return { segments, tail: value.slice(pos) };
+};
+function templateInterpolationBody(expr) {
+  if (!hasMustache(expr))
+    return;
+  const input = expr.replace(ESCAPED_MUSTACHE_REGEX, ESCAPED_MUSTACHE_PLACEHOLDER);
+  const restore = (s) => escapeTemplateLiteralText(s.replaceAll(ESCAPED_MUSTACHE_PLACEHOLDER, "{{"));
+  const { segments, tail } = parseMustacheSegments(input);
+  let result = "";
+  for (const seg of segments)
+    result += restore(seg.staticText) + "${" + seg.expression + "}";
+  return result + restore(tail);
+}
+var TEMPLATE_SENSITIVE = /[\\`]|\$\{/g;
+var escapeTemplateLiteralText = (text) => text.replace(TEMPLATE_SENSITIVE, (match) => `\\${match}`);
+var QES_UNSAFE_CHAR = /["\\\s\u0000-\u001f]/;
+function isQesUncarryableValue(value) {
+  const jsBody = getJsExpressionBody(value);
+  if (jsBody !== undefined)
+    return jsBody.trim() !== "" && QES_UNSAFE_CHAR.test(jsBody);
+  const text = isExpressionValue(value) ? value.expression : typeof value === "string" ? value : "";
+  const templateBody = templateInterpolationBody(text);
+  return templateBody !== undefined && QES_UNSAFE_CHAR.test(templateBody);
+}
+var RESERVED_WORDS = [
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "class",
+  "const",
+  "enum",
+  "export",
+  "extends",
+  "import",
+  "super",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield"
+];
+var VALID_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var FLAT_SEP = "__";
+function generateRandomId(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0;i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+function generateNextId(prefix, count = 6) {
+  return `${prefix}${generateRandomId(count)}`;
+}
+var UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isUnsafeKey = (key) => UNSAFE_PROPERTY_KEYS.has(key);
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return a === b;
+  if (a === undefined || b === undefined)
+    return a === b;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length)
+      return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (typeof a === "object") {
+    if (Array.isArray(b))
+      return false;
+    const objA = a;
+    const objB = b;
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length)
+      return false;
+    return keysA.every((key) => (key in objB) && deepEqual(objA[key], objB[key]));
+  }
+  return false;
+}
+var IN_FILTER_OPERATOR = "in";
+var NOT_IN_FILTER_OPERATOR = "not in";
+var LEGACY_IN_FILTER_OPERATOR = "is any of";
+function isValueListFilterOperator(operator) {
+  return operator === IN_FILTER_OPERATOR || operator === NOT_IN_FILTER_OPERATOR || operator === LEGACY_IN_FILTER_OPERATOR;
+}
+function resolveReadResultMode(cfg) {
+  return cfg?.resultMode === "multiple" ? "multiple" : "single";
+}
+function readExpressionText(value) {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return "";
+  const expression = value.expression;
+  return typeof expression === "string" ? expression : "";
+}
+function isJsExpressionShape(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return value.type === "jsExpression";
+}
+function readEntityFilterValueListIsEmpty(row, multiRecord) {
+  if (!multiRecord || !isValueListFilterOperator(row?.operator))
+    return false;
+  const text = readExpressionText(row?.value);
+  if (!row?.field || !text.trim())
+    return false;
+  if (isJsExpressionShape(row?.value))
+    return false;
+  return text.split(",").every((part) => !part.trim());
+}
+function readEntityFilterRowYieldsPredicate(row, multiRecord) {
+  if (!row?.field || !readExpressionText(row.value).trim())
+    return false;
+  if (!isValueListFilterOperator(row.operator))
+    return true;
+  return multiRecord && !readEntityFilterValueListIsEmpty(row, true);
+}
+function entityWriteRowHasValue(value) {
+  if (typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  const body = getJsExpressionBody(value);
+  if (body !== undefined)
+    return body.trim() !== "";
+  return readExpressionText(value).trim() !== "";
+}
+var SYSTEM_ENTITY_FIELD_NAMES = /* @__PURE__ */ new Set(["id", "createtime", "createdby", "updatetime", "updatedby"]);
+function isNonNullableEntityWriteField(field) {
+  if (!field || field.isRequired !== true)
+    return false;
+  if (field.isAttachment === true || field.isAutoNumber === true || field.isSystemField === true)
+    return false;
+  const name = typeof field.name === "string" ? field.name.trim().toLowerCase() : "";
+  return name !== "" && !SYSTEM_ENTITY_FIELD_NAMES.has(name);
+}
+function isMandatoryEntityWriteField(field) {
+  return isNonNullableEntityWriteField(field) && field?.hasDefaultValue !== true;
+}
+function entityWriteFieldNames(entityFields, predicate) {
+  if (!Array.isArray(entityFields))
+    return [];
+  return entityFields.filter((field) => predicate(field)).map((field) => field.name.trim());
+}
+function nonNullableEntityWriteFields(entityFields) {
+  return entityWriteFieldNames(entityFields, isNonNullableEntityWriteField);
+}
+function mandatoryEntityWriteFields(entityFields) {
+  return entityWriteFieldNames(entityFields, isMandatoryEntityWriteField);
+}
+function readEntityFilterRows(filters) {
+  if (Array.isArray(filters))
+    return filters;
+  if (!filters || typeof filters !== "object")
+    return [];
+  const model = filters;
+  const rows = Array.isArray(model.rows) ? model.rows : [];
+  const groups = Array.isArray(model.groups) ? model.groups : [];
+  return [...rows, ...groups.flatMap((g) => Array.isArray(g?.rows) ? g.rows : [])];
+}
+
+// ../../node_modules/@uipath/flow-schema/dist/chunk-M4DXYS4M.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_errors = __toESM(require_dist(), 1);
 
@@ -26146,7 +26549,7 @@ __export(exports_util2, {
   getParsedType: () => getParsedType2,
   getSizableOrigin: () => getSizableOrigin2,
   isObject: () => isObject2,
-  isPlainObject: () => isPlainObject2,
+  isPlainObject: () => isPlainObject3,
   issue: () => issue2,
   joinValues: () => joinValues2,
   jsonStringifyReplacer: () => jsonStringifyReplacer2,
@@ -26290,7 +26693,7 @@ var allowsEval2 = cached2(() => {
     return false;
   }
 });
-function isPlainObject2(o) {
+function isPlainObject3(o) {
   if (isObject2(o) === false)
     return false;
   const ctor = o.constructor;
@@ -26475,7 +26878,7 @@ function omit2(schema, mask) {
   });
 }
 function extend2(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const def = {
@@ -28464,7 +28867,7 @@ function mergeValues2(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject2(a) && isPlainObject2(b)) {
+  if (isPlainObject3(a) && isPlainObject3(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -28594,7 +28997,7 @@ var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
   $ZodType2.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isPlainObject2(input)) {
+    if (!isPlainObject3(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
@@ -46588,7 +46991,7 @@ var ternary = {
 };
 jsep.plugins.register(ternary);
 
-// ../../node_modules/@uipath/flow-schema/dist/chunk-E6I5CCCH.js
+// ../../node_modules/@uipath/flow-schema/dist/chunk-M4DXYS4M.js
 function isBlockingSeverity(severity) {
   return severity === "error" || severity === "critical";
 }
@@ -46606,186 +47009,6 @@ var agentEnforcementsSchema = exports_external.object({
   shouldEnforceHumanInTheLoop: exports_external.boolean().optional(),
   maxIterations: exports_external.number().nullable().optional()
 });
-var JS_EXPRESSION_PREFIX = "=js:";
-var expressionFieldTypeSchema = exports_external.enum(["string", "number", "boolean", "object", "array", "null"]);
-var expressionModeSchema = exports_external.enum(["literal", "jsExpression"]);
-var expressionValueSchema = exports_external.object({
-  type: expressionModeSchema,
-  expression: exports_external.string(),
-  fieldType: expressionFieldTypeSchema
-}).strict();
-var expressionLikeSchema = exports_external.union([exports_external.string(), expressionValueSchema]);
-function isExpressionValue(v) {
-  return expressionValueSchema.safeParse(v).success;
-}
-function isEmptyExpressionValue(ev) {
-  return ev.expression.trim() === "";
-}
-function inferFieldType(value) {
-  if (Array.isArray(value))
-    return "array";
-  if (value === null)
-    return "null";
-  const t13 = typeof value;
-  if (t13 === "string" || t13 === "number" || t13 === "boolean" || t13 === "object")
-    return t13;
-  return "string";
-}
-function encodeLiteral(raw, fieldType) {
-  switch (fieldType) {
-    case "string":
-      if (typeof raw === "string")
-        return raw;
-      if (raw == null)
-        return "";
-      if (typeof raw === "object") {
-        try {
-          return JSON.stringify(raw);
-        } catch {
-          return String(raw);
-        }
-      }
-      return String(raw);
-    case "number":
-    case "boolean":
-      return raw == null ? "" : String(raw);
-    case "null":
-      return "null";
-    case "object":
-    case "array":
-      return JSON.stringify(raw ?? null);
-  }
-}
-function decodeLiteral(ev) {
-  if (ev.type === "jsExpression")
-    return ev.expression;
-  switch (ev.fieldType) {
-    case "string":
-      return ev.expression;
-    case "number":
-      return ev.expression === "" ? undefined : Number(ev.expression);
-    case "boolean":
-      return ev.expression === "" ? undefined : ev.expression === "true";
-    case "null":
-      return null;
-    case "object":
-    case "array":
-      if (ev.expression === "")
-        return;
-      try {
-        return JSON.parse(ev.expression);
-      } catch {
-        return;
-      }
-  }
-}
-function coerceToExpressionValue(value, fieldType) {
-  if (isExpressionValue(value))
-    return value;
-  const resolvedFieldType = fieldType ?? inferFieldType(value);
-  if (typeof value === "string") {
-    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
-      return {
-        type: "jsExpression",
-        expression: value.slice(JS_EXPRESSION_PREFIX.length),
-        fieldType: resolvedFieldType
-      };
-    }
-    return { type: "literal", expression: value, fieldType: resolvedFieldType };
-  }
-  return { type: "literal", expression: encodeLiteral(value, resolvedFieldType), fieldType: resolvedFieldType };
-}
-function getJsExpressionBody(value) {
-  if (isExpressionValue(value)) {
-    return value.type === "jsExpression" ? value.expression : undefined;
-  }
-  if (typeof value === "string" && value.startsWith(JS_EXPRESSION_PREFIX)) {
-    return value.slice(JS_EXPRESSION_PREFIX.length);
-  }
-  return;
-}
-function expectedTypeToFieldType(expectedType) {
-  switch (expectedType) {
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "object":
-      return "object";
-    case "array":
-      return "array";
-    case "null":
-      return "null";
-    case "string":
-    case "text":
-    default:
-      return "string";
-  }
-}
-function jsonSchemaTypeToFieldType(raw) {
-  if (Array.isArray(raw)) {
-    for (const t13 of raw) {
-      const mapped = jsonSchemaTypeToFieldType(t13);
-      if (mapped)
-        return mapped;
-    }
-    return;
-  }
-  if (typeof raw !== "string")
-    return;
-  switch (raw) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "object":
-    case "array":
-    case "null":
-      return raw;
-    case "integer":
-      return "number";
-    default:
-      return;
-  }
-}
-function coerceInputsViaSchema(value, schema) {
-  if (isExpressionValue(value))
-    return value;
-  if (Array.isArray(value)) {
-    if (schema?.items) {
-      for (let i = 0;i < value.length; i++) {
-        value[i] = coerceInputsViaSchema(value[i], schema.items);
-      }
-    }
-    return value;
-  }
-  if (value !== null && typeof value === "object") {
-    if (schema?.properties) {
-      const props = schema.properties;
-      for (const [k, v] of Object.entries(value)) {
-        value[k] = coerceInputsViaSchema(v, props[k]);
-      }
-    }
-    return value;
-  }
-  if (typeof value === "string") {
-    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
-      return coerceToExpressionValue(value, jsonSchemaTypeToFieldType(schema?.type));
-    }
-    if (hasMustacheInterpolation(value)) {
-      return {
-        type: "literal",
-        expression: value,
-        fieldType: jsonSchemaTypeToFieldType(schema?.type) ?? "string"
-      };
-    }
-  }
-  return value;
-}
-function hasMustacheInterpolation(s) {
-  const stripped = s.replace(/\\\{/g, "").replace(/\\\}/g, "");
-  return /\{\{[^{}]+\}\}/.test(stripped);
-}
 var t2 = instance.getFixedT(null, VALIDATION_NAMESPACE);
 function isExpression(value) {
   if (isExpressionValue(value))
@@ -47916,10 +48139,10 @@ function normalizeFormTriggerSchema(schema) {
   };
 }
 function getHitlFieldChannelKey(field) {
-  if (field.label)
-    return field.label;
   if (field.id)
     return field.id;
+  if (field.label)
+    return field.label;
   return null;
 }
 function isHitlInputDirectionField(field) {
@@ -48394,6 +48617,7 @@ var HITL_CODED_ACTION_NODE_TYPE = "uipath.human-in-the-loop.coded-action-app";
 var HITL_DOC_VALIDATION_NODE_TYPE = "uipath.human-in-the-loop.document-validation";
 var DYNAMIC_EXTRACT_NODE_TYPE = "uipath.ixp.extract-document-builder";
 var FORM_TRIGGER_NODE_TYPE = "core.trigger.form";
+var UI_ONLY_NODE_TYPES = /* @__PURE__ */ new Set(["stickyNote"]);
 var HITL_NODE_TYPES = /* @__PURE__ */ new Set([
   HITL_QUICK_FORM_NODE_TYPE,
   HITL_CODED_ACTION_NODE_TYPE,
@@ -48474,6 +48698,15 @@ function collectStrings(value, out) {
       collectStrings(v, out);
   }
 }
+function collectObjectBindingStrings(value, out) {
+  const { argumentPath } = value;
+  if (typeof argumentPath === "string" && argumentPath)
+    out.push(argumentPath);
+  for (const [key, v] of Object.entries(value)) {
+    if (key !== "argumentPath")
+      collectBindingStrings(v, out);
+  }
+}
 function collectBindingStrings(value, out) {
   if (value == null)
     return;
@@ -48486,8 +48719,7 @@ function collectBindingStrings(value, out) {
     for (const v of value)
       collectBindingStrings(v, out);
   } else if (typeof value === "object") {
-    for (const v of Object.values(value))
-      collectBindingStrings(v, out);
+    collectObjectBindingStrings(value, out);
   }
 }
 var agentEmptyVarRule = {
@@ -48554,154 +48786,399 @@ function emitEmptyVarWarnings(agent, strings, orphanIds) {
   }
   return errors5;
 }
-var VARS_REF_REGEX2 = /\$vars\.([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)/g;
-function pathExistsOnOutputSchema(schema, segments) {
-  let cursor = schema;
-  for (let i = 0;i < segments.length; i++) {
-    const seg = segments[i];
-    if (cursor == null) {
-      return { valid: true };
+var JobAttachmentSchema = {
+  type: "object",
+  "x-uipath-resource-kind": "JobAttachment",
+  properties: {
+    ID: {
+      type: "string",
+      description: "Orchestrator attachment key"
+    },
+    FullName: {
+      type: "string",
+      description: "File name"
+    },
+    MimeType: {
+      type: "string",
+      description: 'The MIME type of the content, such as "application/json" or "image/png"'
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary of metadata",
+      additionalProperties: {
+        type: "string"
+      }
     }
-    if (typeof cursor !== "object") {
-      return { valid: false, missingSegment: seg, matchedDepth: i };
+  },
+  required: ["ID"]
+};
+var ANALYZE_FILES_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachments: {
+        type: "array",
+        items: JobAttachmentSchema,
+        description: "Array of files, documents, images, or other attachments to process"
+      },
+      analysisTask: {
+        type: "string",
+        description: "The task, question, or instruction for processing the files (e.g., 'summarize this document', 'extract key points', 'what is in this image')"
+      }
+    },
+    required: ["attachments", "analysisTask"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      analysis: {
+        type: "string",
+        description: "Analysis result of the attachments (analysis, summary, extracted information, etc.)"
+      }
+    },
+    required: ["analysis"]
+  }
+};
+var SUMMARIZE_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "File or document to summarize",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
+      }
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the analyzed attachment"
+        }
+      }
     }
-    const obj = cursor;
-    let propsContainer;
-    let additionalProps;
-    const inlineProps = obj.properties;
-    if (inlineProps && typeof inlineProps === "object") {
-      propsContainer = inlineProps;
-      additionalProps = obj.additionalProperties;
-    } else if (obj.schema && typeof obj.schema === "object") {
-      const schemaObj = obj.schema;
-      const wrappedProps = schemaObj.properties;
-      if (wrappedProps && typeof wrappedProps === "object") {
-        propsContainer = wrappedProps;
-        additionalProps = schemaObj.additionalProperties;
+  }
+};
+var BATCH_TRANSFORM_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "CSV file to transform",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
+      }
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the transformed row"
+        }
       }
     }
-    if (!propsContainer) {
-      const declaredType = obj.type;
-      if (typeof declaredType === "string" && declaredType !== "object" && declaredType !== "array" && !obj.items) {
-        return { valid: false, missingSegment: seg, matchedDepth: i };
+  }
+};
+var nameValuePairSchema = (nameDescription, valueDescription) => ({
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      description: nameDescription
+    },
+    value: {
+      type: "string",
+      description: valueDescription
+    }
+  },
+  required: ["name", "value"]
+});
+var HTTP_REQUEST_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The absolute URL to send the request to."
+      },
+      method: {
+        type: "string",
+        description: "HTTP method to use, one of: GET, POST, PUT, PATCH, DELETE."
+      },
+      headers: {
+        type: "array",
+        description: "Request headers as a list of name/value pairs.",
+        items: nameValuePairSchema("Header name.", "Header value.")
+      },
+      params: {
+        type: "array",
+        description: "Query-string parameters as a list of name/value pairs.",
+        items: nameValuePairSchema("Parameter name.", "Parameter value.")
+      },
+      body: {
+        type: "string",
+        description: "Request body sent as-is. Provide JSON as a string and set a Content-Type header if the endpoint expects JSON."
+      },
+      timeout: {
+        type: "number",
+        description: "Request timeout in seconds."
       }
-      return { valid: true };
+    },
+    required: ["url"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+var BUILT_IN_TOOL_SCHEMAS = {
+  "uipath.agent.resource.tool.builtin.analyzefiles": ANALYZE_FILES_SCHEMA,
+  "uipath.agent.resource.tool.builtin.summarize": SUMMARIZE_SCHEMA,
+  "uipath.agent.resource.tool.builtin.batchtransform": BATCH_TRANSFORM_SCHEMA,
+  "uipath.agent.resource.tool.builtin.httprequest": HTTP_REQUEST_SCHEMA
+};
+function getToolFields(schema, filterType = "any") {
+  const fields = [];
+  const isTypeCompatible = (type) => {
+    if (filterType === "any")
+      return true;
+    if (!type)
+      return false;
+    if (filterType === "number")
+      return type === "number" || type === "integer";
+    return type === filterType;
+  };
+  const collectPaths = (obj, source, path = "") => {
+    if (!obj || typeof obj !== "object")
+      return;
+    if (obj.type === "object" && obj.properties) {
+      for (const [propName, propSchema] of Object.entries(obj.properties)) {
+        const propPath = path ? `${path}.${propName}` : propName;
+        collectPaths(propSchema, source, propPath);
+      }
+      return;
+    }
+    if (obj.type === "array" && obj.items) {
+      const items = obj.items;
+      const arrayPath = path ? `${path}[*]` : "[*]";
+      if (items.type === "object" && items.properties) {
+        for (const [propName, propSchema] of Object.entries(items.properties)) {
+          const itemPath = `${arrayPath}.${propName}`;
+          collectPaths(propSchema, source, itemPath);
+        }
+      } else if (items.type && isTypeCompatible(items.type)) {
+        fields.push({
+          path: arrayPath,
+          source,
+          title: obj.title || obj.description,
+          type: items.type
+        });
+      }
+      return;
     }
-    const next = propsContainer[seg];
-    if (next === undefined) {
-      if (additionalProps === false) {
-        return { valid: false, missingSegment: seg, matchedDepth: i };
+    if (obj.type && isTypeCompatible(obj.type)) {
+      fields.push({
+        path,
+        source,
+        title: obj.title || obj.description,
+        type: obj.type
+      });
+    }
+  };
+  if (schema.inputSchema) {
+    if (schema.inputSchema.type === "object" && schema.inputSchema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.inputSchema.properties)) {
+        collectPaths(propSchema, "input", propName);
       }
-      return { valid: true };
     }
-    cursor = next;
-  }
-  return { valid: true };
-}
-function* iterateJsExpressionBodies(value, pathPrefix) {
-  const body = getJsExpressionBody(value);
-  if (body !== undefined) {
-    yield { body, path: pathPrefix };
-    return;
   }
-  if (isExpressionValue(value) || typeof value === "string")
-    return;
-  if (Array.isArray(value)) {
-    for (let i = 0;i < value.length; i++) {
-      yield* iterateJsExpressionBodies(value[i], `${pathPrefix}[${i}]`);
+  if (schema.outputSchema) {
+    if (schema.outputSchema.type === "object" && schema.outputSchema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.outputSchema.properties)) {
+        collectPaths(propSchema, "output", propName);
+      }
+    } else if (schema.outputSchema.type === "array" && schema.outputSchema.items) {
+      const items = schema.outputSchema.items;
+      if (items.type === "object" && items.properties) {
+        for (const [propName, propSchema] of Object.entries(items.properties)) {
+          collectPaths(propSchema, "output", `[*].${propName}`);
+        }
+      }
     }
+  }
+  return fields;
+}
+function getBuiltInToolSchema(nodeType2) {
+  return BUILT_IN_TOOL_SCHEMAS[nodeType2];
+}
+var FILE_SCHEMA_FIELDS = Object.keys(JobAttachmentSchema.properties ?? {});
+function isFileTypeString(type) {
+  return type === "file" || type === "octet-stream";
+}
+function isFileShapedSchema(schema) {
+  const properties = schema?.properties;
+  if (!properties)
+    return false;
+  const keys = Object.keys(properties);
+  return keys.length === FILE_SCHEMA_FIELDS.length && FILE_SCHEMA_FIELDS.every((field) => keys.includes(field));
+}
+function isFileSchemaNode(schema) {
+  if (!schema || typeof schema !== "object")
+    return false;
+  return isFileTypeString(schema.type) || isFileShapedSchema(schema);
+}
+function isFileTypedVariable(variable) {
+  if (!variable)
+    return false;
+  if (isFileTypeString(variable.type))
+    return true;
+  if (variable.type === "array" && isFileTypeString(variable.subType))
+    return true;
+  const schema = variable.schema;
+  return isFileShapedSchema(schema) || isFileSchemaNode(schema?.items);
+}
+function isFileShapedInputNode(node) {
+  if (!node || typeof node !== "object")
+    return false;
+  const n = node;
+  if (n["x-uipath-resource-kind"] === "JobAttachment")
+    return true;
+  if (typeof n.$ref === "string" && n.$ref.toLowerCase().includes("job-attachment"))
+    return true;
+  if (n.type === "file" || n.type === "octet-stream")
+    return true;
+  if (n.properties && FILE_SCHEMA_FIELDS.every((field) => (field in n.properties)))
+    return true;
+  return isFileShapedInputNode(n.items);
+}
+function schemaAcceptsFileInput(inputSchema) {
+  const properties = inputSchema?.properties;
+  if (!properties)
+    return false;
+  return Object.values(properties).some(isFileShapedInputNode);
+}
+var FILE_CAPABLE_BUILTIN_TOOL_TYPES = new Set(Object.entries(BUILT_IN_TOOL_SCHEMAS).filter(([, schemas5]) => schemaAcceptsFileInput(schemas5.inputSchema)).map(([nodeType2]) => nodeType2));
+function getNodeType5(node) {
+  return node.data?.type ?? node.type ?? "";
+}
+function getInputs(node) {
+  return node.data?.inputs;
+}
+function collectStrings2(value, out) {
+  if (typeof value === "string") {
+    out.push(value);
+  } else if (Array.isArray(value)) {
+    for (const v of value)
+      collectStrings2(v, out);
   } else if (value && typeof value === "object") {
-    for (const [k, v] of Object.entries(value)) {
-      yield* iterateJsExpressionBodies(v, pathPrefix ? `${pathPrefix}.${k}` : k);
+    for (const v of Object.values(value))
+      collectStrings2(v, out);
+  }
+}
+function extractVarsPaths(text) {
+  const paths = [];
+  const re = /\$vars\.([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)(?![\w$.[])/g;
+  let match;
+  while ((match = re.exec(text)) !== null)
+    paths.push(match[1]);
+  return paths;
+}
+function agentHasFileCapableTool(agent, nodes, edges, toolAcceptsFileFromManifest) {
+  const neighbourIds = collectNeighbourIds(agent.id, edges);
+  if (neighbourIds.size === 0)
+    return false;
+  return nodes.some((node) => {
+    if (!neighbourIds.has(node.id))
+      return false;
+    const nodeType2 = getNodeType5(node);
+    if (!isAgentResourceNodeType(nodeType2))
+      return false;
+    return FILE_CAPABLE_BUILTIN_TOOL_TYPES.has(nodeType2) || (toolAcceptsFileFromManifest?.(node) ?? false);
+  });
+}
+function collectNeighbourIds(nodeId, edges) {
+  const neighbourIds = /* @__PURE__ */ new Set;
+  for (const e of edges) {
+    if (e.source === nodeId && e.target)
+      neighbourIds.add(e.target);
+    else if (e.target === nodeId && e.source)
+      neighbourIds.add(e.source);
+  }
+  return neighbourIds;
+}
+function findUnhandledFilePromptVarPaths(agent, nodes, edges, resolveVariable, toolAcceptsFileFromManifest) {
+  const inputs = getInputs(agent);
+  const promptStrings = [];
+  collectStrings2(inputs?.systemPrompt, promptStrings);
+  collectStrings2(inputs?.userPrompt, promptStrings);
+  const filePaths = /* @__PURE__ */ new Set;
+  for (const text of promptStrings) {
+    for (const path of extractVarsPaths(text)) {
+      if (!filePaths.has(path) && isFileTypedVariable(resolveVariable(path)))
+        filePaths.add(path);
     }
   }
+  if (filePaths.size === 0)
+    return [];
+  if (agentHasFileCapableTool(agent, nodes, edges, toolAcceptsFileFromManifest))
+    return [];
+  return [...filePaths];
+}
+function getNodeType6(node) {
+  return node.data?.type ?? node.type ?? "";
+}
+function indexVariablesByPath(variables) {
+  const byPath = /* @__PURE__ */ new Map;
+  for (const g of variables.globals ?? []) {
+    byPath.set(g.triggerNodeId ? `${g.triggerNodeId}.output.${g.id}` : g.id, g);
+  }
+  for (const output of variables.nodeOutputs ?? []) {
+    byPath.set(output.path, output);
+  }
+  return byPath;
 }
-var expressionRefRule = {
-  id: "expression-ref",
-  severity: "error",
+var agentFileNotAnalyzedRule = {
+  id: "agent-file-not-analyzed",
+  severity: "warning",
   validate(ctx) {
+    if (!ctx.workflowVariables)
+      return [];
+    const variablesByPath = indexVariablesByPath(ctx.workflowVariables);
+    if (variablesByPath.size === 0)
+      return [];
+    const resolveVariable = (path) => variablesByPath.get(path);
+    const toolAcceptsFileFromManifest = (toolNode) => {
+      const type = toolNode.data?.type ?? toolNode.type;
+      if (!type)
+        return false;
+      const version26 = toolNode.data?.typeVersion ?? "1.0.0";
+      const manifest = ctx.manifests.get(`${type}:${version26}`);
+      return manifest ? schemaAcceptsFileInput(manifest.inputDefinition) : false;
+    };
     const errors5 = [];
-    const knownRoots = /* @__PURE__ */ new Set;
-    for (const id of ctx.workflowVariableIds ?? [])
-      knownRoots.add(id);
-    const nodeIds = /* @__PURE__ */ new Set;
-    const nodesById = /* @__PURE__ */ new Map;
-    for (const node of ctx.nodes) {
-      knownRoots.add(node.id);
-      nodeIds.add(node.id);
-      nodesById.set(node.id, node);
-    }
-    const hasWorkflowVarsContext = ctx.workflowVariableIds !== undefined;
-    if (knownRoots.size === 0)
-      return errors5;
-    for (const node of ctx.nodes) {
-      const inputs = node.data?.inputs;
-      if (inputs == null || typeof inputs !== "object")
-        continue;
-      const nodeLabel = getNodeLabel(node, getManifestForNode(node, ctx.manifests));
-      for (const { body, path: fieldPath } of iterateJsExpressionBodies(inputs, "inputs")) {
-        VARS_REF_REGEX2.lastIndex = 0;
-        const seenInThisExpr = /* @__PURE__ */ new Set;
-        let match;
-        while ((match = VARS_REF_REGEX2.exec(body)) !== null) {
-          const fullRef = match[1];
-          if (seenInThisExpr.has(fullRef))
-            continue;
-          seenInThisExpr.add(fullRef);
-          const segments = fullRef.split(".");
-          const rootSegment = segments[0];
-          if (!knownRoots.has(rootSegment)) {
-            if (!hasWorkflowVarsContext)
-              continue;
-            errors5.push({
-              code: "EXPR_UNRESOLVED_REF",
-              message: `Expression in "${nodeLabel}" references "$vars.${rootSegment}" but no workflow variable or node "${rootSegment}" exists. Add the variable/node to the flow or remove the reference.`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-            continue;
-          }
-          if (!nodeIds.has(rootSegment) || segments.length < 2)
-            continue;
-          const producerNode = nodesById.get(rootSegment);
-          if (!producerNode)
-            continue;
-          const producerManifest = getManifestForNode(producerNode, ctx.manifests);
-          const outputDef = producerManifest?.outputDefinition;
-          if (!outputDef || typeof outputDef !== "object")
-            continue;
-          const outputVarName = segments[1];
-          const outputSchema = outputDef[outputVarName];
-          if (outputSchema === undefined) {
-            const available = Object.keys(outputDef);
-            errors5.push({
-              code: "EXPR_INVALID_OUTPUT_PATH",
-              message: `Expression in "${nodeLabel}" references "$vars.${fullRef}" but node "${rootSegment}" has no output named "${outputVarName}". Available outputs: ${available.length > 0 ? available.join(", ") : "(none)"}.`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-            continue;
-          }
-          if (segments.length < 3)
-            continue;
-          const deepPath = segments.slice(2);
-          const result = pathExistsOnOutputSchema(outputSchema, deepPath);
-          if (!result.valid) {
-            const matchedSoFar = [outputVarName, ...deepPath.slice(0, result.matchedDepth ?? 0)].join(".");
-            errors5.push({
-              code: "EXPR_INVALID_OUTPUT_PATH",
-              message: `Expression in "${nodeLabel}" references "$vars.${fullRef}" but field "${result.missingSegment}" is not declared on node "${rootSegment}"'s output schema (matched up to "${matchedSoFar}").`,
-              severity: "error",
-              nodeId: node.id,
-              fieldPath,
-              layer: "field"
-            });
-          }
-        }
+    for (const agent of ctx.nodes.filter((n) => isAutonomousAgentNodeType(getNodeType6(n)))) {
+      for (const path of findUnhandledFilePromptVarPaths(agent, ctx.nodes, ctx.edges, resolveVariable, toolAcceptsFileFromManifest)) {
+        errors5.push({
+          code: "AGENT_FILE_NOT_ANALYZED",
+          ...localized("agentFileNotAnalyzed_unconsumedFileVar_message", { path }, 'Agent uses the file variable "$vars.{{path}}" in its prompt, but it has no tool that can read files, so the agent gets only the file reference and not its contents. Add a file-reading tool such as Analyze Files.'),
+          severity: "warning",
+          nodeId: agent.id,
+          layer: "field"
+        });
       }
     }
     return errors5;
@@ -48719,19 +49196,29 @@ var conversationalRequiredFieldsRule = {
       if (isVoiceAgentNodeType(node.type))
         continue;
       const settings = inputs.conversationalAgentSettings ?? {};
-      const isEmpty = readStringField(settings.conversationId).trim() === "";
-      if (!isEmpty)
-        continue;
       const manifest = getManifestForNode(node, ctx.manifests);
       const label = getNodeLabel(node, manifest);
-      errors5.push({
-        code: "CONVERSATIONAL_CONVERSATION_ID_REQUIRED",
-        message: `${label}: Conversation ID is required`,
-        severity: "error",
-        nodeId: node.id,
-        fieldPath: "inputs.conversationalAgentSettings.conversationId",
-        layer: "node"
-      });
+      if (settings.mode !== "custom" && readStringField(settings.context).trim() === "") {
+        errors5.push({
+          code: "CONVERSATIONAL_CONTEXT_REQUIRED",
+          ...localized("conversationalRequired_contextRequired_message", { label }, "{{label}}: Conversation context is required"),
+          severity: "error",
+          nodeId: node.id,
+          fieldPath: "inputs.conversationalAgentSettings.context",
+          layer: "node"
+        });
+        continue;
+      }
+      if (readStringField(settings.conversationId).trim() === "") {
+        errors5.push({
+          code: "CONVERSATIONAL_CONVERSATION_ID_REQUIRED",
+          ...localized("conversationalRequired_conversationIdRequired_message", { label }, "{{label}}: Conversation ID is required"),
+          severity: "error",
+          nodeId: node.id,
+          fieldPath: "inputs.conversationalAgentSettings.conversationId",
+          layer: "node"
+        });
+      }
     }
     return errors5;
   }
@@ -49045,14 +49532,220 @@ var scriptMustacheRule = {
     return errors5;
   }
 };
-function getNodeType5(node) {
+var MAX_PATH_SEGMENTS = 3;
+var RELATED_PRIMARY_KEY = "Id";
+function relatedPathsIn(config3) {
+  const seen = /* @__PURE__ */ new Set;
+  const rows = readEntityFilterRows(config3._filters);
+  const candidates = [...rows.map((f) => f.field), config3._sort?.field, ...config3._selectedFieldNames ?? []];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.includes("."))
+      seen.add(candidate);
+  }
+  return [...seen];
+}
+function relatedColumnMapIn(config3) {
+  const raw = config3._relatedFields;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const map3 = {};
+  for (const [entity, columns] of Object.entries(raw)) {
+    if (!Array.isArray(columns))
+      continue;
+    map3[entity] = columns.filter((c) => typeof c?.name === "string");
+  }
+  return map3;
+}
+function validateRelatedPaths(fields, relatedPaths, relatedFields) {
+  for (const path of relatedPaths) {
+    const segments = path.split(".");
+    if (segments.length > MAX_PATH_SEGMENTS)
+      return { problem: "unsupportedPathDepth", problemDetail: { path } };
+    if (segments.length < 2 || segments.some((segment) => segment === "")) {
+      return { problem: "unresolvedRelatedField", problemDetail: { path } };
+    }
+    if (QES_UNSAFE_CHAR.test(path))
+      return { problem: "uncarryablePath", problemDetail: { path } };
+    const relation = fields.find((f) => f.name === segments[0])?.referenceEntityName;
+    if (typeof relation !== "string" || relation === "") {
+      return { problem: "unresolvedRelatedField", problemDetail: { path } };
+    }
+    const columns = relatedFields?.[relation];
+    if (columns?.length && !columns.some((column) => column.name === segments[1])) {
+      return { problem: "unresolvedRelatedField", problemDetail: { path } };
+    }
+    if (segments.length === 3 && segments[2] !== RELATED_PRIMARY_KEY) {
+      return { problem: "unsupportedPathDepth", problemDetail: { path } };
+    }
+  }
+  return {};
+}
+var READ_ENTITY = "core.datafabric.read";
+var CREATE_ENTITY = "core.datafabric.create";
+var UPDATE_ENTITY = "core.datafabric.update";
+var RECORD_TARGET_NODES = /* @__PURE__ */ new Set([UPDATE_ENTITY, "core.datafabric.delete"]);
+var PROBLEM_CODES = {
+  uncarryable: "ENTITY_QUERY_EXPRESSION_UNCARRYABLE",
+  cleared: "ENTITY_QUERY_FILTER_EXPRESSION_EMPTY",
+  emptyList: "ENTITY_QUERY_FILTER_VALUE_LIST_EMPTY",
+  unresolvedRelation: "ENTITY_QUERY_UNRESOLVED_RELATION",
+  uncarryableRelationPath: "ENTITY_QUERY_UNCARRYABLE_RELATION_PATH",
+  unfilteredSingle: "ENTITY_QUERY_SINGLE_RECORD_UNFILTERED",
+  incompleteSingleRow: "ENTITY_QUERY_SINGLE_RECORD_ROW_INCOMPLETE",
+  requiredMissing: "ENTITY_WRITE_REQUIRED_FIELD_MISSING",
+  requiredBlanked: "ENTITY_WRITE_REQUIRED_FIELD_BLANKED"
+};
+function writeRows(value) {
+  return Array.isArray(value) ? value.filter((row) => !!row && typeof row === "object") : [];
+}
+function rowField(row) {
+  return typeof row.field === "string" ? row.field.trim() : "";
+}
+function requiredFieldProblem(nodeType2, entityConfig) {
+  if (nodeType2 === CREATE_ENTITY) {
+    const mandatory = mandatoryEntityWriteFields(entityConfig._entityFields);
+    if (mandatory.length === 0)
+      return;
+    const supplied = new Set(writeRows(entityConfig.fieldValues).filter((row) => entityWriteRowHasValue(row.value)).map(rowField));
+    const fields2 = mandatory.filter((name) => !supplied.has(name));
+    return fields2.length > 0 ? { problem: "requiredMissing", fields: fields2 } : undefined;
+  }
+  const nonNullable = new Set(nonNullableEntityWriteFields(entityConfig._entityFields));
+  if (nonNullable.size === 0)
+    return;
+  const fields = [
+    ...new Set(writeRows(entityConfig.fieldUpdates).filter((row) => nonNullable.has(rowField(row)) && !entityWriteRowHasValue(row.value)).map(rowField))
+  ];
+  return fields.length > 0 ? { problem: "requiredBlanked", fields } : undefined;
+}
+function relationProblem(entityConfig) {
+  const paths = relatedPathsIn(entityConfig);
+  if (paths.length === 0)
+    return;
+  const rawFields = entityConfig._entityFields;
+  const fields = Array.isArray(rawFields) ? rawFields.filter((f) => typeof f?.name === "string") : [];
+  const { problem, problemDetail } = validateRelatedPaths(fields, paths, relatedColumnMapIn(entityConfig));
+  if (!problem)
+    return;
+  return {
+    problem: problem === "uncarryablePath" ? "uncarryableRelationPath" : "unresolvedRelation",
+    path: problemDetail?.path
+  };
+}
+var SELF_REFERENCE = /(^|[^\w$])\$self\b/;
+function isSelfReferential(value) {
+  const body = getJsExpressionBody(value);
+  return body !== undefined && SELF_REFERENCE.test(body);
+}
+function isUnqueryable(value) {
+  return isQesUncarryableValue(value) || isSelfReferential(value);
+}
+function isFilterExpressionCleared(f) {
+  const body = getJsExpressionBody(f.value);
+  return body !== undefined && body.trim() === "";
+}
+function problemMessage(problem, relationPath, fields) {
+  switch (problem) {
+    case "unresolvedRelation":
+      return localized("entityQuery_unresolvedRelation_message", { path: relationPath ?? "" }, "{{path}} is no longer available. Pick a field on this entity or one of its direct relations.");
+    case "uncarryableRelationPath":
+      return localized("entityQuery_uncarryableRelationPath_message", { path: relationPath ?? "" }, "{{path}} cannot be used as written. Remove any spaces, quotes or backslashes from the column name.");
+    case "cleared":
+      return localized("entityQuery_emptyFilterExpression_message", {}, "Write an expression for every filter, or remove the filter");
+    case "emptyList":
+      return localized("entityQuery_emptyFilterValueList_message", {}, "Add at least one value to the filter, or remove the filter");
+    case "unfilteredSingle":
+      return localized("entityQuery_unfilteredSingleRecord_message", {}, "Add a condition, or read multiple records instead");
+    case "incompleteSingleRow":
+      return localized("entityQuery_incompleteSingleRecordRow_message", {}, "Select a field and enter a value");
+    case "uncarryable":
+      return localized("entityQuery_uncarryableExpression_message", {}, "Store this expression in a variable, or write it without spaces, quotes, or backslashes");
+    case "requiredMissing":
+      return localized("entityWrite_requiredFieldMissing_message", { fields: fields ?? "" }, "Set a value for {{fields}}");
+    case "requiredBlanked":
+      return localized("entityWrite_requiredFieldBlanked_message", { fields: fields ?? "" }, "Set a value for {{fields}}, or remove them from the update");
+  }
+}
+var entityQueryExpressionRule = {
+  id: "entity-query-expression",
+  severity: "error",
+  validate(ctx) {
+    const errors5 = [];
+    for (const node of ctx.nodes) {
+      const entityConfig = node.data.inputs?.entityConfig ?? {};
+      let problem;
+      let relationPath;
+      if (node.type === READ_ENTITY) {
+        const filters = readEntityFilterRows(entityConfig._filters);
+        const multiRecord = resolveReadResultMode(entityConfig) === "multiple";
+        const compiles = (f) => Boolean(f?.field) && (!isValueListFilterOperator(f.operator) || multiRecord);
+        if (filters.some((f) => compiles(f) && isUnqueryable(f.value)))
+          problem = "uncarryable";
+        else if (multiRecord && (isUnqueryable(entityConfig._recordLimit) || isUnqueryable(entityConfig._skip)))
+          problem = "uncarryable";
+        else if (filters.some((f) => compiles(f) && isFilterExpressionCleared(f)))
+          problem = "cleared";
+        else if (filters.some((f) => readEntityFilterValueListIsEmpty(f, multiRecord)))
+          problem = "emptyList";
+        else {
+          const relation = relationProblem(entityConfig);
+          if (relation) {
+            problem = relation.problem;
+            relationPath = relation.path;
+          } else if (!multiRecord && readStringField(entityConfig.entityName).trim() !== "" && !filters.some((f) => readEntityFilterRowYieldsPredicate(f, false))) {
+            problem = filters.length === 0 ? "unfilteredSingle" : "incompleteSingleRow";
+          }
+        }
+      } else if (RECORD_TARGET_NODES.has(node.type)) {
+        if (isRecordTargetedById(entityConfig) && isUnqueryable(entityConfig.recordId))
+          problem = "uncarryable";
+      }
+      if (problem) {
+        errors5.push({
+          code: PROBLEM_CODES[problem],
+          ...problemMessage(problem, relationPath),
+          severity: "error",
+          nodeId: node.id,
+          fieldPath: "inputs.entityConfig",
+          layer: "field"
+        });
+      }
+      if (node.type !== CREATE_ENTITY && node.type !== UPDATE_ENTITY)
+        continue;
+      if (readStringField(entityConfig.entityName).trim() === "")
+        continue;
+      const required3 = requiredFieldProblem(node.type, entityConfig);
+      if (!required3)
+        continue;
+      errors5.push({
+        code: PROBLEM_CODES[required3.problem],
+        ...problemMessage(required3.problem, undefined, required3.fields.join(", ")),
+        severity: "error",
+        nodeId: node.id,
+        fieldPath: "inputs.entityConfig",
+        layer: "field"
+      });
+    }
+    return errors5;
+  }
+};
+function isRecordTargetedById(entityConfig) {
+  if (entityConfig.recordSource === "byId")
+    return true;
+  if (entityConfig.recordSource === "fromRead" || entityConfig.readEntityNodeId)
+    return false;
+  const recordId = entityConfig.recordId;
+  const text = isExpressionValue(recordId) ? recordId.expression : typeof recordId === "string" ? recordId : "";
+  return text.trim() !== "";
+}
+function getNodeType7(node) {
   return node.data?.type ?? node.type ?? "";
 }
 var singleConversationTriggerRule = {
   id: "single-conversation-trigger",
   severity: "error",
   validate(ctx) {
-    const triggers = ctx.nodes.filter((n) => getNodeType5(n) === "core.trigger.conversation");
+    const triggers = ctx.nodes.filter((n) => getNodeType7(n) === "core.trigger.conversation");
     if (triggers.length <= 1)
       return [];
     return triggers.map((node) => ({
@@ -49109,6 +49802,7 @@ var generalRules = [
   agentInputRefsRule,
   agentDuplicateToolNamesRule,
   agentEmptyVarRule,
+  agentFileNotAnalyzedRule,
   conversationalRequiredFieldsRule,
   conversationalVoiceCallContextRule,
   conversationalVoiceEndCallContextRule,
@@ -49118,10 +49812,11 @@ var generalRules = [
   hitlDocValidationRule,
   ixpSchemaDraftRule,
   scriptMustacheRule,
+  entityQueryExpressionRule,
   singleConversationTriggerRule,
   doWhileLimitRule
 ];
-var cliRules = [...generalRules, expressionRefRule];
+var cliRules = generalRules;
 function runRules(rules, ctx) {
   const errors5 = [];
   for (const rule of rules) {
@@ -49150,95 +49845,6 @@ function toSerializedNodes(nodes, extraData) {
   return nodes.map((node) => toSerializedNode(node, extraData?.(node)));
 }
 
-// ../../node_modules/@uipath/flow-schema/dist/chunk-XPPKWK2Y.js
-var RESERVED_WORDS = [
-  "break",
-  "case",
-  "catch",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "in",
-  "instanceof",
-  "new",
-  "return",
-  "switch",
-  "this",
-  "throw",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "class",
-  "const",
-  "enum",
-  "export",
-  "extends",
-  "import",
-  "super",
-  "implements",
-  "interface",
-  "let",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "static",
-  "yield"
-];
-var VALID_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-var FLAT_SEP = "__";
-function generateRandomId(length) {
-  const chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0;i < length; i++) {
-    result += chars2.charAt(Math.floor(Math.random() * chars2.length));
-  }
-  return result;
-}
-function generateNextId(prefix, count = 6) {
-  return `${prefix}${generateRandomId(count)}`;
-}
-function isPlainObject3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function deepEqual(a, b) {
-  if (a === b)
-    return true;
-  if (a === null || b === null)
-    return a === b;
-  if (a === undefined || b === undefined)
-    return a === b;
-  if (typeof a !== typeof b)
-    return false;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b) || a.length !== b.length)
-      return false;
-    return a.every((val, i) => deepEqual(val, b[i]));
-  }
-  if (typeof a === "object") {
-    if (Array.isArray(b))
-      return false;
-    const objA = a;
-    const objB = b;
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-    if (keysA.length !== keysB.length)
-      return false;
-    return keysA.every((key) => (key in objB) && deepEqual(objA[key], objB[key]));
-  }
-  return false;
-}
-
 // ../../node_modules/@uipath/flow-schema/dist/index.js
 var import_object = __toESM(require_index_cjs(), 1);
 var workflowRuntimeSchema = exports_external.enum(["maestro", "api-function"]);
@@ -49562,6 +50168,7 @@ var nodeSchema2 = nodeSchema.extend({
   typeVersion: exports_external.string().regex(/^\d+\.\d+(\.\d+)?$/, 'Version must be in format "x.y" or "x.y.z"')
 });
 var nodeManifestSchema2 = exports_external.lazy(() => nodeManifestSchema.extend({
+  display: nodeDisplayManifestSchema.extend({ isPreview: exports_external.boolean().optional() }),
   projectId: exports_external.string().optional(),
   entryPointPath: exports_external.string().optional(),
   unsupportedRuntime: exports_external.boolean().optional(),
@@ -49791,7 +50398,6 @@ function constraintWithAddNodePanel(constraint) {
 jsep.plugins.register(import_object.default);
 var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var SAFE_CALLBACK = /* @__PURE__ */ Symbol("safeExpressionCallback");
-var DANGEROUS_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var SAFE_GLOBALS = { Array, Boolean, JSON, Math, Number, Object, String };
 var SAFE_MATH_METHODS = {
   abs: Math.abs,
@@ -49964,7 +50570,7 @@ function getMemberKey(node, context) {
   return node.property.name;
 }
 function isSafePropertyKey(key) {
-  return !DANGEROUS_PROPERTY_NAMES.has(key);
+  return !isUnsafeKey(key);
 }
 function getObjectPropertyKey(prop, context) {
   if (prop.computed)
@@ -50133,7 +50739,7 @@ function createSafeCallback(params, body, context) {
 }
 function parseArrowParams(params) {
   const names = params.split(",").map((param) => param.trim()).filter(Boolean);
-  if (names.some((name) => !IDENTIFIER_RE.test(name) || DANGEROUS_PROPERTY_NAMES.has(name)))
+  if (names.some((name) => !IDENTIFIER_RE.test(name) || isUnsafeKey(name)))
     throw new Error("Unsupported arrow callback params");
   return names;
 }
@@ -50992,7 +51598,7 @@ var ProjectType = {
   ProcessOrchestration: "processorchestration"
 };
 var AGENT_TARGET_RUNTIME = "pythonAgent";
-var solutionSupportedResources = ["process", "queue", "app", "ixpDeployment"];
+var solutionSupportedResources = ["process", "queue", "app", "ixpDeployment", "idpProcessor"];
 var RESOURCE_CONFIG = {
   process: {
     nameField: "name",
@@ -51052,6 +51658,74 @@ var mapTypeToJsonSchema = (type) => {
 var isValidDefaultValueForVariable = (value) => {
   return value !== undefined && value !== "";
 };
+var JOB_ATTACHMENT_DEFINITION_KEY = "job-attachment";
+var JOB_ATTACHMENT_REF = `#/definitions/${JOB_ATTACHMENT_DEFINITION_KEY}`;
+var isJobAttachmentRef = (node) => {
+  const ref = node?.$ref;
+  return typeof ref === "string" && ref.endsWith(`/${JOB_ATTACHMENT_DEFINITION_KEY}`);
+};
+var convertFileTypesToRefs = (schema) => {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return { schema, hasFile: false };
+  const node = schema;
+  if (node.type === "file") {
+    const { type: _type, ...rest } = node;
+    return { schema: { ...rest, $ref: JOB_ATTACHMENT_REF }, hasFile: true };
+  }
+  let hasFile = false;
+  const out = { ...node };
+  for (const key of ["items", "additionalProperties"]) {
+    const child = node[key];
+    if (child && typeof child === "object" && !Array.isArray(child)) {
+      const converted = convertFileTypesToRefs(child);
+      out[key] = converted.schema;
+      if (converted.hasFile)
+        hasFile = true;
+    }
+  }
+  if (node.properties && typeof node.properties === "object" && !Array.isArray(node.properties)) {
+    const props = {};
+    for (const [propKey, propSchema] of Object.entries(node.properties)) {
+      const converted = convertFileTypesToRefs(propSchema);
+      props[propKey] = converted.schema;
+      if (converted.hasFile)
+        hasFile = true;
+    }
+    out.properties = props;
+  }
+  return { schema: out, hasFile };
+};
+var convertJobAttachmentRefsToFileTypes = (schema) => {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return schema;
+  const node = schema;
+  if (isJobAttachmentRef(node)) {
+    const { $ref: _ref, ...rest } = node;
+    return { ...rest, type: "file" };
+  }
+  const out = { ...node };
+  for (const key of ["items", "additionalProperties"]) {
+    const child = node[key];
+    if (child && typeof child === "object" && !Array.isArray(child))
+      out[key] = convertJobAttachmentRefsToFileTypes(child);
+  }
+  if (node.properties && typeof node.properties === "object" && !Array.isArray(node.properties)) {
+    const props = {};
+    for (const [propKey, propSchema] of Object.entries(node.properties)) {
+      props[propKey] = convertJobAttachmentRefsToFileTypes(propSchema);
+    }
+    out.properties = props;
+  }
+  return out;
+};
+var variableHasFileType = (variable) => {
+  if (variable.type === "file")
+    return true;
+  if ((variable.type === "array" || variable.type === "object") && variable.schema) {
+    return convertFileTypesToRefs(variable.schema).hasFile;
+  }
+  return false;
+};
 var variableToJsonSchema = (variable) => {
   if (variable.type === "jsonSchema") {
     const body = variable.body ?? variable.schema;
@@ -51063,7 +51737,7 @@ var variableToJsonSchema = (variable) => {
     return { type: "object" };
   }
   if (variable.type === "file") {
-    return { $ref: "#/definitions/job-attachment" };
+    return { $ref: JOB_ATTACHMENT_REF };
   }
   const defaults = {
     ...isValidDefaultValueForVariable(variable.defaultValue) ? { default: variable.defaultValue } : {},
@@ -51071,7 +51745,7 @@ var variableToJsonSchema = (variable) => {
   };
   if ((variable.type === "array" || variable.type === "object") && variable.schema) {
     const { $schema: _$schema, ...rest } = variable.schema;
-    return { ...rest, title: variable.id, ...defaults };
+    return convertFileTypesToRefs({ ...rest, title: variable.id, ...defaults }).schema;
   }
   const { type, format } = mapTypeToJsonSchema(variable.type);
   return {
@@ -51153,6 +51827,12 @@ var inputsMatchBinding = (node, binding) => {
   const detail = node.inputs?.detail;
   return detail?.connectionResourceId === binding.resourceKey;
 };
+var idpProcessorMatchesBinding = (node, binding) => {
+  if (binding.resource !== "idpProcessor")
+    return false;
+  const processorKey = node.inputs?.processorKey;
+  return typeof processorKey === "string" && processorKey !== "" && processorKey === binding.resourceKey;
+};
 var entityConfigMatchesBinding = (node, binding) => {
   if (binding.resource !== "Entity")
     return false;
@@ -51160,6 +51840,11 @@ var entityConfigMatchesBinding = (node, binding) => {
   const scopeKey = entityConfig?._resourceKey || entityConfig?._entityKey;
   return typeof scopeKey === "string" && scopeKey !== "" && scopeKey === binding.resourceKey;
 };
+var entityNodeIsTenantScoped = (node) => {
+  const entityConfig = node.inputs?.entityConfig;
+  const folderKey = entityConfig?._folderKey;
+  return typeof folderKey !== "string" || folderKey === "";
+};
 var getConnectionMetadata = (manifestModel, node) => {
   const connectorKey = manifestModel?.context?.find((ctx) => ctx.name === "connectorKey")?.value;
   const detail = node?.inputs?.detail;
@@ -51172,7 +51857,9 @@ var getConnectionMetadata = (manifestModel, node) => {
 var getBindingResources = (nodes, bindings, definitions = [], subflows, options = {}) => {
   const bindingResources = [];
   for (const binding of bindings) {
-    const node = nodes.find((n) => modelMatchesBinding(getManifestModel(n, definitions), binding) || inputsMatchBinding(n, binding) || entityConfigMatchesBinding(n, binding));
+    if (binding.resource === "index")
+      continue;
+    const node = nodes.find((n) => modelMatchesBinding(getManifestModel(n, definitions), binding) || inputsMatchBinding(n, binding) || entityConfigMatchesBinding(n, binding) || idpProcessorMatchesBinding(n, binding));
     let subflowNode;
     if (!node && subflows) {
       for (const entry of Object.values(subflows)) {
@@ -51186,6 +51873,9 @@ var getBindingResources = (nodes, bindings, definitions = [], subflows, options
     if (!node && !subflowNode || skippablePropertyAttributes.includes(binding.propertyAttribute?.toLowerCase() || "")) {
       continue;
     }
+    if (binding.resource === "Entity" && node && entityNodeIsTenantScoped(node)) {
+      continue;
+    }
     const resourceConfig = RESOURCE_CONFIG[binding.resource];
     const resource = resourceConfig?.resource || binding.resource;
     const subType = resourceConfig?.subType || binding.resourceSubType;
@@ -51479,6 +52169,7 @@ var JOB_ATTACHMENTS_DEFINITION = {
     "x-uipath-resource-kind": "JobAttachment"
   }
 };
+var isTriggerScopedInput = (global, triggerNodeId) => global.direction === "in" && global.triggerNodeId === triggerNodeId;
 var getEffectiveTriggerInputs = (startNode, definitions, globals) => {
   const def = findNodeManifest(startNode, definitions);
   const schemaProps = def?.outputDefinition?.output?.schema?.properties;
@@ -51490,38 +52181,34 @@ var getEffectiveTriggerInputs = (startNode, definitions, globals) => {
       triggerNodeId: startNode.id
     }));
   }
-  return (globals ?? []).filter((g) => g.direction === "in" && g.triggerNodeId === startNode.id);
+  return (globals ?? []).filter((g) => isTriggerScopedInput(g, startNode.id));
 };
-var buildInputSchema = (variables, startNode, definitions) => {
-  const inputVars = getEffectiveTriggerInputs(startNode, definitions, variables.globals);
-  let hasFileType = false;
+var buildSchemaProperties = (variables) => {
   const properties = {};
-  for (const variable of inputVars) {
-    if (variable.type === "file") {
+  let hasFileType = false;
+  for (const variable of variables) {
+    if (variableHasFileType(variable))
       hasFileType = true;
-    }
     properties[variable.id] = variableToJsonSchema(variable);
   }
+  return { properties, ...hasFileType ? { definitions: JOB_ATTACHMENTS_DEFINITION } : {} };
+};
+var buildInputSchema = (variables, startNode, definitions) => {
+  const inputVars = getEffectiveTriggerInputs(startNode, definitions, variables.globals);
+  const { properties, definitions: fileDefinitions } = buildSchemaProperties(inputVars);
   return {
     type: "object",
     properties,
-    ...hasFileType && { definitions: JOB_ATTACHMENTS_DEFINITION }
+    ...fileDefinitions && { definitions: fileDefinitions }
   };
 };
 var buildOutputSchema = (variables) => {
   const outputVars = (variables.globals || []).filter((v) => v.direction === "out");
-  let hasFileType = false;
-  const properties = {};
-  for (const variable of outputVars) {
-    if (variable.type === "file") {
-      hasFileType = true;
-    }
-    properties[variable.id] = variableToJsonSchema(variable);
-  }
+  const { properties, definitions } = buildSchemaProperties(outputVars);
   return {
     type: "object",
     properties,
-    ...hasFileType && { definitions: JOB_ATTACHMENTS_DEFINITION }
+    ...definitions && { definitions }
   };
 };
 var getEntryPoints = (bpmnFileName, nodes, variables, definitions, projectType = ProjectType.ProcessOrchestration) => {
@@ -51624,9 +52311,10 @@ function assertNoFormTriggerConflict(existing, incoming) {
 var sanitizeFileName = (name) => {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 };
+var toBpmnFileName = (flowFileName) => flowFileName.replace(/\.flow$/, ".bpmn");
 async function generateWorkflowPackaging(options) {
   const { fileName, nodes, bindings, definitions, subflows, includeFormTriggers = false, toBpmn } = options;
-  const bpmnFileName = fileName.replace(/\.flow$/, ".bpmn");
+  const bpmnFileName = toBpmnFileName(fileName);
   const bpmnXml = await toBpmn();
   const bindingResources = getBindingResources(nodes, bindings, definitions, subflows, { includeFormTriggers });
   return { bpmnXml, bpmnFileName, bindingResources };
@@ -51886,7 +52574,7 @@ function matchContextBindings(name, bindings, nodeResourceKey, nodeBindingResour
   return hasScope ? candidates.filter((b) => b.name === name && b.resourceKey === nodeResourceKey) : candidates.filter((b) => b.name === name);
 }
 var CONVERSATIONAL_AGENT_SETTINGS = {
-  model: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  model: "anthropic.claude-sonnet-5",
   maxTokens: 8192,
   maxIterations: 8,
   temperature: 0,
@@ -51930,245 +52618,6 @@ var DEFAULT_CONVERSATIONAL_VOICE_SETTINGS = {
   persona: DEFAULT_CONVERSATIONAL_VOICE_MODEL_ENTRY.personas[0],
   agentSpeaksFirst: DEFAULT_VOICE_AGENT_SPEAKS_FIRST
 };
-var JobAttachmentSchema = {
-  type: "object",
-  "x-uipath-resource-kind": "JobAttachment",
-  properties: {
-    ID: {
-      type: "string",
-      description: "Orchestrator attachment key"
-    },
-    FullName: {
-      type: "string",
-      description: "File name"
-    },
-    MimeType: {
-      type: "string",
-      description: 'The MIME type of the content, such as "application/json" or "image/png"'
-    },
-    Metadata: {
-      type: "object",
-      description: "Dictionary of metadata",
-      additionalProperties: {
-        type: "string"
-      }
-    }
-  },
-  required: ["ID"]
-};
-var ANALYZE_FILES_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachments: {
-        type: "array",
-        items: JobAttachmentSchema,
-        description: "Array of files, documents, images, or other attachments to process"
-      },
-      analysisTask: {
-        type: "string",
-        description: "The task, question, or instruction for processing the files (e.g., 'summarize this document', 'extract key points', 'what is in this image')"
-      }
-    },
-    required: ["attachments", "analysisTask"]
-  },
-  outputSchema: {
-    type: "object",
-    properties: {
-      analysis: {
-        type: "string",
-        description: "Analysis result of the attachments (analysis, summary, extracted information, etc.)"
-      }
-    },
-    required: ["analysis"]
-  }
-};
-var SUMMARIZE_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachment: {
-        type: "object",
-        title: "Source",
-        description: "File or document to summarize",
-        properties: JobAttachmentSchema.properties,
-        required: JobAttachmentSchema.required
-      }
-    },
-    required: ["attachment"]
-  },
-  outputSchema: {
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The content of the analyzed attachment"
-        }
-      }
-    }
-  }
-};
-var BATCH_TRANSFORM_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      attachment: {
-        type: "object",
-        title: "Source",
-        description: "CSV file to transform",
-        properties: JobAttachmentSchema.properties,
-        required: JobAttachmentSchema.required
-      }
-    },
-    required: ["attachment"]
-  },
-  outputSchema: {
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The content of the transformed row"
-        }
-      }
-    }
-  }
-};
-var nameValuePairSchema = (nameDescription, valueDescription) => ({
-  type: "object",
-  properties: {
-    name: {
-      type: "string",
-      description: nameDescription
-    },
-    value: {
-      type: "string",
-      description: valueDescription
-    }
-  },
-  required: ["name", "value"]
-});
-var HTTP_REQUEST_SCHEMA = {
-  inputSchema: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description: "The absolute URL to send the request to."
-      },
-      method: {
-        type: "string",
-        description: "HTTP method to use, one of: GET, POST, PUT, PATCH, DELETE."
-      },
-      headers: {
-        type: "array",
-        description: "Request headers as a list of name/value pairs.",
-        items: nameValuePairSchema("Header name.", "Header value.")
-      },
-      params: {
-        type: "array",
-        description: "Query-string parameters as a list of name/value pairs.",
-        items: nameValuePairSchema("Parameter name.", "Parameter value.")
-      },
-      body: {
-        type: "string",
-        description: "Request body sent as-is. Provide JSON as a string and set a Content-Type header if the endpoint expects JSON."
-      },
-      timeout: {
-        type: "number",
-        description: "Request timeout in seconds."
-      }
-    },
-    required: ["url"]
-  },
-  outputSchema: {
-    type: "object",
-    properties: {}
-  }
-};
-var BUILT_IN_TOOL_SCHEMAS = {
-  "uipath.agent.resource.tool.builtin.analyzefiles": ANALYZE_FILES_SCHEMA,
-  "uipath.agent.resource.tool.builtin.summarize": SUMMARIZE_SCHEMA,
-  "uipath.agent.resource.tool.builtin.batchtransform": BATCH_TRANSFORM_SCHEMA,
-  "uipath.agent.resource.tool.builtin.httprequest": HTTP_REQUEST_SCHEMA
-};
-function getToolFields(schema, filterType = "any") {
-  const fields = [];
-  const isTypeCompatible = (type) => {
-    if (filterType === "any")
-      return true;
-    if (!type)
-      return false;
-    if (filterType === "number")
-      return type === "number" || type === "integer";
-    return type === filterType;
-  };
-  const collectPaths = (obj, source, path = "") => {
-    if (!obj || typeof obj !== "object")
-      return;
-    if (obj.type === "object" && obj.properties) {
-      for (const [propName, propSchema] of Object.entries(obj.properties)) {
-        const propPath = path ? `${path}.${propName}` : propName;
-        collectPaths(propSchema, source, propPath);
-      }
-      return;
-    }
-    if (obj.type === "array" && obj.items) {
-      const items = obj.items;
-      const arrayPath = path ? `${path}[*]` : "[*]";
-      if (items.type === "object" && items.properties) {
-        for (const [propName, propSchema] of Object.entries(items.properties)) {
-          const itemPath = `${arrayPath}.${propName}`;
-          collectPaths(propSchema, source, itemPath);
-        }
-      } else if (items.type && isTypeCompatible(items.type)) {
-        fields.push({
-          path: arrayPath,
-          source,
-          title: obj.title || obj.description,
-          type: items.type
-        });
-      }
-      return;
-    }
-    if (obj.type && isTypeCompatible(obj.type)) {
-      fields.push({
-        path,
-        source,
-        title: obj.title || obj.description,
-        type: obj.type
-      });
-    }
-  };
-  if (schema.inputSchema) {
-    if (schema.inputSchema.type === "object" && schema.inputSchema.properties) {
-      for (const [propName, propSchema] of Object.entries(schema.inputSchema.properties)) {
-        collectPaths(propSchema, "input", propName);
-      }
-    }
-  }
-  if (schema.outputSchema) {
-    if (schema.outputSchema.type === "object" && schema.outputSchema.properties) {
-      for (const [propName, propSchema] of Object.entries(schema.outputSchema.properties)) {
-        collectPaths(propSchema, "output", propName);
-      }
-    } else if (schema.outputSchema.type === "array" && schema.outputSchema.items) {
-      const items = schema.outputSchema.items;
-      if (items.type === "object" && items.properties) {
-        for (const [propName, propSchema] of Object.entries(items.properties)) {
-          collectPaths(propSchema, "output", `[*].${propName}`);
-        }
-      }
-    }
-  }
-  return fields;
-}
-function getBuiltInToolSchema(nodeType2) {
-  return BUILT_IN_TOOL_SCHEMAS[nodeType2];
-}
 var DOTNET_STRING_TYPES = /* @__PURE__ */ new Set(["System.String", "System.Char", "System.Guid", "System.Uri", "System.TimeSpan"]);
 var DOTNET_DATE_TYPES = /* @__PURE__ */ new Set(["System.DateTime", "System.DateOnly", "System.DateTimeOffset"]);
 var DOTNET_INTEGER_TYPES = /* @__PURE__ */ new Set([
@@ -52414,6 +52863,6 @@ async function executeWritePlan(plan, callbacks) {
     inlinedRefs: plan.inlinedRefs
   };
 }
-export { exports_external, instance, migrations, currentStorageSchema, currentAgentStorageSchema, currentResourceStorageSchema, currentFeatureStorageSchema, currentFlowLayoutStorageSchema, applyMigrations, getLatestVersion, isBlockingSeverity, shouldBlockAction, agentEnforcementsSchema, JS_EXPRESSION_PREFIX, expressionFieldTypeSchema, expressionModeSchema, expressionValueSchema, expressionLikeSchema, isExpressionValue, isEmptyExpressionValue, encodeLiteral, decodeLiteral, coerceToExpressionValue, getJsExpressionBody, expectedTypeToFieldType, coerceInputsViaSchema, isExpression, decodeLiteralForValidation, decodeLiteralsForValidation, isJsonSchema, normalizeInputDefinition, resolveNestedFieldSchema, getFieldValidator, getNodeValidator, schemaErrorsToValidationErrors, clearValidatorCache, getManifestForNode, getNodeLabel, resolveTemplate, isTriggerNodeType, isEndNodeType, LOOP_NODE_TYPE, DOWHILE_NODE_TYPE, isLoopNodeType, isCollectionLoopNodeType, isDoWhileNodeType, DOWHILE_MAX_LIMIT, DOWHILE_MIN_LIMIT, parseDoWhileLimit, resolveDoWhileLimit, DECISION_NODE_TYPE, SWITCH_NODE_TYPE, MERGE_NODE_TYPE, MOCK_NODE_TYPE, SYNTHETIC_GATEWAY_OUTPUT_KEYS, isGatewayNodeType, supportsVariableUpdates, SUBFLOW_NODE_TYPE, isSubflowNodeType, AUTONOMOUS_AGENT_NODE_TYPE, CONVERSATIONAL_AGENT_NODE_TYPE, VOICE_AGENT_NODE_TYPE, CONVERSATIONAL_AGENT_ICON, AGENT_NODE_TYPES, isConversationalOrVoiceAgentNodeType, isVoiceAgentNodeType, isAutonomousAgentNodeType, isAgentNodeType, isPublishedAgentNodeType, isAgentToolNodeType, AGENT_RESOURCE_PREFIX, isAgentResourceNodeType, CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE, CONVERSATION_TRIGGER_NODE_TYPE, isConversationalRuntimeNodeType, isCallContextEmpty, schemaValidationRule, minConnectionsRule, triggerRequiredRule, dataTransformRule, outputMappingRule, ESCALATION_QUICK_FORM_NODE_TYPE, ESCALATION_TASK_TYPE, ESCALATION_TYPE_CODE, resolveEscalationTaskType, AGENT_RESOURCE_SOURCE_HANDLES, isToolNode, isContextNode, isEscalationNode, isQuickFormEscalationNode, isMcpNode, isA2aNode, isMemoryNode, isAgentResourceNode, DEFAULT_STORAGE_VERSION, getDefaultAgentContent, RecipientType, BYO_VALIDATOR_TYPE, temperatureExceededMessage, maxTokensExceededMessage, maxIterationsExceededMessage, modelNotAvailableMessage, governanceRule, DEFAULT_TRIGGER_OUTCOME, withDefaultTriggerOutcome, normalizeFormTriggerSchema, getHitlFieldChannelKey, isHitlInputDirectionField, isHitlOutputDirectionField, findDuplicateHitlChannelKeys, isAutoDerivedFieldBinding, stripAutoDerivedFieldBindings, conditionExpressionRule, agentDuplicateToolNamesRule, HITL_NODE_TYPE, HITL_QUICK_FORM_NODE_TYPE, HITL_CODED_ACTION_NODE_TYPE, HITL_DOC_VALIDATION_NODE_TYPE, DYNAMIC_EXTRACT_NODE_TYPE, FORM_TRIGGER_NODE_TYPE, HITL_NODE_TYPES, isHitlNodeType, isHumanActionNodeType, collectWrittenGlobalIds, agentEmptyVarRule, IXP_SCHEMA_EDITOR_DRAFT_EXTENSION, IXP_SCHEMA_EDITOR_ISSUES_EXTENSION, IXP_SCHEMA_INVALID_ERROR_CODE, readIxpSchemaEditorDraft, stripIxpSchemaEditorDraft, attachIxpSchemaEditorDraft, ixpSchemaDraftRule, generalRules, cliRules, runRules, toSerializedNode, toSerializedNodes, RESERVED_WORDS, VALID_IDENTIFIER_PATTERN, FLAT_SEP, generateRandomId, generateNextId, isPlainObject3 as isPlainObject, deepEqual, workflowRuntimeSchema, DEFAULT_WORKFLOW_RUNTIME, argumentBindingSchema, workflowVariableSchema, variableUpdateSchema, nodeVariableSchema, workflowVariablesSchema, EMPTY_VARIABLES, workflowConnectionSchema, nodeLayoutSchema, waypointSchema, edgeLayoutSchema, layoutSchema, bindingSchema, nodeManifestSchema, idSchema, edgeSchema2, nodeSchema2, nodeManifestSchema2, categoryManifestSchema2, versionSchema2, subflowEntrySchema, workflowSchema, workflowSchemaV1_0_0, workflowSchemaV1_0, workflowSchemaV1_1, workflowSchemaV1_2, workflowSchemaV1_3, workflowSchemaV1_4, workflowSchemaV1_5, workflowSchemaV1_6, workflowSchemaV1_7, workflowSchemaV1_8, workflowSchemaV1_9, workflowSchemaV1_10, WORKFLOW_VERSIONS, CURRENT_WORKFLOW_VERSION, MINIMUM_SUPPORTED_SCHEMA_VERSION, workflowFileSchema, subflowFileSchema5, workflowManifestSchema, manifestResponseSchema, handleTargetSchema2, addNodePanelSearchScopeSchema, addNodePanelCreateActionSchema, addNodePanelConfigSchema, connectionConstraintSchema2, constraintWithAddNodePanel, evaluateExpression, evaluateTemplate, evaluateCondition, matchesTypePattern, checkCategoryConstraint, validateConnection, canAcceptMoreConnections, meetsMinimumConnections, resolveRefs, containsRef, applyJsonPointer, parsePointerTokens, toJsonPointer, fileFormatToInMemoryWorkflow, resolveAndConvertWorkflow, inMemoryWorkflowToFileFormat, parseWorkflowJson, workflowScopes, collectWorkflowNodesDeep, compareVersions, CONNECTOR_NODE_PREFIX, CONNECTOR_TRIGGER_PREFIX, CONNECTOR_EVENT_PREFIX, TRIGGER_NODE_PREFIX, TRIGGER_TYPE_PREFIXES, buildConnectorNodeType, parseConnectorNodeType, WEEKDAYS, isQuartzCron, isValidQuartzCron, getTimeCycleFromCronExpression, getCronExpressionFromTimeCycleValue, BINDINGS_PATH_PREFIX, BINDINGS_PLACEHOLDER_PATH_PREFIX, EntryPointType, ProjectType, AGENT_TARGET_RUNTIME, variableToJsonSchema, getBindingResourceValue, getBindingResources, isStartEventNode, getEffectiveTriggerInputs, buildInputSchema, buildOutputSchema, getEntryPoints, getStartEventNodes, generateOperateJson, generatePackageDescriptor, generateBindingsJson, generateEntryPointsJson, deduplicateBindings, mergeBindingResources, sanitizeFileName, generateWorkflowPackaging, applyConnectionOverwritesToWorkflow, applyConnectionRemovalsToWorkflow, createBindingPackage, findDefaultEntryPointNodeId, getAllEntryPoints, serializeFrequencyToCron, parseCronToFrequency, resolveContextBindingPlaceholders, matchContextBindings, CONVERSATIONAL_AGENT_SETTINGS, CONVERSATIONAL_OUTPUTS_MIN_VERSION, DEFAULT_CONVERSATIONAL_VOICE_MODEL, VOICE_MODELS, getVoiceModel, getPersonasForModel, VOICE_TURN_DETECTION_SENSITIVITIES, VOICE_TURN_DETECTION_LIMITS, DEFAULT_VOICE_AGENT_SPEAKS_FIRST, DEFAULT_CONVERSATIONAL_VOICE_SETTINGS, JobAttachmentSchema, ANALYZE_FILES_SCHEMA, SUMMARIZE_SCHEMA, BATCH_TRANSFORM_SCHEMA, HTTP_REQUEST_SCHEMA, BUILT_IN_TOOL_SCHEMAS, getToolFields, getBuiltInToolSchema, createInputSchemaFromAppSchema, createOutputSchemaFromAppSchema, createDotNetTypeMapping, createOutcomeMappingFromSchema, getOutcomeNames, unresolveRefs, createRefResolver, planWriteThrough, executeWritePlan };
+export { exports_external, JS_EXPRESSION_PREFIX, expressionFieldTypeSchema, expressionModeSchema, expressionValueSchema, expressionLikeSchema, isExpressionValue, isEmptyExpressionValue, encodeLiteral, decodeLiteral, coerceToExpressionValue, getJsExpressionBody, expectedTypeToFieldType, coerceInputsViaSchema, ESCAPED_MUSTACHE_PLACEHOLDER, hasMustache, parseMustacheSegments, templateInterpolationBody, QES_UNSAFE_CHAR, isQesUncarryableValue, RESERVED_WORDS, VALID_IDENTIFIER_PATTERN, FLAT_SEP, generateRandomId, generateNextId, UNSAFE_PROPERTY_KEYS, isUnsafeKey, isPlainObject2 as isPlainObject, deepEqual, entityWriteRowHasValue, isNonNullableEntityWriteField, isMandatoryEntityWriteField, nonNullableEntityWriteFields, mandatoryEntityWriteFields, instance, migrations, currentStorageSchema, currentAgentStorageSchema, currentResourceStorageSchema, currentFeatureStorageSchema, currentFlowLayoutStorageSchema, applyMigrations, getLatestVersion, isBlockingSeverity, shouldBlockAction, agentEnforcementsSchema, isExpression, decodeLiteralForValidation, decodeLiteralsForValidation, isJsonSchema, normalizeInputDefinition, resolveNestedFieldSchema, getFieldValidator, getNodeValidator, schemaErrorsToValidationErrors, clearValidatorCache, getManifestForNode, getNodeLabel, resolveTemplate, isTriggerNodeType, isEndNodeType, LOOP_NODE_TYPE, DOWHILE_NODE_TYPE, isLoopNodeType, isCollectionLoopNodeType, isDoWhileNodeType, DOWHILE_MAX_LIMIT, DOWHILE_MIN_LIMIT, parseDoWhileLimit, resolveDoWhileLimit, DECISION_NODE_TYPE, SWITCH_NODE_TYPE, MERGE_NODE_TYPE, MOCK_NODE_TYPE, SYNTHETIC_GATEWAY_OUTPUT_KEYS, isGatewayNodeType, supportsVariableUpdates, SUBFLOW_NODE_TYPE, isSubflowNodeType, AUTONOMOUS_AGENT_NODE_TYPE, CONVERSATIONAL_AGENT_NODE_TYPE, VOICE_AGENT_NODE_TYPE, CONVERSATIONAL_AGENT_ICON, AGENT_NODE_TYPES, isConversationalOrVoiceAgentNodeType, isVoiceAgentNodeType, isAutonomousAgentNodeType, isAgentNodeType, isPublishedAgentNodeType, isAgentToolNodeType, AGENT_RESOURCE_PREFIX, isAgentResourceNodeType, CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE, CONVERSATION_TRIGGER_NODE_TYPE, isConversationalRuntimeNodeType, isCallContextEmpty, schemaValidationRule, minConnectionsRule, triggerRequiredRule, dataTransformRule, outputMappingRule, ESCALATION_QUICK_FORM_NODE_TYPE, ESCALATION_TASK_TYPE, ESCALATION_TYPE_CODE, resolveEscalationTaskType, AGENT_RESOURCE_SOURCE_HANDLES, isToolNode, isContextNode, isEscalationNode, isQuickFormEscalationNode, isMcpNode, isA2aNode, isMemoryNode, isAgentResourceNode, DEFAULT_STORAGE_VERSION, getDefaultAgentContent, RecipientType, BYO_VALIDATOR_TYPE, temperatureExceededMessage, maxTokensExceededMessage, maxIterationsExceededMessage, modelNotAvailableMessage, governanceRule, DEFAULT_TRIGGER_OUTCOME, withDefaultTriggerOutcome, normalizeFormTriggerSchema, getHitlFieldChannelKey, isHitlInputDirectionField, isHitlOutputDirectionField, findDuplicateHitlChannelKeys, isAutoDerivedFieldBinding, stripAutoDerivedFieldBindings, conditionExpressionRule, agentDuplicateToolNamesRule, HITL_NODE_TYPE, HITL_QUICK_FORM_NODE_TYPE, HITL_CODED_ACTION_NODE_TYPE, HITL_DOC_VALIDATION_NODE_TYPE, DYNAMIC_EXTRACT_NODE_TYPE, FORM_TRIGGER_NODE_TYPE, UI_ONLY_NODE_TYPES, HITL_NODE_TYPES, isHitlNodeType, isHumanActionNodeType, collectWrittenGlobalIds, agentEmptyVarRule, JobAttachmentSchema, ANALYZE_FILES_SCHEMA, SUMMARIZE_SCHEMA, BATCH_TRANSFORM_SCHEMA, HTTP_REQUEST_SCHEMA, BUILT_IN_TOOL_SCHEMAS, getToolFields, getBuiltInToolSchema, isFileTypedVariable, schemaAcceptsFileInput, findUnhandledFilePromptVarPaths, IXP_SCHEMA_EDITOR_DRAFT_EXTENSION, IXP_SCHEMA_EDITOR_ISSUES_EXTENSION, IXP_SCHEMA_INVALID_ERROR_CODE, readIxpSchemaEditorDraft, stripIxpSchemaEditorDraft, attachIxpSchemaEditorDraft, ixpSchemaDraftRule, relatedPathsIn, relatedColumnMapIn, validateRelatedPaths, generalRules, cliRules, runRules, toSerializedNode, toSerializedNodes, workflowRuntimeSchema, DEFAULT_WORKFLOW_RUNTIME, argumentBindingSchema, workflowVariableSchema, variableUpdateSchema, nodeVariableSchema, workflowVariablesSchema, EMPTY_VARIABLES, workflowConnectionSchema, nodeLayoutSchema, waypointSchema, edgeLayoutSchema, layoutSchema, bindingSchema, nodeDisplayManifestSchema, nodeManifestSchema, idSchema, edgeSchema2, nodeSchema2, nodeManifestSchema2, categoryManifestSchema2, versionSchema2, subflowEntrySchema, workflowSchema, workflowSchemaV1_0_0, workflowSchemaV1_0, workflowSchemaV1_1, workflowSchemaV1_2, workflowSchemaV1_3, workflowSchemaV1_4, workflowSchemaV1_5, workflowSchemaV1_6, workflowSchemaV1_7, workflowSchemaV1_8, workflowSchemaV1_9, workflowSchemaV1_10, WORKFLOW_VERSIONS, CURRENT_WORKFLOW_VERSION, MINIMUM_SUPPORTED_SCHEMA_VERSION, workflowFileSchema, subflowFileSchema5, workflowManifestSchema, manifestResponseSchema, handleTargetSchema2, addNodePanelSearchScopeSchema, addNodePanelCreateActionSchema, addNodePanelConfigSchema, connectionConstraintSchema2, constraintWithAddNodePanel, evaluateExpression, evaluateTemplate, evaluateCondition, matchesTypePattern, checkCategoryConstraint, validateConnection, canAcceptMoreConnections, meetsMinimumConnections, resolveRefs, containsRef, applyJsonPointer, parsePointerTokens, toJsonPointer, fileFormatToInMemoryWorkflow, resolveAndConvertWorkflow, inMemoryWorkflowToFileFormat, parseWorkflowJson, workflowScopes, collectWorkflowNodesDeep, compareVersions, CONNECTOR_NODE_PREFIX, CONNECTOR_TRIGGER_PREFIX, CONNECTOR_EVENT_PREFIX, TRIGGER_NODE_PREFIX, TRIGGER_TYPE_PREFIXES, buildConnectorNodeType, parseConnectorNodeType, WEEKDAYS, isQuartzCron, isValidQuartzCron, getTimeCycleFromCronExpression, getCronExpressionFromTimeCycleValue, BINDINGS_PATH_PREFIX, BINDINGS_PLACEHOLDER_PATH_PREFIX, EntryPointType, ProjectType, AGENT_TARGET_RUNTIME, JOB_ATTACHMENT_DEFINITION_KEY, JOB_ATTACHMENT_REF, isJobAttachmentRef, convertFileTypesToRefs, convertJobAttachmentRefsToFileTypes, variableToJsonSchema, getBindingResourceValue, getBindingResources, isStartEventNode, isTriggerScopedInput, getEffectiveTriggerInputs, buildSchemaProperties, buildInputSchema, buildOutputSchema, getEntryPoints, getStartEventNodes, generateOperateJson, generatePackageDescriptor, generateBindingsJson, generateEntryPointsJson, deduplicateBindings, mergeBindingResources, sanitizeFileName, toBpmnFileName, generateWorkflowPackaging, applyConnectionOverwritesToWorkflow, applyConnectionRemovalsToWorkflow, createBindingPackage, findDefaultEntryPointNodeId, getAllEntryPoints, serializeFrequencyToCron, parseCronToFrequency, resolveContextBindingPlaceholders, matchContextBindings, CONVERSATIONAL_AGENT_SETTINGS, CONVERSATIONAL_OUTPUTS_MIN_VERSION, DEFAULT_CONVERSATIONAL_VOICE_MODEL, VOICE_MODELS, getVoiceModel, getPersonasForModel, VOICE_TURN_DETECTION_SENSITIVITIES, VOICE_TURN_DETECTION_LIMITS, DEFAULT_VOICE_AGENT_SPEAKS_FIRST, DEFAULT_CONVERSATIONAL_VOICE_SETTINGS, createInputSchemaFromAppSchema, createOutputSchemaFromAppSchema, createDotNetTypeMapping, createOutcomeMappingFromSchema, getOutcomeNames, unresolveRefs, createRefResolver, planWriteThrough, executeWritePlan };
 
-//# debugId=29EAA8DAA6A16F7E64756E2164756E21
+//# debugId=2EBA6A1EF1CF30D564756E2164756E21