software-mansion/live-debugger

LiveDebugger is an OTP application that provides real-time inspection and tracing for Phoenix LiveView applications. It operates by injecting a client-side interface into the browser to discover LiveView processes, monitor their state changes, and visualize callback traces. The system offers developers tools to inspect assigns, simulate user events, and debug async operations, with support for embedding the debugger in Chrome and Firefox DevTools.

62 changes.

This period centered on the v1.0.0 release of LiveDebugger, featuring a major architectural shift to an OTP application with asset isolation and a new event-driven bus. The work included building a comprehensive web UI with Tailwind CSS, developing browser extensions for Chrome and Firefox, and adding extensive test coverage for the new core services and API layers.

4 changes.

This period focused on establishing comprehensive test coverage for debugger components, including user event actions and editor utilities. It also involved migrating the end-to-end testing suite to Playwright, setting up the necessary infrastructure and initial test cases for verifying the debugger's functionality.

A new Firefox extension has been added to allow running the LiveDebugger inside the browser's DevTools. The extension registers a 'LiveDebugger' panel that loads the debugger interface via an iframe when the panel is shown, requiring Firefox version 58.0 or later.

devtools/firefox · high confidence

A new SocketDiscoveryController has been added to handle redirections to the debugger node inspector based on socket and node identifiers. This controller filters discovered LiveView processes to find the correct target and redirects the user, while logging errors and redirecting to an error page if multiple or no matching processes are found.

_lib/live\debugger/app/controllers · high confidence

The application now includes two new helper modules in the web helpers layer to improve developer experience and code safety. The \Hooks\ module provides utility functions (\check\_assigns!\, \check\_stream!\, \check\_hook!\, \check\_private!\, \register\_hook\) that validate the presence of specific keys in a Phoenix LiveView socket's assigns, streams, private data, and hooks, raising clear errors if they are missing. The \Routes\ module introduces verified route generation for the debugger interface, supporting navigation to node inspectors, global traces, resources, settings, and error pages with proper parameter handling.

_lib/live\debugger/app/web/helpers · high confidence

The landing page now includes a set of new static assets in the public directory, specifically SVG files for social media icons (Chrome, Discord, Dribbble, Facebook, Firefox, GitHub, Instagram, LinkedIn) and brand logos (GEM, LiveDebugger, Membrane, Popcorn). These files are now available for use in the site's UI, such as in the footer or topbar banners.

landing/src · high confidence

The LiveDebugger now includes a new SuccessorDiscoverer service that automatically detects when a debugged LiveView process is replaced (e.g., after a page reload or BEAM process restart) and identifies its successor. This ensures a smoother debugging experience by maintaining the connection context across LiveView lifecycle changes, using both transport PID and window ID strategies to track process transitions.

_lib/live\_debugger/services/successor\discoverer · high confidence

The application now includes a \config/config.exs\ file that establishes the build and runtime settings for development and testing. In development, it configures esbuild (v0.18.6) and Tailwind (v4.1.8) to output assets to separate \dev\ and production directories, enables LiveDebugger live-reload for static assets and source files, and activates verbose error debugging. In the test environment, it sets the server port to 4008, enables specific debugging features like dead view mode and garbage collection tracing, and configures Phoenix to initialize plugs at runtime for faster compilation.

config · high confidence

This change introduces the Chrome-specific implementation for the LiveDebugger DevTools extension. It includes a manifest (Manifest V3) that registers a new DevTools panel named 'LiveDebugger' and a background script that initializes this panel. When the panel is shown, the script attempts to load the debugger interface into an iframe by fetching the session URL; if this fails, it clears the iframe content to prevent errors.

devtools/chrome · high confidence

This change introduces the complete web-based user interface for LiveDebugger, built on Phoenix LiveView. It provides the core debugging experience, including a node discovery page, a detailed node inspector for viewing assigns and callback traces, and a resources page. The interface includes new features such as a history of assigns, a dead LiveViews section, and a streams section. It also adds usability enhancements like search functionality for callback traces, an 'open in editor' action, and automatic update checks. The web endpoint now supports graceful startup failures via the \:ignore\_startup\_errors\ configuration, ensuring the host application continues running if the debugger fails to bind to its port.

_lib/live\debugger/app/web · high confidence

The landing page has been rebuilt using Astro, integrating React for components and Tailwind CSS for styling. This change introduces a new configuration setup that includes strict TypeScript support, local font provisioning for the Aeonik typeface, and environment variable handling for analytics and YouTube API access. The site is configured to serve under the /live-debugger base path on docs.swmansion.com.

landing · high confidence

The LiveDebugger now includes two new internal services to improve trace collection and state management. The CallbackTracer service replaces the previous tracing mechanism by using Erlang's \:dbg\ module to monitor LiveView and LiveComponent callbacks, persisting function traces, diffs, and state changes to ETS tables, and broadcasting events for stream updates and component lifecycles. It also handles recompilation monitoring to keep traces accurate. The TelemetryHandler service attaches to Phoenix telemetry events (specifically \:phoenix.live\_component.destroyed\) to capture component destruction and ensure state is saved, providing a more robust way to track LiveView state across the application lifecycle.

_lib/live\_debugger/services/callback\tracer · high confidence

This change adds the client-side assets for the LiveDebugger, including a draggable debug button, a context menu, and element inspection tools. The debug button is rendered inside a Shadow DOM to isolate its styles and scripts from the host application, preventing conflicts. It supports toggling between a bug icon and an inspect cursor, and includes a tooltip for displaying node information during inspection. The client initializes a debug socket connection, handles nested LiveView socket IDs, and respects a configuration flag to disable the debug button entirely.

assets/client · high confidence

A new ProcessMonitor service has been added to the LiveDebugger to track the lifecycle of LiveView processes in the debugged application. This service monitors when LiveView processes start or terminate and broadcasts corresponding events (LiveViewBorn, LiveViewDied, LiveComponentCreated, LiveComponentDeleted) to the debugger. It also maintains state regarding which LiveComponents are associated with each LiveView process, enabling real-time visibility into the application's process activity and stability.

_lib/live\_debugger/services/process\monitor · high confidence

A new GarbageCollector service has been added to automatically manage Erlang ETS tables used by the debugger. The service includes a TableWatcher that tracks which LiveViews are being debugged and which processes are alive, and a GarbageCollector GenServer that periodically trims active tables exceeding size limits (50 MB for watched, 5 MB for non-watched) or deletes tables associated with unobserved processes. This helps prevent memory bloat in the LiveDebugger by ensuring ETS tables do not grow indefinitely.

_lib/live\_debugger/services/garbage\collector · high confidence

The live debugger now uses dedicated structs to represent core debugging entities. \LvProcess\ models a LiveView process with fields for socket IDs, PIDs, and flags indicating if it is nested, embedded, or the debugger itself. \LvState\ captures the current state of a LiveView, including its components and their assigns. \Trace\ unifies function and diff traces under a common type, providing a consistent way to track LiveView events. These structures form the foundation for how the debugger captures and displays LiveView internals.

_lib/live\debugger/structs · high confidence

The LiveDebugger app now uses a dedicated \LiveDebugger.App\ module to organize its LiveView UI, establishing a consistent file structure for features (actions, queries, events) and nested LiveViews. This change introduces a new event system (\LiveDebugger.App.Events\) to standardize UI interactions like settings changes and trace refreshes. Additionally, it adds support for flash notifications via a new \Flash\ hook and defines a \HookComponent\ behavior, allowing function components to manage their own markup and events while sharing state with parent LiveViews.

_lib/live\debugger/app · high confidence

This change introduces a new \lib/live\_debugger/api\ module structure that serves as the core interface for the debugger. It adds \LiveViewDebug\ and \LiveViewDiscovery\ to list and inspect LiveView processes and their component trees, \UserEvents\ to allow developers to send simulated user interactions (events, casts, calls, info messages) to LiveView processes, and dedicated storage modules (\SettingsStorage\, \StatesStorage\, \TracesStorage\) to manage debugger configuration, LiveView state snapshots, and callback traces using ETS. This refactors the internal mechanics of how the debugger discovers, stores, and interacts with LiveView processes.

_lib/live\debugger/api · high confidence

The devtools/common area now includes the core HTML and JavaScript files for the browser extension's UI. The panel displays the debugger interface in an iframe and shows a specific error message if the LiveDebugger meta tag is missing from the inspected page. The url.js module handles session detection by reading the meta tag and constructing the correct session URL based on the detected LiveDebugger version (0.2 vs newer).

devtools/common · high confidence

The LiveDebugger app now includes a dedicated Discovery page that displays both active and dead LiveView sessions. This new section allows users to view inactive (dead) LiveViews, toggle their visibility via a 'DeadView mode' setting, and manually remove their stored state. The page also provides information about garbage collection behavior regarding these dead sessions.

_lib/live\debugger/app/discovery · high confidence

A new tooltip component has been added to the Live Debugger to display node information during highlighting. This UI element shows the element's type (LiveComponent or LiveView) with distinct icons and colors, the module name, and the specific ID key/value. It intelligently positions itself relative to the highlighted element, adjusting vertically and horizontally to stay within the viewport, and includes an arrow indicator that points up or down based on available space.

assets/client/components/tooltip · high confidence

This change introduces four new JavaScript services in the client assets to power the LiveDebugger's browser-side capabilities. The \debug\_socket.js\ service establishes the WebSocket connection and sends a window-initialized event, utilizing \window\_identifier.js\ to generate or persist a unique window ID via \window.name\ to prevent duplication. The \highlight.js\ service handles visual feedback, including drawing bounding boxes for LiveViews and LiveComponents (even when embedded or with zero-size parents), pulsing animations, and tooltips. Finally, \inspect.js\ implements the element inspection mode, allowing users to hover over and click DOM elements to request node information and inspect their corresponding LiveView/Component state, with proper cleanup on escape or right-click.

assets/client/services · high confidence

This change introduces four new LiveView hooks in the \lib/live\_debugger/app/web/hooks\ directory to enhance the debugger's UI capabilities. The \Flash\ hook provides a mechanism to push flash messages (including error and info types) from nested LiveComponents to the root LiveView, ensuring users see critical feedback like crash notifications or info alerts. The \IframeCheck\ hook detects if the debugger is running inside an iframe and assigns this state for conditional UI logic. The \TracerStatus\ hook monitors the background tracing service, updating the UI to reflect whether tracing is active or has stopped (e.g., due to a crash or heap limit). Finally, the \URL\ hook tracks the current relative URL, keeping the UI state synchronized with navigation.

_lib/live\debugger/app/web/hooks · high confidence

A new Settings page has been added to the LiveDebugger application, allowing users to configure debugging behavior and display preferences. Users can now toggle the Debug Button visibility, enable DeadView mode to inspect dead LiveViews, control whether tracing starts automatically, and manage garbage collection to balance memory usage. The page also includes controls for highlighting components in the browser and switching between dark and light themes. Changes are persisted via the settings storage and broadcast to the client to update the UI immediately.

_lib/live\debugger/app/settings · high confidence

The client now includes a debug options menu component that provides users with a tooltip interface containing three actions: opening the Live Debugger in a new tab, inspecting elements, and moving the debug button. The menu intelligently positions itself to avoid overflowing the viewport and automatically hides when the inspect mode changes, the window is resized, or a click occurs outside the menu.

_assets/client/components/debug\options · high confidence

The debugger now includes dedicated sections to monitor background async jobs (start\_async/assign\_async) and display trees of associated LiveViews with navigation support. Users can also send user-triggered events to LiveView and LiveComponent processes via a new form that supports handle\_event, handle\_info, handle\_cast, handle\_call, and update handlers, with payload parsing and validation.

_lib/live\debugger/app/debugger · high confidence

A new self-contained Phoenix application (LiveDebuggerDev) has been added to the dev environment to serve as a test harness for the debugger. It includes a router with multiple LiveView routes (such as embedded views, streams, async demos, and crash simulations), a layout with Tailwind CSS and LiveReloader integration, and helper components. This allows developers to run and interact with various LiveView states and edge cases locally.

dev · high confidence

Added a suite of new LiveViews in the \dev/live\_views\ directory to serve as interactive test cases for the debugger. \AsyncDemo\ demonstrates \start\_async\, \assign\_async\, and cancelable async operations with configurable load times. \CallbackCrash\ allows intentionally triggering crashes in specific LiveView callbacks (mount, render, event, info, cast, call, async) to verify error handling. \EndlessCrashReload\ creates a loop where an async task crashes immediately upon completion, testing reload stability. \MemoryExplosion\ simulates high-frequency event churn with large assigns to reproduce memory pressure. \Stream\ provides a playground for stream operations (insert, update, delete, reset) across multiple streams. Other views like \Main\, \Nested\, \Embedded\, \Messages\, \Side\, and \Simple\ provide additional contexts for testing component nesting, large data structures, and message handling.

_dev/live\views · high confidence

This update introduces a suite of new JavaScript hooks in the assets/app/hooks directory that power the enhanced Node Inspector and debugging interface. Key additions include ChartHook for visualizing runtime metrics (memory, heap, reductions) via Chart.js, and CodeMirrorTextarea for syntax-highlighted Elixir code editing with theme support. Search functionality is expanded with AssignsBodySearchHighlight and TraceBodySearchHighlight to visually emphasize matching text in assigns and trace bodies, while TraceLabelSearchHighlight improves trace list readability by shortening and highlighting labels. Interactive behaviors are enhanced via Collapsible (with browser state persistence), CollapsedSectionPulse and DiffPulse for visual change indicators, and Fullscreen for modal management. Additional utilities include AutoClearFlash for transient messages, SurveyBanner for version-based feedback, and improved Tooltip positioning logic.

assets/app/hooks · high confidence

The dev environment now includes a suite of new LiveComponent examples for testing and demonstration purposes. These include AsyncDemoComponent for showcasing async operations (start\_async, assign\_async, cancelable), Crash for simulating various exception types, Conditional for toggling child visibility, ManyAssigns for handling temporary assigns, Name for passing props, Recursive for nested component rendering, Send for inter-component messaging, Stream for list management, and utility components like Wrapper and VeryLongName.

_dev/live\components · high confidence

Added two new Mix tasks to streamline development workflows. The \mix build\_devtools\ task automates the creation of browser extension packages for Chrome and Firefox by copying source files and zipping them. The \mix igniter.install live\_debugger\ task integrates the Live Debugger into Phoenix applications by automatically injecting the required script tag into the root layout and providing notices about Content Security Policy adjustments if necessary.

lib/mix · high confidence

The LiveDebugger application now includes a new \Navbar\ component that structures the top navigation bar. This component introduces a dismissible survey banner linking to a Google Form for user feedback, which displays the current application version. It also adds a conditional warning block that alerts users when garbage collection is disabled, helping them understand potential memory usage impacts. The navbar provides standard navigation utilities including a return link, settings button, and logo display.

_lib/live\debugger/app/web/components · high confidence

The LiveDebugger now includes dedicated structs to represent specific types of trace data: \DiffTrace\ for LiveView diffs, \ErrorTrace\ for trace errors, and \FunctionTrace\ for function call traces. These structures standardize how trace information is captured and stored, enabling more detailed inspection of LiveView and LiveComponent behavior, including function arguments, return values, and errors.

_lib/live\debugger/structs/trace · high confidence

Added four new utility modules to the LiveDebugger library: \Callbacks\ provides ordered lists of LiveView and LiveComponent callback signatures; \FunctionMatcher\ replays pattern matching against BEAM debug info to identify the specific source clause handling a function call; \Memory\ offers helpers for measuring term sizes, setting heap limits, and formatting byte counts; and \Modules\ includes a helper to identify LiveDebugger modules by name prefix.

_lib/live\debugger/utils · high confidence

The Live Debugger now includes a suite of new utility modules in \lib/live\_debugger/app/utils\ to enhance how terms are displayed and tracked. \TermDiffer\ calculates structural diffs between Elixir terms (maps, lists, structs, etc.) to identify inserted, deleted, or changed values. \TermParser\ and \TermNode\ work together to convert these terms into a displayable tree structure, supporting features like search highlighting and visual pulse effects on changes. \Parsers\ provides helpers for formatting timestamps, elapsed times, and PIDs, while \TermSanitizer\ ensures terms can be safely encoded to JSON by converting non-serializable types like PIDs and functions into strings. Additional utilities include \Format\ for text transformation, \URL\ for query parameter management, and \parsers\ for time unit conversions.

_lib/live\debugger/app/utils · high confidence

The debugger can now be embedded in iframes by removing restrictive X-Frame-Options and Content-Security-Policy headers via a new plug. Additionally, a new client communicator service has been introduced to handle 'request-node-element' events, enabling the debugger to discover and report details for LiveViews and LiveComponents to the client.

_lib/live\_debugger/app/web/plugs, lib/live\_debugger/services/client\communicator · high confidence

The LiveDebugger client now uses a dedicated Phoenix channel and socket to manage communication with the debugged LiveView browser. This change introduces \LiveDebugger.Client.Channel\ for handling message broadcasting via PubSub, \LiveDebugger.Client.Socket\ for establishing the connection and assigning socket IDs, and \LiveDebugger.Client.ConfigComponent\ to inject configuration meta tags and scripts into the debugged app's layout. This new structure supports features like disabling the debug button and isolating injected assets, replacing previous mechanisms for client-side integration.

_lib/live\debugger/client · high confidence

The \lib/live\_debugger/api/system\ directory now contains dedicated API modules that wrap Erlang/OTP and Elixir system functions to provide a consistent interface for the debugger. \LiveDebugger.API.System.Dbg\ replaces the standard \:dbg\ library with direct \:erlang.trace\ BIFs to reduce per-message overhead, while \LiveDebugger.API.System.FileSystem\ wraps the \FileSystem\ library for monitoring file changes. Additionally, \LiveDebugger.API.System.Module\ provides safe introspection of loaded modules and behaviors (including a fix to check for \:module\_info\ export), and \LiveDebugger.API.System.ProcessInfo\ wraps \:erlang.process\_info\ to retrieve specific process metrics. These modules use a pluggable implementation pattern via application environment configuration.

_lib/live\debugger/api/system · high confidence

The LiveDebugger library has been restructured to improve reliability and configurability. A new event system using the \LiveDebugger.Event\ macro provides structured, type-enforced events for tracking state changes. Internal communication now relies on a dedicated \LiveDebugger.Bus\ module built on Phoenix.PubSub, separating general events, traces, and states into distinct topics. The application's startup process is managed by \LiveDebugger.App\, which explicitly handles PubSub and endpoint initialization. Additionally, the \:auto\_port\ configuration option has been introduced, allowing the debugger to automatically find an available port if the specified one is in use, and \:ignore\_startup\_errors\ allows the application to start even if the endpoint fails to bind initially.

_lib/live\debugger · high confidence

The library has been refactored from a simple utility module into a full OTP application that starts a supervision tree, enabling background services like settings and trace storage. Users can now configure the debugger's network binding via \:ip\, \:port\, and a new \:auto\_port\ option, as well as specify a custom \:server\ process and \:adapter\ for the internal endpoint. The debug interface's visibility is controlled by a \:disabled?\ flag and a \:browser\_features?\ setting, while the \:external\_url\ config allows correct URL generation when using Unix sockets or non-standard network setups.

lib · high confidence

This entry covers the v1.0.0 release of LiveDebugger, which now requires Phoenix LiveView v1.1.7 or later. The release includes a significant architectural change to isolate LiveDebugger's injected assets from the debugged application to prevent conflicts. It also introduces a new feature allowing users to open source files directly in their editor from the debugger interface. Several bug fixes are included, such as resolving an endless reload loop, correcting filter button behavior, and fixing trace fullscreen highlighting. Additionally, the changelog notes improvements to tracing performance and fixes for MapSet assign summary updates.

(repo-wide) · high confidence

The application now uses a new CSS-based design system that introduces a dark theme alongside the existing light theme, allowing users to switch between the two. This update also integrates the Inter typeface for improved typography and defines a comprehensive set of semantic color variables (such as error, warning, and status colors) to ensure consistent visual feedback across the interface.

assets/app/styles · high confidence

The LiveDebugger now uses two dedicated GenServers to track process lifecycles: \DebuggedProcessesMonitor\ observes the debugged application's LiveViews and components by listening to trace and telemetry events, while \DebuggerProcessesMonitor\ tracks the debugger's own LiveView processes. This separation ensures that the debugger can correctly detect when debugged LiveViews are created, updated, or destroyed, and when the debugger itself terminates, improving stability during debugging sessions.

_lib/live\_debugger/services/process\_monitor/gen\servers · high confidence

The LiveDebugger user interface has been redesigned using Tailwind CSS, introducing a modern styling system with support for dark and light themes that respect system preferences. This update adds several visual enhancements to improve debugging clarity: a new tab icon (favicon) that adapts to the active theme, a pulse animation on assign changes, and status dots to indicate when assigns are loading. Additionally, the interface now includes a version update check feature that notifies users of new releases, and a survey banner for user feedback.

assets/app · high confidence

The application's visual presentation has been updated by replacing the previous stylesheet with a new \app.css\ generated by Tailwind CSS v4.1.8. This change introduces a comprehensive set of CSS variables (design tokens) that define the application's color palette, spacing, typography, and component styles. It also establishes a complete dark mode theme, allowing the interface to adapt to system preferences or user toggles, and includes updated iconography and layout utilities for the dashboard and inspector views.

priv · high confidence

Added system-level unit tests for debugger, module, and process info implementations; Added test support fakes for LiveDebugger structures; Added tests for ClientCommunicator GenServer and LvProcess queries; Added tests for DebuggedProcessesMonitor GenServer; Added tests for LiveView discovery actions and queries; Added tests for async job query logic; Added tests for debugger editor utility; Added tests for debugger queries and successor discovery service; Added tests for debugger user event actions; Added tests for function matching and memory utility modules; Added tests for node state query functions; Added tests for the Live Debugger Igniter installation task; Added unit tests for CallbackTracer actions and queries; Added unit tests for GarbageCollector and ProcessMonitor services; Added unit tests for app utility modules; Added unit tests for callback tracing display and filter logic; Added unit tests for core LiveDebugger components; Added unit tests for debugger components, settings, and web hooks; Added unit tests for the LiveDebugger API layer; Added unit tests for the callback tracer gen\_servers; Initial Playwright-based E2E test infrastructure; Migrate end-to-end tests to Playwright.

The project's dependency manifests have been updated to newer versions across both the Elixir and JavaScript ecosystems. In the Elixir layer, \mix.lock\ now pins Phoenix to 1.8.5, Phoenix LiveView to 1.1.28, Plug to 1.19.1, and Igniter to 0.7.7. On the JavaScript side, \assets/app/package.json\ and \assets/client/package.json\ introduce new dependencies including \alpinejs\ (3.14.7), \chart.js\ (4.5.1), \codemirror\ (6.0.2), and \uuid\ (11.1.0), while the landing page site (\landing/package.json\) upgrades to Astro 5.18.0 and React 19.2.0. Additionally, end-to-end testing dependencies in \e2e/package.json\ have been updated to Playwright 1.58.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 52 → 53 (+0.3)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 81 → 58 (-23.4)
• Architecture 78 → 83 (+4.6)
• Maturity 65 → 65 (+0.1)
• Readiness 48 → 49 (+0.7)
• Security 49 → 51 (+1.8)
• Accessibility 53 → 53 (+0.0)
• Performance 100 (new)

• (anonymous) (cognitive 100) (priv/static/client.js)
• (anonymous) (cyclomatic 104) (priv/static/client.js)
• Documentation: no installation or build instructions (docs/config.md)
• Documentation: no licence statement (docs/config.md)
• Documentation: no usage examples (docs/config.md)
• Duplicated block (5 lines × 2) (lib/live_debugger/services/callback_tracer/actions/diff_trace.ex)
• No assertions: debugger captures runtime errors and exceptions in global callbacks 1 (e2e/tests/exception-trace.spec.ts)
• No assertions: debugger captures runtime errors and exceptions in global callbacks 2 (e2e/tests/exception-trace.spec.ts)
• No assertions: debugger captures runtime errors and exceptions in global callbacks 3 (e2e/tests/exception-trace.spec.ts)
• Off-boarding risk: anonymized user #1

• Duplicated block (5 lines × 2) (lib/live_debugger/services/callback_tracer/actions/state.ex)
• Duplicated block (7 lines × 2) (lib/live_debugger/services/callback_tracer/actions/diff_trace.ex)
• End-of-life runtime: Node.js 20
• FunctionTooLong: TopBarBannerClient.TopBarBanner (landing/src/components/TopBarBanner/TopBarBannerClient.tsx)
• High CVE: [GHSA redacted] (landing/package-lock.json)
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

software-mansion/live-debugger was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.