diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc06004fe..401bc19e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,27 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 
 ## [Unreleased]
 
+### Added
+
+- `<SilkActivityControl />`, `<ActivityExecutionErrorReportModal />`
+    - support `aria-label` and `aria-labelledby` for naming activity error report dialogs without a visible title
+    - support `fullScreenTogglerTexts` to set localized texts for the full screen toggler of the error report dialog
+- `<SimpleDialog />`
+    - `fullScreenTogglerTexts` property: sets the texts of the full screen toggler for the `maximize` and `minimize` state, used as `title` and accessible name of the button
+
+### Changed
+
+- `<SimpleDialog />`
+    - the full screen toggler has an accessible name and a `title` now, the default texts are "Show in full screen" and "Exit full screen", use `fullScreenTogglerTexts` to localize them
+- `<SilkActivityControl />`, `<ActivityExecutionErrorReportModal />`
+    - error report dialogs without title, `aria-label` and `aria-labelledby` get a fallback accessible name, `translate("showErrorReport")` in `<SilkActivityControl />` and "Activity execution error report" in `<ActivityExecutionErrorReportModal />`
+    - the error report dialog uses the full screen toggler of `<SimpleDialog />` instead of an own implementation
+- `<Modal />`
+    - the elements referenced by `aria-labelledby` are checked for existence when the modal is opened, invalid references are reported as console warning and removed from `aria-labelledby`
+    - if none of the elements referenced by `aria-labelledby` exists then a given `aria-label` is used as fallback, without `aria-label` the `role` and `aria-modal` attributes are removed
+- `<SimpleDialog />`, `<AlertDialog />`
+    - the intent state is also used as `aria-label` fallback if none of the elements referenced by `aria-labelledby` exists
+
 ## [26.2.1] - 2026-11-02
 
 ### Fixed
diff --git a/src/cmem/ActivityControl/ActivityExecutionErrorReportModal.tsx b/src/cmem/ActivityControl/ActivityExecutionErrorReportModal.tsx
index be2e7a932..d986ee2d4 100644
--- a/src/cmem/ActivityControl/ActivityExecutionErrorReportModal.tsx
+++ b/src/cmem/ActivityControl/ActivityExecutionErrorReportModal.tsx
@@ -1,12 +1,20 @@
-import React, { useState } from "react";
+import React from "react";
 
 import Button from "../../components/Button/Button";
-import SimpleDialog from "../../components/Dialog/SimpleDialog";
-import IconButton from "../../components/Icon/IconButton";
+import SimpleDialog, { SimpleDialogProps } from "../../components/Dialog/SimpleDialog";
 import HtmlContentBlock from "../../components/Typography/HtmlContentBlock";
 
-interface ActivityExecutionErrorReportModalProps {
-    // Title of the modal
+interface ActivityExecutionErrorReportModalProps extends Pick<
+    SimpleDialogProps,
+    "aria-label" | "aria-labelledby" | "fullScreenTogglerTexts"
+> {
+    /**
+     * Title of the modal.
+     * If set, it is used as the accessible name of the dialog via `aria-labelledby`
+     * (unless `aria-labelledby` is given explicitly), so `aria-label` is ignored.
+     * Use `aria-label` only for modals without title.
+     * If neither `title`, a non-empty `aria-label` nor `aria-labelledby` is set, then "Activity execution error report" is used as `aria-label`.
+     */
     title?: string;
     // Called when the close button is clicked
     onDiscard: () => any;
@@ -23,13 +31,15 @@ interface ActivityExecutionErrorReportModalProps {
 /** Shows the execution error report to the user and offers to download the report. */
 export const ActivityExecutionErrorReportModal = ({
     title,
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledby,
     onDiscard,
     report,
     downloadButtonValue,
     closeButtonValue,
+    fullScreenTogglerTexts,
     fetchErrorReport,
 }: ActivityExecutionErrorReportModalProps) => {
-    const [displayFullscreen, setDisplayFullscreen] = useState<boolean>(false);
     const fileName =
         "Activity execution report from " +
         new Date().toISOString().replace(/T/, " ").replace(/:/g, "-").substr(0, 19) +
@@ -51,15 +61,13 @@ export const ActivityExecutionErrorReportModal = ({
     return (
         <SimpleDialog
             title={title}
+            aria-label={ariaLabel || "Activity execution error report"}
+            aria-labelledby={ariaLabelledby}
             isOpen={true}
-            size={displayFullscreen ? "fullscreen" : "large"}
+            size="large"
+            showFullScreenToggler
+            fullScreenTogglerTexts={fullScreenTogglerTexts}
             onClose={onDiscard}
-            headerOptions={
-                <IconButton
-                    name={displayFullscreen ? "toggler-minimize" : "toggler-maximize"}
-                    onClick={() => setDisplayFullscreen(!displayFullscreen)}
-                />
-            }
             actions={[
                 <Button data-test-id={"error-report-download-btn"} affirmative onClick={handleDownload} key="download">
                     {downloadButtonValue}
diff --git a/src/cmem/ActivityControl/SilkActivityControl.tsx b/src/cmem/ActivityControl/SilkActivityControl.tsx
index 3f9e54ce0..29588f735 100644
--- a/src/cmem/ActivityControl/SilkActivityControl.tsx
+++ b/src/cmem/ActivityControl/SilkActivityControl.tsx
@@ -3,6 +3,7 @@ import { Intent } from "@blueprintjs/core/src/common/intent";
 
 import { Icon, Spacing } from "../../";
 import { IntentTypes } from "../../common/Intent";
+import { SimpleDialogProps } from "../../components/Dialog/SimpleDialog";
 import { TestableComponent } from "../../components/interfaces";
 import { ElapsedDateTimeDisplay, ElapsedDateTimeDisplayUnits } from "../DateTimeDisplay/ElapsedDateTimeDisplay";
 
@@ -90,8 +91,17 @@ const defaultLayout: SilkActivityControlLayoutProps = {
     visualization: "spinner",
 };
 
-interface IErrorReportAction {
-    // The title of the error report modal
+interface IErrorReportAction extends Pick<
+    SimpleDialogProps,
+    "aria-label" | "aria-labelledby" | "fullScreenTogglerTexts"
+> {
+    /**
+     * The title of the error report modal.
+     * If set, it is used as the accessible name of the dialog via `aria-labelledby`
+     * (unless `aria-labelledby` is given explicitly), so `aria-label` is ignored.
+     * Use `aria-label` only for modals without title.
+     * If neither `title`, a non-empty `aria-label` nor `aria-labelledby` is set, then `translate("showErrorReport")` is used as `aria-label`.
+     */
     title?: string;
     // The element that will be rendered in the modal, either as Markdown or object
     renderReport: (report: string | SilkActivityExecutionReportProps) => React.JSX.Element;
@@ -362,9 +372,12 @@ export function useSilkActivityControl({
             {errorReport && failureReportAction && (
                 <ActivityExecutionErrorReportModal
                     title={failureReportAction.title}
+                    aria-label={failureReportAction["aria-label"] || translate("showErrorReport")}
+                    aria-labelledby={failureReportAction["aria-labelledby"]}
                     key={"error-report-modal"}
                     closeButtonValue={failureReportAction.closeButtonValue}
                     downloadButtonValue={failureReportAction.downloadButtonValue}
+                    fullScreenTogglerTexts={failureReportAction.fullScreenTogglerTexts}
                     fetchErrorReport={async () => {
                         return (await failureReportAction.fetchErrorReport(true)) as string | undefined;
                     }}
diff --git a/src/cmem/ActivityControl/tests/SilkActivityControl.test.tsx b/src/cmem/ActivityControl/tests/SilkActivityControl.test.tsx
new file mode 100644
index 000000000..cf6f900f2
--- /dev/null
+++ b/src/cmem/ActivityControl/tests/SilkActivityControl.test.tsx
@@ -0,0 +1,132 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+
+import "@testing-library/jest-dom";
+
+import { ActivityExecutionErrorReportModal } from "../ActivityExecutionErrorReportModal";
+import { SilkActivityControl, SilkActivityControlProps } from "../SilkActivityControl";
+
+type FailureReportAction = NonNullable<SilkActivityControlProps["failureReportAction"]>;
+
+const renderFailedActivity = (
+    failureReportAction: Partial<FailureReportAction>,
+    additionalContent?: React.ReactNode,
+) => {
+    const props: SilkActivityControlProps = {
+        label: "Execution",
+        initialStatus: {
+            activity: "execute",
+            activityLabel: "Execution",
+            isRunning: false,
+            failed: true,
+            statusName: "Finished",
+            progress: 100,
+            lastUpdateTime: 0,
+            message: "Failed",
+            cancelled: false,
+            concreteStatus: "Failed",
+        },
+        registerForUpdates: jest.fn(),
+        unregisterFromUpdates: jest.fn(),
+        showStartAction: false,
+        showStopAction: false,
+        showReloadAction: false,
+        executeActivityAction: jest.fn(),
+        translate: (key) => key,
+        failureReportAction: {
+            renderReport: () => <p>Error details</p>,
+            renderMarkdown: true,
+            fetchErrorReport: async () => "Error details",
+            downloadButtonValue: "Download",
+            closeButtonValue: "Close",
+            ...failureReportAction,
+        },
+    };
+    const utils = render(
+        <>
+            {additionalContent}
+            <SilkActivityControl {...props} />
+        </>,
+    );
+    const openErrorReport = () =>
+        fireEvent.click(utils.container.querySelector("[data-test-id='activity-show-error-report']") as HTMLElement);
+    return { ...utils, openErrorReport };
+};
+
+describe("SilkActivityControl error report", () => {
+    it("uses the title as accessible name of the error report dialog", async () => {
+        const { openErrorReport } = renderFailedActivity({ title: "Error report" });
+        openErrorReport();
+        expect(await screen.findByRole("dialog", { name: "Error report" })).toHaveAttribute("aria-modal", "true");
+    });
+
+    it("forwards `aria-label` to a titleless error report dialog", async () => {
+        const { openErrorReport } = renderFailedActivity({
+            title: "",
+            "aria-label": "Activity execution error report",
+        });
+        openErrorReport();
+        const dialog = await screen.findByRole("dialog", { name: "Activity execution error report" });
+        expect(dialog).toHaveAttribute("aria-modal", "true");
+
+        fireEvent.click(screen.getByRole("button", { name: "Close" }));
+        await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
+    });
+
+    it("uses the translated `showErrorReport` text as fallback name for a titleless error report dialog", async () => {
+        const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        try {
+            const { openErrorReport } = renderFailedActivity({ title: "", "aria-label": "" });
+            openErrorReport();
+            expect(await screen.findByRole("dialog", { name: "showErrorReport" })).toHaveAttribute(
+                "aria-modal",
+                "true",
+            );
+            expect(warnSpy).not.toHaveBeenCalled();
+        } finally {
+            warnSpy.mockRestore();
+        }
+    });
+
+    it("forwards the full screen toggler texts to the error report dialog", async () => {
+        const { openErrorReport } = renderFailedActivity({
+            title: "Error report",
+            fullScreenTogglerTexts: { maximize: "Vollbild anzeigen", minimize: "Vollbild verlassen" },
+        });
+        openErrorReport();
+        const dialog = await screen.findByRole("dialog", { name: "Error report" });
+        const toggler = within(dialog).getByRole("button", { name: "Vollbild anzeigen" });
+
+        fireEvent.click(toggler);
+        expect(toggler).toHaveAccessibleName("Vollbild verlassen");
+    });
+
+    it("forwards `aria-labelledby` to a titleless error report dialog", async () => {
+        const { openErrorReport } = renderFailedActivity(
+            { "aria-labelledby": "external-report-label" },
+            <span id="external-report-label">Referenced error report label</span>,
+        );
+        openErrorReport();
+        const dialog = await screen.findByRole("dialog", { name: "Referenced error report label" });
+        expect(dialog).toHaveAttribute("aria-labelledby", "external-report-label");
+    });
+});
+
+describe("ActivityExecutionErrorReportModal", () => {
+    it.each([undefined, ""])(
+        "uses an english fallback name if neither title nor aria attributes are given (aria-label: %p)",
+        (ariaLabel) => {
+            render(
+                <ActivityExecutionErrorReportModal
+                    aria-label={ariaLabel}
+                    onDiscard={jest.fn()}
+                    report={<p>Error details</p>}
+                    downloadButtonValue="Download"
+                    closeButtonValue="Close"
+                    fetchErrorReport={async () => "Error details"}
+                />,
+            );
+            expect(screen.getByRole("dialog", { name: "Activity execution error report" })).toBeInTheDocument();
+        },
+    );
+});
diff --git a/src/components/Dialog/AlertDialog.tsx b/src/components/Dialog/AlertDialog.tsx
index 24adecbbf..f82a785de 100644
--- a/src/components/Dialog/AlertDialog.tsx
+++ b/src/components/Dialog/AlertDialog.tsx
@@ -22,7 +22,8 @@ export interface AlertDialogProps extends Omit<SimpleDialogProps, "intent" | "ro
 /**
  * Special element to display alert notification in modal dialogs.
  * Inherits all properties from `SimpleDialog`, except `intent` and `role`.
- * If `title`, `aria-label` nor a `aria-labelledby` is given then the alert level automatically used as fallback for `aria-label`.
+ * If no `aria-label` is given then the alert level is automatically used as fallback for `aria-label`.
+ * It is only used if there is no `title` and no valid `aria-labelledby` reference.
  */
 export const AlertDialog = ({
     children,
diff --git a/src/components/Dialog/Modal.tsx b/src/components/Dialog/Modal.tsx
index 5c6160f74..f64dcc8d5 100644
--- a/src/components/Dialog/Modal.tsx
+++ b/src/components/Dialog/Modal.tsx
@@ -70,6 +70,64 @@ export interface ModalProps
 
 export type ModalSize = "tiny" | "small" | "regular" | "large" | "xlarge" | "fullscreen";
 
+/**
+ * Checks if the elements referenced by `aria-labelledby` exist.
+ * Invalid references are reported in the console and removed from `aria-labelledby`.
+ * If none of them exists then `aria-label` is used as fallback, if it was given.
+ * Changes are applied directly to the DOM element to prevent an additional re-rendering.
+ * React does not touch these attributes again as long as their properties do not change.
+ * Returns `false` if the modal has no accessible name, then its role need to be removed.
+ */
+const validateAriaLabelledby = (
+    modalElement: HTMLElement,
+    role: string,
+    ariaLabelledby?: string,
+    ariaLabel?: string,
+): boolean => {
+    if (!ariaLabelledby) {
+        return true;
+    }
+    const rootNode = modalElement.getRootNode();
+    // targets can also be located inside a shadow DOM
+    const lookupRoot: Pick<Document, "getElementById"> =
+        "getElementById" in rootNode ? (rootNode as Document | ShadowRoot) : modalElement.ownerDocument;
+    const referencedIds = ariaLabelledby.split(/\s+/).filter((id) => !!id);
+    const invalidIds = referencedIds.filter((id) => !lookupRoot.getElementById(id));
+    const validIds = referencedIds.filter((id) => !invalidIds.includes(id));
+    const hasValidTarget = validIds.length > 0;
+
+    if (hasValidTarget) {
+        // invalid references are removed, so screen readers cannot stumble over them
+        if (invalidIds.length > 0) {
+            modalElement.setAttribute("aria-labelledby", validIds.join(" "));
+        }
+        // `aria-label` is never rendered together with `aria-labelledby`, so it can only be a former fallback
+        modalElement.removeAttribute("aria-label");
+    } else {
+        modalElement.removeAttribute("aria-labelledby");
+        if (ariaLabel) {
+            modalElement.setAttribute("aria-label", ariaLabel);
+        }
+    }
+
+    if (invalidIds.length === 0 && hasValidTarget) {
+        return true;
+    }
+
+    const invalidTargets = invalidIds.length > 0 ? invalidIds.map((id) => `#${id}`).join(", ") : `"${ariaLabelledby}"`;
+    let fallbackInfo: string;
+    if (hasValidTarget) {
+        fallbackInfo = "They were removed, fallback to aria-label not necessary because other targets are valid.";
+    } else if (ariaLabel) {
+        fallbackInfo = `aria-labelledby was removed, fallback to aria-label="${ariaLabel}" was used.`;
+    } else {
+        fallbackInfo = `aria-labelledby was removed, fallback to aria-label not possible because it is not given, modal has no accessible name and role=${role} was removed.`;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(`aria-labelledby of modal references invalid targets: ${invalidTargets}. ${fallbackInfo}`);
+    return hasValidTarget || !!ariaLabel;
+};
+
 /**
  * Displays contents on top of other elements, used to create dialogs.
  * For most situations the usage of `SimpleDialog` and `AlertDialog` should be sufficient.
@@ -111,11 +169,18 @@ export const Modal = ({
         };
     }, []);
 
+    const modalElementRef = React.useRef<HTMLElement>(null);
+    // prevents that the same element is validated multiple times with unchanged properties
+    const lastLabelValidation = React.useRef<{ element?: HTMLElement; key?: string }>({});
+    // set if none of the `aria-labelledby` targets exists and no `aria-label` is given as fallback
+    const hasNoValidLabelTarget = React.useRef<boolean>(false);
+
+    const hasLabelProperty = !!(ariaLabel || ariaLabelledby);
     // always remove the role if there is no explanation
-    const modalRole = ariaLabel || ariaLabelledby ? role : undefined;
+    const modalRole = hasLabelProperty && !hasNoValidLabelTarget.current ? role : undefined;
 
     React.useEffect(() => {
-        if (!modalRole && otherProps.isOpen) {
+        if (!hasLabelProperty && otherProps.isOpen) {
             // eslint-disable-next-line no-console
             console.warn(
                 `role=${role} removed from modal because neither aria-label nor aria-labelledby is available.`,
@@ -155,6 +220,8 @@ export const Modal = ({
             // call the original event handler
             onOpening(modalElement);
         }
+        // content of the modal is available now, so targets inside of it can be found
+        checkLabelTargets();
         if (usePortal && forceTopPosition) {
             const parentalPortal = modalElement.closest(`.${BlueprintClassNames.PORTAL}`) as HTMLElement;
             const highestTopIndex = (utils.getGlobalVar("highestModalTopIndex") as unknown as number) ?? 0;
@@ -184,6 +251,33 @@ export const Modal = ({
         "aria-modal": modalRole ? isTopMostModal : undefined,
     };
 
+    const checkLabelTargets = () => {
+        const element = modalElementRef.current;
+        const key = `${ariaLabelledby}|${ariaLabel}`;
+        if (!element || (lastLabelValidation.current.element === element && lastLabelValidation.current.key === key)) {
+            return;
+        }
+        lastLabelValidation.current = { element, key };
+        const hasAccessibleName = validateAriaLabelledby(element, role, ariaLabelledby, ariaLabel);
+        hasNoValidLabelTarget.current = !hasAccessibleName;
+        // role and modality are changed directly on the DOM element, following renderings respect the flag
+        if (!hasAccessibleName) {
+            element.removeAttribute("role");
+            element.removeAttribute("aria-modal");
+        } else if (hasLabelProperty && !element.hasAttribute("role")) {
+            // restore them if they were removed by a former check
+            element.setAttribute("role", role);
+            element.setAttribute("aria-modal", `${isTopMostModal}`);
+        }
+    };
+
+    React.useEffect(() => {
+        // only for changes while the modal is open, initial check is done when it is opening
+        if (otherProps.isOpen) {
+            checkLabelTargets();
+        }
+    }, [ariaLabelledby, ariaLabel]);
+
     return (
         <BlueprintOverlay
             {...otherProps}
@@ -212,6 +306,7 @@ export const Modal = ({
                         (className ? " " + className : "")
                     }
                     {...modalAriaAttributes}
+                    ref={modalElementRef}
                 >
                     {alteredChildren}
                 </section>
diff --git a/src/components/Dialog/SimpleDialog.tsx b/src/components/Dialog/SimpleDialog.tsx
index c118c2377..24d02876d 100644
--- a/src/components/Dialog/SimpleDialog.tsx
+++ b/src/components/Dialog/SimpleDialog.tsx
@@ -45,6 +45,15 @@ export interface SimpleDialogProps extends ModalProps, TestableComponent {
     showFullScreenToggler?: boolean;
     /** Starts the modal in full screen mode. The show full screen toggler will be automatically enabled. */
     startInFullScreenMode?: boolean;
+    /**
+     * Texts for the full screen toggler, used as tooltip and accessible name of the button.
+     * `maximize` is shown while the dialog is in its normal size, `minimize` while it is in full screen mode.
+     * Defaults to "Show in full screen" and "Exit full screen".
+     */
+    fullScreenTogglerTexts?: {
+        maximize?: string;
+        minimize?: string;
+    };
     /** Forward properties to the actions footer component. */
     actionsProps?: Omit<CardActionsProps, "inverseDirection">;
 }
@@ -53,6 +62,8 @@ export interface SimpleDialogProps extends ModalProps, TestableComponent {
  * Simplifies the dialog display by providing a direct `Card` template for the `Modal` element.
  * If not given then aria attributes like `role` and `aria-labelledby` are set automatically.
  * `aria-describedby` is only automatically when an `intent` state is set.
+ * With an `intent` state the intent is also used as fallback for `aria-label`,
+ * if no `aria-label` is given and there is no title or the elements referenced by `aria-labelledby` do not exist.
  * Inherits all properties from `Modal`.
  */
 export const SimpleDialog = ({
@@ -69,6 +80,7 @@ export const SimpleDialog = ({
     headerOptions,
     showFullScreenToggler = false,
     startInFullScreenMode = false,
+    fullScreenTogglerTexts,
     size,
     role,
     "aria-labelledby": ariaLabelledby,
@@ -80,6 +92,9 @@ export const SimpleDialog = ({
     const dialogUniqueId = React.useId().replace(/[^a-zA-Z0-9_-]/g, "");
     const [displayFullscreen, setDisplayFullscreen] = React.useState<boolean>(startInFullScreenMode);
     const showToggler = startInFullScreenMode || showFullScreenToggler;
+    const togglerText = displayFullscreen
+        ? (fullScreenTogglerTexts?.minimize ?? "Exit full screen")
+        : (fullScreenTogglerTexts?.maximize ?? "Show in full screen");
     const intentClassName = intent ? `${eccgui}-intent--${intent}` : "";
     const wrapperDivProps = {
         ...modalPreventEvents,
@@ -87,7 +102,9 @@ export const SimpleDialog = ({
     };
 
     const hasSemanticIntent = intent && ["success", "warning", "danger", "info"].includes(intent);
-    const labelFallback = hasSemanticIntent && !title && !ariaLabel && !ariaLabelledby ? intent : undefined;
+    // the fallback is also given when there is a title or `aria-labelledby` because `Modal` ignores it then,
+    // but uses it if none of the elements referenced by `aria-labelledby` exists
+    const labelFallback = hasSemanticIntent && !ariaLabel ? intent : undefined;
 
     return (
         <Modal
@@ -116,6 +133,9 @@ export const SimpleDialog = ({
                                 {showToggler && (
                                     <IconButton
                                         name={displayFullscreen ? "toggler-minimize" : "toggler-maximize"}
+                                        text={togglerText}
+                                        tooltipAsTitle
+                                        aria-label={togglerText}
                                         onClick={() => setDisplayFullscreen(!displayFullscreen)}
                                     />
                                 )}
diff --git a/src/components/Dialog/tests/AlertDialog.test.tsx b/src/components/Dialog/tests/AlertDialog.test.tsx
index d73a116c9..6332b9b4b 100644
--- a/src/components/Dialog/tests/AlertDialog.test.tsx
+++ b/src/components/Dialog/tests/AlertDialog.test.tsx
@@ -95,10 +95,29 @@ describe("AlertDialog", () => {
             expect(dialog).toHaveAttribute("aria-label", "Alert label");
         });
         it("should not use the fallback label if `aria-labelledby` is given", () => {
-            const { dialog } = renderAlert({ "aria-labelledby": "externaltitle" });
+            const { dialog } = renderAlert({
+                "aria-labelledby": "externaltitle",
+                children: <h3 id="externaltitle">External title</h3>,
+            });
             expect(dialog).not.toHaveAttribute("aria-label");
             expect(dialog).toHaveAttribute("aria-labelledby", "externaltitle");
         });
+        it("should use the alert level as `aria-label` fallback if no `aria-labelledby` target exists", () => {
+            const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+            const { dialog } = renderAlert({ warning: true, "aria-labelledby": "missing" });
+            expect(dialog).toHaveAttribute("aria-label", "warning");
+            expect(dialog).not.toHaveAttribute("aria-labelledby");
+            expect(dialog).toHaveAttribute("role", "alertdialog");
+            expect(dialog).toHaveAttribute("aria-modal", "true");
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('aria-label="warning" was used'));
+            consoleWarnSpy.mockRestore();
+        });
+        it("should prefer a given `aria-label` over the alert level if no `aria-labelledby` target exists", () => {
+            const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+            const { dialog } = renderAlert({ "aria-label": "Alert label", "aria-labelledby": "missing" });
+            expect(dialog).toHaveAttribute("aria-label", "Alert label");
+            consoleWarnSpy.mockRestore();
+        });
         it("should always have an accessible name, so the role is never removed", () => {
             const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
             expect(renderAlert().dialog).toHaveAttribute("role", "alertdialog");
diff --git a/src/components/Dialog/tests/Modal.test.tsx b/src/components/Dialog/tests/Modal.test.tsx
index 557baa1a3..89394ef77 100644
--- a/src/components/Dialog/tests/Modal.test.tsx
+++ b/src/components/Dialog/tests/Modal.test.tsx
@@ -9,6 +9,7 @@ import Modal, { ModalProps } from "../Modal";
 import { ModalContext, ModalContextProps, useModalContext } from "../ModalContext";
 
 const dialogWrapper = `${eccgui}-dialog__wrapper`;
+const customTitle = <h2 id="customtitle">Custom title</h2>;
 
 const renderModal = (props: Partial<ModalProps> = {}) => {
     const { children, ...otherProps } = props;
@@ -127,6 +128,7 @@ describe("Modal", () => {
             const { modal } = renderModal({
                 "aria-labelledby": "customtitle",
                 "aria-describedby": "customdescription",
+                children: customTitle,
             });
             expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
             expect(modal).toHaveAttribute("aria-describedby", "customdescription");
@@ -138,13 +140,21 @@ describe("Modal", () => {
         });
         it("should ignore `aria-label` if `aria-labelledby` is given", () => {
             // `aria-labelledby` wins over `aria-label`, so the label would never be used
-            const { modal } = renderModal({ "aria-label": "Modal label", "aria-labelledby": "customtitle" });
+            const { modal } = renderModal({
+                "aria-label": "Modal label",
+                "aria-labelledby": "customtitle",
+                children: customTitle,
+            });
             expect(modal).not.toHaveAttribute("aria-label");
             expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
         });
         it("should keep the role if only `aria-labelledby` is given", () => {
             // the ignored `aria-label` must not affect the accessible name detection
-            const { modal } = renderModal({ "aria-label": "Modal label", "aria-labelledby": "customtitle" });
+            const { modal } = renderModal({
+                "aria-label": "Modal label",
+                "aria-labelledby": "customtitle",
+                children: customTitle,
+            });
             expect(modal).toHaveAttribute("role", "dialog");
             expect(consoleWarnSpy).not.toHaveBeenCalled();
         });
@@ -158,7 +168,10 @@ describe("Modal", () => {
         });
         it("should keep the role if the modal has an accessible name", () => {
             expect(renderModal({ "aria-label": "Modal label" }).modal).toHaveAttribute("role", "dialog");
-            expect(renderModal({ "aria-labelledby": "customtitle" }).modal).toHaveAttribute("role", "dialog");
+            expect(renderModal({ "aria-labelledby": "customtitle", children: customTitle }).modal).toHaveAttribute(
+                "role",
+                "dialog",
+            );
         });
         it("should remove the role if there is only a description but no name", () => {
             // a description alone does not make the dialog identifiable for screen readers
@@ -177,6 +190,169 @@ describe("Modal", () => {
         });
     });
 
+    describe("aria-labelledby targets", () => {
+        it("should not warn if all targets exist", () => {
+            renderModal({
+                "aria-labelledby": "customtitle othertitle",
+                children: [
+                    customTitle,
+                    <p id="othertitle" key="other">
+                        Other title
+                    </p>,
+                ],
+            });
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+        it("should find targets outside of the modal", () => {
+            render(<h2 id="externaltitle">External title</h2>);
+            const { modal } = renderModal({ "aria-labelledby": "externaltitle", "aria-label": "Modal label" });
+            expect(modal).toHaveAttribute("aria-labelledby", "externaltitle");
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+        it("should warn about invalid targets and remove them if at least one target is valid", () => {
+            const { modal } = renderModal({
+                "aria-labelledby": "customtitle missing1 missing2",
+                "aria-label": "Modal label",
+                children: customTitle,
+            });
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+            expect(modal).not.toHaveAttribute("aria-label");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("#missing1, #missing2"));
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("not necessary"));
+            expect(consoleWarnSpy).not.toHaveBeenCalledWith(expect.stringContaining("#customtitle"));
+        });
+        it("should use `aria-label` as fallback if no target is valid", () => {
+            const { modal } = renderModal({ "aria-labelledby": "missing", "aria-label": "Modal label" });
+            expect(modal).toHaveAttribute("aria-label", "Modal label");
+            expect(modal).not.toHaveAttribute("aria-labelledby");
+            expect(modal).toHaveAttribute("role", "dialog");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("#missing"));
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('aria-label="Modal label" was used'));
+        });
+        it("should warn that no fallback is possible if no target is valid and `aria-label` is missing", () => {
+            const { modal } = renderModal({ "aria-labelledby": "missing" });
+            expect(modal).not.toHaveAttribute("aria-labelledby");
+            expect(modal).not.toHaveAttribute("aria-label");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("#missing"));
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("not possible"));
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("role=dialog was removed"));
+        });
+        it("should remove role and modality if no target is valid and `aria-label` is missing", () => {
+            const { modal } = renderModal({ "aria-labelledby": "missing", role: "alertdialog" });
+            expect(modal).not.toHaveAttribute("role");
+            expect(modal).not.toHaveAttribute("aria-modal");
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("role=alertdialog was removed"));
+        });
+        it("should keep role and modality removed on re-renderings if no target is valid", () => {
+            const TrackedModals = ({ children }: { children: React.ReactNode }) => {
+                const modalContext = useModalContext();
+                return <ModalContext.Provider value={modalContext}>{children}</ModalContext.Provider>;
+            };
+            const modalStack = (secondOpen: boolean) => (
+                <TrackedModals>
+                    <Modal isOpen usePortal={false} modalId="nameless" aria-labelledby="missing">
+                        nameless content
+                    </Modal>
+                    <Modal isOpen={secondOpen} usePortal={false} modalId="ontop" aria-label="ontop">
+                        content on top
+                    </Modal>
+                </TrackedModals>
+            );
+            const { container, rerender } = render(modalStack(false));
+            const modal = container.querySelector(`.${dialogWrapper}:not([aria-label])`) as HTMLElement;
+            expect(modal).toHaveTextContent("nameless content");
+            expect(modal).not.toHaveAttribute("role");
+            expect(modal).not.toHaveAttribute("aria-modal");
+            // modality of the nameless modal changes, React must not render it again
+            rerender(modalStack(true));
+            expect(modal).not.toHaveAttribute("role");
+            expect(modal).not.toHaveAttribute("aria-modal");
+        });
+        it("should restore role and modality if `aria-labelledby` becomes valid while the modal is open", () => {
+            const { modal, rerender } = renderModal({ "aria-labelledby": "missing" });
+            expect(modal).not.toHaveAttribute("role");
+            rerender(
+                <Modal isOpen usePortal={false} aria-labelledby="customtitle">
+                    {customTitle}
+                </Modal>,
+            );
+            expect(modal).toHaveAttribute("role", "dialog");
+            expect(modal).toHaveAttribute("aria-modal", "true");
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+        });
+        it("should not warn twice about a removed role", () => {
+            renderModal({ "aria-labelledby": "missing" });
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+            expect(consoleWarnSpy).not.toHaveBeenCalledWith(expect.stringContaining("neither aria-label"));
+        });
+        it("should keep removed invalid targets out on re-renderings with unchanged properties", () => {
+            const props = { "aria-labelledby": "customtitle missing", children: customTitle };
+            const { modal, rerender } = renderModal(props);
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+            rerender(
+                <Modal isOpen usePortal={false} {...props} className="changed">
+                    {customTitle}
+                </Modal>,
+            );
+            expect(modal).toHaveClass("changed");
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+        });
+        it("should remove invalid targets again if `aria-labelledby` changes while the modal is open", () => {
+            const { modal, rerender } = renderModal({
+                "aria-labelledby": "customtitle missing",
+                children: customTitle,
+            });
+            rerender(
+                <Modal isOpen usePortal={false} aria-labelledby="othermissing customtitle">
+                    {customTitle}
+                </Modal>,
+            );
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(2);
+            expect(consoleWarnSpy).toHaveBeenLastCalledWith(expect.stringContaining("#othermissing."));
+        });
+        it("should keep the fallback on re-renderings with unchanged properties", () => {
+            const { modal, rerender } = renderModal({ "aria-labelledby": "missing", "aria-label": "Modal label" });
+            rerender(
+                <Modal isOpen usePortal={false} aria-labelledby="missing" aria-label="Modal label" className="changed">
+                    modal content
+                </Modal>,
+            );
+            expect(modal).toHaveClass("changed");
+            expect(modal).toHaveAttribute("aria-label", "Modal label");
+            expect(modal).not.toHaveAttribute("aria-labelledby");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+        });
+        it("should check the targets again if `aria-labelledby` changes while the modal is open", () => {
+            const { modal, rerender } = renderModal({ "aria-labelledby": "missing", "aria-label": "Modal label" });
+            expect(modal).toHaveAttribute("aria-label", "Modal label");
+            rerender(
+                <Modal isOpen usePortal={false} aria-labelledby="customtitle" aria-label="Modal label">
+                    {customTitle}
+                </Modal>,
+            );
+            expect(modal).toHaveAttribute("aria-labelledby", "customtitle");
+            // the former fallback must be removed
+            expect(modal).not.toHaveAttribute("aria-label");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+        });
+        it("should check the targets inside a portal", () => {
+            render(
+                <Modal isOpen aria-labelledby="portaltitle missing" aria-label="Modal label">
+                    <h2 id="portaltitle">Portal title</h2>
+                </Modal>,
+            );
+            const modal = document.getElementsByClassName(dialogWrapper)[0] as HTMLElement;
+            expect(modal).toHaveAttribute("aria-labelledby", "portaltitle");
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("#missing."));
+        });
+    });
+
     describe("focus and closing behaviour", () => {
         it("should be focusable by default", () => {
             const { container } = renderModal();
diff --git a/src/components/Dialog/tests/SimpleDialog.test.tsx b/src/components/Dialog/tests/SimpleDialog.test.tsx
index f75d800d4..c58e23b2e 100644
--- a/src/components/Dialog/tests/SimpleDialog.test.tsx
+++ b/src/components/Dialog/tests/SimpleDialog.test.tsx
@@ -146,7 +146,11 @@ describe("SimpleDialog", () => {
             expect(content.id).toBe("");
         });
         it("should use a given `aria-labelledby`", () => {
-            const { dialog } = renderDialog({ title: "My title", "aria-labelledby": "customtitle" });
+            const { dialog } = renderDialog({
+                title: "My title",
+                "aria-labelledby": "customtitle",
+                children: <h3 id="customtitle">Custom title</h3>,
+            });
             expect(dialog).toHaveAttribute("aria-labelledby", "customtitle");
         });
         it("should connect the content to the dialog via `aria-describedby` if an intent state is set", () => {
@@ -167,6 +171,16 @@ describe("SimpleDialog", () => {
             const { dialog } = renderDialog({ "aria-label": "Dialog label" });
             expect(dialog).toHaveAttribute("aria-label", "Dialog label");
         });
+        it("should use the intent as `aria-label` fallback if no `aria-labelledby` target exists", () => {
+            const { dialog } = renderDialog({ intent: "danger", "aria-labelledby": "missing" });
+            expect(dialog).toHaveAttribute("aria-label", "danger");
+            expect(dialog).toHaveAttribute("role", "alertdialog");
+        });
+        it("should not use an intent fallback if there is no alert intent state", () => {
+            const { dialog } = renderDialog({ "aria-labelledby": "missing" });
+            expect(dialog).not.toHaveAttribute("aria-label");
+            expect(dialog).not.toHaveAttribute("role");
+        });
         it("should use alert semantics for each alert intent state", () => {
             (["success", "warning", "danger", "info"] as IntentTypes[]).forEach((intent) => {
                 const { dialog, content } = renderDialog({ intent, title: "My title" });
@@ -217,6 +231,32 @@ describe("SimpleDialog", () => {
             fireEvent.click(toggler);
             expect(dialog).toHaveClass(`${dialogWrapper}--small`);
         });
+        it("should give the toggler an accessible name that reflects its state", () => {
+            const { toggler } = renderDialog({ showFullScreenToggler: true });
+            expect(toggler).toHaveAccessibleName("Show in full screen");
+
+            fireEvent.click(toggler);
+            expect(toggler).toHaveAccessibleName("Exit full screen");
+        });
+        it("should keep the toggler button itself focusable and show its text as title", () => {
+            const { toggler } = renderDialog({ showFullScreenToggler: true });
+            expect(toggler).not.toHaveAttribute("tabindex", "-1");
+            expect(toggler).toHaveAttribute("title", "Show in full screen");
+            expect(toggler.querySelector("[tabindex]")).toBeNull();
+
+            toggler.focus();
+            expect(toggler).toHaveFocus();
+        });
+        it("should use custom toggler texts if given", () => {
+            const { toggler } = renderDialog({
+                showFullScreenToggler: true,
+                fullScreenTogglerTexts: { maximize: "Vollbild anzeigen", minimize: "Vollbild verlassen" },
+            });
+            expect(toggler).toHaveAccessibleName("Vollbild anzeigen");
+
+            fireEvent.click(toggler);
+            expect(toggler).toHaveAccessibleName("Vollbild verlassen");
+        });
         it("should start in full screen mode and enable the toggler", () => {
             const { dialog, toggler } = renderDialog({ startInFullScreenMode: true, size: "small" });
             expect(dialog).toHaveClass(`${dialogWrapper}--fullscreen`);