diff --git a/README.md b/README.md
index f77b1f03..fd415585 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,69 @@ SelenideLogger.addListener("AllureSelenide", new AllureSelenide().enableLogs(Log
 https://github.com/SeleniumHQ/selenium/wiki/Logging
 ```
 
-
+## Playwright Java
+
+AspectJ-based integration for Playwright Java that reports browser actions as Allure steps and attaches
+Playwright screenshots automatically:
+
+```xml
+<dependency>
+   <groupId>io.qameta.allure</groupId>
+   <artifactId>allure-playwright</artifactId>
+   <version>$LATEST_VERSION</version>
+</dependency>
+```
+
+Enable the AspectJ weaver for automatic action steps:
+```
+-javaagent:/path/to/aspectjweaver.jar
+```
+
+Usage example with Playwright Java JUnit fixtures:
+```java
+@UsePlaywright
+class UiTest {
+
+    @Test
+    void shouldOpenPage(Page page) {
+        page.navigate("https://playwright.dev");
+        page.screenshot();
+    }
+}
+```
+
+The module registers an Allure test lifecycle listener automatically, so per-test cleanup, failure diagnostics,
+and final trace/log flush work with any test framework that reports through Allure. Playwright pages and
+contexts are tracked by the AspectJ integration when they are created or used. Use
+`AllurePlaywright.register(...)` only for pages or contexts the aspect cannot observe.
+
+Frameworks or custom runners that do not use the Allure lifecycle can call the reporting hooks directly:
+```java
+AllurePlaywright.beforeTest();
+try {
+    testBody();
+} catch (Throwable e) {
+    AllurePlaywright.afterTestFailure(e);
+    throw e;
+} finally {
+    AllurePlaywright.afterTest();
+}
+```
+
+The following defaults can be overridden in `allure.properties`:
+```
+allure.playwright.steps.enabled=true
+allure.playwright.steps.mode=actions
+allure.playwright.parameters=redacted
+allure.playwright.screenshots.attach=true
+allure.playwright.failure.screenshot=true
+allure.playwright.failure.page-source=true
+allure.playwright.close.trace=true
+allure.playwright.close.video=true
+allure.playwright.close.page-logs=true
+```
+
+
 ## Rest Assured
 
 Filter for rest-assured http client, that generates attachment for allure.
diff --git a/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java b/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java
new file mode 100644
index 00000000..806fb391
--- /dev/null
+++ b/allure-model/src/main/java/io/qameta/allure/model/AttachmentType.java
@@ -0,0 +1,46 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.model;
+
+/**
+ * Common attachment media types and file extensions.
+ */
+public final class AttachmentType {
+
+    public static final AttachmentType PNG = new AttachmentType("image/png", "png");
+    public static final AttachmentType JPEG = new AttachmentType("image/jpeg", "jpg");
+    public static final AttachmentType TEXT = new AttachmentType("text/plain", "txt");
+    public static final AttachmentType HTML = new AttachmentType("text/html", "html");
+    public static final AttachmentType ZIP = new AttachmentType("application/zip", "zip");
+    public static final AttachmentType WEBM = new AttachmentType("video/webm", "webm");
+    public static final AttachmentType OCTET_STREAM = new AttachmentType("application/octet-stream", "");
+
+    private final String mediaType;
+    private final String extension;
+
+    private AttachmentType(final String mediaType, final String extension) {
+        this.mediaType = mediaType;
+        this.extension = extension;
+    }
+
+    public String getMediaType() {
+        return mediaType;
+    }
+
+    public String getExtension() {
+        return extension;
+    }
+}
diff --git a/allure-playwright/build.gradle.kts b/allure-playwright/build.gradle.kts
new file mode 100644
index 00000000..55bec923
--- /dev/null
+++ b/allure-playwright/build.gradle.kts
@@ -0,0 +1,36 @@
+description = "Allure Playwright Integration"
+
+val agent: Configuration by configurations.creating
+
+val playwrightVersion = "1.59.0"
+
+dependencies {
+    agent("org.aspectj:aspectjweaver")
+    api(project(":allure-java-commons"))
+    compileOnly("com.microsoft.playwright:playwright:$playwrightVersion")
+    compileOnly("org.aspectj:aspectjrt")
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testImplementation("com.microsoft.playwright:playwright:$playwrightVersion")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-assertj"))
+    testImplementation(project(":allure-java-commons-test"))
+    testImplementation(project(":allure-junit-platform"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks.jar {
+    manifest {
+        attributes(mapOf(
+                "Automatic-Module-Name" to "io.qameta.allure.playwright"
+        ))
+    }
+}
+
+tasks.test {
+    useJUnitPlatform()
+    doFirst {
+        jvmArgs("-javaagent:${agent.singleFile}")
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java
new file mode 100644
index 00000000..ff5a9ad4
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywright.java
@@ -0,0 +1,571 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.Browser;
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.ConsoleMessage;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.Tracing;
+import com.microsoft.playwright.Video;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.model.AttachmentType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Supplier;
+
+/**
+ * Utility methods for attaching Playwright Java diagnostics to the current Allure test.
+ */
+public final class AllurePlaywright {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AllurePlaywright.class);
+
+    private static final String SCREENSHOT = "Screenshot";
+    private static final String PAGE_SOURCE = "Page source";
+    private static final String TRACE = "Playwright trace";
+    private static final String VIDEO = "Playwright video";
+    private static final String CONSOLE_MESSAGES = "Console messages";
+    private static final String PAGE_ERRORS = "Page errors";
+
+    private static final ThreadLocal<Boolean> SUPPRESS_ASPECT = new ThreadLocal<Boolean>() {
+        @Override
+        protected Boolean initialValue() {
+            return Boolean.FALSE;
+        }
+    };
+
+    private AllurePlaywright() {
+        throw new IllegalStateException("Do not instance");
+    }
+
+    /**
+     * Clears Playwright reporting state before a test starts.
+     */
+    public static void beforeTest() {
+        clear();
+    }
+
+    /**
+     * Attaches final Playwright artifacts and clears reporting state after a test finishes.
+     */
+    public static void afterTest() {
+        attachRegisteredCloseArtifacts();
+        clear();
+    }
+
+    /**
+     * Attaches failure diagnostics for the current test.
+     */
+    public static void afterTestFailure() {
+        attachFailureArtifacts();
+    }
+
+    /**
+     * Attaches failure diagnostics for the current test.
+     *
+     * @param throwable the test failure.
+     */
+    public static void afterTestFailure(final Throwable throwable) {
+        LOGGER.debug("Attaching Playwright failure artifacts", throwable);
+        afterTestFailure();
+    }
+
+    /**
+     * Registers a Playwright page for failure diagnostics produced by reporting lifecycle hooks.
+     *
+     * @param page the page to register.
+     */
+    public static void register(final Page page) {
+        AllurePlaywrightRegistry.register(page);
+    }
+
+    /**
+     * Registers a Playwright browser context for failure diagnostics produced by reporting lifecycle hooks.
+     *
+     * @param context the browser context to register.
+     */
+    public static void register(final BrowserContext context) {
+        AllurePlaywrightRegistry.register(context);
+    }
+
+    /**
+     * Captures and attaches a page screenshot.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachScreenshot(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final byte[] screenshot = withAspectSuppressed(new Supplier<byte[]>() {
+                @Override
+                public byte[] get() {
+                    return page.screenshot();
+                }
+            });
+            attachBytes(defaultName(name, SCREENSHOT), AttachmentType.PNG, screenshot);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright screenshot", e);
+        }
+    }
+
+    /**
+     * Captures and attaches page source.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachPageSource(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = withAspectSuppressed(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return page.content();
+                }
+            });
+            attachBytes(defaultName(name, PAGE_SOURCE), AttachmentType.HTML, content.getBytes(StandardCharsets.UTF_8));
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright page source", e);
+        }
+    }
+
+    /**
+     * Captures and attaches Playwright console messages retained by the page.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachConsoleMessages(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = formatConsoleMessages(page.consoleMessages());
+            attachText(defaultName(name, CONSOLE_MESSAGES), content);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright console messages", e);
+        }
+    }
+
+    /**
+     * Captures and attaches Playwright page errors retained by the page.
+     *
+     * @param name the attachment name.
+     * @param page the page to capture.
+     */
+    public static void attachPageErrors(final String name, final Page page) {
+        if (page == null || !hasAllureContext()) {
+            return;
+        }
+        try {
+            final String content = formatLines(page.pageErrors());
+            attachText(defaultName(name, PAGE_ERRORS), content);
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not capture Playwright page errors", e);
+        }
+    }
+
+    /**
+     * Attaches a Playwright trace archive.
+     *
+     * @param name the attachment name.
+     * @param traceZip the path to the trace zip file.
+     */
+    public static void attachTrace(final String name, final Path traceZip) {
+        attachPath(defaultName(name, TRACE), AttachmentType.ZIP, traceZip);
+    }
+
+    /**
+     * Attaches a Playwright video file.
+     *
+     * @param name the attachment name.
+     * @param videoFile the path to the video file.
+     */
+    public static void attachVideo(final String name, final Path videoFile) {
+        attachPath(defaultName(name, VIDEO), videoType(videoFile), videoFile);
+    }
+
+    /**
+     * Starts Playwright tracing and registers the trace for failure diagnostics.
+     *
+     * @param context the browser context to trace.
+     * @return trace session that stops tracing and attaches the generated archive when closed.
+     */
+    public static TraceSession startTracing(final BrowserContext context) {
+        return startTracing(TRACE, context);
+    }
+
+    /**
+     * Starts Playwright tracing and registers the trace for failure diagnostics.
+     *
+     * @param name the attachment name to use when the trace is attached.
+     * @param context the browser context to trace.
+     * @return trace session that stops tracing and attaches the generated archive when closed.
+     */
+    public static TraceSession startTracing(final String name, final BrowserContext context) {
+        if (context == null) {
+            throw new IllegalArgumentException("context must not be null");
+        }
+        final Tracing.StartOptions options = new Tracing.StartOptions()
+                .setScreenshots(true)
+                .setSnapshots(true);
+        context.tracing().start(options);
+        final DefaultTraceSession traceSession = new DefaultTraceSession(context, defaultName(name, TRACE));
+        AllurePlaywrightRegistry.register(context);
+        AllurePlaywrightRegistry.register(traceSession);
+        return traceSession;
+    }
+
+    static CloseArtifacts beforeClose(final Object target) {
+        final CloseArtifacts closeArtifacts = new CloseArtifacts();
+        if (target instanceof Page) {
+            collectPageCloseArtifacts((Page) target, closeArtifacts);
+        } else if (target instanceof BrowserContext) {
+            collectContextCloseArtifacts((BrowserContext) target, closeArtifacts);
+        } else if (target instanceof Browser) {
+            collectBrowserCloseArtifacts((Browser) target, closeArtifacts);
+        }
+        return closeArtifacts;
+    }
+
+    static void attachScreenshotBytes(final String name, final AttachmentType type, final byte[] bytes) {
+        if (!AllurePlaywrightConfig.shouldAttachScreenshots()) {
+            return;
+        }
+        attachBytes(defaultName(name, SCREENSHOT), type, bytes);
+    }
+
+    static AttachmentType screenshotType(final Object... args) {
+        final Object options = args.length == 0 ? null : args[0];
+        if (isJpegType(options)) {
+            return AttachmentType.JPEG;
+        }
+        if (isJpegPath(options)) {
+            return AttachmentType.JPEG;
+        }
+        return AttachmentType.PNG;
+    }
+
+    static boolean hasAllureContext() {
+        return Allure.getLifecycle().getCurrentTestCaseOrStep().isPresent();
+    }
+
+    static boolean isAspectSuppressed() {
+        return SUPPRESS_ASPECT.get();
+    }
+
+    static <T> T withAspectSuppressed(final Supplier<T> supplier) {
+        final Boolean previous = SUPPRESS_ASPECT.get();
+        SUPPRESS_ASPECT.set(Boolean.TRUE);
+        try {
+            return supplier.get();
+        } finally {
+            SUPPRESS_ASPECT.set(previous);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    static void clear() {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions()) {
+            traceSession.stopWithoutAttachment();
+        }
+        AllurePlaywrightRegistry.clear();
+    }
+
+    static void attachFailureArtifacts() {
+        if (!AllurePlaywrightRegistry.markFailureArtifactsAttached()) {
+            return;
+        }
+        if (AllurePlaywrightConfig.shouldAttachFailureScreenshot()) {
+            attachFailureScreenshots();
+        }
+        if (AllurePlaywrightConfig.shouldAttachFailurePageSource()) {
+            attachFailurePageSources();
+        }
+        attachFailureTraces();
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    static void attachRegisteredCloseArtifacts() {
+        if (!hasAllureContext()) {
+            return;
+        }
+        if (AllurePlaywrightConfig.shouldAttachClosePageLogs()) {
+            for (Page page : AllurePlaywrightRegistry.getPages()) {
+                attachPageCloseLogs(page);
+            }
+        }
+        if (AllurePlaywrightConfig.shouldAttachCloseTrace()) {
+            attachFailureTraces();
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void collectBrowserCloseArtifacts(final Browser browser, final CloseArtifacts closeArtifacts) {
+        for (BrowserContext context : contexts(browser)) {
+            collectContextCloseArtifacts(context, closeArtifacts);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void collectContextCloseArtifacts(final BrowserContext context,
+                                                     final CloseArtifacts closeArtifacts) {
+        register(context);
+        for (Page page : pages(context)) {
+            collectPageCloseArtifacts(page, closeArtifacts);
+        }
+        if (AllurePlaywrightConfig.shouldAttachCloseTrace()) {
+            attachCloseTraces(context);
+        }
+    }
+
+    private static void collectPageCloseArtifacts(final Page page, final CloseArtifacts closeArtifacts) {
+        register(page);
+        attachPageCloseLogs(page);
+        if (AllurePlaywrightRegistry.markCloseVideoAttached(page)) {
+            closeArtifacts.addVideo(video(page));
+        }
+    }
+
+    private static void attachPageCloseLogs(final Page page) {
+        if (AllurePlaywrightConfig.shouldAttachClosePageLogs()
+                && AllurePlaywrightRegistry.markClosePageLogsAttached(page)) {
+            attachConsoleMessages(CONSOLE_MESSAGES, page);
+            attachPageErrors(PAGE_ERRORS, page);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void attachCloseTraces(final BrowserContext context) {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions(context)) {
+            traceSession.attach();
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void attachFailureScreenshots() {
+        for (Page page : AllurePlaywrightRegistry.getPages()) {
+            attachScreenshot(SCREENSHOT, page);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void attachFailurePageSources() {
+        for (Page page : AllurePlaywrightRegistry.getPages()) {
+            attachPageSource(PAGE_SOURCE, page);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    private static void attachFailureTraces() {
+        for (DefaultTraceSession traceSession : AllurePlaywrightRegistry.getTraceSessions()) {
+            traceSession.attach();
+        }
+    }
+
+    private static List<BrowserContext> contexts(final Browser browser) {
+        try {
+            return browser.contexts();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright browser contexts", e);
+            return Collections.emptyList();
+        }
+    }
+
+    private static List<Page> pages(final BrowserContext context) {
+        try {
+            return context.pages();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright pages", e);
+            return Collections.emptyList();
+        }
+    }
+
+    private static Video video(final Page page) {
+        try {
+            return page.video();
+        } catch (RuntimeException e) {
+            LOGGER.warn("Could not collect Playwright video", e);
+            return null;
+        }
+    }
+
+    private static AttachmentType videoType(final Path path) {
+        if (path == null) {
+            return AttachmentType.WEBM;
+        }
+        final String name = path.getFileName().toString().toLowerCase(Locale.ROOT);
+        if (name.endsWith(".webm")) {
+            return AttachmentType.WEBM;
+        }
+        return AttachmentType.OCTET_STREAM;
+    }
+
+    private static void attachPath(final String name, final AttachmentType type, final Path path) {
+        if (path == null || !hasAllureContext() || !Files.isRegularFile(path)) {
+            return;
+        }
+        try {
+            attachBytes(name, type, Files.readAllBytes(path));
+        } catch (IOException e) {
+            LOGGER.warn("Could not attach Playwright artifact {}", path, e);
+        }
+    }
+
+    private static void attachBytes(final String name, final AttachmentType type, final byte[] bytes) {
+        if (bytes == null || !hasAllureContext()) {
+            return;
+        }
+        final AllureLifecycle lifecycle = Allure.getLifecycle();
+        lifecycle.addAttachment(name, type.getMediaType(), type.getExtension(), bytes);
+    }
+
+    private static void attachText(final String name, final String content) {
+        if (content == null || content.isEmpty()) {
+            return;
+        }
+        attachBytes(name, AttachmentType.TEXT, content.getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static String defaultName(final String name, final String fallback) {
+        return name == null || name.isEmpty() ? fallback : name;
+    }
+
+    private static boolean isJpegType(final Object options) {
+        final Object type = readField(options, "type");
+        return type != null && "JPEG".equals(type.toString());
+    }
+
+    private static boolean isJpegPath(final Object options) {
+        final Object path = readField(options, "path");
+        if (!(path instanceof Path)) {
+            return false;
+        }
+        final String name = ((Path) path).getFileName().toString().toLowerCase(Locale.ROOT);
+        return name.endsWith(".jpg") || name.endsWith(".jpeg");
+    }
+
+    private static Object readField(final Object target, final String name) {
+        if (target == null) {
+            return null;
+        }
+        try {
+            final Field field = target.getClass().getField(name);
+            return field.get(target);
+        } catch (ReflectiveOperationException ignored) {
+            return null;
+        }
+    }
+
+    private static String formatConsoleMessages(final List<ConsoleMessage> messages) {
+        if (messages == null || messages.isEmpty()) {
+            return "";
+        }
+        final StringBuilder builder = new StringBuilder();
+        for (ConsoleMessage message : messages) {
+            final String type = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.type();
+                }
+            });
+            final String text = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.text();
+                }
+            });
+            final String location = safe(new Supplier<String>() {
+                @Override
+                public String get() {
+                    return message.location();
+                }
+            });
+            builder.append('[').append(type).append("] ").append(text);
+            if (!location.isEmpty()) {
+                builder.append(" (").append(location).append(')');
+            }
+            builder.append(System.lineSeparator());
+        }
+        return builder.toString();
+    }
+
+    private static String formatLines(final List<String> lines) {
+        if (lines == null || lines.isEmpty()) {
+            return "";
+        }
+        final StringBuilder builder = new StringBuilder();
+        for (String line : lines) {
+            builder.append(line).append(System.lineSeparator());
+        }
+        return builder.toString();
+    }
+
+    private static String safe(final Supplier<String> supplier) {
+        try {
+            final String value = supplier.get();
+            return value == null ? "" : value;
+        } catch (RuntimeException ignored) {
+            return "";
+        }
+    }
+
+    static final class CloseArtifacts {
+
+        private final List<Video> videos = new ArrayList<>();
+
+        private void addVideo(final Video video) {
+            if (video != null) {
+                videos.add(video);
+            }
+        }
+
+        void attachAfterClose() {
+            if (!AllurePlaywrightConfig.shouldAttachCloseVideo()) {
+                return;
+            }
+            for (Video video : videos) {
+                attachVideo(VIDEO, path(video));
+            }
+        }
+
+        private static Path path(final Video video) {
+            try {
+                return video.path();
+            } catch (RuntimeException e) {
+                LOGGER.warn("Could not resolve Playwright video path", e);
+                return null;
+            }
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java
new file mode 100644
index 00000000..2601d27b
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightAspect.java
@@ -0,0 +1,226 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.model.AttachmentType;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StepResult;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+
+import java.util.UUID;
+import java.util.function.Supplier;
+
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+
+/**
+ * Aspect that logs Playwright Java browser actions as Allure steps.
+ */
+@Aspect
+public class AllurePlaywrightAspect {
+
+    private static final ThreadLocal<Integer> DEPTH = new ThreadLocal<Integer>() {
+        @Override
+        protected Integer initialValue() {
+            return 0;
+        }
+    };
+
+    private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE =
+            new InheritableThreadLocal<AllureLifecycle>() {
+                @Override
+                protected AllureLifecycle initialValue() {
+                    return Allure.getLifecycle();
+                }
+            };
+
+    @Pointcut("execution(public * com.microsoft.playwright.Page+.*(..))"
+            + " || execution(public * com.microsoft.playwright.Frame+.*(..))"
+            + " || execution(public * com.microsoft.playwright.Locator+.*(..))"
+            + " || execution(public * com.microsoft.playwright.ElementHandle+.*(..))"
+            + " || execution(public * com.microsoft.playwright.assertions.*Assertions+.*(..))")
+    public void playwrightApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut("execution(public byte[] com.microsoft.playwright.Page+.screenshot(..))"
+            + " || execution(public byte[] com.microsoft.playwright.Locator+.screenshot(..))"
+            + " || execution(public byte[] com.microsoft.playwright.ElementHandle+.screenshot(..))")
+    public void screenshotApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut("execution(public com.microsoft.playwright.BrowserContext "
+            + "com.microsoft.playwright.Browser+.newContext(..))")
+    public void newContextApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut("execution(public com.microsoft.playwright.Page com.microsoft.playwright.Browser+.newPage(..))"
+            + " || execution(public com.microsoft.playwright.Page "
+            + "com.microsoft.playwright.BrowserContext+.newPage(..))")
+    public void newPageApi() {
+        //pointcut body, should be empty
+    }
+
+    @Pointcut("execution(public void com.microsoft.playwright.Browser+.close(..))"
+            + " || execution(public void com.microsoft.playwright.BrowserContext+.close(..))"
+            + " || execution(public void com.microsoft.playwright.Page+.close(..))")
+    public void closeApi() {
+        //pointcut body, should be empty
+    }
+
+    @Around("playwrightApi() && !screenshotApi()")
+    public Object logPlaywrightStep(final ProceedingJoinPoint joinPoint) throws Throwable {
+        registerTarget(joinPoint.getTarget());
+        if (shouldSkip()) {
+            return joinPoint.proceed();
+        }
+        final PlaywrightAction action = PlaywrightAction.from(joinPoint, false);
+        if (!action.isLogged()) {
+            return joinPoint.proceed();
+        }
+        return runStep(joinPoint, action, false);
+    }
+
+    @Around("screenshotApi()")
+    public Object logScreenshotStep(final ProceedingJoinPoint joinPoint) throws Throwable {
+        registerTarget(joinPoint.getTarget());
+        if (shouldSkip()) {
+            return joinPoint.proceed();
+        }
+        return runStep(joinPoint, PlaywrightAction.from(joinPoint, true), true);
+    }
+
+    @Around("newContextApi() || newPageApi()")
+    public Object registerCreatedPlaywrightObject(final ProceedingJoinPoint joinPoint) throws Throwable {
+        final Object result = joinPoint.proceed();
+        if (!shouldSkipArtifacts()) {
+            register(result);
+        }
+        return result;
+    }
+
+    @Around("closeApi()")
+    public Object attachCloseArtifacts(final ProceedingJoinPoint joinPoint) throws Throwable {
+        if (shouldSkipArtifacts()) {
+            return joinPoint.proceed();
+        }
+        final AllurePlaywright.CloseArtifacts closeArtifacts = beforeClose(joinPoint.getTarget());
+        final Object result = joinPoint.proceed();
+        afterClose(closeArtifacts);
+        return result;
+    }
+
+    /**
+     * For tests only.
+     *
+     * @param lifecycle allure lifecycle to set.
+     */
+    public static void setLifecycle(final AllureLifecycle lifecycle) {
+        LIFECYCLE.set(lifecycle);
+    }
+
+    public static AllureLifecycle getLifecycle() {
+        return LIFECYCLE.get();
+    }
+
+    private static Object runStep(final ProceedingJoinPoint joinPoint, final PlaywrightAction action,
+                                  final boolean screenshot) throws Throwable {
+        final String uuid = UUID.randomUUID().toString();
+        DEPTH.set(DEPTH.get() + 1);
+        getLifecycle().startStep(uuid, new StepResult().setName(action.getName()));
+        try {
+            final Object result = joinPoint.proceed();
+            if (screenshot && result instanceof byte[]) {
+                attachScreenshot(joinPoint, (byte[]) result);
+            }
+            getLifecycle().updateStep(uuid, step -> step.setStatus(Status.PASSED));
+            return result;
+        } catch (Throwable e) {
+            getLifecycle().updateStep(uuid, step -> step
+                    .setStatus(getStatus(e).orElse(Status.BROKEN))
+                    .setStatusDetails(getStatusDetails(e).orElse(null)));
+            throw e;
+        } finally {
+            getLifecycle().stopStep(uuid);
+            DEPTH.set(DEPTH.get() - 1);
+        }
+    }
+
+    private static void attachScreenshot(final ProceedingJoinPoint joinPoint, final byte[] bytes) {
+        if (AllurePlaywrightConfig.shouldAttachScreenshots()) {
+            final AttachmentType type = AllurePlaywright.screenshotType(joinPoint.getArgs());
+            getLifecycle().addAttachment("Screenshot", type.getMediaType(), type.getExtension(), bytes);
+        }
+    }
+
+    private static void registerTarget(final Object target) {
+        if (!shouldSkipArtifacts()) {
+            register(target);
+        }
+    }
+
+    private static void register(final Object result) {
+        AllurePlaywright.withAspectSuppressed(new Supplier<Object>() {
+            @Override
+            public Object get() {
+                if (result instanceof com.microsoft.playwright.Page) {
+                    AllurePlaywrightRegistry.registerPage((com.microsoft.playwright.Page) result);
+                } else if (result instanceof com.microsoft.playwright.BrowserContext) {
+                    AllurePlaywright.register((com.microsoft.playwright.BrowserContext) result);
+                }
+                return null;
+            }
+        });
+    }
+
+    private static AllurePlaywright.CloseArtifacts beforeClose(final Object target) {
+        return AllurePlaywright.withAspectSuppressed(new Supplier<AllurePlaywright.CloseArtifacts>() {
+            @Override
+            public AllurePlaywright.CloseArtifacts get() {
+                return AllurePlaywright.beforeClose(target);
+            }
+        });
+    }
+
+    private static void afterClose(final AllurePlaywright.CloseArtifacts closeArtifacts) {
+        AllurePlaywright.withAspectSuppressed(new Supplier<Object>() {
+            @Override
+            public Object get() {
+                closeArtifacts.attachAfterClose();
+                return null;
+            }
+        });
+    }
+
+    private static boolean shouldSkip() {
+        return !AllurePlaywrightConfig.isStepsEnabled()
+                || AllurePlaywright.isAspectSuppressed()
+                || DEPTH.get() > 0
+                || !getLifecycle().getCurrentTestCaseOrStep().isPresent();
+    }
+
+    private static boolean shouldSkipArtifacts() {
+        return AllurePlaywright.isAspectSuppressed()
+                || !AllurePlaywright.hasAllureContext();
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java
new file mode 100644
index 00000000..8bdf5065
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightConfig.java
@@ -0,0 +1,97 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.util.PropertiesUtils;
+
+import java.util.Locale;
+import java.util.Properties;
+
+final class AllurePlaywrightConfig {
+
+    static final String STEPS_ENABLED = "allure.playwright.steps.enabled";
+    static final String STEPS_MODE = "allure.playwright.steps.mode";
+    static final String PARAMETERS = "allure.playwright.parameters";
+    static final String SCREENSHOTS_ATTACH = "allure.playwright.screenshots.attach";
+    static final String FAILURE_SCREENSHOT = "allure.playwright.failure.screenshot";
+    static final String FAILURE_PAGE_SOURCE = "allure.playwright.failure.page-source";
+    static final String CLOSE_TRACE = "allure.playwright.close.trace";
+    static final String CLOSE_VIDEO = "allure.playwright.close.video";
+    static final String CLOSE_PAGE_LOGS = "allure.playwright.close.page-logs";
+
+    private static final String ACTIONS = "actions";
+    private static final String ALL = "all";
+    private static final String REDACTED = "redacted";
+
+    private AllurePlaywrightConfig() {
+    }
+
+    static boolean isStepsEnabled() {
+        return getBoolean(STEPS_ENABLED, true);
+    }
+
+    static boolean isActionsMode() {
+        return ACTIONS.equals(getString(STEPS_MODE, ACTIONS));
+    }
+
+    static boolean isAllMode() {
+        return ALL.equals(getString(STEPS_MODE, ACTIONS));
+    }
+
+    static boolean isParametersRedacted() {
+        return REDACTED.equals(getString(PARAMETERS, REDACTED));
+    }
+
+    static boolean shouldAttachScreenshots() {
+        return getBoolean(SCREENSHOTS_ATTACH, true);
+    }
+
+    static boolean shouldAttachFailureScreenshot() {
+        return getBoolean(FAILURE_SCREENSHOT, true);
+    }
+
+    static boolean shouldAttachFailurePageSource() {
+        return getBoolean(FAILURE_PAGE_SOURCE, true);
+    }
+
+    static boolean shouldAttachCloseTrace() {
+        return getBoolean(CLOSE_TRACE, true);
+    }
+
+    static boolean shouldAttachCloseVideo() {
+        return getBoolean(CLOSE_VIDEO, true);
+    }
+
+    static boolean shouldAttachClosePageLogs() {
+        return getBoolean(CLOSE_PAGE_LOGS, true);
+    }
+
+    private static boolean getBoolean(final String key, final boolean defaultValue) {
+        return Boolean.parseBoolean(getProperties().getProperty(key, Boolean.toString(defaultValue)));
+    }
+
+    private static String getString(final String key, final String defaultValue) {
+        return getProperties()
+                .getProperty(key, defaultValue)
+                .trim()
+                .toLowerCase(Locale.ROOT);
+    }
+
+    private static Properties getProperties() {
+        return PropertiesUtils.loadAllureProperties();
+    }
+
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java
new file mode 100644
index 00000000..793defa8
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightLifecycle.java
@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import io.qameta.allure.listener.TestLifecycleListener;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.TestResult;
+
+/**
+ * Allure lifecycle listener that attaches Playwright diagnostics for any supported test framework.
+ */
+public class AllurePlaywrightLifecycle implements TestLifecycleListener {
+
+    @Override
+    public void afterTestStart(final TestResult result) {
+        AllurePlaywright.beforeTest();
+    }
+
+    @Override
+    public void beforeTestStop(final TestResult result) {
+        if (isFailed(result)) {
+            AllurePlaywright.afterTestFailure();
+        }
+        AllurePlaywright.afterTest();
+    }
+
+    private static boolean isFailed(final TestResult result) {
+        return result != null && (Status.FAILED == result.getStatus() || Status.BROKEN == result.getStatus());
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java
new file mode 100644
index 00000000..410b7ac0
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/AllurePlaywrightRegistry.java
@@ -0,0 +1,128 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.Page;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Set;
+
+final class AllurePlaywrightRegistry {
+
+    private static final ThreadLocal<State> STATE = new ThreadLocal<State>() {
+        @Override
+        protected State initialValue() {
+            return new State();
+        }
+    };
+
+    private AllurePlaywrightRegistry() {
+    }
+
+    static void register(final Page page) {
+        if (page == null) {
+            return;
+        }
+        registerPage(page);
+        try {
+            register(page.context());
+        } catch (RuntimeException ignored) {
+            // The page may already be closed. Failure diagnostics must not alter test behavior.
+        }
+    }
+
+    static void register(final BrowserContext context) {
+        if (context != null) {
+            STATE.get().contexts.add(context);
+        }
+    }
+
+    static void register(final DefaultTraceSession traceSession) {
+        STATE.get().traceSessions.add(traceSession);
+    }
+
+    static void registerPage(final Page page) {
+        if (page != null) {
+            STATE.get().pages.add(page);
+        }
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    static Set<Page> getPages() {
+        final State state = STATE.get();
+        for (BrowserContext context : state.contexts) {
+            try {
+                state.pages.addAll(context.pages());
+            } catch (RuntimeException ignored) {
+                // The context may already be closed. Failure diagnostics must not alter test behavior.
+            }
+        }
+        return state.pages;
+    }
+
+    static Set<DefaultTraceSession> getTraceSessions() {
+        return STATE.get().traceSessions;
+    }
+
+    @SuppressWarnings("PMD.CloseResource")
+    static List<DefaultTraceSession> getTraceSessions(final BrowserContext context) {
+        final List<DefaultTraceSession> result = new ArrayList<>();
+        for (DefaultTraceSession traceSession : STATE.get().traceSessions) {
+            if (traceSession.isFor(context)) {
+                result.add(traceSession);
+            }
+        }
+        return result;
+    }
+
+    static boolean markFailureArtifactsAttached() {
+        final State state = STATE.get();
+        if (state.failureArtifactsAttached) {
+            return false;
+        }
+        state.failureArtifactsAttached = true;
+        return true;
+    }
+
+    static boolean markClosePageLogsAttached(final Page page) {
+        return STATE.get().pagesWithCloseLogs.add(page);
+    }
+
+    static boolean markCloseVideoAttached(final Page page) {
+        return STATE.get().pagesWithCloseVideo.add(page);
+    }
+
+    static void clear() {
+        STATE.remove();
+    }
+
+    private static final class State {
+        private final Set<Page> pages = identitySet();
+        private final Set<BrowserContext> contexts = identitySet();
+        private final Set<DefaultTraceSession> traceSessions = identitySet();
+        private final Set<Page> pagesWithCloseLogs = identitySet();
+        private final Set<Page> pagesWithCloseVideo = identitySet();
+        private boolean failureArtifactsAttached;
+
+        private static <T> Set<T> identitySet() {
+            return Collections.newSetFromMap(new IdentityHashMap<T, Boolean>());
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java
new file mode 100644
index 00000000..e8eac1c0
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/DefaultTraceSession.java
@@ -0,0 +1,88 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.Tracing;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+final class DefaultTraceSession implements TraceSession {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultTraceSession.class);
+
+    private final BrowserContext context;
+    private final String name;
+    private boolean stopped;
+
+    DefaultTraceSession(final BrowserContext context, final String name) {
+        this.context = context;
+        this.name = name;
+    }
+
+    @Override
+    public void attach() {
+        stop(true);
+    }
+
+    @Override
+    public void close() {
+        attach();
+    }
+
+    void stopWithoutAttachment() {
+        stop(false);
+    }
+
+    @SuppressWarnings("PMD.CompareObjectsWithEquals")
+    boolean isFor(final BrowserContext candidate) {
+        return context == candidate;
+    }
+
+    private void stop(final boolean attach) {
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        Path trace = null;
+        try {
+            trace = Files.createTempFile("allure-playwright-trace-", ".zip");
+            context.tracing().stop(new Tracing.StopOptions().setPath(trace));
+            if (attach) {
+                AllurePlaywright.attachTrace(name, trace);
+            }
+        } catch (IOException | RuntimeException e) {
+            LOGGER.warn("Could not stop Playwright tracing", e);
+        } finally {
+            delete(trace);
+        }
+    }
+
+    private static void delete(final Path path) {
+        if (path == null) {
+            return;
+        }
+        try {
+            Files.deleteIfExists(path);
+        } catch (IOException e) {
+            LOGGER.debug("Could not delete temporary Playwright trace {}", path, e);
+        }
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java
new file mode 100644
index 00000000..3d675888
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/PlaywrightAction.java
@@ -0,0 +1,285 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+final class PlaywrightAction {
+
+    private static final String METHOD_NAVIGATE = "navigate";
+    private static final String METHOD_CLICK = "click";
+    private static final String METHOD_DBLCLICK = "dblclick";
+    private static final String METHOD_CHECK = "check";
+    private static final String METHOD_UNCHECK = "uncheck";
+    private static final String METHOD_TAP = "tap";
+    private static final String METHOD_FILL = "fill";
+    private static final String METHOD_CLEAR = "clear";
+    private static final String METHOD_PRESS = "press";
+    private static final String METHOD_TYPE = "type";
+    private static final String METHOD_HOVER = "hover";
+    private static final String METHOD_DRAG_TO = "dragTo";
+    private static final String METHOD_DRAG_AND_DROP = "dragAndDrop";
+    private static final String METHOD_SET_INPUT_FILES = "setInputFiles";
+    private static final String METHOD_SELECT_OPTION = "selectOption";
+    private static final String METHOD_DISPATCH_EVENT = "dispatchEvent";
+    private static final String DRAG_PREFIX = "Drag ";
+    private static final String ON = " on ";
+    private static final String ASSERTIONS_PACKAGE = ".assertions.";
+    private static final String SELECTOR = "selector";
+    private static final String LOCATOR = "locator";
+    private static final String ELEMENT = "element";
+    private static final String REDACTED = "<redacted>";
+
+    private static final Set<String> ACTION_METHODS = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(
+            METHOD_NAVIGATE,
+            METHOD_CLICK,
+            METHOD_DBLCLICK,
+            METHOD_CHECK,
+            METHOD_UNCHECK,
+            METHOD_TAP,
+            METHOD_FILL,
+            METHOD_CLEAR,
+            METHOD_PRESS,
+            METHOD_TYPE,
+            METHOD_HOVER,
+            METHOD_DRAG_TO,
+            METHOD_DRAG_AND_DROP,
+            METHOD_SET_INPUT_FILES,
+            METHOD_SELECT_OPTION,
+            METHOD_DISPATCH_EVENT,
+            "focus",
+            "blur",
+            "setChecked",
+            "setContent",
+            "reload",
+            "goBack",
+            "goForward",
+            "bringToFront",
+            "close",
+            "waitForCondition",
+            "waitForClose",
+            "waitForConsoleMessage",
+            "waitForDownload",
+            "waitForFileChooser",
+            "waitForFunction",
+            "waitForLoadState",
+            "waitForNavigation",
+            "waitForPopup",
+            "waitForRequest",
+            "waitForRequestFinished",
+            "waitForResponse",
+            "waitForSelector",
+            "waitForTimeout",
+            "waitForURL",
+            "waitForWebSocket",
+            "waitForWorker"
+    )));
+
+    private static final Map<String, String> ACTION_PREFIXES = createActionPrefixes();
+
+    private static final Set<String> IGNORED_METHODS = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(
+            "equals",
+            "hashCode",
+            "toString",
+            "not"
+    )));
+
+    private final boolean logged;
+    private final String name;
+
+    private PlaywrightAction(final boolean logged, final String name) {
+        this.logged = logged;
+        this.name = name;
+    }
+
+    boolean isLogged() {
+        return logged;
+    }
+
+    String getName() {
+        return name;
+    }
+
+    static PlaywrightAction from(final JoinPoint joinPoint, final boolean screenshot) {
+        final MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        final String method = signature.getName();
+        if (screenshot) {
+            return new PlaywrightAction(true, "Take screenshot");
+        }
+        if (!shouldLog(joinPoint, method)) {
+            return new PlaywrightAction(false, method);
+        }
+        return new PlaywrightAction(true, name(joinPoint, method));
+    }
+
+    private static boolean shouldLog(final JoinPoint joinPoint, final String method) {
+        if (IGNORED_METHODS.contains(method)) {
+            return false;
+        }
+        if (AllurePlaywrightConfig.isAllMode()) {
+            return true;
+        }
+        return isAssertion(joinPoint) || ACTION_METHODS.contains(method);
+    }
+
+    private static String name(final JoinPoint joinPoint, final String method) {
+        final String result;
+        if (isAssertion(joinPoint)) {
+            result = "Expect " + target(joinPoint) + " " + method;
+        } else if (METHOD_NAVIGATE.equals(method)) {
+            result = "Navigate to " + arg(joinPoint, 0, "url");
+        } else if (METHOD_FILL.equals(method)) {
+            result = "Fill " + target(joinPoint) + " with " + secret(joinPoint, 1);
+        } else if (METHOD_PRESS.equals(method)) {
+            result = "Press " + secret(joinPoint, 0) + ON + target(joinPoint);
+        } else if (METHOD_TYPE.equals(method)) {
+            result = "Type " + secret(joinPoint, 1) + " into " + target(joinPoint);
+        } else if (METHOD_DISPATCH_EVENT.equals(method)) {
+            result = "Dispatch " + arg(joinPoint, 1, "event") + ON + target(joinPoint);
+        } else {
+            result = prefix(method) + target(joinPoint);
+        }
+        return result;
+    }
+
+    private static String prefix(final String method) {
+        final String prefix = ACTION_PREFIXES.get(method);
+        return prefix == null ? humanize(method) + " " : prefix;
+    }
+
+    private static Map<String, String> createActionPrefixes() {
+        final Map<String, String> prefixes = new HashMap<>();
+        prefixes.put(METHOD_CLICK, "Click ");
+        prefixes.put(METHOD_DBLCLICK, "Double click ");
+        prefixes.put(METHOD_HOVER, "Hover ");
+        prefixes.put(METHOD_DRAG_TO, DRAG_PREFIX);
+        prefixes.put(METHOD_DRAG_AND_DROP, DRAG_PREFIX);
+        prefixes.put(METHOD_SET_INPUT_FILES, "Set input files for ");
+        prefixes.put(METHOD_SELECT_OPTION, "Select option in ");
+        return Collections.unmodifiableMap(prefixes);
+    }
+
+    private static boolean isAssertion(final JoinPoint joinPoint) {
+        final String name = joinPoint.getSignature().getDeclaringTypeName();
+        final String targetName = joinPoint.getTarget() == null ? "" : joinPoint.getTarget().getClass().getName();
+        return name.contains(ASSERTIONS_PACKAGE) || targetName.contains(ASSERTIONS_PACKAGE);
+    }
+
+    private static String target(final JoinPoint joinPoint) {
+        final Object[] args = joinPoint.getArgs();
+        if (args.length > 0 && args[0] instanceof String) {
+            return String.valueOf(args[0]);
+        }
+        final String locator = locatorDescription(joinPoint.getTarget());
+        if (locator != null && !locator.isEmpty()) {
+            return locator;
+        }
+        return targetKind(joinPoint);
+    }
+
+    private static String targetKind(final JoinPoint joinPoint) {
+        final String simpleName = joinPoint.getSignature().getDeclaringType().getSimpleName();
+        if (simpleName.contains("Locator")) {
+            return LOCATOR;
+        }
+        if (simpleName.contains("Element")) {
+            return ELEMENT;
+        }
+        return simpleName.toLowerCase(Locale.ROOT);
+    }
+
+    private static String arg(final JoinPoint joinPoint, final int index, final String fallback) {
+        final Object[] args = joinPoint.getArgs();
+        if (index >= args.length || args[index] == null) {
+            return fallback;
+        }
+        return String.valueOf(args[index]);
+    }
+
+    private static String secret(final JoinPoint joinPoint, final int index) {
+        if (AllurePlaywrightConfig.isParametersRedacted()) {
+            return REDACTED;
+        }
+        return arg(joinPoint, index, REDACTED);
+    }
+
+    private static String humanize(final String method) {
+        final StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < method.length(); i++) {
+            final char ch = method.charAt(i);
+            if (Character.isUpperCase(ch)) {
+                builder.append(' ').append(Character.toLowerCase(ch));
+            } else {
+                builder.append(ch);
+            }
+        }
+        builder.setCharAt(0, Character.toUpperCase(builder.charAt(0)));
+        return builder.toString();
+    }
+
+    private static String locatorDescription(final Object target) {
+        final String description = invokeDescription(target);
+        if (description != null && !description.isEmpty()) {
+            return description;
+        }
+        return readSelector(target);
+    }
+
+    private static String invokeDescription(final Object target) {
+        if (target == null) {
+            return null;
+        }
+        try {
+            final Method method = target.getClass().getMethod("description");
+            final Object value = method.invoke(target);
+            return value == null ? null : String.valueOf(value);
+        } catch (ReflectiveOperationException ignored) {
+            return null;
+        }
+    }
+
+    @SuppressWarnings("PMD.AvoidAccessibilityAlteration")
+    private static String readSelector(final Object target) {
+        if (target == null) {
+            return null;
+        }
+        Class<?> type = target.getClass();
+        while (type != null) {
+            try {
+                final Field field = type.getDeclaredField(SELECTOR);
+                field.setAccessible(true);
+                final Object value = field.get(target);
+                return value == null ? null : String.valueOf(value);
+            } catch (NoSuchFieldException e) {
+                type = type.getSuperclass();
+            } catch (ReflectiveOperationException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+}
diff --git a/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java b/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java
new file mode 100644
index 00000000..5085a8fe
--- /dev/null
+++ b/allure-playwright/src/main/java/io/qameta/allure/playwright/TraceSession.java
@@ -0,0 +1,33 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+/**
+ * Playwright trace session started through {@link AllurePlaywright#startTracing}.
+ */
+public interface TraceSession extends AutoCloseable {
+
+    /**
+     * Stops tracing and attaches the generated trace archive.
+     */
+    void attach();
+
+    /**
+     * Stops tracing and attaches the generated trace archive.
+     */
+    @Override
+    void close();
+}
diff --git a/allure-playwright/src/main/resources/META-INF/aop-ajc.xml b/allure-playwright/src/main/resources/META-INF/aop-ajc.xml
new file mode 100644
index 00000000..62e24509
--- /dev/null
+++ b/allure-playwright/src/main/resources/META-INF/aop-ajc.xml
@@ -0,0 +1,6 @@
+<aspectj>
+    <weaver options="-warn:none -Xlint:ignore"/>
+    <aspects>
+        <aspect name="io.qameta.allure.playwright.AllurePlaywrightAspect"/>
+    </aspects>
+</aspectj>
diff --git a/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener b/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
new file mode 100644
index 00000000..1f0ef821
--- /dev/null
+++ b/allure-playwright/src/main/resources/META-INF/services/io.qameta.allure.listener.TestLifecycleListener
@@ -0,0 +1 @@
+io.qameta.allure.playwright.AllurePlaywrightLifecycle
diff --git a/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java b/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java
new file mode 100644
index 00000000..ce13316c
--- /dev/null
+++ b/allure-playwright/src/test/java/io/qameta/allure/playwright/AllurePlaywrightTest.java
@@ -0,0 +1,642 @@
+/*
+ *  Copyright 2016-2026 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.playwright;
+
+import com.microsoft.playwright.Browser;
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.BrowserType;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.Playwright;
+import com.microsoft.playwright.PlaywrightException;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.Description;
+import io.qameta.allure.Param;
+import io.qameta.allure.Step;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureFeatures;
+import io.qameta.allure.test.AllureResults;
+import io.qameta.allure.test.AllureResultsWriterStub;
+import io.qameta.allure.test.AllureTestCommonsUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.api.parallel.ResourceLock;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.qameta.allure.model.Parameter.Mode.HIDDEN;
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
+
+@ResourceLock(value = "io.qameta.allure.playwright.lifecycle", mode = READ_WRITE)
+class AllurePlaywrightTest {
+
+    private static final byte[] PNG_HEADER = new byte[]{(byte) 0x89, 'P', 'N', 'G'};
+    private static final byte[] ZIP_HEADER = new byte[]{'P', 'K'};
+    private static final String FAILURE_HTML = "<html><body><h1>Failure diagnostics</h1></body></html>";
+
+    private static Playwright playwright;
+    private static Browser browser;
+
+    private final List<BrowserContext> contexts = new ArrayList<>();
+
+    @BeforeAll
+    static void startBrowser() {
+        try {
+            playwright = Playwright.create();
+            browser = playwright.chromium().launch(new BrowserType.LaunchOptions()
+                    .setHeadless(true)
+                    .setArgs(Collections.singletonList("--no-sandbox")));
+        } catch (PlaywrightException e) {
+            closeBrowser();
+            assumeTrue(false, "Chromium is not available for Playwright integration tests: " + e.getMessage());
+        }
+    }
+
+    @AfterAll
+    static void closeBrowser() {
+        if (browser != null) {
+            close(browser::close);
+        }
+        if (playwright != null) {
+            close(playwright::close);
+        }
+        browser = null;
+        playwright = null;
+    }
+
+    @AfterEach
+    void clearRegistry() {
+        for (BrowserContext context : contexts) {
+            close(context::close);
+        }
+        contexts.clear();
+        AllurePlaywright.clear();
+    }
+
+    /**
+     * Checks that a real Playwright browser action is reported as an Allure step.
+     *
+     * The test clicks a button on a Chromium page and verifies that the aspect records one passed action step with the
+     * expected human-readable name.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldLogPlaywrightActionSteps() {
+        final Page page = newPageWithContent("<button>Save</button>");
+
+        final AllureResults results = runWithPlaywrightContext(() -> page.click("button"));
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("Click button", Status.PASSED));
+    }
+
+    /**
+     * Checks that Playwright action steps are nested under user-created Allure runtime steps.
+     *
+     * The test wraps a real Playwright click in {@code Allure.step(...)} and verifies that Allure keeps the user step as
+     * the parent while reporting the Playwright action as its child step.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldNestPlaywrightActionStepsInsideRuntimeSteps() {
+        final Page page = newPageWithContent("<button>Pay</button>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> Allure.step("Checkout flow", () -> page.click("button"))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Checkout flow", Status.PASSED);
+        assertThat(step.getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(tuple("Click button", Status.PASSED));
+    }
+
+    /**
+     * Checks that sensitive action parameters are redacted in generated step names.
+     *
+     * The test fills an input with a real value and verifies that the reported Playwright step contains the selector but
+     * replaces the typed value with the configured redaction marker.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldRedactTypedValuesInActionStepNames() {
+        final Page page = newPageWithContent("<input id='password'>");
+
+        final AllureResults results = runWithPlaywrightContext(() -> page.fill("#password", "secret"));
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly("Fill #password with <redacted>");
+    }
+
+    /**
+     * Checks that Playwright action failures keep their original exception details in Allure.
+     *
+     * The test clicks a missing element with a short timeout and verifies that the reported action step is marked broken
+     * and includes the Playwright failure message.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Steps
+    @Test
+    void shouldPreservePlaywrightActionFailures() {
+        final Page page = newPageWithContent("<button>Present</button>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> page.click("#missing", new Page.ClickOptions().setTimeout(100))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Click #missing", Status.BROKEN);
+        assertThat(message(step.getStatusDetails()))
+                .contains("#missing");
+    }
+
+    /**
+     * Checks that user-created Playwright screenshots are attached automatically.
+     *
+     * The test calls the real {@code Page.screenshot(...)} API and verifies that the returned bytes are attached to the
+     * screenshot step without changing the value returned to the test.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachUserScreenshotsAutomatically() {
+        final AtomicReference<byte[]> screenshot = new AtomicReference<>();
+        final Page page = newPageWithContent("<main style='width: 100px; height: 40px'>Screenshot</main>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> screenshot.set(page.screenshot(new Page.ScreenshotOptions()))
+        );
+
+        final StepResult step = results.getTestResults().iterator().next().getSteps().iterator().next();
+        final Attachment attachment = step.getAttachments().iterator().next();
+
+        assertThat(step)
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly("Take screenshot", Status.PASSED);
+        assertThat(attachment)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactly("Screenshot", "image/png");
+        assertAttachmentContent(results, screenshot.get());
+    }
+
+    /**
+     * Checks that the public screenshot helper attaches a page image without creating an extra action step.
+     *
+     * The helper suppresses the Playwright aspect while it captures the screenshot, so the test verifies that only the
+     * attachment is written and the generated PNG bytes are present in Allure results.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachScreenshotThroughHelperWithoutDuplicateAspectAttachment() {
+        final Page page = newPageWithContent("<main style='width: 100px; height: 40px'>Current page</main>");
+
+        final AllureResults results = runWithPlaywrightContext(
+                () -> AllurePlaywright.attachScreenshot("Current page", page)
+        );
+
+        assertThat(results.getTestResults())
+                .flatExtracting(TestResult::getSteps)
+                .isEmpty();
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, PNG_HEADER);
+    }
+
+    /**
+     * Checks that explicitly registered pages produce failure diagnostics.
+     *
+     * The test registers a real page, invokes the failure hook, and verifies that Allure receives both a screenshot and
+     * the current page source for the failed test.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachFailureDiagnosticsForRegisteredPages() {
+        final Page page = newPageWithContent(FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.register(page);
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that the Allure test lifecycle listener attaches diagnostics for failed tests.
+     *
+     * The test marks the current Allure test as failed and verifies that the Playwright lifecycle hook adds screenshot
+     * and page source artifacts before the test result is written.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachFailureDiagnosticsFromAllureLifecycle() {
+        final Page page = newPageWithContent(FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.register(page);
+            Allure.getLifecycle().updateTestCase(testResult -> testResult.setStatus(Status.FAILED));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that pages touched by reported Playwright actions are registered automatically.
+     *
+     * The test performs a real click, triggers failure diagnostics, and verifies that the page observed by the aspect is
+     * used for screenshot and page source attachments.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRegisterPageWhenPlaywrightActionIsReported() {
+        final Page page = newPageWithContent("<button>Attach diagnostics</button>" + FAILURE_HTML);
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.click("button");
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that pages created through Playwright contexts are registered automatically.
+     *
+     * The test creates a page from a real browser context, triggers failure diagnostics, and verifies that the created
+     * page contributes screenshot and page source artifacts even without manual registration.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldRegisterCreatedPagesAutomatically() {
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            final BrowserContext context = newContext();
+            final Page page = context.newPage();
+            AllurePlaywright.withAspectSuppressed(() -> {
+                page.setContent(FAILURE_HTML);
+                return null;
+            });
+            AllurePlaywright.afterTestFailure(new AssertionError("boom"));
+        });
+
+        assertFailureDiagnostics(results);
+    }
+
+    /**
+     * Checks that a tracing session attaches its trace archive when closed.
+     *
+     * The test starts Playwright tracing on a real context, performs browser activity, closes the returned session, and
+     * verifies that Allure receives a zip trace attachment.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenSessionIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            final TraceSession traceSession = AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+            page.click("button");
+            traceSession.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that registered tracing is attached when a browser context closes.
+     *
+     * The test starts tracing, closes the real Playwright context, and verifies that the close hook stops tracing and
+     * writes the generated trace archive to Allure.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenContextIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that unfinished tracing sessions are attached during Allure test shutdown.
+     *
+     * The test leaves an active Playwright trace open and verifies that the Allure lifecycle hook stops it and attaches
+     * the generated trace archive before clearing per-test state.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachTraceWhenAllureLifecycleStopsTest() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            AllurePlaywright.startTracing("Trace", context);
+            page.setContent("<button>Trace</button>");
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentStartsWith(results, ZIP_HEADER);
+    }
+
+    /**
+     * Checks that page console messages and page errors are attached when a context closes.
+     *
+     * The test emits a browser console error and an uncaught page error, closes the real context, and verifies that both
+     * diagnostic text attachments are present.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachPageLogsWhenContextIsClosed() {
+        final BrowserContext context = newContext();
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.setContent("<script>"
+                    + "console.error('console boom');"
+                    + "setTimeout(() => { throw new Error('page boom'); }, 0);"
+                    + "</script>");
+            page.waitForTimeout(250);
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(2);
+        assertTextAttachmentContent(results, "console boom");
+        assertTextAttachmentContent(results, "page boom");
+    }
+
+    /**
+     * Checks that Playwright-recorded videos are attached when a video context closes.
+     *
+     * The test enables video recording on a real context, closes it after page activity, and verifies that exactly one
+     * non-empty video attachment is written.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachVideoWhenContextIsClosed(@TempDir final Path videoDir) {
+        final BrowserContext context = newVideoContext(videoDir);
+        final Page page = context.newPage();
+
+        final AllureResults results = runWithPlaywrightContext(() -> {
+            page.setContent("<h1>Video</h1>");
+            page.waitForTimeout(100);
+            context.close();
+        });
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).isNotEmpty());
+    }
+
+    /**
+     * Checks that the public video helper attaches an existing video file.
+     *
+     * The test writes a temporary WebM file, passes it to {@code AllurePlaywright.attachVideo(...)}, and verifies that
+     * the exact file bytes are stored as an Allure attachment.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAttachVideoFile(@TempDir final Path tempDir) throws IOException {
+        final byte[] video = "video".getBytes(StandardCharsets.UTF_8);
+        final Path path = tempDir.resolve("video.webm");
+        Files.write(path, video);
+
+        final AllureResults results = runWithPlaywrightContext(() -> AllurePlaywright.attachVideo("Video", path));
+
+        assertThat(results.getAttachments())
+                .hasSize(1);
+        assertAttachmentContent(results, video);
+    }
+
+    /**
+     * Checks that helper attachments are ignored when no Allure test or step is active.
+     *
+     * The test installs a lifecycle without a running test, calls the video helper, and verifies that no attachment is
+     * written outside an Allure context.
+     */
+    @Description(useJavaDoc = true)
+    @AllureFeatures.Attachments
+    @Test
+    void shouldIgnoreMissingAllureContext(@TempDir final Path tempDir) throws IOException {
+        final byte[] video = "video".getBytes(StandardCharsets.UTF_8);
+        final Path path = tempDir.resolve("video.webm");
+        Files.write(path, video);
+
+        final AllureResultsWriterStub writer = runWithoutAllureContext(
+                () -> AllurePlaywright.attachVideo("Video", path)
+        );
+
+        assertThat(writer.getAttachments())
+                .isEmpty();
+    }
+
+    @Step("Create Playwright page with HTML content")
+    private Page newPageWithContent(@Param(mode = HIDDEN) final String html) {
+        final Page page = newContext().newPage();
+        page.setContent(html);
+        return page;
+    }
+
+    @Step("Create Playwright browser context")
+    private BrowserContext newContext() {
+        final BrowserContext context = browser.newContext();
+        contexts.add(context);
+        return context;
+    }
+
+    @Step("Create Playwright browser context with video recording")
+    private BrowserContext newVideoContext(final Path videoDir) {
+        final BrowserContext context = browser.newContext(new Browser.NewContextOptions().setRecordVideoDir(videoDir));
+        contexts.add(context);
+        return context;
+    }
+
+    @Step("Close Playwright resource")
+    private static void close(@Param(mode = HIDDEN) final Runnable close) {
+        try {
+            AllurePlaywright.withAspectSuppressed(() -> {
+                close.run();
+                return null;
+            });
+        } catch (RuntimeException ignored) {
+            // The test may have already closed this Playwright resource.
+        }
+    }
+
+    @Step("Run Playwright adapter scenario")
+    private static AllureResults runWithPlaywrightContext(@Param(mode = HIDDEN) final Runnable runnable) {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(writer);
+        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
+        final AllureLifecycle defaultAspectLifecycle = AllurePlaywrightAspect.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            AllurePlaywrightAspect.setLifecycle(lifecycle);
+            runSyntheticTest(runnable, lifecycle);
+            return writer;
+        } finally {
+            Allure.setLifecycle(defaultLifecycle);
+            AllurePlaywrightAspect.setLifecycle(defaultAspectLifecycle);
+            attachResults(writer);
+        }
+    }
+
+    @Step("Run helper without active Allure context")
+    private static AllureResultsWriterStub runWithoutAllureContext(@Param(mode = HIDDEN) final Runnable runnable) {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(writer);
+        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
+        final AllureLifecycle defaultAspectLifecycle = AllurePlaywrightAspect.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            AllurePlaywrightAspect.setLifecycle(lifecycle);
+            runnable.run();
+            return writer;
+        } finally {
+            Allure.setLifecycle(defaultLifecycle);
+            AllurePlaywrightAspect.setLifecycle(defaultAspectLifecycle);
+            attachResults(writer);
+        }
+    }
+
+    private static void runSyntheticTest(final Runnable runnable, final AllureLifecycle lifecycle) {
+        final String uuid = UUID.randomUUID().toString();
+        final TestResult result = new TestResult().setUuid(uuid);
+        try {
+            lifecycle.scheduleTestCase(result);
+            lifecycle.startTestCase(uuid);
+            runnable.run();
+        } catch (Throwable e) {
+            lifecycle.updateTestCase(uuid, testResult -> {
+                getStatus(e).ifPresent(testResult::setStatus);
+                getStatusDetails(e).ifPresent(testResult::setStatusDetails);
+            });
+        } finally {
+            lifecycle.stopTestCase(uuid);
+            lifecycle.writeTestCase(uuid);
+        }
+    }
+
+    @Step("Attach collected Allure results")
+    private static void attachResults(@Param(mode = HIDDEN) final AllureResults results) {
+        AllureTestCommonsUtils.attach(results);
+    }
+
+    @Step("Assert failure diagnostics attachments")
+    private static void assertFailureDiagnostics(@Param(mode = HIDDEN) final AllureResults results) {
+        assertThat(attachments(results))
+                .extracting(Attachment::getName, Attachment::getType)
+                .contains(
+                        tuple("Screenshot", "image/png"),
+                        tuple("Page source", "text/html")
+                );
+        assertAttachmentStartsWith(results, PNG_HEADER);
+        assertTextAttachmentContent(results, "Failure diagnostics");
+    }
+
+    private static List<Attachment> attachments(final AllureResults results) {
+        final List<Attachment> attachments = new ArrayList<>();
+        for (TestResult testResult : results.getTestResults()) {
+            attachments.addAll(testResult.getAttachments());
+            for (StepResult step : testResult.getSteps()) {
+                attachments.addAll(step.getAttachments());
+            }
+        }
+        return attachments;
+    }
+
+    @Step("Assert exact attachment payload")
+    private static void assertAttachmentContent(@Param(mode = HIDDEN) final AllureResults results,
+                                                @Param(mode = HIDDEN) final byte[] expected) {
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).containsExactly(expected));
+    }
+
+    @Step("Assert attachment payload prefix")
+    private static void assertAttachmentStartsWith(@Param(mode = HIDDEN) final AllureResults results,
+                                                   @Param(mode = HIDDEN) final byte[] expected) {
+        assertThat(results.getAttachments().values())
+                .anySatisfy(actual -> assertThat(actual).startsWith(expected));
+    }
+
+    private static String message(final StatusDetails statusDetails) {
+        return statusDetails == null ? null : statusDetails.getMessage();
+    }
+
+    @Step("Assert text attachment contains {expected}")
+    private static void assertTextAttachmentContent(@Param(mode = HIDDEN) final AllureResults results,
+                                                    final String expected) {
+        assertThat(results.getAttachments().values())
+                .map(actual -> new String(actual, StandardCharsets.UTF_8))
+                .anySatisfy(actual -> assertThat(actual).contains(expected));
+    }
+}
diff --git a/allure-playwright/src/test/resources/allure.properties b/allure-playwright/src/test/resources/allure.properties
new file mode 100644
index 00000000..e3a692e0
--- /dev/null
+++ b/allure-playwright/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.model.indentOutput=true
+allure.results.directory=build/allure-results
+allure.label.module=allure-playwright
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 02cf649a..6f2e058a 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -30,6 +30,7 @@ include("allure-karate")
 include("allure-model")
 include("allure-okhttp")
 include("allure-okhttp3")
+include("allure-playwright")
 include("allure-reader")
 include("allure-rest-assured")
 include("allure-scalatest")