@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/{packager-tool-vdd02vns.js → packager-tool-9bec251q.js}

@@ -1,3 +1,16 @@
+import {
+  en_default
+} from "./packager-tool-z9bfhmm5.js";
+import {
+  __export as __export2,
+  __glob,
+  init_esm_shims
+} from "./packager-tool-6ejqwbw9.js";
+import {
+  __commonJS,
+  __export,
+  __toESM
+} from "./packager-tool-mcaf4ewf.js";
 import {
   CONNECTOR_NODE_PREFIX,
   CONVERSATIONAL_AGENT_ICON,
@@ -17,31 +30,20 @@ import {
   buildConnectorNodeType,
   coerceToExpressionValue,
   constraintWithAddNodePanel,
-  createI18nRegistrar,
   getDefaultAgentContent,
   isExpressionValue,
   isHitlNodeType,
   nodeManifestSchema,
   workflowManifestSchema
-} from "./packager-tool-78a3szsp.js";
+} from "./packager-tool-m5qfverj.js";
 import {
-  en_default
-} from "./packager-tool-0567pxpm.js";
-import {
-  __export as __export2,
-  __glob,
-  init_esm_shims
-} from "./packager-tool-6ejqwbw9.js";
-import {
-  __commonJS,
-  __export,
-  __toESM
-} from "./packager-tool-mcaf4ewf.js";
+  createI18nRegistrar
+} from "./packager-tool-e0p2zsyc.js";
 import {
   __require
-} from "./packager-tool-wckvcay0.js";
+} from "./packager-tool-1yh8g550.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/chunk-EOYR77QF.js
+// ../../node_modules/@uipath/flow-converter/dist/chunk-PWOKCJ2I.js
 var require_listCacheClear = __commonJS({
   "../../node_modules/.pnpm/lodash@4.18.1/node_modules/lodash/_listCacheClear.js"(exports, module) {
     init_esm_shims();
@@ -1464,8 +1466,8 @@ function stripWildcard(name) {
 function hasWildcardKey(record2) {
   return record2 ? Object.keys(record2).some((key) => key.includes("[*]")) : false;
 }
-function hasWildcard(schema124) {
-  return hasWildcardKey(schema124.properties) || hasWildcardKey(schema124.definitions) || hasWildcardKey(schema124.$defs);
+function hasWildcard(schema117) {
+  return hasWildcardKey(schema117.properties) || hasWildcardKey(schema117.definitions) || hasWildcardKey(schema117.$defs);
 }
 function rewriteKeyedSchemas(record2) {
   const result = {};
@@ -1492,14 +1494,14 @@ function sanitizeNode(node) {
   }
   return result;
 }
-function sanitizeConnectorSchema(schema124) {
-  if (!schema124 || !hasWildcard(schema124))
-    return schema124;
-  const result = sanitizeNode(schema124);
-  if (schema124.definitions)
-    result.definitions = rewriteKeyedSchemas(schema124.definitions);
-  if (schema124.$defs)
-    result.$defs = rewriteKeyedSchemas(schema124.$defs);
+function sanitizeConnectorSchema(schema117) {
+  if (!schema117 || !hasWildcard(schema117))
+    return schema117;
+  const result = sanitizeNode(schema117);
+  if (schema117.definitions)
+    result.definitions = rewriteKeyedSchemas(schema117.definitions);
+  if (schema117.$defs)
+    result.$defs = rewriteKeyedSchemas(schema117.$defs);
   return result;
 }
 var JSON_STRING_PREFIX = "=jsonString:";
@@ -1539,9 +1541,9 @@ function parseConfigurationJson(configuration) {
     return null;
   }
 }
-function resolveJsonSchema(schema124, options = {}) {
+function resolveJsonSchema(schema117, options = {}) {
   const { maxDepth = 25 } = options;
-  const definitions = schema124.definitions || schema124.$defs || {};
+  const definitions = schema117.definitions || schema117.$defs || {};
   function resolveRef2(ref) {
     const match = ref.match(/^#\/(?:definitions|\$defs)\/(.+)$/);
     if (!match)
@@ -1574,10 +1576,10 @@ function resolveJsonSchema(schema124, options = {}) {
     }
     return result;
   }
-  const isArray = schema124.type === "array";
-  let rootSchema = schema124;
-  if (isArray && schema124.items && !Array.isArray(schema124.items)) {
-    rootSchema = schema124.items;
+  const isArray = schema117.type === "array";
+  let rootSchema = schema117;
+  if (isArray && schema117.items && !Array.isArray(schema117.items)) {
+    rootSchema = schema117.items;
   }
   return {
     schema: resolve2(rootSchema, /* @__PURE__ */ new Set, 0),
@@ -1596,13 +1598,13 @@ function resolveLocalRef(root, node) {
 function resolveConnectorOutputSchema(rawOutputJsonSchema, fieldsContainer) {
   if (!rawOutputJsonSchema || typeof rawOutputJsonSchema !== "object")
     return;
-  const schema124 = sanitizeConnectorSchema(rawOutputJsonSchema);
-  if (!schema124.type && !schema124.properties && !schema124.$ref && !schema124.definitions && !schema124.$defs)
+  const schema117 = sanitizeConnectorSchema(rawOutputJsonSchema);
+  if (!schema117.type && !schema117.properties && !schema117.$ref && !schema117.definitions && !schema117.$defs)
     return;
-  const jsonSchemaType = typeof schema124.type === "string" ? schema124.type : "object";
+  const jsonSchemaType = typeof schema117.type === "string" ? schema117.type : "object";
   const formatFields = fieldsContainer ? collectResponseFieldFormats(fieldsContainer) : [];
   if (formatFields.length > 0) {
-    const stamped = structuredClone(schema124);
+    const stamped = structuredClone(schema117);
     for (const field of formatFields) {
       const target = findSchemaNodeByFieldPath(stamped, field.name.split("."));
       if (target)
@@ -1610,7 +1612,7 @@ function resolveConnectorOutputSchema(rawOutputJsonSchema, fieldsContainer) {
     }
     return { jsonSchemaType, schema: stamped };
   }
-  return { jsonSchemaType, schema: schema124 };
+  return { jsonSchemaType, schema: schema117 };
 }
 function resolveConnectorOutputTypeSchema(inputsDetail) {
   if (!inputsDetail || typeof inputsDetail !== "object")
@@ -1708,20 +1710,20 @@ function generateNodeVariables(nodes, definitions) {
 init_esm_shims();
 init_esm_shims();
 var globImport_locales_json = __glob({
-  "../../locales/de.json": () => import("./de-5HU6GFWV-4EZK6G7N-yrh21f52.js"),
-  "../../locales/en.json": () => import("./en-MABQK6C4-REWE2WG2-8dp4cqdg.js"),
-  "../../locales/es-MX.json": () => import("./es-MX-POESXYP2-UW6VP5QI-cd3a79g9.js"),
-  "../../locales/es.json": () => import("./es-LUTYN7U7-IY5QWOUF-k2aefzc0.js"),
-  "../../locales/fr.json": () => import("./fr-LJIK56LW-STG6QR3T-cextvv8q.js"),
-  "../../locales/ja.json": () => import("./ja-FGEGLBJ3-MG3BSWXD-vq19zt2p.js"),
-  "../../locales/ko.json": () => import("./ko-TUAK3G3A-TBEBKOTM-ns78t2rv.js"),
-  "../../locales/pt-BR.json": () => import("./pt-BR-7XGDXRDJ-TR5D7JYL-533wvy7p.js"),
-  "../../locales/pt.json": () => import("./pt-TMVOOITK-H2ADYHSD-ezpggv33.js"),
-  "../../locales/ro.json": () => import("./ro-2VALF3S5-NXBJUEZN-nqw1zs33.js"),
-  "../../locales/ru.json": () => import("./ru-GSCT4ARZ-FTVCGQTL-5nh4jf2e.js"),
-  "../../locales/tr.json": () => import("./tr-RIFCEXFH-BZS7S7QK-q465b62g.js"),
-  "../../locales/zh-CN.json": () => import("./zh-CN-IP3FMXWM-H3JI2XUM-ta4yac7h.js"),
-  "../../locales/zh-TW.json": () => import("./zh-TW-AGIDXIPF-R4XZRDJZ-cgxxz5k4.js")
+  "../../locales/de.json": () => import("./de-7XQXX2DK-IDWR6CAR-n4z245kt.js"),
+  "../../locales/en.json": () => import("./en-5ZGC5VQ3-EWX7ILY7-rmtj70fk.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-U2VN3SZW-KYAJ2ONK-kdram1g1.js"),
+  "../../locales/es.json": () => import("./es-ZGCPPOME-24PJEGPV-rn86z9kn.js"),
+  "../../locales/fr.json": () => import("./fr-T3G5GZCT-TU4IKBEG-k6xz1s1f.js"),
+  "../../locales/ja.json": () => import("./ja-BI5K3JDZ-GTIHISTZ-s6n3r2ab.js"),
+  "../../locales/ko.json": () => import("./ko-JOBF5V7N-O7T4HKIE-ape840y0.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-7DYX2YPT-LZYH4YFD-bx43vx3z.js"),
+  "../../locales/pt.json": () => import("./pt-HTXGGX6Y-ZHQSDFKI-vehfxadc.js"),
+  "../../locales/ro.json": () => import("./ro-KTNQ3MNU-XIE6YPQN-gen8p82z.js"),
+  "../../locales/ru.json": () => import("./ru-GSCT4ARZ-FTVCGQTL-gee86v14.js"),
+  "../../locales/tr.json": () => import("./tr-XHSSPNK7-GW5KVXR3-2w3f1ss6.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-2EHQT23P-T5XRQCVS-ac17dpc1.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-MGZCE5BT-P6FLIUAR-zmq07vhs.js")
 });
 var MANIFEST_NAMESPACE = "manifest";
 var registerFlowCoreI18n = createI18nRegistrar({
@@ -4902,8 +4904,8 @@ function mergeDefs(...defs) {
   }
   return Object.defineProperties({}, mergedDescriptors);
 }
-function cloneDef(schema124) {
-  return mergeDefs(schema124._zod.def);
+function cloneDef(schema117) {
+  return mergeDefs(schema117._zod.def);
 }
 function getElementAtPath(obj, path) {
   if (!path)
@@ -5124,14 +5126,14 @@ var BIGINT_FORMAT_RANGES = {
   int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
   uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
 };
-function pick(schema124, mask) {
-  const currDef = schema124._zod.def;
+function pick(schema117, mask) {
+  const currDef = schema117._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema124._zod.def, {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
       const newShape = {};
       for (const key in mask) {
@@ -5147,18 +5149,18 @@ function pick(schema124, mask) {
     },
     checks: []
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
-function omit(schema124, mask) {
-  const currDef = schema124._zod.def;
+function omit(schema117, mask) {
+  const currDef = schema117._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema124._zod.def, {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
-      const newShape = { ...schema124._zod.def.shape };
+      const newShape = { ...schema117._zod.def.shape };
       for (const key in mask) {
         if (!(key in currDef.shape)) {
           throw new Error(`Unrecognized key: "${key}"`);
@@ -5172,43 +5174,43 @@ function omit(schema124, mask) {
     },
     checks: []
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
-function extend(schema124, shape) {
+function extend(schema117, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema124._zod.def.checks;
+  const checks = schema117._zod.def.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
-    const existingShape = schema124._zod.def.shape;
+    const existingShape = schema117._zod.def.shape;
     for (const key in shape) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
   }
-  const def = mergeDefs(schema124._zod.def, {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
-      const _shape = { ...schema124._zod.def.shape, ...shape };
+      const _shape = { ...schema117._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
-function safeExtend(schema124, shape) {
+function safeExtend(schema117, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema124._zod.def, {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
-      const _shape = { ...schema124._zod.def.shape, ...shape };
+      const _shape = { ...schema117._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     }
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
 function merge(a, b) {
   if (a._zod.def.checks?.length) {
@@ -5227,16 +5229,16 @@ function merge(a, b) {
   });
   return clone(a, def);
 }
-function partial(Class2, schema124, mask) {
-  const currDef = schema124._zod.def;
+function partial(Class2, schema117, mask) {
+  const currDef = schema117._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
-  const def = mergeDefs(schema124._zod.def, {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
-      const oldShape = schema124._zod.def.shape;
+      const oldShape = schema117._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -5263,12 +5265,12 @@ function partial(Class2, schema124, mask) {
     },
     checks: []
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
-function required(Class2, schema124, mask) {
-  const def = mergeDefs(schema124._zod.def, {
+function required(Class2, schema117, mask) {
+  const def = mergeDefs(schema117._zod.def, {
     get shape() {
-      const oldShape = schema124._zod.def.shape;
+      const oldShape = schema117._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
         for (const key in mask) {
@@ -5294,7 +5296,7 @@ function required(Class2, schema124, mask) {
       return shape;
     }
   });
-  return clone(schema124, def);
+  return clone(schema117, def);
 }
 function aborted(x, startIndex = 0) {
   if (x.aborted === true)
@@ -5569,9 +5571,9 @@ function prettifyError(error51) {
   return lines.join(`
 `);
 }
-var _parse = (_Err) => (schema124, value, _ctx, _params) => {
+var _parse = (_Err) => (schema117, value, _ctx, _params) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema124._zod.run({ value, issues: [] }, ctx);
+  const result = schema117._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError;
   }
@@ -5583,9 +5585,9 @@ var _parse = (_Err) => (schema124, value, _ctx, _params) => {
   return result.value;
 };
 var parse = /* @__PURE__ */ _parse($ZodRealError);
-var _parseAsync = (_Err) => async (schema124, value, _ctx, params) => {
+var _parseAsync = (_Err) => async (schema117, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema124._zod.run({ value, issues: [] }, ctx);
+  let result = schema117._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   if (result.issues.length) {
@@ -5596,9 +5598,9 @@ var _parseAsync = (_Err) => async (schema124, value, _ctx, params) => {
   return result.value;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-var _safeParse = (_Err) => (schema124, value, _ctx) => {
+var _safeParse = (_Err) => (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema124._zod.run({ value, issues: [] }, ctx);
+  const result = schema117._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise) {
     throw new $ZodAsyncError;
   }
@@ -5608,9 +5610,9 @@ var _safeParse = (_Err) => (schema124, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-var _safeParseAsync = (_Err) => async (schema124, value, _ctx) => {
+var _safeParseAsync = (_Err) => async (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema124._zod.run({ value, issues: [] }, ctx);
+  let result = schema117._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
     result = await result;
   return result.issues.length ? {
@@ -5619,40 +5621,40 @@ var _safeParseAsync = (_Err) => async (schema124, value, _ctx) => {
   } : { success: true, data: result.value };
 };
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-var _encode = (_Err) => (schema124, value, _ctx) => {
+var _encode = (_Err) => (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parse(_Err)(schema124, value, ctx);
+  return _parse(_Err)(schema117, value, ctx);
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
-var _decode = (_Err) => (schema124, value, _ctx) => {
-  return _parse(_Err)(schema124, value, _ctx);
+var _decode = (_Err) => (schema117, value, _ctx) => {
+  return _parse(_Err)(schema117, value, _ctx);
 };
 var decode = /* @__PURE__ */ _decode($ZodRealError);
-var _encodeAsync = (_Err) => async (schema124, value, _ctx) => {
+var _encodeAsync = (_Err) => async (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _parseAsync(_Err)(schema124, value, ctx);
+  return _parseAsync(_Err)(schema117, value, ctx);
 };
 var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
-var _decodeAsync = (_Err) => async (schema124, value, _ctx) => {
-  return _parseAsync(_Err)(schema124, value, _ctx);
+var _decodeAsync = (_Err) => async (schema117, value, _ctx) => {
+  return _parseAsync(_Err)(schema117, value, _ctx);
 };
 var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-var _safeEncode = (_Err) => (schema124, value, _ctx) => {
+var _safeEncode = (_Err) => (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse(_Err)(schema124, value, ctx);
+  return _safeParse(_Err)(schema117, value, ctx);
 };
 var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-var _safeDecode = (_Err) => (schema124, value, _ctx) => {
-  return _safeParse(_Err)(schema124, value, _ctx);
+var _safeDecode = (_Err) => (schema117, value, _ctx) => {
+  return _safeParse(_Err)(schema117, value, _ctx);
 };
 var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-var _safeEncodeAsync = (_Err) => async (schema124, value, _ctx) => {
+var _safeEncodeAsync = (_Err) => async (schema117, value, _ctx) => {
   const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync(_Err)(schema124, value, ctx);
+  return _safeParseAsync(_Err)(schema117, value, ctx);
 };
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-var _safeDecodeAsync = (_Err) => async (schema124, value, _ctx) => {
-  return _safeParseAsync(_Err)(schema124, value, _ctx);
+var _safeDecodeAsync = (_Err) => async (schema117, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema117, value, _ctx);
 };
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 init_esm_shims();
@@ -7219,9 +7221,9 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc(key);
-      const schema124 = shape[key];
-      const isOptionalIn = schema124?._zod?.optin === "optional";
-      const isOptionalOut = schema124?._zod?.optout === "optional";
+      const schema117 = shape[key];
+      const isOptionalIn = schema117?._zod?.optin === "optional";
+      const isOptionalOut = schema117?._zod?.optout === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
@@ -14393,11 +14395,11 @@ var $ZodRegistry = class {
     this._map = /* @__PURE__ */ new WeakMap;
     this._idmap = /* @__PURE__ */ new Map;
   }
-  add(schema124, ..._meta) {
+  add(schema117, ..._meta) {
     const meta3 = _meta[0];
-    this._map.set(schema124, meta3);
+    this._map.set(schema117, meta3);
     if (meta3 && typeof meta3 === "object" && "id" in meta3) {
-      this._idmap.set(meta3.id, schema124);
+      this._idmap.set(meta3.id, schema117);
     }
     return this;
   }
@@ -14406,26 +14408,26 @@ var $ZodRegistry = class {
     this._idmap = /* @__PURE__ */ new Map;
     return this;
   }
-  remove(schema124) {
-    const meta3 = this._map.get(schema124);
+  remove(schema117) {
+    const meta3 = this._map.get(schema117);
     if (meta3 && typeof meta3 === "object" && "id" in meta3) {
       this._idmap.delete(meta3.id);
     }
-    this._map.delete(schema124);
+    this._map.delete(schema117);
     return this;
   }
-  get(schema124) {
-    const p = schema124._zod.parent;
+  get(schema117) {
+    const p = schema117._zod.parent;
     if (p) {
       const pm = { ...this.get(p) ?? {} };
       delete pm.id;
-      const f = { ...pm, ...this._map.get(schema124) };
+      const f = { ...pm, ...this._map.get(schema117) };
       return Object.keys(f).length ? f : undefined;
     }
-    return this._map.get(schema124);
+    return this._map.get(schema117);
   }
-  has(schema124) {
-    return this._map.has(schema124);
+  has(schema117) {
+    return this._map.has(schema117);
   }
 };
 function registry() {
@@ -15003,11 +15005,11 @@ function _endsWith(suffix, params) {
     suffix
   });
 }
-function _property(property, schema124, params) {
+function _property(property, schema117, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema: schema124,
+    schema: schema117,
     ...normalizeParams(params)
   });
 }
@@ -15220,22 +15222,22 @@ function _promise(Class2, innerType) {
 function _custom(Class2, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema124 = new Class2({
+  const schema117 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema124;
+  return schema117;
 }
 function _refine(Class2, fn, _params) {
-  const schema124 = new Class2({
+  const schema117 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema124;
+  return schema117;
 }
 function _superRefine(fn, params) {
   const ch = /* @__PURE__ */ _check((payload) => {
@@ -15374,40 +15376,40 @@ function initializeContext(params) {
     external: params?.external ?? undefined
   };
 }
-function process(schema124, ctx, _params = { path: [], schemaPath: [] }) {
+function process(schema117, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
-  const def = schema124._zod.def;
-  const seen = ctx.seen.get(schema124);
+  const def = schema117._zod.def;
+  const seen = ctx.seen.get(schema117);
   if (seen) {
     seen.count++;
-    const isCycle = _params.schemaPath.includes(schema124);
+    const isCycle = _params.schemaPath.includes(schema117);
     if (isCycle) {
       seen.cycle = _params.path;
     }
     return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
-  ctx.seen.set(schema124, result);
-  const overrideSchema = schema124._zod.toJSONSchema?.();
+  ctx.seen.set(schema117, result);
+  const overrideSchema = schema117._zod.toJSONSchema?.();
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
     const params = {
       ..._params,
-      schemaPath: [..._params.schemaPath, schema124],
+      schemaPath: [..._params.schemaPath, schema117],
       path: _params.path
     };
-    if (schema124._zod.processJSONSchema) {
-      schema124._zod.processJSONSchema(ctx, result.schema, params);
+    if (schema117._zod.processJSONSchema) {
+      schema117._zod.processJSONSchema(ctx, result.schema, params);
     } else {
       const _json = result.schema;
       const processor = ctx.processors[def.type];
       if (!processor) {
         throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
       }
-      processor(schema124, ctx, _json, params);
+      processor(schema117, ctx, _json, params);
     }
-    const parent = schema124._zod.parent;
+    const parent = schema117._zod.parent;
     if (parent) {
       if (!result.ref)
         result.ref = parent;
@@ -15415,21 +15417,21 @@ function process(schema124, ctx, _params = { path: [], schemaPath: [] }) {
       ctx.seen.get(parent).isParent = true;
     }
   }
-  const meta3 = ctx.metadataRegistry.get(schema124);
+  const meta3 = ctx.metadataRegistry.get(schema117);
   if (meta3)
     Object.assign(result.schema, meta3);
-  if (ctx.io === "input" && isTransforming(schema124)) {
+  if (ctx.io === "input" && isTransforming(schema117)) {
     delete result.schema.examples;
     delete result.schema.default;
   }
   if (ctx.io === "input" && "_prefault" in result.schema)
     (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
   delete result.schema._prefault;
-  const _result = ctx.seen.get(schema124);
+  const _result = ctx.seen.get(schema117);
   return _result.schema;
 }
-function extractDefs(ctx, schema124) {
-  const root = ctx.seen.get(schema124);
+function extractDefs(ctx, schema117) {
+  const root = ctx.seen.get(schema117);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map;
@@ -15472,11 +15474,11 @@ function extractDefs(ctx, schema124) {
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
-    const schema125 = seen.schema;
-    for (const key in schema125) {
-      delete schema125[key];
+    const schema118 = seen.schema;
+    for (const key in schema118) {
+      delete schema118[key];
     }
-    schema125.$ref = ref;
+    schema118.$ref = ref;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -15490,13 +15492,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
-    if (schema124 === entry[0]) {
+    if (schema117 === entry[0]) {
       extractToDef(entry);
       continue;
     }
     if (ctx.external) {
       const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema124 !== entry[0] && ext) {
+      if (schema117 !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
@@ -15518,16 +15520,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 }
-function finalize(ctx, schema124) {
-  const root = ctx.seen.get(schema124);
+function finalize(ctx, schema117) {
+  const root = ctx.seen.get(schema117);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
     if (seen.ref === null)
       return;
-    const schema125 = seen.def ?? seen.schema;
-    const _cached = { ...schema125 };
+    const schema118 = seen.def ?? seen.schema;
+    const _cached = { ...schema118 };
     const ref = seen.ref;
     seen.ref = null;
     if (ref) {
@@ -15535,28 +15537,28 @@ function finalize(ctx, schema124) {
       const refSeen = ctx.seen.get(ref);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
-        schema125.allOf = schema125.allOf ?? [];
-        schema125.allOf.push(refSchema);
+        schema118.allOf = schema118.allOf ?? [];
+        schema118.allOf.push(refSchema);
       } else {
-        Object.assign(schema125, refSchema);
+        Object.assign(schema118, refSchema);
       }
-      Object.assign(schema125, _cached);
+      Object.assign(schema118, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema125) {
+        for (const key in schema118) {
           if (key === "$ref" || key === "allOf")
             continue;
           if (!(key in _cached)) {
-            delete schema125[key];
+            delete schema118[key];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema125) {
+        for (const key in schema118) {
           if (key === "$ref" || key === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema125[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema125[key];
+          if (key in refSeen.def && JSON.stringify(schema118[key]) === JSON.stringify(refSeen.def[key])) {
+            delete schema118[key];
           }
         }
       }
@@ -15566,13 +15568,13 @@ function finalize(ctx, schema124) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
-        schema125.$ref = parentSeen.schema.$ref;
+        schema118.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema125) {
+          for (const key in schema118) {
             if (key === "$ref" || key === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema125[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema125[key];
+            if (key in parentSeen.def && JSON.stringify(schema118[key]) === JSON.stringify(parentSeen.def[key])) {
+              delete schema118[key];
             }
           }
         }
@@ -15580,7 +15582,7 @@ function finalize(ctx, schema124) {
     }
     ctx.override({
       zodSchema,
-      jsonSchema: schema125,
+      jsonSchema: schema118,
       path: seen.path ?? []
     });
   };
@@ -15596,13 +15598,13 @@ function finalize(ctx, schema124) {
     result.$schema = "http://json-schema.org/draft-04/schema#";
   } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
-    const id = ctx.external.registry.get(schema124)?.id;
+    const id = ctx.external.registry.get(schema117)?.id;
     if (!id)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
   Object.assign(result, root.def ?? root.schema);
-  const rootMetaId = ctx.metadataRegistry.get(schema124)?.id;
+  const rootMetaId = ctx.metadataRegistry.get(schema117)?.id;
   if (rootMetaId !== undefined && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
@@ -15627,10 +15629,10 @@ function finalize(ctx, schema124) {
     const finalized = JSON.parse(JSON.stringify(result));
     Object.defineProperty(finalized, "~standard", {
       value: {
-        ...schema124["~standard"],
+        ...schema117["~standard"],
         jsonSchema: {
-          input: createStandardJSONSchemaMethod(schema124, "input", ctx.processors),
-          output: createStandardJSONSchemaMethod(schema124, "output", ctx.processors)
+          input: createStandardJSONSchemaMethod(schema117, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema117, "output", ctx.processors)
         }
       },
       enumerable: false,
@@ -15694,18 +15696,18 @@ function isTransforming(_schema, _ctx) {
   }
   return false;
 }
-var createToJSONSchemaMethod = (schema124, processors = {}) => (params) => {
+var createToJSONSchemaMethod = (schema117, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema124, ctx);
-  extractDefs(ctx, schema124);
-  return finalize(ctx, schema124);
+  process(schema117, ctx);
+  extractDefs(ctx, schema117);
+  return finalize(ctx, schema117);
 };
-var createStandardJSONSchemaMethod = (schema124, io, processors = {}) => (params) => {
+var createStandardJSONSchemaMethod = (schema117, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema124, ctx);
-  extractDefs(ctx, schema124);
-  return finalize(ctx, schema124);
+  process(schema117, ctx);
+  extractDefs(ctx, schema117);
+  return finalize(ctx, schema117);
 };
 init_esm_shims();
 var formatMap = {
@@ -15715,10 +15717,10 @@ var formatMap = {
   json_string: "json-string",
   regex: ""
 };
-var stringProcessor = (schema124, ctx, _json, _params) => {
+var stringProcessor = (schema117, ctx, _json, _params) => {
   const json2 = _json;
   json2.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding } = schema124._zod.bag;
+  const { minimum, maximum, format, patterns, contentEncoding } = schema117._zod.bag;
   if (typeof minimum === "number")
     json2.minLength = minimum;
   if (typeof maximum === "number")
@@ -15747,9 +15749,9 @@ var stringProcessor = (schema124, ctx, _json, _params) => {
     }
   }
 };
-var numberProcessor = (schema124, ctx, _json, _params) => {
+var numberProcessor = (schema117, ctx, _json, _params) => {
   const json2 = _json;
-  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema124._zod.bag;
+  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema117._zod.bag;
   if (typeof format === "string" && format.includes("int"))
     json2.type = "integer";
   else
@@ -15822,8 +15824,8 @@ var dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor = (schema124, _ctx, json2, _params) => {
-  const def = schema124._zod.def;
+var enumProcessor = (schema117, _ctx, json2, _params) => {
+  const def = schema117._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
     json2.type = "number";
@@ -15831,8 +15833,8 @@ var enumProcessor = (schema124, _ctx, json2, _params) => {
     json2.type = "string";
   json2.enum = values;
 };
-var literalProcessor = (schema124, ctx, json2, _params) => {
-  const def = schema124._zod.def;
+var literalProcessor = (schema117, ctx, json2, _params) => {
+  const def = schema117._zod.def;
   const vals = [];
   for (const val of def.values) {
     if (val === undefined) {
@@ -15874,22 +15876,22 @@ var nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor = (schema124, _ctx, json2, _params) => {
+var templateLiteralProcessor = (schema117, _ctx, json2, _params) => {
   const _json = json2;
-  const pattern = schema124._zod.pattern;
+  const pattern = schema117._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema124, _ctx, json2, _params) => {
+var fileProcessor = (schema117, _ctx, json2, _params) => {
   const _json = json2;
   const file2 = {
     type: "string",
     format: "binary",
     contentEncoding: "binary"
   };
-  const { minimum, maximum, mime } = schema124._zod.bag;
+  const { minimum, maximum, mime } = schema117._zod.bag;
   if (minimum !== undefined)
     file2.minLength = minimum;
   if (maximum !== undefined)
@@ -15934,10 +15936,10 @@ var setProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Set cannot be represented in JSON Schema");
   }
 };
-var arrayProcessor = (schema124, ctx, _json, params) => {
+var arrayProcessor = (schema117, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema124._zod.def;
-  const { minimum, maximum } = schema124._zod.bag;
+  const def = schema117._zod.def;
+  const { minimum, maximum } = schema117._zod.bag;
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
@@ -15948,9 +15950,9 @@ var arrayProcessor = (schema124, ctx, _json, params) => {
     path: [...params.path, "items"]
   });
 };
-var objectProcessor = (schema124, ctx, _json, params) => {
+var objectProcessor = (schema117, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema124._zod.def;
+  const def = schema117._zod.def;
   json2.type = "object";
   json2.properties = {};
   const shape = def.shape;
@@ -15984,8 +15986,8 @@ var objectProcessor = (schema124, ctx, _json, params) => {
     });
   }
 };
-var unionProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var unionProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => process(x, ctx, {
     ...params,
@@ -15997,8 +15999,8 @@ var unionProcessor = (schema124, ctx, json2, params) => {
     json2.anyOf = options;
   }
 };
-var intersectionProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var intersectionProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   const a = process(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
@@ -16014,9 +16016,9 @@ var intersectionProcessor = (schema124, ctx, json2, params) => {
   ];
   json2.allOf = allOf;
 };
-var tupleProcessor = (schema124, ctx, _json, params) => {
+var tupleProcessor = (schema117, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema124._zod.def;
+  const def = schema117._zod.def;
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
@@ -16050,15 +16052,15 @@ var tupleProcessor = (schema124, ctx, _json, params) => {
       json2.additionalItems = rest;
     }
   }
-  const { minimum, maximum } = schema124._zod.bag;
+  const { minimum, maximum } = schema117._zod.bag;
   if (typeof minimum === "number")
     json2.minItems = minimum;
   if (typeof maximum === "number")
     json2.maxItems = maximum;
 };
-var recordProcessor = (schema124, ctx, _json, params) => {
+var recordProcessor = (schema117, ctx, _json, params) => {
   const json2 = _json;
-  const def = schema124._zod.def;
+  const def = schema117._zod.def;
   json2.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
@@ -16092,10 +16094,10 @@ var recordProcessor = (schema124, ctx, _json, params) => {
     }
   }
 };
-var nullableProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var nullableProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   const inner = process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
     json2.nullable = true;
@@ -16103,31 +16105,31 @@ var nullableProcessor = (schema124, ctx, json2, params) => {
     json2.anyOf = [inner, { type: "null" }];
   }
 };
-var nonoptionalProcessor = (schema124, ctx, _json, params) => {
-  const def = schema124._zod.def;
+var nonoptionalProcessor = (schema117, ctx, _json, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
 };
-var defaultProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var defaultProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var prefaultProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var prefaultProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
   if (ctx.io === "input")
     json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var catchProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var catchProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
   let catchValue;
   try {
@@ -16137,37 +16139,37 @@ var catchProcessor = (schema124, ctx, json2, params) => {
   }
   json2.default = catchValue;
 };
-var pipeProcessor = (schema124, ctx, _json, params) => {
-  const def = schema124._zod.def;
+var pipeProcessor = (schema117, ctx, _json, params) => {
+  const def = schema117._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
   process(innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema124, ctx, json2, params) => {
-  const def = schema124._zod.def;
+var readonlyProcessor = (schema117, ctx, json2, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
-var promiseProcessor = (schema124, ctx, _json, params) => {
-  const def = schema124._zod.def;
+var promiseProcessor = (schema117, ctx, _json, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
 };
-var optionalProcessor = (schema124, ctx, _json, params) => {
-  const def = schema124._zod.def;
+var optionalProcessor = (schema117, ctx, _json, params) => {
+  const def = schema117._zod.def;
   process(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = def.innerType;
 };
-var lazyProcessor = (schema124, ctx, _json, params) => {
-  const innerType = schema124._zod.innerType;
+var lazyProcessor = (schema117, ctx, _json, params) => {
+  const innerType = schema117._zod.innerType;
   process(innerType, ctx, params);
-  const seen = ctx.seen.get(schema124);
+  const seen = ctx.seen.get(schema117);
   seen.ref = innerType;
 };
 var allProcessors = {
@@ -16217,8 +16219,8 @@ function toJSONSchema(input, params) {
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
-      const [_, schema124] = entry;
-      process(schema124, ctx2);
+      const [_, schema117] = entry;
+      process(schema117, ctx2);
     }
     const schemas = {};
     const external = {
@@ -16228,9 +16230,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry2._idmap.entries()) {
-      const [key, schema124] = entry;
-      extractDefs(ctx2, schema124);
-      schemas[key] = finalize(ctx2, schema124);
+      const [key, schema117] = entry;
+      extractDefs(ctx2, schema117);
+      schemas[key] = finalize(ctx2, schema117);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -16286,10 +16288,10 @@ var JSONSchemaGenerator = class {
       ...params?.io && { io: params.io }
     });
   }
-  process(schema124, _params = { path: [], schemaPath: [] }) {
-    return process(schema124, this.ctx, _params);
+  process(schema117, _params = { path: [], schemaPath: [] }) {
+    return process(schema117, this.ctx, _params);
   }
-  emit(schema124, _params) {
+  emit(schema117, _params) {
     if (_params) {
       if (_params.cycles)
         this.ctx.cycles = _params.cycles;
@@ -16298,8 +16300,8 @@ var JSONSchemaGenerator = class {
       if (_params.external)
         this.ctx.external = _params.external;
     }
-    extractDefs(this.ctx, schema124);
-    const result = finalize(this.ctx, schema124);
+    extractDefs(this.ctx, schema117);
+    const result = finalize(this.ctx, schema117);
     const { "~standard": _, ...plainResult } = result;
     return plainResult;
   }
@@ -17251,8 +17253,8 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 function array(element, params) {
   return _array(ZodArray, element, params);
 }
-function keyof(schema124) {
-  const shape = schema124._zod.def.shape;
+function keyof(schema117) {
+  const shape = schema117._zod.def.shape;
   return _enum2(Object.keys(shape));
 }
 var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
@@ -17875,11 +17877,11 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema124) {
+function preprocess(fn, schema117) {
   return new ZodPreprocess({
     type: "pipe",
     in: transform(fn),
-    out: schema124
+    out: schema117
   });
 }
 init_esm_shims();
@@ -17971,8 +17973,8 @@ var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
   "nullable",
   "readOnly"
 ]);
-function detectVersion(schema124, defaultTarget) {
-  const $schema = schema124.$schema;
+function detectVersion(schema117, defaultTarget) {
+  const $schema = schema117.$schema;
   if ($schema === "https://json-schema.org/draft/2020-12/schema") {
     return "draft-2020-12";
   }
@@ -18002,27 +18004,27 @@ function resolveRef(ref, ctx) {
   }
   throw new Error(`Reference not found: ${ref}`);
 }
-function convertBaseSchema(schema124, ctx) {
-  if (schema124.not !== undefined) {
-    if (typeof schema124.not === "object" && Object.keys(schema124.not).length === 0) {
+function convertBaseSchema(schema117, ctx) {
+  if (schema117.not !== undefined) {
+    if (typeof schema117.not === "object" && Object.keys(schema117.not).length === 0) {
       return z.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  if (schema124.unevaluatedItems !== undefined) {
+  if (schema117.unevaluatedItems !== undefined) {
     throw new Error("unevaluatedItems is not supported");
   }
-  if (schema124.unevaluatedProperties !== undefined) {
+  if (schema117.unevaluatedProperties !== undefined) {
     throw new Error("unevaluatedProperties is not supported");
   }
-  if (schema124.if !== undefined || schema124.then !== undefined || schema124.else !== undefined) {
+  if (schema117.if !== undefined || schema117.then !== undefined || schema117.else !== undefined) {
     throw new Error("Conditional schemas (if/then/else) are not supported");
   }
-  if (schema124.dependentSchemas !== undefined || schema124.dependentRequired !== undefined) {
+  if (schema117.dependentSchemas !== undefined || schema117.dependentRequired !== undefined) {
     throw new Error("dependentSchemas and dependentRequired are not supported");
   }
-  if (schema124.$ref) {
-    const refPath = schema124.$ref;
+  if (schema117.$ref) {
+    const refPath = schema117.$ref;
     if (ctx.refs.has(refPath)) {
       return ctx.refs.get(refPath);
     }
@@ -18041,9 +18043,9 @@ function convertBaseSchema(schema124, ctx) {
     ctx.processing.delete(refPath);
     return zodSchema2;
   }
-  if (schema124.enum !== undefined) {
-    const enumValues = schema124.enum;
-    if (ctx.version === "openapi-3.0" && schema124.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+  if (schema117.enum !== undefined) {
+    const enumValues = schema117.enum;
+    if (ctx.version === "openapi-3.0" && schema117.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
       return z.null();
     }
     if (enumValues.length === 0) {
@@ -18061,13 +18063,13 @@ function convertBaseSchema(schema124, ctx) {
     }
     return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema124.const !== undefined) {
-    return z.literal(schema124.const);
+  if (schema117.const !== undefined) {
+    return z.literal(schema117.const);
   }
-  const type = schema124.type;
+  const type = schema117.type;
   if (Array.isArray(type)) {
     const typeSchemas = type.map((t8) => {
-      const typeSchema = { ...schema124, type: t8 };
+      const typeSchema = { ...schema117, type: t8 };
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
@@ -18085,8 +18087,8 @@ function convertBaseSchema(schema124, ctx) {
   switch (type) {
     case "string": {
       let stringSchema = z.string();
-      if (schema124.format) {
-        const format = schema124.format;
+      if (schema117.format) {
+        const format = schema117.format;
         if (format === "email") {
           stringSchema = stringSchema.check(z.email());
         } else if (format === "uri" || format === "uri-reference") {
@@ -18135,14 +18137,14 @@ function convertBaseSchema(schema124, ctx) {
           stringSchema = stringSchema.check(z.ksuid());
         }
       }
-      if (typeof schema124.minLength === "number") {
-        stringSchema = stringSchema.min(schema124.minLength);
+      if (typeof schema117.minLength === "number") {
+        stringSchema = stringSchema.min(schema117.minLength);
       }
-      if (typeof schema124.maxLength === "number") {
-        stringSchema = stringSchema.max(schema124.maxLength);
+      if (typeof schema117.maxLength === "number") {
+        stringSchema = stringSchema.max(schema117.maxLength);
       }
-      if (schema124.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema124.pattern));
+      if (schema117.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema117.pattern));
       }
       zodSchema = stringSchema;
       break;
@@ -18150,24 +18152,24 @@ function convertBaseSchema(schema124, ctx) {
     case "number":
     case "integer": {
       let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema124.minimum === "number") {
-        numberSchema = numberSchema.min(schema124.minimum);
+      if (typeof schema117.minimum === "number") {
+        numberSchema = numberSchema.min(schema117.minimum);
       }
-      if (typeof schema124.maximum === "number") {
-        numberSchema = numberSchema.max(schema124.maximum);
+      if (typeof schema117.maximum === "number") {
+        numberSchema = numberSchema.max(schema117.maximum);
       }
-      if (typeof schema124.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema124.exclusiveMinimum);
-      } else if (schema124.exclusiveMinimum === true && typeof schema124.minimum === "number") {
-        numberSchema = numberSchema.gt(schema124.minimum);
+      if (typeof schema117.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema117.exclusiveMinimum);
+      } else if (schema117.exclusiveMinimum === true && typeof schema117.minimum === "number") {
+        numberSchema = numberSchema.gt(schema117.minimum);
       }
-      if (typeof schema124.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema124.exclusiveMaximum);
-      } else if (schema124.exclusiveMaximum === true && typeof schema124.maximum === "number") {
-        numberSchema = numberSchema.lt(schema124.maximum);
+      if (typeof schema117.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema117.exclusiveMaximum);
+      } else if (schema117.exclusiveMaximum === true && typeof schema117.maximum === "number") {
+        numberSchema = numberSchema.lt(schema117.maximum);
       }
-      if (typeof schema124.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema124.multipleOf);
+      if (typeof schema117.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema117.multipleOf);
       }
       zodSchema = numberSchema;
       break;
@@ -18182,15 +18184,15 @@ function convertBaseSchema(schema124, ctx) {
     }
     case "object": {
       const shape = {};
-      const properties = schema124.properties || {};
-      const requiredSet = new Set(schema124.required || []);
+      const properties = schema117.properties || {};
+      const requiredSet = new Set(schema117.required || []);
       for (const [key, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
         shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
       }
-      if (schema124.propertyNames) {
-        const keySchema = convertSchema(schema124.propertyNames, ctx);
-        const valueSchema = schema124.additionalProperties && typeof schema124.additionalProperties === "object" ? convertSchema(schema124.additionalProperties, ctx) : z.any();
+      if (schema117.propertyNames) {
+        const keySchema = convertSchema(schema117.propertyNames, ctx);
+        const valueSchema = schema117.additionalProperties && typeof schema117.additionalProperties === "object" ? convertSchema(schema117.additionalProperties, ctx) : z.any();
         if (Object.keys(shape).length === 0) {
           zodSchema = z.record(keySchema, valueSchema);
           break;
@@ -18200,8 +18202,8 @@ function convertBaseSchema(schema124, ctx) {
         zodSchema = z.intersection(objectSchema2, recordSchema);
         break;
       }
-      if (schema124.patternProperties) {
-        const patternProps = schema124.patternProperties;
+      if (schema117.patternProperties) {
+        const patternProps = schema117.patternProperties;
         const patternKeys = Object.keys(patternProps);
         const looseRecords = [];
         for (const pattern of patternKeys) {
@@ -18228,18 +18230,18 @@ function convertBaseSchema(schema124, ctx) {
         break;
       }
       const objectSchema = z.object(shape);
-      if (schema124.additionalProperties === false) {
+      if (schema117.additionalProperties === false) {
         zodSchema = objectSchema.strict();
-      } else if (typeof schema124.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema124.additionalProperties, ctx));
+      } else if (typeof schema117.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema117.additionalProperties, ctx));
       } else {
         zodSchema = objectSchema.passthrough();
       }
       break;
     }
     case "array": {
-      const prefixItems = schema124.prefixItems;
-      const items = schema124.items;
+      const prefixItems = schema117.prefixItems;
+      const items = schema117.items;
       if (prefixItems && Array.isArray(prefixItems)) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : undefined;
@@ -18248,34 +18250,34 @@ function convertBaseSchema(schema124, ctx) {
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema124.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema124.minItems));
+        if (typeof schema117.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema117.minItems));
         }
-        if (typeof schema124.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema124.maxItems));
+        if (typeof schema117.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema117.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema124.additionalItems && typeof schema124.additionalItems === "object" ? convertSchema(schema124.additionalItems, ctx) : undefined;
+        const rest = schema117.additionalItems && typeof schema117.additionalItems === "object" ? convertSchema(schema117.additionalItems, ctx) : undefined;
         if (rest) {
           zodSchema = z.tuple(tupleItems).rest(rest);
         } else {
           zodSchema = z.tuple(tupleItems);
         }
-        if (typeof schema124.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema124.minItems));
+        if (typeof schema117.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema117.minItems));
         }
-        if (typeof schema124.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema124.maxItems));
+        if (typeof schema117.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema117.maxItems));
         }
       } else if (items !== undefined) {
         const element = convertSchema(items, ctx);
         let arraySchema = z.array(element);
-        if (typeof schema124.minItems === "number") {
-          arraySchema = arraySchema.min(schema124.minItems);
+        if (typeof schema117.minItems === "number") {
+          arraySchema = arraySchema.min(schema117.minItems);
         }
-        if (typeof schema124.maxItems === "number") {
-          arraySchema = arraySchema.max(schema124.maxItems);
+        if (typeof schema117.maxItems === "number") {
+          arraySchema = arraySchema.max(schema117.maxItems);
         }
         zodSchema = arraySchema;
       } else {
@@ -18288,76 +18290,76 @@ function convertBaseSchema(schema124, ctx) {
   }
   return zodSchema;
 }
-function convertSchema(schema124, ctx) {
-  if (typeof schema124 === "boolean") {
-    return schema124 ? z.any() : z.never();
+function convertSchema(schema117, ctx) {
+  if (typeof schema117 === "boolean") {
+    return schema117 ? z.any() : z.never();
   }
-  let baseSchema = convertBaseSchema(schema124, ctx);
-  const hasExplicitType = schema124.type || schema124.enum !== undefined || schema124.const !== undefined;
-  if (schema124.anyOf && Array.isArray(schema124.anyOf)) {
-    const options = schema124.anyOf.map((s) => convertSchema(s, ctx));
+  let baseSchema = convertBaseSchema(schema117, ctx);
+  const hasExplicitType = schema117.type || schema117.enum !== undefined || schema117.const !== undefined;
+  if (schema117.anyOf && Array.isArray(schema117.anyOf)) {
+    const options = schema117.anyOf.map((s) => convertSchema(s, ctx));
     const anyOfUnion = z.union(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (schema124.oneOf && Array.isArray(schema124.oneOf)) {
-    const options = schema124.oneOf.map((s) => convertSchema(s, ctx));
+  if (schema117.oneOf && Array.isArray(schema117.oneOf)) {
+    const options = schema117.oneOf.map((s) => convertSchema(s, ctx));
     const oneOfUnion = z.xor(options);
     baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  if (schema124.allOf && Array.isArray(schema124.allOf)) {
-    if (schema124.allOf.length === 0) {
+  if (schema117.allOf && Array.isArray(schema117.allOf)) {
+    if (schema117.allOf.length === 0) {
       baseSchema = hasExplicitType ? baseSchema : z.any();
     } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema124.allOf[0], ctx);
+      let result = hasExplicitType ? baseSchema : convertSchema(schema117.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx;i < schema124.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema124.allOf[i], ctx));
+      for (let i = startIdx;i < schema117.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema117.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
-  if (schema124.nullable === true && ctx.version === "openapi-3.0") {
+  if (schema117.nullable === true && ctx.version === "openapi-3.0") {
     baseSchema = z.nullable(baseSchema);
   }
-  if (schema124.readOnly === true) {
+  if (schema117.readOnly === true) {
     baseSchema = z.readonly(baseSchema);
   }
-  if (schema124.default !== undefined) {
-    baseSchema = baseSchema.default(schema124.default);
+  if (schema117.default !== undefined) {
+    baseSchema = baseSchema.default(schema117.default);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
   for (const key of coreMetadataKeys) {
-    if (key in schema124) {
-      extraMeta[key] = schema124[key];
+    if (key in schema117) {
+      extraMeta[key] = schema117[key];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
-    if (key in schema124) {
-      extraMeta[key] = schema124[key];
+    if (key in schema117) {
+      extraMeta[key] = schema117[key];
     }
   }
-  for (const key of Object.keys(schema124)) {
+  for (const key of Object.keys(schema117)) {
     if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema124[key];
+      extraMeta[key] = schema117[key];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
     ctx.registry.add(baseSchema, extraMeta);
   }
-  if (schema124.description) {
-    baseSchema = baseSchema.describe(schema124.description);
+  if (schema117.description) {
+    baseSchema = baseSchema.describe(schema117.description);
   }
   return baseSchema;
 }
-function fromJSONSchema(schema124, params) {
-  if (typeof schema124 === "boolean") {
-    return schema124 ? z.any() : z.never();
+function fromJSONSchema(schema117, params) {
+  if (typeof schema117 === "boolean") {
+    return schema117 ? z.any() : z.never();
   }
   let normalized;
   try {
-    normalized = JSON.parse(JSON.stringify(schema124));
+    normalized = JSON.parse(JSON.stringify(schema117));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
@@ -45516,9 +45518,9 @@ var migration86 = {
     const d = def;
     const voiceProps = d.inputDefinition?.properties?.voice;
     if (voiceProps?.properties) {
-      for (const [name, schema124] of Object.entries(NEW_VOICE_INPUT_PROPERTIES)) {
+      for (const [name, schema117] of Object.entries(NEW_VOICE_INPUT_PROPERTIES)) {
         if (!voiceProps.properties[name])
-          voiceProps.properties[name] = schema124;
+          voiceProps.properties[name] = schema117;
       }
     }
     const advanced = d.form?.sections?.find((section) => section.id === "section-advanced");
@@ -47762,7 +47764,6 @@ __export2(core_datafabric_read_exports, {
   migrations: () => migrations47,
   v1_0: () => definition136,
   v1_1: () => definition137,
-  v1_2: () => definition138,
   versionHashes: () => versionHashes48
 });
 var inputDefinitionSchema91 = external_exports.object({
@@ -47966,123 +47967,6 @@ var definition137 = {
     ]
   }
 };
-var inputDefinitionSchema93 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema103 = external_exports.object({
-  id: external_exports.literal("read-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema112 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.read"),
-  version: external_exports.literal("1.2"),
-  inputDefinition: inputDefinitionSchema93,
-  form: formSchema103
-});
-var LABEL = "Read entity records";
-var LEGACY_LABEL = /^Read (?:Entity|entity)( \d+)?$/;
-var migration90 = {
-  nodeType: "core.datafabric.read",
-  from: "1.1",
-  to: "1.2",
-  description: "This node is now called Read entity records, so it reads as acting on records inside an entity rather than on the entity itself.",
-  applyDefinition(_def) {
-    return structuredClone(definition138);
-  },
-  applyInstance(node) {
-    const display = node.display;
-    if (typeof display?.label !== "string")
-      return node;
-    const match = LEGACY_LABEL.exec(display.label);
-    return match ? { ...node, display: { ...display, label: `${LABEL}${match[1] ?? ""}` } } : node;
-  }
-};
-var definition138 = {
-  nodeType: "core.datafabric.read",
-  version: "1.2",
-  category: "data",
-  description: "Read one or more entity records from Data Fabric",
-  tags: ["datafabric", "entity", "data", "read", "query"],
-  sortOrder: categorySortOrders["data"] + 5,
-  display: {
-    label: LABEL,
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          resultMode: {
-            type: "string",
-            enum: ["single", "multiple"],
-            description: "Whether the node reads one record or a list of records",
-            errorMessage: "Choose whether to read one record or multiple records"
-          }
-        },
-        required: ["entityName"],
-        errorMessage: { required: "An entity must be selected" }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: { resultMode: "single" }
-  },
-  outputDefinition: {
-    output: {
-      type: "jsonSchema",
-      description: 'Entity record read by this node, or the matching records under "results"',
-      source: "=response",
-      var: "output"
-    }
-  },
-  form: {
-    id: "read-entity-properties",
-    title: "Read entity records configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "entity-config", label: "" }]
-      }
-    ]
-  }
-};
 var NODE_I18N48 = {
   description: "manifest_node_readEntity_description",
   display: {
@@ -48103,15 +47987,14 @@ var NODE_I18N48 = {
   }
 };
 var NODE_I18N_OVERLAYS48 = {};
-var core_datafabric_read_default = definition138;
-var latest48 = definition138;
-var allVersions48 = [definition136, definition137, definition138];
-var latestSchema37 = schema112;
-var migrations47 = [migration89, migration90];
+var core_datafabric_read_default = definition137;
+var latest48 = definition137;
+var allVersions48 = [definition136, definition137];
+var latestSchema37 = schema111;
+var migrations47 = [migration89];
 var versionHashes48 = {
   "1.0": "ad95a30a0bb6612a808ee0508cb2298379f535e33a8cf1a1502c7f312216a1e5",
-  "1.1": "b651e40bd3ad016730662b4519124b15d3fcf8371e89ff847b23bddb46fa6620",
-  "1.2": "b6f55a3978936568149c73a4c0bb2c518c41e8cf2a3c81a1dd168ca0be4d42f3"
+  "1.1": "b651e40bd3ad016730662b4519124b15d3fcf8371e89ff847b23bddb46fa6620"
 };
 var uipath_document_classify_exports = {};
 __export2(uipath_document_classify_exports, {
@@ -48125,7 +48008,7 @@ __export2(uipath_document_classify_exports, {
   latest: () => latest49,
   latestSchema: () => latestSchema38,
   migrations: () => migrations48,
-  v1_0: () => definition139,
+  v1_0: () => definition138,
   versionHashes: () => versionHashes49
 });
 function hasFileResource(prop) {
@@ -48271,8 +48154,8 @@ function mapOutputTypes(props) {
 function parseOrchestratorIO(release) {
   let inputs;
   let inputProperties;
-  const resolveSchemaProperties = (schema124) => {
-    const parsed = toSchema(schema124);
+  const resolveSchemaProperties = (schema117) => {
+    const parsed = toSchema(schema117);
     const resolved = resolveJsonSchema(parsed).schema;
     return resolved.properties;
   };
@@ -48308,7 +48191,7 @@ function normalizeTags(tags) {
 function sanitizeNodeType(value) {
   return value.replace(/[^a-zA-Z0-9.]+/g, "-").toLowerCase();
 }
-var schema113 = {
+var schema112 = {
   $schema: "http://json-schema.org/draft-07/schema#",
   definitions: {
     "UiPath.DocumentProcessing.Contracts.Actions.DocumentActionPriority": {
@@ -51547,7 +51430,7 @@ var DOCUMENT_CLASSIFY_EVALUATION_TARGET = {
   attachmentPolicy: { acceptedExtensions: [".pdf", ".png", ".jpg", ".jpeg", ".tif", ".tiff"] }
 };
 var CLASSIFICATION_RESULT_SCHEMA = resolveJsonSchema({
-  ...schema113,
+  ...schema112,
   $ref: "#/definitions/UiPath.DocumentProcessing.Contracts.Results.ClassificationResult"
 }).schema;
 var DEFAULT_CLASSIFY_MODEL_CONFIG = {
@@ -51561,7 +51444,7 @@ var DEFAULT_CLASSIFICATION_SCHEMA = {
   generalInstructions: "",
   classes: []
 };
-var inputDefinitionSchema94 = external_exports.object({
+var inputDefinitionSchema93 = external_exports.object({
   type: external_exports.literal("object"),
   properties: external_exports.object({
     modelConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough(),
@@ -51575,7 +51458,7 @@ var outputDefinitionSchema70 = external_exports.object({
   output: external_exports.object({ type: external_exports.literal("object") }).passthrough(),
   error: external_exports.object({ type: external_exports.literal("object") }).passthrough()
 });
-var formSchema104 = external_exports.object({
+var formSchema103 = external_exports.object({
   id: external_exports.literal("classify-document-properties"),
   title: external_exports.string(),
   sections: external_exports.tuple([
@@ -51599,14 +51482,14 @@ var formSchema104 = external_exports.object({
     }).passthrough()
   ])
 }).passthrough();
-var schema114 = nodeManifestSchema.extend({
+var schema113 = nodeManifestSchema.extend({
   nodeType: external_exports.literal("uipath.document.classify"),
   version: external_exports.literal("1.0"),
-  inputDefinition: inputDefinitionSchema94,
+  inputDefinition: inputDefinitionSchema93,
   outputDefinition: outputDefinitionSchema70,
-  form: formSchema104
+  form: formSchema103
 });
-var definition139 = {
+var definition138 = {
   nodeType: "uipath.document.classify",
   version: "1.0",
   category: "document-processing",
@@ -51760,10 +51643,10 @@ var NODE_I18N49 = {
   }
 };
 var NODE_I18N_OVERLAYS49 = {};
-var uipath_document_classify_default = definition139;
-var latest49 = definition139;
-var allVersions49 = [definition139];
-var latestSchema38 = schema114;
+var uipath_document_classify_default = definition138;
+var latest49 = definition138;
+var allVersions49 = [definition138];
+var latestSchema38 = schema113;
 var migrations48 = [];
 var versionHashes49 = {
   "1.0": "6ee9b556527bb29d35f58f67efa522cda1d3e1b136e4bb0f4766ce66683fe7fb"
@@ -51777,18 +51660,16 @@ __export2(core_datafabric_update_exports, {
   latest: () => latest50,
   latestSchema: () => latestSchema39,
   migrations: () => migrations49,
-  v1_0: () => definition140,
-  v1_1: () => definition141,
-  v1_2: () => definition142,
+  v1_0: () => definition139,
   versionHashes: () => versionHashes50
 });
-var inputDefinitionSchema95 = external_exports.object({
+var inputDefinitionSchema94 = external_exports.object({
   type: external_exports.literal("object"),
   properties: external_exports.object({
     entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
   }).passthrough()
 }).passthrough();
-var formSchema105 = external_exports.object({
+var formSchema104 = external_exports.object({
   id: external_exports.literal("update-entity-properties"),
   title: external_exports.string(),
   sections: external_exports.tuple([
@@ -51804,13 +51685,13 @@ var formSchema105 = external_exports.object({
     }).passthrough()
   ])
 }).passthrough();
-var schema115 = nodeManifestSchema.extend({
+var schema114 = nodeManifestSchema.extend({
   nodeType: external_exports.literal("core.datafabric.update"),
   version: external_exports.literal("1.0"),
-  inputDefinition: inputDefinitionSchema95,
-  form: formSchema105
+  inputDefinition: inputDefinitionSchema94,
+  form: formSchema104
 });
-var definition140 = {
+var definition139 = {
   nodeType: "core.datafabric.update",
   version: "1.0",
   category: "data",
@@ -51844,749 +51725,25 @@ var definition140 = {
         type: "object",
         properties: {
           entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: { type: "string" },
-          readEntityNodeId: { type: "string" },
-          fieldUpdates: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: { field: { type: "string", pattern: "\\S" } },
-              required: ["field"]
-            },
-            errorMessage: "Select a field to update"
-          }
-        },
-        required: ["entityName", "fieldUpdates"],
-        allOf: [
-          {
-            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
-            then: {
-              required: ["recordId"],
-              properties: { recordId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A record ID is required"
-            }
-          },
-          {
-            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
-            then: {
-              required: ["readEntityNodeId"],
-              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A Read entity node must be selected"
-            }
-          }
-        ],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            fieldUpdates: "Select a field to update"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  outputDefinition: {
-    output: { type: "jsonSchema", description: "Entity record after the update", source: "=response", var: "output" }
-  },
-  form: {
-    id: "update-entity-properties",
-    title: "Update entity configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "update-entity-config", label: "" }]
-      }
-    ]
-  }
-};
-var inputDefinitionSchema96 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema106 = external_exports.object({
-  id: external_exports.literal("update-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("update-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema116 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.update"),
-  version: external_exports.literal("1.1"),
-  inputDefinition: inputDefinitionSchema96,
-  form: formSchema106
-});
-var NON_BLANK_EXPRESSION = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var RECORD_ID_TYPE = { anyOf: [{ type: "string" }, NON_BLANK_EXPRESSION] };
-var RECORD_ID_PRESENT = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION] };
-var migration91 = {
-  nodeType: "core.datafabric.update",
-  from: "1.0",
-  to: "1.1",
-  description: "The values you write accept any expression, and the record ID accepts a variable or a single-term one.",
-  applyDefinition(_def) {
-    return structuredClone(definition141);
-  },
-  applyInstance(node) {
-    return node;
-  }
-};
-var definition141 = {
-  nodeType: "core.datafabric.update",
-  version: "1.1",
-  category: "data",
-  description: "Update an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "update", "write"],
-  sortOrder: categorySortOrders["data"] + 6,
-  display: {
-    label: "Update entity",
-    canvasLabel: "Update entity",
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: RECORD_ID_TYPE,
-          readEntityNodeId: { type: "string" },
-          fieldUpdates: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: { field: { type: "string", pattern: "\\S" } },
-              required: ["field"]
-            },
-            errorMessage: "Select a field to update"
-          }
-        },
-        required: ["entityName", "fieldUpdates"],
-        allOf: [
-          {
-            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
-            then: {
-              required: ["recordId"],
-              properties: { recordId: RECORD_ID_PRESENT },
-              errorMessage: "A record ID is required"
-            }
-          },
-          {
-            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
-            then: {
-              required: ["readEntityNodeId"],
-              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A Read entity node must be selected"
-            }
-          }
-        ],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            fieldUpdates: "Select a field to update"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  outputDefinition: {
-    output: { type: "jsonSchema", description: "Entity record after the update", source: "=response", var: "output" }
-  },
-  form: {
-    id: "update-entity-properties",
-    title: "Update entity configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "update-entity-config", label: "" }]
-      }
-    ]
-  }
-};
-var inputDefinitionSchema97 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema107 = external_exports.object({
-  id: external_exports.literal("update-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("update-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema117 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.update"),
-  version: external_exports.literal("1.2"),
-  inputDefinition: inputDefinitionSchema97,
-  form: formSchema107
-});
-var NON_BLANK_EXPRESSION2 = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var RECORD_ID_TYPE2 = { anyOf: [{ type: "string" }, NON_BLANK_EXPRESSION2] };
-var RECORD_ID_PRESENT2 = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION2] };
-var LABEL2 = "Update entity record";
-var LEGACY_LABEL2 = /^Update entity( \d+)?$/;
-var migration92 = {
-  nodeType: "core.datafabric.update",
-  from: "1.1",
-  to: "1.2",
-  description: "This node is now called Update entity record, so it reads as changing a record inside an entity rather than the entity itself.",
-  applyDefinition(_def) {
-    return structuredClone(definition142);
-  },
-  applyInstance(node) {
-    const display = node.display;
-    if (typeof display?.label !== "string")
-      return node;
-    const match = LEGACY_LABEL2.exec(display.label);
-    return match ? { ...node, display: { ...display, label: `${LABEL2}${match[1] ?? ""}` } } : node;
-  }
-};
-var definition142 = {
-  nodeType: "core.datafabric.update",
-  version: "1.2",
-  category: "data",
-  description: "Update an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "update", "write"],
-  sortOrder: categorySortOrders["data"] + 6,
-  display: {
-    label: LABEL2,
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: RECORD_ID_TYPE2,
-          readEntityNodeId: { type: "string" },
-          fieldUpdates: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: { field: { type: "string", pattern: "\\S" } },
-              required: ["field"]
-            },
-            errorMessage: "Select a field to update"
-          }
-        },
-        required: ["entityName", "fieldUpdates"],
-        allOf: [
-          {
-            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
-            then: {
-              required: ["recordId"],
-              properties: { recordId: RECORD_ID_PRESENT2 },
-              errorMessage: "A record ID is required"
-            }
-          },
-          {
-            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
-            then: {
-              required: ["readEntityNodeId"],
-              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "Select a Read entity records node"
-            }
-          }
-        ],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            fieldUpdates: "Select a field to update"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  outputDefinition: {
-    output: { type: "jsonSchema", description: "Entity record after the update", source: "=response", var: "output" }
-  },
-  form: {
-    id: "update-entity-properties",
-    title: "Update entity record configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "update-entity-config", label: "" }]
-      }
-    ]
-  }
-};
-var NODE_I18N50 = {
-  description: "manifest_node_updateEntity_description",
-  display: {
-    label: "manifest_node_updateEntity_display_label"
-  },
-  outputDefinition: {
-    output: {
-      description: "manifest_node_updateEntity_output_output_description"
-    }
-  },
-  form: {
-    title: "manifest_node_updateEntity_form_title",
-    sections: {
-      "entity-config": {
-        title: "manifest_node_updateEntity_form_entityConfig_title"
-      }
-    }
-  }
-};
-var NODE_I18N_OVERLAYS50 = {};
-var core_datafabric_update_default = definition142;
-var latest50 = definition142;
-var allVersions50 = [definition140, definition141, definition142];
-var latestSchema39 = schema117;
-var migrations49 = [migration91, migration92];
-var versionHashes50 = {
-  "1.0": "bd31f98cd75b1db33103e3e5ead539ed527f9b58cee62129798ae2663a1ed3b6",
-  "1.1": "920799f60ff251a9ed2401e14d2b79eabdc4cbd656b4bd7a4fcceff6e1a3c3c8",
-  "1.2": "0e2e94ff1a6b85bd1d5f40f22e8bb606ad2c2d9f4519bbaf28b17715a7a8db23"
-};
-var core_datafabric_delete_exports = {};
-__export2(core_datafabric_delete_exports, {
-  NODE_I18N: () => NODE_I18N51,
-  NODE_I18N_OVERLAYS: () => NODE_I18N_OVERLAYS51,
-  allVersions: () => allVersions51,
-  default: () => core_datafabric_delete_default,
-  latest: () => latest51,
-  latestSchema: () => latestSchema40,
-  migrations: () => migrations50,
-  v1_0: () => definition143,
-  v1_1: () => definition144,
-  v1_2: () => definition145,
-  versionHashes: () => versionHashes51
-});
-var inputDefinitionSchema98 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema108 = external_exports.object({
-  id: external_exports.literal("delete-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("delete-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema118 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.delete"),
-  version: external_exports.literal("1.0"),
-  inputDefinition: inputDefinitionSchema98,
-  form: formSchema108
-});
-var definition143 = {
-  nodeType: "core.datafabric.delete",
-  version: "1.0",
-  category: "data",
-  description: "Delete an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "delete", "write"],
-  sortOrder: categorySortOrders["data"] + 8,
-  display: {
-    label: "Delete entity",
-    canvasLabel: "Delete entity",
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: { type: "string" },
-          readEntityNodeId: { type: "string" }
-        },
-        required: ["entityName", "recordSource"],
-        allOf: [
-          {
-            properties: { recordSource: { type: "string", enum: ["byId", "fromRead"] } },
-            errorMessage: "Choose how to identify the record"
-          },
-          {
-            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
-            then: {
-              required: ["recordId"],
-              properties: { recordId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A record ID is required"
-            }
-          },
-          {
-            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
-            then: {
-              required: ["readEntityNodeId"],
-              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A Read entity node must be selected"
-            }
-          }
-        ],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            recordSource: "Choose how to identify the record"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  form: {
-    id: "delete-entity-properties",
-    title: "Delete entity configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "delete-entity-config", label: "" }]
-      }
-    ]
-  }
-};
-var inputDefinitionSchema99 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema109 = external_exports.object({
-  id: external_exports.literal("delete-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("delete-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema119 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.delete"),
-  version: external_exports.literal("1.1"),
-  inputDefinition: inputDefinitionSchema99,
-  form: formSchema109
-});
-var NON_BLANK_EXPRESSION3 = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var RECORD_ID_TYPE3 = { anyOf: [{ type: "string" }, NON_BLANK_EXPRESSION3] };
-var RECORD_ID_PRESENT3 = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION3] };
-var migration93 = {
-  nodeType: "core.datafabric.delete",
-  from: "1.0",
-  to: "1.1",
-  description: "The record ID accepts a variable or a single-term expression as well as a fixed value.",
-  applyDefinition(_def) {
-    return structuredClone(definition144);
-  },
-  applyInstance(node) {
-    return node;
-  }
-};
-var definition144 = {
-  nodeType: "core.datafabric.delete",
-  version: "1.1",
-  category: "data",
-  description: "Delete an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "delete", "write"],
-  sortOrder: categorySortOrders["data"] + 8,
-  display: {
-    label: "Delete entity",
-    canvasLabel: "Delete entity",
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: RECORD_ID_TYPE3,
-          readEntityNodeId: { type: "string" }
-        },
-        required: ["entityName", "recordSource"],
-        allOf: [
-          {
-            properties: { recordSource: { type: "string", enum: ["byId", "fromRead"] } },
-            errorMessage: "Choose how to identify the record"
-          },
-          {
-            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
-            then: {
-              required: ["recordId"],
-              properties: { recordId: RECORD_ID_PRESENT3 },
-              errorMessage: "A record ID is required"
-            }
-          },
-          {
-            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
-            then: {
-              required: ["readEntityNodeId"],
-              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "A Read entity node must be selected"
-            }
-          }
-        ],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            recordSource: "Choose how to identify the record"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  form: {
-    id: "delete-entity-properties",
-    title: "Delete entity configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "delete-entity-config", label: "" }]
-      }
-    ]
-  }
-};
-var inputDefinitionSchema100 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema110 = external_exports.object({
-  id: external_exports.literal("delete-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("delete-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema120 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.delete"),
-  version: external_exports.literal("1.2"),
-  inputDefinition: inputDefinitionSchema100,
-  form: formSchema110
-});
-var NON_BLANK_EXPRESSION4 = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var RECORD_ID_TYPE4 = { anyOf: [{ type: "string" }, NON_BLANK_EXPRESSION4] };
-var RECORD_ID_PRESENT4 = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION4] };
-var LABEL3 = "Delete entity record";
-var LEGACY_LABEL3 = /^Delete entity( \d+)?$/;
-var migration94 = {
-  nodeType: "core.datafabric.delete",
-  from: "1.1",
-  to: "1.2",
-  description: "This node is now called Delete entity record, so it reads as removing a record from an entity rather than deleting the entity itself.",
-  applyDefinition(_def) {
-    return structuredClone(definition145);
-  },
-  applyInstance(node) {
-    const display = node.display;
-    if (typeof display?.label !== "string")
-      return node;
-    const match = LEGACY_LABEL3.exec(display.label);
-    return match ? { ...node, display: { ...display, label: `${LABEL3}${match[1] ?? ""}` } } : node;
-  }
-};
-var definition145 = {
-  nodeType: "core.datafabric.delete",
-  version: "1.2",
-  category: "data",
-  description: "Delete an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "delete", "write"],
-  sortOrder: categorySortOrders["data"] + 8,
-  display: {
-    label: LABEL3,
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          recordId: RECORD_ID_TYPE4,
-          readEntityNodeId: { type: "string" }
+          recordId: { type: "string" },
+          readEntityNodeId: { type: "string" },
+          fieldUpdates: {
+            type: "array",
+            contains: {
+              type: "object",
+              properties: { field: { type: "string", pattern: "\\S" } },
+              required: ["field"]
+            },
+            errorMessage: "Select a field to update"
+          }
         },
-        required: ["entityName", "recordSource"],
+        required: ["entityName", "fieldUpdates"],
         allOf: [
-          {
-            properties: { recordSource: { type: "string", enum: ["byId", "fromRead"] } },
-            errorMessage: "Choose how to identify the record"
-          },
           {
             if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
             then: {
               required: ["recordId"],
-              properties: { recordId: RECORD_ID_PRESENT4 },
+              properties: { recordId: { type: "string", pattern: "\\S" } },
               errorMessage: "A record ID is required"
             }
           },
@@ -52595,14 +51752,14 @@ var definition145 = {
             then: {
               required: ["readEntityNodeId"],
               properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
-              errorMessage: "Select a Read entity records node"
+              errorMessage: "A Read entity node must be selected"
             }
           }
         ],
         errorMessage: {
           required: {
             entityName: "An entity must be selected",
-            recordSource: "Choose how to identify the record"
+            fieldUpdates: "Select a field to update"
           }
         }
       }
@@ -52612,67 +51769,71 @@ var definition145 = {
   inputDefaults: {
     entityConfig: {}
   },
+  outputDefinition: {
+    output: { type: "jsonSchema", description: "Entity record after the update", source: "=response", var: "output" }
+  },
   form: {
-    id: "delete-entity-properties",
-    title: "Delete entity record configuration",
+    id: "update-entity-properties",
+    title: "Update entity configuration",
     sections: [
       {
         id: "entity-config",
         title: "Entity configuration",
         collapsible: true,
         defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "delete-entity-config", label: "" }]
+        fields: [{ name: "inputs.entityConfig", type: "custom", component: "update-entity-config", label: "" }]
       }
     ]
   }
 };
-var NODE_I18N51 = {
-  description: "manifest_node_deleteEntity_description",
+var NODE_I18N50 = {
+  description: "manifest_node_updateEntity_description",
   display: {
-    label: "manifest_node_deleteEntity_display_label"
+    label: "manifest_node_updateEntity_display_label"
+  },
+  outputDefinition: {
+    output: {
+      description: "manifest_node_updateEntity_output_output_description"
+    }
   },
   form: {
-    title: "manifest_node_deleteEntity_form_title",
+    title: "manifest_node_updateEntity_form_title",
     sections: {
       "entity-config": {
-        title: "manifest_node_deleteEntity_form_entityConfig_title"
+        title: "manifest_node_updateEntity_form_entityConfig_title"
       }
     }
   }
 };
-var NODE_I18N_OVERLAYS51 = {};
-var core_datafabric_delete_default = definition145;
-var latest51 = definition145;
-var allVersions51 = [definition143, definition144, definition145];
-var latestSchema40 = schema120;
-var migrations50 = [migration93, migration94];
-var versionHashes51 = {
-  "1.0": "50a06db83b00fbe4e2aaf3c4aa3552106bc42c588c167c4a2293005f9d88954e",
-  "1.1": "ee47da9599a22e1309aed622533cf769314db5e0648c0d734dcdaf4ee5d0819b",
-  "1.2": "79403f2b61af692b3ef3de76e28cd1f92ac7cc74906e4a34674df8fdf0b69951"
+var NODE_I18N_OVERLAYS50 = {};
+var core_datafabric_update_default = definition139;
+var latest50 = definition139;
+var allVersions50 = [definition139];
+var latestSchema39 = schema114;
+var migrations49 = [];
+var versionHashes50 = {
+  "1.0": "bd31f98cd75b1db33103e3e5ead539ed527f9b58cee62129798ae2663a1ed3b6"
 };
-var core_datafabric_create_exports = {};
-__export2(core_datafabric_create_exports, {
-  NODE_I18N: () => NODE_I18N52,
-  NODE_I18N_OVERLAYS: () => NODE_I18N_OVERLAYS52,
-  allVersions: () => allVersions52,
-  default: () => core_datafabric_create_default,
-  latest: () => latest52,
-  latestSchema: () => latestSchema41,
-  migrations: () => migrations51,
-  v1_0: () => definition146,
-  v1_1: () => definition147,
-  v1_2: () => definition148,
-  versionHashes: () => versionHashes52
+var core_datafabric_delete_exports = {};
+__export2(core_datafabric_delete_exports, {
+  NODE_I18N: () => NODE_I18N51,
+  NODE_I18N_OVERLAYS: () => NODE_I18N_OVERLAYS51,
+  allVersions: () => allVersions51,
+  default: () => core_datafabric_delete_default,
+  latest: () => latest51,
+  latestSchema: () => latestSchema40,
+  migrations: () => migrations50,
+  v1_0: () => definition140,
+  versionHashes: () => versionHashes51
 });
-var inputDefinitionSchema101 = external_exports.object({
+var inputDefinitionSchema95 = external_exports.object({
   type: external_exports.literal("object"),
   properties: external_exports.object({
     entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
   }).passthrough()
 }).passthrough();
-var formSchema111 = external_exports.object({
-  id: external_exports.literal("create-entity-properties"),
+var formSchema105 = external_exports.object({
+  id: external_exports.literal("delete-entity-properties"),
   title: external_exports.string(),
   sections: external_exports.tuple([
     external_exports.object({
@@ -52681,28 +51842,28 @@ var formSchema111 = external_exports.object({
         external_exports.object({
           name: external_exports.literal("inputs.entityConfig"),
           type: external_exports.literal("custom"),
-          component: external_exports.literal("create-entity-config")
+          component: external_exports.literal("delete-entity-config")
         }).passthrough()
       ])
     }).passthrough()
   ])
 }).passthrough();
-var schema121 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.create"),
+var schema115 = nodeManifestSchema.extend({
+  nodeType: external_exports.literal("core.datafabric.delete"),
   version: external_exports.literal("1.0"),
-  inputDefinition: inputDefinitionSchema101,
-  form: formSchema111
+  inputDefinition: inputDefinitionSchema95,
+  form: formSchema105
 });
-var definition146 = {
-  nodeType: "core.datafabric.create",
+var definition140 = {
+  nodeType: "core.datafabric.delete",
   version: "1.0",
   category: "data",
-  description: "Create an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "create", "insert", "write"],
-  sortOrder: categorySortOrders["data"] + 7,
+  description: "Delete an entity record in Data Fabric",
+  tags: ["datafabric", "entity", "data", "delete", "write"],
+  sortOrder: categorySortOrders["data"] + 8,
   display: {
-    label: "Create entity",
-    canvasLabel: "Create entity",
+    label: "Delete entity",
+    canvasLabel: "Delete entity",
     icon: "layers-arrow-up-right"
   },
   handleConfiguration: [
@@ -52727,21 +51888,36 @@ var definition146 = {
         type: "object",
         properties: {
           entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          fieldValues: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: { field: { type: "string", pattern: "\\S" }, value: { type: "string", pattern: "\\S" } },
-              required: ["field", "value"]
-            },
-            errorMessage: "Set a value for at least one field"
-          }
+          recordId: { type: "string" },
+          readEntityNodeId: { type: "string" }
         },
-        required: ["entityName", "fieldValues"],
+        required: ["entityName", "recordSource"],
+        allOf: [
+          {
+            properties: { recordSource: { type: "string", enum: ["byId", "fromRead"] } },
+            errorMessage: "Choose how to identify the record"
+          },
+          {
+            if: { properties: { recordSource: { const: "byId" } }, required: ["recordSource"] },
+            then: {
+              required: ["recordId"],
+              properties: { recordId: { type: "string", pattern: "\\S" } },
+              errorMessage: "A record ID is required"
+            }
+          },
+          {
+            if: { properties: { recordSource: { const: "fromRead" } }, required: ["recordSource"] },
+            then: {
+              required: ["readEntityNodeId"],
+              properties: { readEntityNodeId: { type: "string", pattern: "\\S" } },
+              errorMessage: "A Read entity node must be selected"
+            }
+          }
+        ],
         errorMessage: {
           required: {
             entityName: "An entity must be selected",
-            fieldValues: "Set a value for at least one field"
+            recordSource: "Choose how to identify the record"
           }
         }
       }
@@ -52751,151 +51927,62 @@ var definition146 = {
   inputDefaults: {
     entityConfig: {}
   },
-  outputDefinition: {
-    output: { type: "jsonSchema", description: "Fields written by this node", source: "=response", var: "output" }
-  },
   form: {
-    id: "create-entity-properties",
-    title: "Create entity configuration",
+    id: "delete-entity-properties",
+    title: "Delete entity configuration",
     sections: [
       {
         id: "entity-config",
         title: "Entity configuration",
         collapsible: true,
         defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "create-entity-config", label: "" }]
+        fields: [{ name: "inputs.entityConfig", type: "custom", component: "delete-entity-config", label: "" }]
       }
     ]
   }
 };
-var inputDefinitionSchema102 = external_exports.object({
-  type: external_exports.literal("object"),
-  properties: external_exports.object({
-    entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
-  }).passthrough()
-}).passthrough();
-var formSchema112 = external_exports.object({
-  id: external_exports.literal("create-entity-properties"),
-  title: external_exports.string(),
-  sections: external_exports.tuple([
-    external_exports.object({
-      id: external_exports.literal("entity-config"),
-      fields: external_exports.tuple([
-        external_exports.object({
-          name: external_exports.literal("inputs.entityConfig"),
-          type: external_exports.literal("custom"),
-          component: external_exports.literal("create-entity-config")
-        }).passthrough()
-      ])
-    }).passthrough()
-  ])
-}).passthrough();
-var schema122 = nodeManifestSchema.extend({
-  nodeType: external_exports.literal("core.datafabric.create"),
-  version: external_exports.literal("1.1"),
-  inputDefinition: inputDefinitionSchema102,
-  form: formSchema112
-});
-var NON_BLANK_EXPRESSION5 = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var FIELD_VALUE_PRESENT = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION5] };
-var migration95 = {
-  nodeType: "core.datafabric.create",
-  from: "1.0",
-  to: "1.1",
-  description: "The values you write accept an expression as well as a fixed value.",
-  applyDefinition(_def) {
-    return structuredClone(definition147);
-  },
-  applyInstance(node) {
-    return node;
-  }
-};
-var definition147 = {
-  nodeType: "core.datafabric.create",
-  version: "1.1",
-  category: "data",
-  description: "Create an entity record in Data Fabric",
-  tags: ["datafabric", "entity", "data", "create", "insert", "write"],
-  sortOrder: categorySortOrders["data"] + 7,
+var NODE_I18N51 = {
+  description: "manifest_node_deleteEntity_description",
   display: {
-    label: "Create entity",
-    canvasLabel: "Create entity",
-    icon: "layers-arrow-up-right"
-  },
-  handleConfiguration: [
-    {
-      position: "left",
-      handles: [{ id: "input", type: "target", handleType: "input" }]
-    },
-    {
-      position: "right",
-      handles: [{ id: "output", type: "source", handleType: "output" }]
-    }
-  ],
-  model: {
-    type: "bpmn:Task",
-    debug: { runtime: "bpmnEngine" }
-  },
-  runtimeConstraints: { exclude: ["api-function"] },
-  inputDefinition: {
-    type: "object",
-    properties: {
-      entityConfig: {
-        type: "object",
-        properties: {
-          entityName: { type: "string", minLength: 1, errorMessage: "An entity must be selected" },
-          fieldValues: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: { field: { type: "string", pattern: "\\S" }, value: FIELD_VALUE_PRESENT },
-              required: ["field", "value"]
-            },
-            errorMessage: "Set a value for at least one field"
-          }
-        },
-        required: ["entityName", "fieldValues"],
-        errorMessage: {
-          required: {
-            entityName: "An entity must be selected",
-            fieldValues: "Set a value for at least one field"
-          }
-        }
-      }
-    },
-    required: ["entityConfig"]
-  },
-  inputDefaults: {
-    entityConfig: {}
-  },
-  outputDefinition: {
-    output: { type: "jsonSchema", description: "Fields written by this node", source: "=response", var: "output" }
+    label: "manifest_node_deleteEntity_display_label"
   },
   form: {
-    id: "create-entity-properties",
-    title: "Create entity configuration",
-    sections: [
-      {
-        id: "entity-config",
-        title: "Entity configuration",
-        collapsible: true,
-        defaultExpanded: true,
-        fields: [{ name: "inputs.entityConfig", type: "custom", component: "create-entity-config", label: "" }]
+    title: "manifest_node_deleteEntity_form_title",
+    sections: {
+      "entity-config": {
+        title: "manifest_node_deleteEntity_form_entityConfig_title"
       }
-    ]
+    }
   }
 };
-var inputDefinitionSchema103 = external_exports.object({
+var NODE_I18N_OVERLAYS51 = {};
+var core_datafabric_delete_default = definition140;
+var latest51 = definition140;
+var allVersions51 = [definition140];
+var latestSchema40 = schema115;
+var migrations50 = [];
+var versionHashes51 = {
+  "1.0": "50a06db83b00fbe4e2aaf3c4aa3552106bc42c588c167c4a2293005f9d88954e"
+};
+var core_datafabric_create_exports = {};
+__export2(core_datafabric_create_exports, {
+  NODE_I18N: () => NODE_I18N52,
+  NODE_I18N_OVERLAYS: () => NODE_I18N_OVERLAYS52,
+  allVersions: () => allVersions52,
+  default: () => core_datafabric_create_default,
+  latest: () => latest52,
+  latestSchema: () => latestSchema41,
+  migrations: () => migrations51,
+  v1_0: () => definition141,
+  versionHashes: () => versionHashes52
+});
+var inputDefinitionSchema96 = external_exports.object({
   type: external_exports.literal("object"),
   properties: external_exports.object({
     entityConfig: external_exports.object({ type: external_exports.literal("object") }).passthrough()
   }).passthrough()
 }).passthrough();
-var formSchema113 = external_exports.object({
+var formSchema106 = external_exports.object({
   id: external_exports.literal("create-entity-properties"),
   title: external_exports.string(),
   sections: external_exports.tuple([
@@ -52911,45 +51998,22 @@ var formSchema113 = external_exports.object({
     }).passthrough()
   ])
 }).passthrough();
-var schema123 = nodeManifestSchema.extend({
+var schema116 = nodeManifestSchema.extend({
   nodeType: external_exports.literal("core.datafabric.create"),
-  version: external_exports.literal("1.2"),
-  inputDefinition: inputDefinitionSchema103,
-  form: formSchema113
+  version: external_exports.literal("1.0"),
+  inputDefinition: inputDefinitionSchema96,
+  form: formSchema106
 });
-var NON_BLANK_EXPRESSION6 = {
-  type: "object",
-  properties: { type: { const: "jsExpression" }, expression: { type: "string", pattern: "\\S" } },
-  required: ["type", "expression"]
-};
-var FIELD_VALUE_PRESENT2 = { anyOf: [{ type: "string", pattern: "\\S" }, NON_BLANK_EXPRESSION6] };
-var LABEL4 = "Create entity record";
-var LEGACY_LABEL4 = /^Create entity( \d+)?$/;
-var migration96 = {
-  nodeType: "core.datafabric.create",
-  from: "1.1",
-  to: "1.2",
-  description: "This node is now called Create entity record, so it reads as adding a record to an entity rather than creating the entity itself.",
-  applyDefinition(_def) {
-    return structuredClone(definition148);
-  },
-  applyInstance(node) {
-    const display = node.display;
-    if (typeof display?.label !== "string")
-      return node;
-    const match = LEGACY_LABEL4.exec(display.label);
-    return match ? { ...node, display: { ...display, label: `${LABEL4}${match[1] ?? ""}` } } : node;
-  }
-};
-var definition148 = {
+var definition141 = {
   nodeType: "core.datafabric.create",
-  version: "1.2",
+  version: "1.0",
   category: "data",
   description: "Create an entity record in Data Fabric",
   tags: ["datafabric", "entity", "data", "create", "insert", "write"],
   sortOrder: categorySortOrders["data"] + 7,
   display: {
-    label: LABEL4,
+    label: "Create entity",
+    canvasLabel: "Create entity",
     icon: "layers-arrow-up-right"
   },
   handleConfiguration: [
@@ -52978,7 +52042,7 @@ var definition148 = {
             type: "array",
             contains: {
               type: "object",
-              properties: { field: { type: "string", pattern: "\\S" }, value: FIELD_VALUE_PRESENT2 },
+              properties: { field: { type: "string", pattern: "\\S" }, value: { type: "string", pattern: "\\S" } },
               required: ["field", "value"]
             },
             errorMessage: "Set a value for at least one field"
@@ -53003,7 +52067,7 @@ var definition148 = {
   },
   form: {
     id: "create-entity-properties",
-    title: "Create entity record configuration",
+    title: "Create entity configuration",
     sections: [
       {
         id: "entity-config",
@@ -53035,15 +52099,13 @@ var NODE_I18N52 = {
   }
 };
 var NODE_I18N_OVERLAYS52 = {};
-var core_datafabric_create_default = definition148;
-var latest52 = definition148;
-var allVersions52 = [definition146, definition147, definition148];
-var latestSchema41 = schema123;
-var migrations51 = [migration95, migration96];
+var core_datafabric_create_default = definition141;
+var latest52 = definition141;
+var allVersions52 = [definition141];
+var latestSchema41 = schema116;
+var migrations51 = [];
 var versionHashes52 = {
-  "1.0": "b1dbd6e0f4c7be63dec257c588231ed0f75e29bf18dda1b4fb3fee41184e2f1e",
-  "1.1": "f85e7ff94c525e6add9d2f4d5add0add5e0ed82e53f40bfe608781bad8e24535",
-  "1.2": "07eda33f78b688ad3cefb6f971f33a60810d335636202bc85900fde35c7e9dc1"
+  "1.0": "b1dbd6e0f4c7be63dec257c588231ed0f75e29bf18dda1b4fb3fee41184e2f1e"
 };
 var allNodeModules = [
   core_action_script_exports,
@@ -53102,14 +52164,14 @@ var allNodeModules = [
 var nodeModuleRegistry = Object.fromEntries(allNodeModules.map((m) => [m.latest.nodeType, m]));
 var allDefinitions = allNodeModules.flatMap((m) => m.allVersions);
 var latestDefinitions = allNodeModules.map((m) => m.latest);
-var latestDefinitionsByNodeType = new Map(latestDefinitions.map((definition149) => [definition149.nodeType, definition149]));
+var latestDefinitionsByNodeType = new Map(latestDefinitions.map((definition142) => [definition142.nodeType, definition142]));
 function getLatestDefinitionByNodeType(nodeType) {
   return latestDefinitionsByNodeType.get(nodeType);
 }
 function getManifestKey(nodeType, version2) {
   return `${nodeType}:${version2}`;
 }
-var definitionsByKey = new Map(allDefinitions.map((definition149) => [getManifestKey(definition149.nodeType, definition149.version), definition149]));
+var definitionsByKey = new Map(allDefinitions.map((definition142) => [getManifestKey(definition142.nodeType, definition142.version), definition142]));
 var publicOotbModules = [
   core_logic_mock_exports,
   core_logic_decision_exports,
@@ -53406,9 +52468,9 @@ function createModel(input) {
     ]
   };
 }
-function buildInputField(key, formType, schema124) {
+function buildInputField(key, formType, schema117) {
   if (formType === "object" || formType === "array") {
-    const effectiveSchema = schema124 ?? (formType === "array" ? { type: "array" } : undefined);
+    const effectiveSchema = schema117 ?? (formType === "array" ? { type: "array" } : undefined);
     return {
       name: "inputs." + key,
       type: "custom",
@@ -53716,11 +52778,11 @@ var DYNAMIC_EXTRACT_INPUT_DEFINITION = {
   required: ["fileRef"]
 };
 var TAXONOMY_SCHEMA = resolveJsonSchema({
-  ...schema113,
+  ...schema112,
   $ref: "#/definitions/UiPath.DocumentProcessing.Contracts.Taxonomy.DocumentTaxonomy"
 }).schema;
 var EXTRACTION_RESULT_SCHEMA = resolveJsonSchema({
-  ...schema113,
+  ...schema112,
   $ref: "#/definitions/UiPath.DocumentProcessing.Contracts.Results.ExtractionResult"
 }).schema;
 var IXP_OUTPUT_DEFINITION = {
@@ -55058,7 +54120,7 @@ function mapRelease(release, isAsync = false) {
   };
 }
 async function fetchOrchestratorPage(baseUrl, organizationId, tenantName, token, processType, skip, top) {
-  const url2 = `${baseUrl}/${organizationId}/${tenantName}/orchestrator_/odata/Releases/UiPath.Server.Configuration.OData.ListReleases?$select=${ORCH_SELECT}&$top=${top}&$skip=${skip}&$expand=${ORCH_EXPAND}&$orderby=Name%20asc&$filter=((ProcessType eq '${processType}'))&$count=true`;
+  const url2 = `${baseUrl}/${organizationId}/${tenantName}/orchestrator_/odata/Releases/UiPath.Server.Configuration.OData.ListReleases?$select=${ORCH_SELECT}&$top=${top}&$skip=${skip}&$expand=${ORCH_EXPAND}&$orderby=Name%20asc&$filter=((ProcessType eq '${processType}') and (OrganizationUnitType ne 'DebugSolution'))&$count=true`;
   const response = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
   if (!response.ok)
     throw new Error(`Orchestrator ${processType} fetch failed: ${response.status}`);
@@ -55077,9 +54139,11 @@ async function fetchAllReleasesForType(baseUrl, organizationId, tenantName, toke
   const totalPages = Math.ceil(first.totalCount / pageSize);
   if (totalPages > 1) {
     const remaining = await Promise.allSettled(Array.from({ length: totalPages - 1 }, (_, i) => fetchOrchestratorPage(baseUrl, organizationId, tenantName, token, processType, (i + 1) * pageSize, pageSize)));
-    for (const result of remaining) {
+    for (const [i, result] of remaining.entries()) {
       if (result.status === "fulfilled")
         Object.assign(all, result.value.items);
+      else
+        console.warn(`[fetchAllReleasesForType] ${processType} page ${i + 1} dropped:`, result.reason);
     }
   }
   return all;
@@ -55722,7 +54786,13 @@ var _ManifestClient = class _ManifestClient2 {
     branches.push({
       name: "orchestrator",
       run: async () => {
-        const { nodes } = await this.fetchers.fetchOrchestratorNodes({ ...config2, disabledResourceTypes: options.disabledResourceTypes });
+        const { nodes, failures } = await this.fetchers.fetchOrchestratorNodes({
+          ...config2,
+          disabledResourceTypes: options.disabledResourceTypes
+        });
+        if (failures.length) {
+          console.warn(`[ManifestClient] orchestrator partial fetch: ${failures.map((f) => f.source).join(", ")}`, failures);
+        }
         return { nodes, categories: [] };
       }
     });
@@ -55772,26 +54842,12 @@ init_esm_shims();
 var VARS_PREFIX = "$vars";
 var METADATA_PREFIX = "$metadata";
 var SELF_PREFIX = "$self";
+var AGENT_PREFIX = "$agent";
 var VARS_IDENTIFIER = "vars";
 var METADATA_IDENTIFIER = "metadata";
 var VARIABLE_PATH_IDENTIFIER_PATTERN = String.raw`[a-zA-Z_]\w*`;
 var VARIABLE_PATH_SELECTOR_PATTERN = String.raw`(?:\[\d+\]|\.${VARIABLE_PATH_IDENTIFIER_PATTERN})*`;
 var VARIABLE_PATH_PATTERN = String.raw`${VARIABLE_PATH_IDENTIFIER_PATTERN}${VARIABLE_PATH_SELECTOR_PATTERN}`;
-function asExpressionValue(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return;
-  const ev = value;
-  return typeof ev.expression === "string" ? ev : undefined;
-}
-function expressionText(value) {
-  if (typeof value === "string")
-    return value;
-  const ev = asExpressionValue(value);
-  return typeof ev?.expression === "string" ? ev.expression : "";
-}
-function isJsExpressionValue(value) {
-  return asExpressionValue(value)?.type === "jsExpression";
-}
 var ENGINE_NAMESPACES = ["vars", "metadata", "iterator"];
 var ENGINE_REF = new RegExp(`^(?:${ENGINE_NAMESPACES.join("|")})(?:\\.[A-Za-z_$][\\w$]*|\\[\\d+\\])+$`);
 var RESOLVABLE_BY_ACCESSOR_WALK = new RegExp(`^(?:${ENGINE_NAMESPACES.join("|")})\\.[A-Za-z_$][\\w$]*(?:\\[\\d+\\])*$`);
@@ -55815,7 +54871,7 @@ var MULTI_RECORD_MIN_LIMIT = 1;
 var MULTI_RECORD_MAX_LIMIT = 1000;
 var MULTI_RECORD_MIN_SKIP = 0;
 function isRecordWindowVariable(value) {
-  return isEngineRef(expressionText(value));
+  return isEngineRef(value);
 }
 function clampRecordLimit(limit) {
   if (typeof limit === "string" && limit.trim() !== "" && !isRecordWindowVariable(limit)) {
@@ -55841,24 +54897,18 @@ var IN_FILTER_OPERATOR = "is any of";
 function splitInValues(raw) {
   return raw.split(",").map((part) => part.trim()).filter(Boolean);
 }
-function rowInValues(row) {
-  const text = expressionText(row.value);
-  if (isJsExpressionValue(row.value))
-    return text.trim() ? [text] : [];
-  return splitInValues(text);
-}
 function filterRowWasAuthored(row) {
-  return Boolean(row?.field || expressionText(row?.value).trim());
+  return Boolean(row?.field || row?.value?.trim());
 }
 function filterRowYieldsPredicate(row, multiRecord) {
-  if (!row?.field || !expressionText(row.value).trim())
+  if (!row?.field || !row.value?.trim())
     return false;
   if (row.operator !== IN_FILTER_OPERATOR)
     return true;
-  return multiRecord && rowInValues(row).length > 0;
+  return multiRecord && splitInValues(row.value).length > 0;
 }
 function filterRowDropWouldWiden(row, multiRecord) {
-  if (!row?.field || !expressionText(row.value).trim())
+  if (!row?.field || !row.value?.trim())
     return false;
   return !filterRowYieldsPredicate(row, multiRecord);
 }
@@ -55870,7 +54920,7 @@ function resolveUpdateRecordSource(cfg) {
     return cfg.recordSource;
   if (cfg.readEntityNodeId)
     return "fromRead";
-  if (expressionText(cfg.recordId).trim())
+  if (cfg.recordId)
     return "byId";
   return;
 }
@@ -55919,6 +54969,6 @@ function findTerminalNodes(nodes, edges, isStartEvent) {
 }
 init_esm_shims();
 
-export { JSON_STRING_PREFIX, JIT_OBJECT_INPUT_MODE, parseConfigurationJson, resolveNodeOutputTypeSchema, createNodeVariable, generateNodeVariables, instance, NodeType, FIRE_AND_FORGET_INPUT, getResourceByServiceType, MANAGED_HTTP_NODE_TYPE, buildConnectorHttpRequestDetail, getLatestDefinitionByNodeType, getManifestKey, getConnectorHttpRequestKey, VARS_PREFIX, METADATA_PREFIX, SELF_PREFIX, VARS_IDENTIFIER, METADATA_IDENTIFIER, VARIABLE_PATH_IDENTIFIER_PATTERN, VARIABLE_PATH_SELECTOR_PATTERN, VARIABLE_PATH_PATTERN, toEngineRefPath, isEngineRef, engineRefNeedsJsEvaluator, isMultiRecordRead, clampRecordLimit, clampRecordSkip, IN_FILTER_OPERATOR, splitInValues, filterRowWasAuthored, filterRowYieldsPredicate, filterRowDropWouldWiden, isFileType, resolveUpdateRecordSource, stripVarsPrefix, findTerminalNodes };
+export { JSON_STRING_PREFIX, JIT_OBJECT_INPUT_MODE, parseConfigurationJson, resolveNodeOutputTypeSchema, createNodeVariable, generateNodeVariables, instance, NodeType, FIRE_AND_FORGET_INPUT, getResourceByServiceType, MANAGED_HTTP_NODE_TYPE, buildConnectorHttpRequestDetail, getLatestDefinitionByNodeType, getManifestKey, getConnectorHttpRequestKey, VARS_PREFIX, METADATA_PREFIX, SELF_PREFIX, AGENT_PREFIX, VARS_IDENTIFIER, METADATA_IDENTIFIER, VARIABLE_PATH_IDENTIFIER_PATTERN, VARIABLE_PATH_SELECTOR_PATTERN, VARIABLE_PATH_PATTERN, toEngineRefPath, isEngineRef, engineRefNeedsJsEvaluator, isMultiRecordRead, clampRecordLimit, clampRecordSkip, IN_FILTER_OPERATOR, splitInValues, filterRowWasAuthored, filterRowYieldsPredicate, filterRowDropWouldWiden, isFileType, resolveUpdateRecordSource, stripVarsPrefix, findTerminalNodes };
 
-//# debugId=3831971B8E7FB7A964756E2164756E21
+//# debugId=C2A3AB055ADBE93B64756E2164756E21