@prorobotech/openapi-k8s-toolkit 1.4.0-alpha.8 → 1.4.0-alpha.9

package/dist/openapi-k8s-toolkit.umd.js

@@ -2164,7 +2164,7 @@
    *
    * @returns {?Array}
    */
-  const toArray$4 = (thing) => {
+  const toArray$3 = (thing) => {
     if (!thing) return null;
     if (isArray(thing)) return thing;
     let i = thing.length;
@@ -2444,7 +2444,7 @@
     kindOf: kindOf$1,
     kindOfTest,
     endsWith,
-    toArray: toArray$4,
+    toArray: toArray$3,
     forEachEntry,
     matchAll,
     isHTMLForm,
@@ -43439,6 +43439,36 @@
     BigText: BigText$1
   };
 
+  const findManagedFieldsLine = (model) => {
+    let inMetadata = false;
+    let metadataIndent = -1;
+    for (let lineNumber = 1; lineNumber <= model.getLineCount(); lineNumber++) {
+      const line = model.getLineContent(lineNumber);
+      const trimmed = line.trim();
+      const indent = line.match(/^\s*/)?.[0].length ?? 0;
+      if (!inMetadata && /^metadata\s*:\s*$/.test(trimmed)) {
+        inMetadata = true;
+        metadataIndent = indent;
+      } else if (inMetadata) {
+        if (trimmed && indent <= metadataIndent) {
+          inMetadata = false;
+        } else if (/^managedFields\s*:\s*$/.test(trimmed)) {
+          return lineNumber;
+        }
+      }
+    }
+    return null;
+  };
+  const collapseManagedFieldsInEditor = (editor) => {
+    const model = editor.getModel();
+    if (!model) return;
+    const managedFieldsLine = findManagedFieldsLine(model);
+    if (managedFieldsLine === null) return;
+    if (managedFieldsLine >= model.getLineCount()) return;
+    editor.setPosition({ lineNumber: managedFieldsLine, column: 1 });
+    editor.trigger("managed-fields-collapse", "editor.fold", null);
+  };
+
   const NOTIFICATION_KEY = "yaml-data-changed";
   const YamlEditorSingleton$1 = ({
     theme,
@@ -43465,6 +43495,12 @@
     const initialPrefillYamlRef = React$1.useRef(null);
     const latestPrefillYamlRef = React$1.useRef(null);
     const firstLoadRef = React$1.useRef(true);
+    const editorRef = React$1.useRef(null);
+    const collapseManagedFieldsIfNeeded = React$1.useCallback(() => {
+      const editor = editorRef.current;
+      if (!editor) return;
+      collapseManagedFieldsInEditor(editor);
+    }, []);
     const handleReload = React$1.useCallback(() => {
       api.destroy(NOTIFICATION_KEY);
       const nextYaml = latestPrefillYamlRef.current ?? initialPrefillYamlRef.current;
@@ -43508,6 +43544,12 @@
       }
       latestPrefillYamlRef.current = nextYaml;
     }, [prefillValuesSchema, openNotificationYamlChanged]);
+    React$1.useEffect(() => {
+      const id = setTimeout(() => {
+        collapseManagedFieldsIfNeeded();
+      }, 0);
+      return () => clearTimeout(id);
+    }, [yamlData, collapseManagedFieldsIfNeeded]);
     const onSubmit = () => {
       setIsLoading(true);
       setError(void 0);
@@ -43565,6 +43607,12 @@
           width: "100%",
           height: designNewLayoutHeight || "75vh",
           value: yamlData,
+          onMount: (editor) => {
+            editorRef.current = editor;
+            setTimeout(() => {
+              collapseManagedFieldsIfNeeded();
+            }, 0);
+          },
           onChange: (value) => {
             if (!readOnly) {
               setYamlData(value || "");
@@ -44140,15 +44188,15 @@
   };
 
   const includesPath = (haystack, needle) => haystack.some((h) => h.length === needle.length && h.every((seg, i) => seg === String(needle[i])));
-  const toArray$3 = (p) => (
+  const toArray$2 = (p) => (
     // eslint-disable-next-line no-nested-ternary
     p === void 0 ? void 0 : Array.isArray(p) ? p : [p]
   );
 
   const HiddenContainer$1 = ({ name, secondName, children }) => {
     const hiddenPaths = useHiddenPathsLayout();
-    const nameArr = toArray$3(name);
-    const secondArr = toArray$3(secondName);
+    const nameArr = toArray$2(name);
+    const secondArr = toArray$2(secondName);
     const isHidden = !!hiddenPaths && !!nameArr && includesPath(hiddenPaths, nameArr);
     const isHiddenSecond = !!hiddenPaths && !!secondArr && includesPath(hiddenPaths, secondArr);
     return /* @__PURE__ */ jsxRuntimeExports.jsx(PossibleHiddenContainer, { $isHidden: !hiddenPaths || isHidden || isHiddenSecond, children });
@@ -45101,7 +45149,24 @@
     ] });
   };
 
+  const handleLabelsToSearchParamsLinkClick = ({
+    e,
+    hrefPrepared,
+    navigate
+  }) => {
+    const isExternal = isExternalHref(hrefPrepared);
+    if (isExternal) {
+      return;
+    }
+    e.preventDefault();
+    navigate(hrefPrepared);
+  };
+
   const LabelsToSearchParams = ({ data, children }) => {
+    const renderWithSearchIcon = (content) => /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Flex, { align: "flex-start", gap: 8, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.SearchOutlined, { style: { marginTop: 4 } }),
+      content
+    ] });
     const {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       id,
@@ -45110,10 +45175,12 @@
       linkPrefix,
       textLink,
       errorText,
+      errorMode = "errorText",
       maxTextLength,
       renderLabelsAsRows,
       ...linkProps
     } = data;
+    const navigate = reactRouterDom.useNavigate();
     const { data: multiQueryData, isLoading: isMultiQueryLoading, isError: isMultiQueryErrors, errors } = useMultiQuery();
     const partsOfUrl = usePartsOfUrl();
     if (isMultiQueryLoading) {
@@ -45136,32 +45203,53 @@
     const anythingForNow = jp.query(jsonRoot || {}, `$${jsonPathToLabels}`);
     const { data: labelsRaw, error: errorArrayOfObjects } = parseLabelsArrayOfAny(anythingForNow);
     const linkPrefixPrepared = parseAll({ text: linkPrefix, replaceValues, multiQueryData });
+    const labelsPrefixPrepared = linkPrefixPrepared.includes("?") ? `${linkPrefixPrepared}${linkPrefixPrepared.endsWith("?") || linkPrefixPrepared.endsWith("&") ? "" : "&"}labels=` : `${linkPrefixPrepared}?labels=`;
+    const renderErrorFallback = () => {
+      if (errorMode === "default") {
+        const fallbackText = textLink || errorText;
+        const handleDefaultFallbackLinkClick = (e) => handleLabelsToSearchParamsLinkClick({
+          e,
+          hrefPrepared: linkPrefixPrepared,
+          navigate
+        });
+        return renderWithSearchIcon(
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: linkPrefixPrepared, onClick: handleDefaultFallbackLinkClick, ...linkProps, children: [
+            fallbackText,
+            children
+          ] })
+        );
+      }
+      return renderWithSearchIcon(
+        /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Text, { children: [
+          errorText,
+          children
+        ] })
+      );
+    };
     if (!labelsRaw) {
       if (errorArrayOfObjects) {
         console.log(errorArrayOfObjects);
-        return /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Text, { children: [
-          errorText,
-          children
-        ] });
+        return renderErrorFallback();
       }
       console.log("Not a valid data structure");
-      return /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Text, { children: [
-        errorText,
-        children
-      ] });
+      return renderErrorFallback();
     }
     const labels = Object.entries(labelsRaw).map(([key, value]) => `${key}=${value}`).join(",");
     const labelsRows = Object.entries(labelsRaw).map(([key, value]) => `${key}=${value}`);
     const labelsEncoded = encodeURIComponent(labels);
-    const hrefPrepared = `${linkPrefixPrepared}${labelsEncoded}`;
+    const hrefPrepared = `${labelsPrefixPrepared}${labelsEncoded}`;
+    const handleLinkClick = (e) => handleLabelsToSearchParamsLinkClick({
+      e,
+      hrefPrepared,
+      navigate
+    });
     if (renderLabelsAsRows) {
-      return /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Flex, { align: "flex-start", gap: 8, children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.SearchOutlined, { style: { marginTop: 4 } }),
+      return renderWithSearchIcon(
         /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Flex, { vertical: true, children: [
-          labelsRows.map((row, index) => /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Typography.Link, { href: hrefPrepared, ...linkProps, children: index < labelsRows.length - 1 ? `${row},` : row }, row)),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Typography.Link, { href: hrefPrepared, onClick: handleLinkClick, ...linkProps, children: labelsRows.map((row, index) => /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { display: "block" }, children: index < labelsRows.length - 1 ? `${row},` : row }, `${row}-${index}`)) }),
           children
         ] })
-      ] });
+      );
     }
     if (maxTextLength && !textLink) {
       const truncatedLabels = maxTextLength ? truncate$1(labels, maxTextLength) : labels;
@@ -45169,10 +45257,12 @@
         antd.Popover,
         {
           content: /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Flex, { vertical: true, gap: 8, children: Object.entries(labelsRaw).map(([key, value]) => /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: `${key}=${value}` }, key)) }),
-          children: /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, ...linkProps, children: [
-            truncatedLabels,
-            children
-          ] })
+          children: renderWithSearchIcon(
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, onClick: handleLinkClick, ...linkProps, children: [
+              truncatedLabels,
+              children
+            ] })
+          )
         }
       );
     }
@@ -45182,17 +45272,21 @@
         antd.Popover,
         {
           content: /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Flex, { vertical: true, gap: 8, children: Object.entries(labelsRaw).map(([key, value]) => /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: `${key}=${value}` }, key)) }),
-          children: /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, ...linkProps, children: [
-            truncatedTextLink,
-            children
-          ] })
+          children: renderWithSearchIcon(
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, onClick: handleLinkClick, ...linkProps, children: [
+              truncatedTextLink,
+              children
+            ] })
+          )
         }
       );
     }
-    return /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, ...linkProps, children: [
-      textLink || labels,
-      children
-    ] });
+    return renderWithSearchIcon(
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Link, { href: hrefPrepared, onClick: handleLinkClick, ...linkProps, children: [
+        textLink || labels,
+        children
+      ] })
+    );
   };
 
   const flattenOnce$1 = (arr) => arr.reduce((acc, row) => [...acc, ...row], []);
@@ -46766,9 +46860,15 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
     user-select: none;
   }
 `;
-  const DisabledInput = styled(antd.Input)`
+  const hiddenCursor = styled.css`
   /* stylelint-disable declaration-no-important */
   cursor: ${({ $hidden }) => $hidden ? "default" : "pointer"} !important;
+`;
+  const DisabledInput = styled(antd.Input)`
+  ${hiddenCursor}
+`;
+  const DisabledTextArea = styled(antd.Input.TextArea)`
+  ${hiddenCursor}
 `;
   const NotificationOverrides = styled.createGlobalStyle`
   .no-message-notif .ant-notification-notice-message {
@@ -46778,15 +46878,45 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
   const Styled$s = {
     NoSelect,
     DisabledInput,
+    DisabledTextArea,
     NotificationOverrides
   };
 
+  const decodeIfBase64 = (value, shouldDecode) => {
+    if (!shouldDecode) {
+      return value;
+    }
+    try {
+      return atob(value);
+    } catch (error) {
+      console.error(error);
+      return value;
+    }
+  };
+  const resolveMultilineRows = (value, multilineRows) => {
+    const computedRows = Math.min(12, Math.max(3, value.split(/\r\n|\r|\n/).length));
+    if (typeof multilineRows === "number" && Number.isFinite(multilineRows)) {
+      return Math.min(30, Math.max(1, Math.floor(multilineRows)));
+    }
+    return computedRows;
+  };
+
   const SecretBase64Plain = ({ data }) => {
     const {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       id,
+      type,
+      value,
+      reqIndex,
+      jsonPathToSecrets,
       base64Value,
       plainTextValue,
+      multiline,
+      multilineRows,
+      shownByDefault,
+      hideEye,
+      textStyle,
+      emptyText,
       containerStyle,
       inputContainerStyle,
       flexProps,
@@ -46794,8 +46924,9 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
       notificationText,
       notificationWidth
     } = data;
-    const [hidden, setHidden] = React$1.useState(true);
-    const inputRef = React$1.useRef(null);
+    const hiddenDefault = !shownByDefault;
+    const [hidden, setHidden] = React$1.useState(hiddenDefault);
+    const [hiddenByKey, setHiddenByKey] = React$1.useState({});
     const [notificationApi, contextHolder] = antd.notification.useNotification();
     const { data: multiQueryData, isLoading, isError, errors } = useMultiQuery();
     const partsOfUrl = usePartsOfUrl();
@@ -46809,20 +46940,26 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
         /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { children: errors.map((e, i) => e && /* @__PURE__ */ jsxRuntimeExports.jsx("li", { children: typeof e === "string" ? e : e.message }, i)) })
       ] });
     }
-    const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value, index) => {
-      acc[index.toString()] = value;
+    const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value2, index) => {
+      acc[index.toString()] = value2;
       return acc;
     }, {});
     const parsedText = parseAll({
-      text: base64Value || plainTextValue || "Oneof required",
+      text: value ?? base64Value ?? plainTextValue ?? "Value required",
       replaceValues,
       multiQueryData
     });
-    const decodedText = base64Value ? atob(parsedText) : parsedText;
-    const copyToClipboard = async () => {
+    const emptyTextPrepared = typeof emptyText === "string" && emptyText.length > 0 ? parseAll({
+      text: emptyText,
+      replaceValues,
+      multiQueryData
+    }) : void 0;
+    const shouldDecodeSingle = type === "base64" ? true : type === "plain" ? false : base64Value !== void 0;
+    const decodedText = decodeIfBase64(parsedText, shouldDecodeSingle);
+    const copyToClipboard = async (valueToCopy) => {
       try {
-        if (decodedText !== null && decodedText !== void 0) {
-          await navigator.clipboard.writeText(decodedText);
+        if (valueToCopy !== null && valueToCopy !== void 0) {
+          await navigator.clipboard.writeText(valueToCopy);
           notificationApi.info({
             // message: `Copied: ${decodedText.substring(0, 5)}...`,
             message: notificationText || "Text copied to clipboard",
@@ -46840,42 +46977,103 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
         console.error(error);
       }
     };
-    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: containerStyle, children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NotificationOverrides, {}),
-      /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Flex, { gap: 8, ...flexProps, children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NoSelect, { style: inputContainerStyle, children: niceLooking ? /* @__PURE__ */ jsxRuntimeExports.jsx(te, { theme, hidden, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+    const handleInputClick = async (e, isHidden, valueToCopy) => {
+      if (isHidden) {
+        return;
+      }
+      e.currentTarget.focus();
+      e.currentTarget.select();
+      await copyToClipboard(valueToCopy);
+    };
+    const useNiceLooking = !!niceLooking && !multiline;
+    const renderSecretField = ({
+      value: value2,
+      isHidden,
+      onToggle
+    }) => {
+      const effectiveHidden = hideEye ? false : isHidden;
+      const shownValue = useNiceLooking ? value2 : effectiveHidden ? "" : value2;
+      const resolvedMultilineRows = resolveMultilineRows(value2, multilineRows);
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Flex, { gap: 8, ...flexProps, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NoSelect, { style: inputContainerStyle, children: useNiceLooking ? /* @__PURE__ */ jsxRuntimeExports.jsx(te, { theme, hidden: effectiveHidden, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
           Styled$s.DisabledInput,
           {
-            $hidden: hidden,
-            ref: inputRef,
-            onClick: () => {
-              if (!hidden) {
-                inputRef.current?.focus({
-                  cursor: "all"
-                });
-                copyToClipboard();
-              }
-            },
-            value: decodedText
+            $hidden: effectiveHidden,
+            onClick: (e) => handleInputClick(e, effectiveHidden, value2),
+            value: shownValue,
+            readOnly: true
           }
-        ) }) : /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ) }) : multiline ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+          Styled$s.DisabledTextArea,
+          {
+            $hidden: effectiveHidden,
+            onClick: (e) => handleInputClick(e, effectiveHidden, value2),
+            value: shownValue,
+            rows: resolvedMultilineRows,
+            readOnly: true
+          }
+        ) : /* @__PURE__ */ jsxRuntimeExports.jsx(
           Styled$s.DisabledInput,
           {
-            $hidden: hidden,
-            ref: inputRef,
-            onClick: () => {
-              if (!hidden) {
-                inputRef.current?.focus({
-                  cursor: "all"
-                });
-                copyToClipboard();
-              }
-            },
-            value: hidden ? "" : decodedText
+            $hidden: effectiveHidden,
+            onClick: (e) => handleInputClick(e, effectiveHidden, value2),
+            value: shownValue,
+            readOnly: true
           }
         ) }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Button, { type: "text", onClick: () => setHidden(!hidden), children: hidden ? /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.EyeOutlined, {}) : /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.EyeInvisibleOutlined, {}) })
-      ] }),
+        !hideEye && /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Button, { type: "text", onClick: onToggle, children: isHidden ? /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.EyeOutlined, {}) : /* @__PURE__ */ jsxRuntimeExports.jsx(AntIcons.EyeInvisibleOutlined, {}) })
+      ] });
+    };
+    if (reqIndex && jsonPathToSecrets) {
+      const reqIndexPrepared = parseAll({ text: reqIndex, replaceValues, multiQueryData });
+      const jsonPathToSecretsPrepared = parseAll({ text: jsonPathToSecrets, replaceValues, multiQueryData });
+      const jsonRoot = multiQueryData[`req${reqIndexPrepared}`];
+      if (jsonRoot === void 0) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "No root for json path" });
+      }
+      const pathResults = jp.query(jsonRoot || {}, `$${jsonPathToSecretsPrepared}`);
+      const objectToRender = pathResults.find((item) => item !== null && typeof item === "object" && !Array.isArray(item)) || null;
+      const secretsEntries = objectToRender ? Object.entries(objectToRender) : [];
+      if (secretsEntries.length === 0) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: containerStyle, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NotificationOverrides, {}),
+          emptyTextPrepared && /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Typography.Text, { style: textStyle, children: emptyTextPrepared }),
+          contextHolder
+        ] });
+      }
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: containerStyle, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NotificationOverrides, {}),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Flex, { vertical: true, gap: 8, children: secretsEntries.map(([key, rawValue]) => {
+          const parsedValue = parseAll({
+            text: typeof rawValue === "string" ? rawValue : String(rawValue),
+            replaceValues,
+            multiQueryData
+          });
+          const shouldDecodeObject = type !== "plain";
+          const secretValue = decodeIfBase64(parsedValue, shouldDecodeObject);
+          const hiddenForKey = hiddenByKey[key] ?? hiddenDefault;
+          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Typography.Text, { strong: true, style: textStyle, children: key }),
+            renderSecretField({
+              value: secretValue,
+              isHidden: hiddenForKey,
+              onToggle: () => setHiddenByKey((prevState) => ({
+                ...prevState,
+                [key]: !(prevState[key] ?? hiddenDefault)
+              }))
+            })
+          ] }, key);
+        }) }),
+        contextHolder
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: containerStyle, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$s.NotificationOverrides, {}),
+      renderSecretField({
+        value: decodedText,
+        isHidden: hidden,
+        onToggle: () => setHidden(!hidden)
+      }),
       contextHolder
     ] });
   };
@@ -67835,7 +68033,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
   	exports.last = last; 
   } (last$2));
 
-  var toArray$2 = {};
+  var toArray$1 = {};
 
   (function (exports) {
 
@@ -67846,14 +68044,14 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
   	}
 
   	exports.toArray = toArray; 
-  } (toArray$2));
+  } (toArray$1));
 
   (function (exports) {
 
   	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
   	const last$1 = last$2;
-  	const toArray = toArray$2;
+  	const toArray = toArray$1;
   	const isArrayLike$1 = isArrayLike;
 
   	function last(array) {
@@ -68399,7 +68597,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
    * @param children do not use
    * @return deprecated do not use
    */
-  var toArray$1 = children => {
+  var toArray = children => {
     if (children === lastChildren && Array.isArray(lastResult)) {
       return lastResult;
     }
@@ -68407,7 +68605,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     React$1.Children.forEach(children, child => {
       if (isNullish(child)) return;
       if (reactIsExports.isFragment(child)) {
-        result = result.concat(toArray$1(child.props.children));
+        result = result.concat(toArray(child.props.children));
       } else {
         // @ts-expect-error this could still be Iterable<ReactNode> and TS does not like that
         result.push(child);
@@ -68436,7 +68634,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     } else {
       types = [getDisplayName(type)];
     }
-    toArray$1(children).forEach(child => {
+    toArray(children).forEach(child => {
       // @ts-expect-error toArray and lodash.get are not compatible. Let's get rid of the whole findAllByType function
       var childType = get$1(child, 'type.displayName') || get$1(child, 'type.name');
       if (childType && types.indexOf(childType) !== -1) {
@@ -79208,6 +79406,28 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     ] });
   };
 
+  const ACTION_REQUIRED_PERMISSIONS = {
+    edit: { verb: "update" },
+    editLabels: { verb: "patch" },
+    editAnnotations: { verb: "patch" },
+    editTaints: { verb: "patch" },
+    editTolerations: { verb: "patch" },
+    delete: { verb: "delete" },
+    cordon: { verb: "patch" },
+    uncordon: { verb: "patch" },
+    suspend: { verb: "patch" },
+    resume: { verb: "patch" },
+    rolloutRestart: { verb: "patch" },
+    evict: { verb: "create", subresource: "eviction" },
+    openKubeletConfig: { verb: "get", subresource: "proxy" },
+    scale: { verb: "update", subresource: "scale" },
+    triggerRun: { verb: "create" },
+    deleteChildren: { verb: "delete" },
+    rerunLast: { verb: "create" },
+    drain: { verb: "patch" },
+    rollback: { verb: "patch" }
+  };
+
   const IconWrapper = styled.span`
   display: inline-flex;
   width: 14px;
@@ -79232,45 +79452,29 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     IconButton
   };
 
-  const ACTION_REQUIRED_PERMISSIONS = {
-    edit: { verb: "update" },
-    editLabels: { verb: "patch" },
-    editAnnotations: { verb: "patch" },
-    editTaints: { verb: "patch" },
-    editTolerations: { verb: "patch" },
-    delete: { verb: "delete" },
-    cordon: { verb: "patch" },
-    uncordon: { verb: "patch" },
-    suspend: { verb: "patch" },
-    resume: { verb: "patch" },
-    rolloutRestart: { verb: "patch" },
-    evict: { verb: "create", subresource: "eviction" },
-    openKubeletConfig: { verb: "get", subresource: "proxy" }
-  };
-  const toArray = (value) => Array.isArray(value) ? value : [value];
-  const getRequiredPermissions = (actions) => {
-    return actions.flatMap((action) => toArray(ACTION_REQUIRED_PERMISSIONS[action.type]));
-  };
   const UNDEFINED_FALLBACK = "Undefined with no fallback";
   const isMeaningfulValue = (value) => value.length > 0 && value !== "-" && value !== UNDEFINED_FALLBACK;
   const getVisibleActions = (actions, { replaceValues, multiQueryData }) => {
-    return actions.filter((action) => {
+    return actions.flatMap((action, index) => {
       const condition = action.props.visibleWhen;
-      if (!condition) return true;
+      if (!condition) {
+        return [{ action, actionKey: `${action.type}-${index}` }];
+      }
       const currentValue = parseAll({ text: condition.value, replaceValues, multiQueryData });
       const hasValue = isMeaningfulValue(currentValue);
       if (condition.criteria === "exists") {
-        return hasValue;
+        return hasValue ? [{ action, actionKey: `${action.type}-${index}` }] : [];
       }
       if (condition.criteria === "notExists") {
-        return !hasValue;
+        return !hasValue ? [{ action, actionKey: `${action.type}-${index}` }] : [];
       }
       if (condition.valueToCompare === void 0) {
-        return true;
+        return [{ action, actionKey: `${action.type}-${index}` }];
       }
       const expectedValues = (Array.isArray(condition.valueToCompare) ? condition.valueToCompare : [condition.valueToCompare]).map((value) => parseAll({ text: value, replaceValues, multiQueryData }));
       const matches = expectedValues.includes(currentValue);
-      return condition.criteria === "equals" ? matches : !matches;
+      const isVisible = condition.criteria === "equals" ? matches : !matches;
+      return isVisible ? [{ action, actionKey: `${action.type}-${index}` }] : [];
     });
   };
   const buildEditUrl = (props, fullPath) => {
@@ -79299,35 +79503,14 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     }
     return void 0;
   };
-  const isActionDisabledByPermission = (action, permissions) => {
-    switch (action.type) {
-      case "edit":
-        return permissions.canUpdate !== true;
-      case "editLabels":
-      case "editAnnotations":
-      case "editTaints":
-      case "editTolerations":
-      case "cordon":
-      case "uncordon":
-      case "suspend":
-      case "resume":
-      case "rolloutRestart":
-        return permissions.canPatch !== true;
-      case "delete":
-        return permissions.canDelete !== true;
-      case "evict":
-        return permissions.canCreate !== true;
-      case "openKubeletConfig":
-        return permissions.canGet !== true;
-      default:
-        return true;
-    }
+  const isActionDisabledByPermission = (actionKey, permissions) => {
+    return permissions[actionKey] !== true;
   };
-  const getMenuItems = (actions, onActionClick, permissions) => actions.map((action, index) => ({
-    key: `${action.type}-${index}`,
+  const getMenuItems = (visibleActions, onActionClick, permissions) => visibleActions.map(({ action, actionKey }) => ({
+    key: actionKey,
     label: action.props.tooltip ? /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Tooltip, { title: action.props.tooltip, children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: action.props.text }) }) : action.props.text,
     icon: getActionIcon(action),
-    disabled: action.props.disabled || isActionDisabledByPermission(action, permissions),
+    disabled: action.props.disabled || isActionDisabledByPermission(actionKey, permissions),
     danger: action.props.danger,
     onClick: () => onActionClick(action)
   }));
@@ -79338,6 +79521,18 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     }
     return value;
   };
+  const resolveObjectFromTemplate = (template, multiQueryData) => {
+    const match = template.match(/^\{reqs\[(\d+)\]\[((?:\s*['"][^'"]+['"]\s*,?)+)\]\}$/);
+    if (match) {
+      const reqIndex = parseInt(match[1], 10);
+      const pathKeys = Array.from(match[2].matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]);
+      const reqData = multiQueryData[`req${reqIndex}`];
+      if (reqData != null) {
+        return _$1.get(reqData, pathKeys);
+      }
+    }
+    return void 0;
+  };
   const buildEvictModalData = (props, ctx) => {
     const endpointPrepared = parseAll({ text: props.endpoint, ...ctx });
     const namePrepared = parseAll({ text: props.name, ...ctx });
@@ -79370,6 +79565,35 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       ...Object.keys(deleteOptions).length > 0 ? { deleteOptions } : {}
     };
   };
+  const buildDeleteChildrenData = (action, ctx) => {
+    const childResourceNamePrepared = parseAll({ text: action.props.childResourceName, ...ctx });
+    const childrenTemplatePrepared = parseWithoutPartsOfUrl({
+      text: action.props.children,
+      multiQueryData: ctx.multiQueryData
+    });
+    let parsedChildren;
+    try {
+      parsedChildren = JSON.parse(childrenTemplatePrepared);
+    } catch {
+      throw new Error("Could not parse children data");
+    }
+    if (!Array.isArray(parsedChildren)) {
+      throw new Error("No children found to delete");
+    }
+    const children = parsedChildren.filter(
+      (el) => typeof el === "object" && el !== null && typeof el.name === "string" && typeof el.endpoint === "string"
+    ).map((el) => ({
+      name: parsePartsOfUrl({ template: el.name, replaceValues: ctx.replaceValues }),
+      endpoint: parsePartsOfUrl({ template: el.endpoint, replaceValues: ctx.replaceValues })
+    }));
+    if (children.length === 0) {
+      throw new Error("No children found to delete");
+    }
+    return {
+      children,
+      childResourceName: childResourceNamePrepared
+    };
+  };
   const handleEditAction = (action, ctx, fullPath, navigate) => {
     const clusterPrepared = parseAll({ text: action.props.cluster, ...ctx });
     const namespacePrepared = action.props.namespace ? parseAll({ text: action.props.namespace, ...ctx }) : void 0;
@@ -79438,7 +79662,6 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       }
     }).then(() => onSuccess(actionLabel)).catch((error) => {
       onError(actionLabel, error);
-      console.error(error);
     });
   };
   const handleOpenKubeletConfigAction = (action, ctx, setActiveAction, setModalOpen) => {
@@ -79456,6 +79679,183 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     });
     setModalOpen(true);
   };
+  const generateDnsCompliantName = (prefix, maxLength = 63) => {
+    const timestamp = Date.now();
+    const randomHex = Math.random().toString(16).substring(2, 6);
+    const suffix = `-${timestamp}-${randomHex}`;
+    const truncatedPrefix = prefix.substring(0, maxLength - suffix.length);
+    return `${truncatedPrefix}${suffix}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  };
+  const JOB_MANAGED_LABEL_KEYS = [
+    "controller-uid",
+    "job-name",
+    "batch.kubernetes.io/controller-uid",
+    "batch.kubernetes.io/job-name"
+  ];
+  const stripManagedJobLabels = (labels) => {
+    if (!labels || typeof labels !== "object" || Array.isArray(labels)) {
+      return void 0;
+    }
+    const cleaned = { ...labels };
+    JOB_MANAGED_LABEL_KEYS.forEach((key) => delete cleaned[key]);
+    return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+  };
+  const stripMetadataForRerun = (sourceObj, sourceJobName) => {
+    const normalizedSourceObj = _$1.isPlainObject(_$1.get(sourceObj, "spec")) ? sourceObj : _$1.isPlainObject(sourceObj) && _$1.isPlainObject(_$1.get(sourceObj, "template")) ? { spec: sourceObj } : sourceObj;
+    const copy = JSON.parse(JSON.stringify(normalizedSourceObj));
+    const oldMeta = copy.metadata ?? {};
+    const cleanedMetadataLabels = stripManagedJobLabels(oldMeta.labels);
+    copy.metadata = {
+      ...oldMeta.namespace ? { namespace: oldMeta.namespace } : {},
+      ...cleanedMetadataLabels ? { labels: cleanedMetadataLabels } : {},
+      ...oldMeta.annotations ? { annotations: oldMeta.annotations } : {},
+      generateName: `${sourceJobName}-rerun-`
+    };
+    const spec = _$1.get(copy, "spec");
+    if (_$1.isPlainObject(spec)) {
+      const specObj = spec;
+      delete specObj.selector;
+      delete specObj.manualSelector;
+    }
+    const templateLabels = _$1.get(copy, "spec.template.metadata.labels");
+    if (_$1.isPlainObject(templateLabels)) {
+      const cleanedTemplateLabels = stripManagedJobLabels(templateLabels);
+      if (cleanedTemplateLabels) {
+        _$1.set(copy, "spec.template.metadata.labels", cleanedTemplateLabels);
+      } else {
+        _$1.unset(copy, "spec.template.metadata.labels");
+      }
+    }
+    delete copy.status;
+    return copy;
+  };
+  const useScaleHandlers = (ctx, { showSuccess, showError }) => {
+    const [scaleModalData, setScaleModalData] = React$1.useState(null);
+    const [isScaleLoading, setIsScaleLoading] = React$1.useState(false);
+    const handleScaleAction = (action) => {
+      const endpointPrepared = parseAll({ text: action.props.endpoint, ...ctx });
+      const namePrepared = parseAll({ text: action.props.name, ...ctx });
+      const namespacePrepared = action.props.namespace ? parseAll({ text: action.props.namespace, ...ctx }) : void 0;
+      const apiVersionPrepared = action.props.apiVersion ? parseAll({ text: action.props.apiVersion, ...ctx }) : "autoscaling/v1";
+      const currentReplicasStr = parseAll({ text: action.props.currentReplicas, ...ctx });
+      const currentReplicas = parseInt(currentReplicasStr, 10) || 0;
+      setScaleModalData({
+        endpoint: endpointPrepared,
+        currentReplicas,
+        name: namePrepared,
+        namespace: namespacePrepared,
+        apiVersion: apiVersionPrepared
+      });
+    };
+    const handleScaleConfirm = (newReplicas) => {
+      if (!scaleModalData) return;
+      setIsScaleLoading(true);
+      const body = {
+        apiVersion: scaleModalData.apiVersion,
+        kind: "Scale",
+        metadata: {
+          name: scaleModalData.name,
+          ...scaleModalData.namespace ? { namespace: scaleModalData.namespace } : {}
+        },
+        spec: { replicas: newReplicas }
+      };
+      const scaleLabel = `Scale ${scaleModalData.name}`;
+      updateEntry({ endpoint: scaleModalData.endpoint, body }).then(() => showSuccess(scaleLabel)).catch((error) => {
+        showError(scaleLabel, error);
+      }).finally(() => {
+        setIsScaleLoading(false);
+        setScaleModalData(null);
+      });
+    };
+    const handleScaleCancel = () => {
+      setScaleModalData(null);
+      setIsScaleLoading(false);
+    };
+    return { scaleModalData, isScaleLoading, handleScaleAction, handleScaleConfirm, handleScaleCancel };
+  };
+  const useEvictHandlers = ({ showSuccess, showError }) => {
+    const [evictModalData, setEvictModalData] = React$1.useState(null);
+    const [isEvictLoading, setIsEvictLoading] = React$1.useState(false);
+    const handleEvictConfirm = () => {
+      if (!evictModalData) return;
+      setIsEvictLoading(true);
+      const body = buildEvictBody(evictModalData);
+      const evictLabel = `Evict ${evictModalData.name}`;
+      createNewEntry({ endpoint: evictModalData.endpoint, body }).then(() => showSuccess(evictLabel)).catch((error) => {
+        showError(evictLabel, error);
+      }).finally(() => {
+        setIsEvictLoading(false);
+        setEvictModalData(null);
+      });
+    };
+    const handleEvictCancel = () => {
+      setEvictModalData(null);
+      setIsEvictLoading(false);
+    };
+    return { evictModalData, isEvictLoading, setEvictModalData, handleEvictConfirm, handleEvictCancel };
+  };
+  const useRerunHandlers = (ctx, multiQueryData, { showSuccess, showError }) => {
+    const [rerunModalData, setRerunModalData] = React$1.useState(null);
+    const [isRerunLoading, setIsRerunLoading] = React$1.useState(false);
+    const handleRerunLastAction = (action) => {
+      const createEndpointPrepared = parseAll({ text: action.props.createEndpoint, ...ctx });
+      const sourceJobNamePrepared = parseAll({ text: action.props.sourceJobName, ...ctx });
+      const sourceJobObj = resolveObjectFromTemplate(action.props.sourceJobSpec, multiQueryData);
+      if (!sourceJobObj) {
+        showError("Rerun job", new Error("Could not resolve source job spec from resource data"));
+        return;
+      }
+      setRerunModalData({
+        createEndpoint: createEndpointPrepared,
+        sourceName: sourceJobNamePrepared,
+        sourceSpec: sourceJobObj
+      });
+    };
+    const handleRerunConfirm = () => {
+      if (!rerunModalData) return;
+      setIsRerunLoading(true);
+      const body = stripMetadataForRerun(rerunModalData.sourceSpec, rerunModalData.sourceName);
+      const rerunLabel = `Rerun ${rerunModalData.sourceName}`;
+      createNewEntry({ endpoint: rerunModalData.createEndpoint, body }).then(() => showSuccess(rerunLabel)).catch((error) => {
+        showError(rerunLabel, error);
+      }).finally(() => {
+        setIsRerunLoading(false);
+        setRerunModalData(null);
+      });
+    };
+    const handleRerunCancel = () => {
+      setRerunModalData(null);
+      setIsRerunLoading(false);
+    };
+    return { rerunModalData, isRerunLoading, handleRerunLastAction, handleRerunConfirm, handleRerunCancel };
+  };
+  const fireTriggerRunAction = (action, ctx, multiQueryData, { showSuccess, showError }) => {
+    const createEndpointPrepared = parseAll({ text: action.props.createEndpoint, ...ctx });
+    const cronJobNamePrepared = parseAll({ text: action.props.cronJobName, ...ctx });
+    const jobTemplateObj = resolveObjectFromTemplate(action.props.jobTemplate, multiQueryData);
+    if (!jobTemplateObj) {
+      showError("Trigger run", new Error("Could not resolve job template from resource data"));
+      return;
+    }
+    const jobName = generateDnsCompliantName(`${cronJobNamePrepared}-manual`);
+    const namespaceParsed = cronJobNamePrepared ? _$1.get(jobTemplateObj, ["metadata", "namespace"]) : void 0;
+    const body = {
+      apiVersion: "batch/v1",
+      kind: "Job",
+      metadata: {
+        name: jobName,
+        ...namespaceParsed ? { namespace: namespaceParsed } : {},
+        annotations: {
+          "cronjob.kubernetes.io/instantiate": "manual"
+        }
+      },
+      spec: jobTemplateObj.spec
+    };
+    const triggerLabel = `Trigger run for ${cronJobNamePrepared}`;
+    createNewEntry({ endpoint: createEndpointPrepared, body }).then(() => showSuccess(triggerLabel)).catch((error) => {
+      showError(triggerLabel, error);
+    });
+  };
   const useActionsDropdownHandlers = ({ replaceValues, multiQueryData }) => {
     const navigate = reactRouterDom.useNavigate();
     const location = reactRouterDom.useLocation();
@@ -79466,8 +79866,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     const [activeAction, setActiveAction] = React$1.useState(null);
     const [modalOpen, setModalOpen] = React$1.useState(false);
     const [deleteModalData, setDeleteModalData] = React$1.useState(null);
-    const [evictModalData, setEvictModalData] = React$1.useState(null);
-    const [isEvictLoading, setIsEvictLoading] = React$1.useState(false);
+    const [deleteChildrenModalData, setDeleteChildrenModalData] = React$1.useState(null);
     const invalidateMultiQuery = () => {
       queryClient.invalidateQueries({ queryKey: ["multi"] });
     };
@@ -79495,6 +79894,26 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       });
     };
     const ctx = { replaceValues, multiQueryData };
+    const notificationCallbacks = { showSuccess, showError };
+    const { scaleModalData, isScaleLoading, handleScaleAction, handleScaleConfirm, handleScaleCancel } = useScaleHandlers(
+      ctx,
+      notificationCallbacks
+    );
+    const { evictModalData, isEvictLoading, setEvictModalData, handleEvictConfirm, handleEvictCancel } = useEvictHandlers(notificationCallbacks);
+    const { rerunModalData, isRerunLoading, handleRerunLastAction, handleRerunConfirm, handleRerunCancel } = useRerunHandlers(ctx, multiQueryData, notificationCallbacks);
+    const handleDeleteChildrenAction = (action) => {
+      try {
+        const data = buildDeleteChildrenData(action, ctx);
+        setDeleteChildrenModalData(data);
+      } catch (error) {
+        const childResourceNamePrepared = parseAll({ text: action.props.childResourceName, ...ctx });
+        showError(`Delete ${childResourceNamePrepared}`, error);
+      }
+    };
+    const handleDeleteChildrenClose = () => {
+      setDeleteChildrenModalData(null);
+      invalidateMultiQuery();
+    };
     const handleActionClick = (action) => {
       if (action.type === "edit") {
         handleEditAction(action, ctx, fullPath, navigate);
@@ -79521,25 +79940,28 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
         handleOpenKubeletConfigAction(action, ctx, setActiveAction, setModalOpen);
         return;
       }
+      if (action.type === "scale") {
+        handleScaleAction(action);
+        return;
+      }
+      if (action.type === "triggerRun") {
+        fireTriggerRunAction(action, ctx, multiQueryData, notificationCallbacks);
+        return;
+      }
+      if (action.type === "deleteChildren") {
+        handleDeleteChildrenAction(action);
+        return;
+      }
+      if (action.type === "rerunLast") {
+        handleRerunLastAction(action);
+        return;
+      }
+      if (action.type === "drain" || action.type === "rollback") {
+        return;
+      }
       setActiveAction(action);
       setModalOpen(true);
     };
-    const handleEvictConfirm = () => {
-      if (!evictModalData) return;
-      setIsEvictLoading(true);
-      const body = buildEvictBody(evictModalData);
-      const evictLabel = `Evict ${evictModalData.name}`;
-      createNewEntry({ endpoint: evictModalData.endpoint, body }).then(() => showSuccess(evictLabel)).catch((error) => {
-        showError(evictLabel, error);
-      }).finally(() => {
-        setIsEvictLoading(false);
-        setEvictModalData(null);
-      });
-    };
-    const handleEvictCancel = () => {
-      setEvictModalData(null);
-      setIsEvictLoading(false);
-    };
     const handleCloseModal = () => {
       setModalOpen(false);
       setActiveAction(null);
@@ -79561,78 +79983,122 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       deleteModalData,
       evictModalData,
       isEvictLoading,
+      scaleModalData,
+      isScaleLoading,
+      deleteChildrenModalData,
+      rerunModalData,
+      isRerunLoading,
       handleActionClick,
       handleCloseModal,
       handleDeleteModalClose,
       handleEvictConfirm,
-      handleEvictCancel
+      handleEvictCancel,
+      handleScaleConfirm,
+      handleScaleCancel,
+      handleDeleteChildrenClose,
+      handleRerunConfirm,
+      handleRerunCancel
     };
   };
 
+  const buildCacheKey = (slot) => `${slot.cluster}|${slot.namespace ?? ""}|${slot.apiGroup ?? ""}|${slot.plural}|${slot.subresource ?? ""}|${slot.verb}`;
+  const parsePermissionContext = (ctx, parseCtx) => ({
+    cluster: parseAll({ text: ctx.cluster, ...parseCtx }),
+    namespace: ctx.namespace ? parseAll({ text: ctx.namespace, ...parseCtx }) : void 0,
+    apiGroup: ctx.apiGroup ? parseAll({ text: ctx.apiGroup, ...parseCtx }) : void 0,
+    plural: parseAll({ text: ctx.plural, ...parseCtx }),
+    subresource: ctx.subresource ? parseAll({ text: ctx.subresource, ...parseCtx }) : void 0
+  });
+  const isValidContext = (parsed) => !!parsed.cluster && parsed.cluster !== "-" && !!parsed.plural && parsed.plural !== "-";
+  const useManyPermissions = (slots, enabled) => {
+    return reactQuery.useQueries({
+      queries: slots.map((slot) => ({
+        queryKey: [
+          "usePermissions",
+          slot.cluster,
+          slot.namespace,
+          slot.apiGroup,
+          slot.plural,
+          slot.subresource,
+          slot.verb,
+          void 0
+        ],
+        queryFn: async () => (await checkPermission({
+          cluster: slot.cluster,
+          body: {
+            namespace: slot.namespace,
+            apiGroup: slot.apiGroup,
+            plural: slot.plural,
+            subresource: slot.subresource,
+            verb: slot.verb
+          }
+        })).data,
+        refetchInterval: false,
+        enabled
+      }))
+    });
+  };
   const useActionsDropdownPermissions = ({
     actions,
     permissions,
-    permissionContext,
     replaceValues,
     multiQueryData,
     isMultiQueryLoading
   }) => {
-    const permissionContextPrepared = permissionContext ? {
-      cluster: parseAll({ text: permissionContext.cluster, replaceValues, multiQueryData }),
-      namespace: permissionContext.namespace ? parseAll({ text: permissionContext.namespace, replaceValues, multiQueryData }) : void 0,
-      apiGroup: permissionContext.apiGroup ? parseAll({ text: permissionContext.apiGroup, replaceValues, multiQueryData }) : void 0,
-      plural: parseAll({ text: permissionContext.plural, replaceValues, multiQueryData })
-    } : void 0;
-    const isPermissionContextValid = !!permissionContextPrepared && !isMultiQueryLoading && !!permissionContextPrepared.cluster && permissionContextPrepared.cluster !== "-" && !!permissionContextPrepared.plural && permissionContextPrepared.plural !== "-";
     const shouldCheckPermissions = !permissions;
-    const requiredPermissions = shouldCheckPermissions ? getRequiredPermissions(actions) : [];
-    const requiredVerbs = new Set(requiredPermissions.map((permission) => permission.verb));
-    const getSubresourceForVerb = (verb) => requiredPermissions.find((p) => p.verb === verb && p.subresource)?.subresource;
-    const permissionBaseParams = {
-      cluster: permissionContextPrepared?.cluster || "",
-      namespace: permissionContextPrepared?.namespace,
-      apiGroup: permissionContextPrepared?.apiGroup,
-      plural: permissionContextPrepared?.plural || "",
-      refetchInterval: false
-    };
-    const updatePermission = usePermissions({
-      ...permissionBaseParams,
-      verb: "update",
-      subresource: getSubresourceForVerb("update"),
-      enabler: shouldCheckPermissions && isPermissionContextValid && requiredVerbs.has("update")
-    });
-    const patchPermission = usePermissions({
-      ...permissionBaseParams,
-      verb: "patch",
-      subresource: getSubresourceForVerb("patch"),
-      enabler: shouldCheckPermissions && isPermissionContextValid && requiredVerbs.has("patch")
-    });
-    const deletePermission = usePermissions({
-      ...permissionBaseParams,
-      verb: "delete",
-      subresource: getSubresourceForVerb("delete"),
-      enabler: shouldCheckPermissions && isPermissionContextValid && requiredVerbs.has("delete")
-    });
-    const createPermission = usePermissions({
-      ...permissionBaseParams,
-      verb: "create",
-      subresource: getSubresourceForVerb("create"),
-      enabler: shouldCheckPermissions && isPermissionContextValid && requiredVerbs.has("create")
-    });
-    const getPermission = usePermissions({
-      ...permissionBaseParams,
-      verb: "get",
-      subresource: getSubresourceForVerb("get"),
-      enabler: shouldCheckPermissions && isPermissionContextValid && requiredVerbs.has("get")
+    const { slots, mappings } = React$1.useMemo(() => {
+      if (!shouldCheckPermissions || isMultiQueryLoading) {
+        return {
+          slots: [],
+          mappings: []
+        };
+      }
+      const parseCtx = { replaceValues, multiQueryData };
+      const uniqueSlots = [];
+      const cacheKeyToIndex = /* @__PURE__ */ new Map();
+      const actionMappings = [];
+      actions.forEach((action, index) => {
+        const actionKey = `${action.type}-${index}`;
+        const permCtx = action.props.permissionContext;
+        if (!permCtx) {
+          return;
+        }
+        const parsed = parsePermissionContext(permCtx, parseCtx);
+        if (!isValidContext(parsed)) {
+          return;
+        }
+        const requiredPerm = ACTION_REQUIRED_PERMISSIONS[action.type];
+        const subresource = requiredPerm.subresource ?? parsed.subresource;
+        const slotData = {
+          cluster: parsed.cluster,
+          namespace: parsed.namespace,
+          apiGroup: parsed.apiGroup,
+          plural: parsed.plural,
+          subresource,
+          verb: requiredPerm.verb
+        };
+        const cacheKey = buildCacheKey(slotData);
+        let slotIndex = cacheKeyToIndex.get(cacheKey);
+        if (slotIndex === void 0) {
+          slotIndex = uniqueSlots.length;
+          uniqueSlots.push({ ...slotData, cacheKey });
+          cacheKeyToIndex.set(cacheKey, slotIndex);
+        }
+        actionMappings.push({ actionKey, slotIndex });
+      });
+      return { slots: uniqueSlots, mappings: actionMappings };
+    }, [shouldCheckPermissions, isMultiQueryLoading, actions, replaceValues, multiQueryData]);
+    const enabled = shouldCheckPermissions && !isMultiQueryLoading;
+    const slotResults = useManyPermissions(slots, enabled);
+    if (permissions) {
+      return permissions;
+    }
+    const computed = {};
+    mappings.forEach((mapping) => {
+      const result = slotResults[mapping.slotIndex];
+      computed[mapping.actionKey] = result?.data?.status?.allowed;
     });
-    const computedPermissions = {
-      canUpdate: requiredVerbs.has("update") ? updatePermission.data?.status.allowed : void 0,
-      canPatch: requiredVerbs.has("patch") ? patchPermission.data?.status.allowed : void 0,
-      canDelete: requiredVerbs.has("delete") ? deletePermission.data?.status.allowed : void 0,
-      canCreate: requiredVerbs.has("create") ? createPermission.data?.status.allowed : void 0,
-      canGet: requiredVerbs.has("get") ? getPermission.data?.status.allowed : void 0
-    };
-    return permissions ?? computedPermissions;
+    return computed;
   };
 
   const toYamlString = (value) => {
@@ -79718,6 +80184,13 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
         return null;
       case "openKubeletConfig":
         return /* @__PURE__ */ jsxRuntimeExports.jsx(OpenKubeletConfigModal, { ...extraProps, props: action.props });
+      case "scale":
+      case "triggerRun":
+      case "deleteChildren":
+      case "rerunLast":
+      case "drain":
+      case "rollback":
+        return null;
       default: {
         const _exhaustive = action;
         return _exhaustive;
@@ -79725,15 +80198,55 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     }
   };
 
+  const ScaleModal = ({ open, onClose, onConfirm, currentReplicas, name, isLoading }) => {
+    const [replicas, setReplicas] = React$1.useState(currentReplicas);
+    React$1.useEffect(() => {
+      if (open) {
+        setReplicas(currentReplicas);
+      }
+    }, [open, currentReplicas]);
+    const isValidReplicas = Number.isInteger(replicas) && (replicas ?? -1) >= 0;
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      antd.Modal,
+      {
+        title: `Scale «${name}»`,
+        open,
+        onOk: () => {
+          if (isValidReplicas) {
+            onConfirm(replicas);
+          }
+        },
+        onCancel: onClose,
+        okText: "Scale",
+        confirmLoading: isLoading,
+        okButtonProps: { disabled: !isValidReplicas },
+        width: 400,
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(antd.Typography.Paragraph, { children: [
+            "Current replicas: ",
+            /* @__PURE__ */ jsxRuntimeExports.jsx("strong", { children: currentReplicas })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(antd.Typography.Paragraph, { children: "New replicas:" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            antd.InputNumber,
+            {
+              min: 0,
+              precision: 0,
+              step: 1,
+              value: replicas,
+              parser: (value) => Number(value ? value.replace(/[^\d]/g, "") : 0),
+              onChange: (value) => setReplicas(typeof value === "number" ? value : null),
+              style: { width: "100%" },
+              autoFocus: true
+            }
+          )
+        ]
+      }
+    );
+  };
+
   const ActionsDropdown = ({ data, children }) => {
-    const {
-      buttonText = "Actions",
-      buttonVariant = "default",
-      containerStyle,
-      actions,
-      permissions,
-      permissionContext
-    } = data;
+    const { buttonText = "Actions", buttonVariant = "default", containerStyle, actions, permissions } = data;
     const { data: multiQueryData, isLoading: isMultiQueryLoading, isError: isMultiQueryError, errors } = useMultiQuery();
     const partsOfUrl = usePartsOfUrl();
     const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value, index) => {
@@ -79741,18 +80254,17 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       return acc;
     }, {});
     const safeMultiQueryData = multiQueryData ?? {};
-    const visibleActions = getVisibleActions(actions, {
-      replaceValues,
-      multiQueryData: safeMultiQueryData
-    });
     const effectivePermissions = useActionsDropdownPermissions({
-      actions: visibleActions,
+      actions,
       permissions,
-      permissionContext,
       replaceValues,
       multiQueryData: safeMultiQueryData,
       isMultiQueryLoading
     });
+    const visibleActions = getVisibleActions(actions, {
+      replaceValues,
+      multiQueryData: safeMultiQueryData
+    });
     const {
       notificationContextHolder,
       activeAction,
@@ -79760,11 +80272,21 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       deleteModalData,
       evictModalData,
       isEvictLoading,
+      scaleModalData,
+      isScaleLoading,
+      deleteChildrenModalData,
+      rerunModalData,
+      isRerunLoading,
       handleActionClick,
       handleCloseModal,
       handleDeleteModalClose,
       handleEvictConfirm,
-      handleEvictCancel
+      handleEvictCancel,
+      handleScaleConfirm,
+      handleScaleCancel,
+      handleDeleteChildrenClose,
+      handleRerunConfirm,
+      handleRerunCancel
     } = useActionsDropdownHandlers({
       replaceValues,
       multiQueryData: safeMultiQueryData
@@ -79814,6 +80336,29 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
           children: "This will evict the pod. It may be blocked by PodDisruptionBudget."
         }
       ),
+      scaleModalData && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ScaleModal,
+        {
+          open: true,
+          currentReplicas: scaleModalData.currentReplicas,
+          name: scaleModalData.name,
+          onConfirm: handleScaleConfirm,
+          onClose: handleScaleCancel,
+          isLoading: isScaleLoading
+        }
+      ),
+      deleteChildrenModalData && /* @__PURE__ */ jsxRuntimeExports.jsx(DeleteModalMany, { data: deleteChildrenModalData.children, onClose: handleDeleteChildrenClose }),
+      rerunModalData && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ConfirmModal,
+        {
+          title: `Rerun job "${rerunModalData.sourceName}"?`,
+          onConfirm: handleRerunConfirm,
+          onClose: handleRerunCancel,
+          confirmText: "Rerun",
+          confirmLoading: isRerunLoading,
+          children: "This will create a new Job with the same spec."
+        }
+      ),
       children
     ] });
   };
@@ -84583,6 +85128,7 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
     const [isLoading, setIsLoading] = React$1.useState(true);
     const [isNamespaced, setIsNamespaced] = React$1.useState(false);
     const [isError, setIsError] = React$1.useState(false);
+    const hasAppliedBackendModeRef = React$1.useRef(false);
     const { data: overridesData, isLoading: overridesLoading } = useK8sSmartResource({
       cluster,
       apiGroup: forcingCustomization.baseApiGroup,
@@ -84601,20 +85147,20 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       )
     });
     const fallbackToManualMode = React$1.useCallback(() => {
-      if (modeData) {
-        modeData.onChange("Manual");
-        modeData.onDisabled();
-      }
+      if (!modeData || hasAppliedBackendModeRef.current) return;
+      modeData.onChange("Manual");
+      hasAppliedBackendModeRef.current = true;
     }, [modeData]);
     const applyForceViewMode = React$1.useCallback(
       (forceViewMode) => {
-        if (!modeData || !forceViewMode) return;
+        if (!modeData || !forceViewMode || hasAppliedBackendModeRef.current) return;
         if (forceViewMode === "Manual") {
           modeData.onChange("Manual");
-          modeData.onDisabled();
+          hasAppliedBackendModeRef.current = true;
           return;
         }
         modeData.onChange("OpenAPI");
+        hasAppliedBackendModeRef.current = true;
       },
       [modeData]
     );
@@ -85120,8 +85666,8 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       namespace,
       apiGroup,
       apiVersion: apiVersion || "",
-      plural: type,
-      isEnabled: Boolean(apiVersion && addedMode && type !== "direct")
+      plural: plural || "",
+      isEnabled: Boolean(apiVersion && plural && addedMode && type !== "direct")
     });
     const isAddedMode = Boolean(addedMode);
     const isDirectType = type === "direct";
@@ -89239,7 +89785,13 @@ Take a look at the reducer(s) handling this action type: ${action.type}.
       queryKey: ["usePluginManifest", cluster],
       queryFn: () => getPlugins({ cluster }),
       refetchInterval: refetchInterval !== void 0 ? refetchInterval : 6e4,
-      enabled: isEnabled
+      enabled: isEnabled,
+      // 🔴 Disable ALL auto refetching
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      refetchOnMount: false,
+      // 🟢 Optional: Make data never go stale
+      staleTime: Infinity
     });
   };