plotly/dash

This system is the Plotly Dash framework, a Python library for building analytical web applications. It provides a comprehensive suite of UI components, including core interactive elements, HTML wrappers, and a data table, all of which have been modernized with TypeScript and enhanced with features like virtualization and lazy loading. The framework supports complex application logic through background callbacks, WebSocket streaming, and a pluggable backend architecture, while also offering new capabilities for AI integration via the Model Context Protocol.

71 changes.

This period focused on modernizing the Dash architecture by migrating the renderer to React 19 and TypeScript, introducing WebSocket-based callbacks, and implementing a new Patch API for efficient state updates. It also involved significant rewrites of core UI components like Dash Table and Dash Core Components to improve performance, accessibility, and build tooling, supported by extensive new integration and unit test suites.

49 changes.

This period focused on integrating the Model Context Protocol (MCP) to expose Dash apps to AI agents, alongside a major architectural shift to a pluggable backend system with native WebSocket support. The work also included migrating core components to TypeScript, introducing background callback execution, and establishing comprehensive test coverage and performance benchmarking.

The base module for the test component now supports TypeScript-based component generation. This includes a new \_\init\\_.py that loads version and package metadata, defines JavaScript distribution paths (including a dev-only proptypes file), and attaches these assets to the generated components. Additionally, a py.typed marker file has been added to enable static type checking for this package.

@plotly/dash-generator-test-component-typescript/base · high confidence

MCP tool responses now automatically enrich callback outputs with human-readable content. Plotly Graph figures are rendered as embedded PNG images, and tabular data from components like DataTable or AgGrid is converted into markdown tables (limited to 50 rows). This applies to standard Dash callback outputs exposed via the MCP protocol, improving how LLM clients consume these results.

dash/mcp/primitives/tools/results · high confidence

New R vignettes have been added for the \dashCoreComponents\ and \dashHtmlComponents\ packages, providing users with interactive documentation and code examples for R-based Dash applications. The \dashCoreComponents\ vignette covers interactive UI elements such as Dropdowns (including multi-value, searchable, and disabled states) and Sliders (including marks, steps, and styling). The \dashHtmlComponents\ vignette explains how to compose layouts using R functions that wrap HTML5 elements, detailing attribute mapping for styles, classes, and IDs, as well as Markdown support.

(repo-wide) · high confidence

Introduced a new test package, @plotly/dash-generator-test-component-typescript, containing TypeScript-based Dash components (including React.FC, class, and memoized variants) along with the necessary build configuration (Webpack, Babel, tsconfig) and a test suite to validate metadata generation for various prop types such as strings, numbers, unions, enums, and tuples.

@plotly/dash-generator-test-component-typescript · high confidence

The @plotly/dash-generator-test-component-typescript package now includes a new set of TypeScript-based test components (TypeScriptComponent, TypeScriptClassComponent, MemoTypeScriptComponent, FCComponent, etc.) along with their corresponding prop type definitions in props.ts. These components demonstrate various TypeScript features including union types, enums, tuples, object-of types, and mixed prop-types/TypeScript usage, serving as test cases for the TypeScript component generation system.

@plotly/dash-generator-test-component-typescript/src · high confidence

The test components library now includes an AsyncComponent and an AsyncComponentLoader to support testing scenarios involving dynamic imports and asynchronous component loading.

@plotly/dash-test-components/src/fragments · high confidence

Introduced two new packages, @plotly/eslint-config-dash and @plotly/prettier-config-dash, providing standardized linting and formatting rules for Dash projects. The ESLint config extends recommended settings with React and import plugins, enforcing specific style rules like single quotes and no unused variables, while also offering a TypeScript variant that integrates @typescript-eslint. The Prettier config enforces a 4-space tab width, single quotes, and avoids arrow parens and trailing commas.

@plotly/eslint-config-dash, @plotly/prettier-config-dash · high confidence

Introduces a new \dash/mcp/tasks\ module that enables programmatic management of background callbacks through the Model Context Protocol (MCP). This change adds support for creating, querying, and canceling background tasks, allowing users to poll for task status and retrieve results without relying on Flask-specific request contexts. The implementation includes robust task ID parsing with cryptographic signature verification to prevent tampering, handles race conditions between job completion and teardown, and exposes task metadata such as expiration time and polling intervals directly through MCP tools.

dash/mcp/tasks · high confidence

Dash 4.2.0 introduces a global \@dash.callback\ decorator that allows registering callbacks without defining or importing the \app\ object, alongside a new \background\ parameter for long-running tasks that can be managed by \CeleryManager\ or \DiskcacheManager\. The release also adds a backend-agnostic shared storage system (\BaseSharedStorage\, \DiskcacheSharedStorage\, \LocalSharedStorage\, \RedisSharedStorage\) for state management and pub/sub, and exposes a new \ctx\ alias for \callback\_context\ to simplify accessing callback context properties like \triggered\ and \inputs\.

dash · high confidence

The Dash Core Components library has been migrated from JavaScript to TypeScript, introducing stricter type definitions and improved developer experience. This update includes the addition of several new components: Button, Checklist, DatePickerRange, DatePickerSingle, RadioItems, Textarea, and Tooltip. Existing components such as Dropdown, Slider, Input, and Markdown have also been refactored, with specific behavioral improvements like controlled dropdown result ordering via the \search\_order\ prop, support for disabling slider inputs, and fixes for responsive option labels and default autoComplete behavior.

components/dash-core-components/src · high confidence

The Dash Table component has been rewritten in TypeScript, introducing a modular architecture with dedicated factories for cells, filters, headers, and edges. This update includes a new LazyLoader utility that dynamically imports heavy dependencies like xlsx and highlight.js to improve initial load performance. The rewrite also modernizes the codebase by migrating React refs to createRef and implementing memoization for derived styles and cell contents.

components/dash-table/src/dash-table · high confidence

The @plotly/dash-test-components package has been significantly expanded with new components to support testing complex Dash patterns. Key additions include ComponentAsProp, which accepts React nodes, shapes, and nested lists/objects as props to validate callback graph handling; ExternalComponent, which leverages the ExternalWrapper API to render external components (like dash\_core\_components Input) for testing dynamic component injection; and MountStateComponent, which addresses a specific behavior where initial state set on mount was previously wiped on the first render (issue \#3929). Additional components like AddPropsComponent and ReceivePropsComponent facilitate testing of prop passing and cloning, while MyPersistedComponent and MyPersistedComponentNested provide robust fixtures for testing local/session persistence with nested value transforms. The package also introduces RenderType to test internal render type subscriptions and DrawCounter to verify component draw counts.

@plotly/dash-test-components/src/components · high confidence

This change introduces a new set of MCP (Model Context Protocol) resource providers in the \dash/mcp/primitives/resources\ module, enabling external tools to inspect Dash application structure and behavior. The implementation adds a base \MCPResourceProvider\ class and five specific providers: \LayoutResource\ (exposes the full component tree at \dash://layout\), \ComponentsResource\ (lists all component IDs and types at \dash://components\), \PagesResource\ (details multi-page app metadata at \dash://pages\), \PageLayoutResource\ (provides per-page layout trees via template \dash://page-layout/{path}\), and \ClientsideCallbacksResource\ (maps clientside callback inputs/outputs at \dash://clientside-callbacks\). These resources allow MCP clients to programmatically read app layouts, page registries, and callback definitions as JSON.

dash/mcp/primitives/resources · high confidence

Dash applications can now expose their callbacks as Model Context Protocol (MCP) tools, allowing LLMs to trigger app logic directly. This change introduces a new tool provider system in dash/mcp/primitives/tools that registers callbacks as tools with generated input/output schemas and descriptions. Users can invoke callbacks via MCP tool calls, with support for background task polling and cancellation. The system includes a decorator (@mcp\_enabled) to explicitly mark functions as MCP tools, and a built-in get\_dash\_component tool for inspecting component properties and their relationships to callbacks.

dash/mcp/primitives/tools · high confidence

The \dash/mcp/primitives\ module now exports core Model Context Protocol (MCP) operations, allowing users to list and read resources, list resource templates, and call tools directly from this package.

dash/mcp/primitives · high confidence

This change introduces the new @plotly/dash-component-plugins package, providing core utilities for Dash component development. It adds async support for lazy-loaded components via the \asyncDecorator\ and \inheritAsyncDecorator\ functions, allowing components to expose a readiness state (\\_dashprivate\_isLazyComponentReady\). It also includes a \History\ module that standardizes location change notifications by dispatching and listening to custom events on the window object. The package is built with Webpack 5 and Babel, targeting UMD output.

@plotly/dash-component-plugins · high confidence

The @plotly/dash-test-components package is introduced, providing a set of components designed for testing Dash applications. This includes a Python package structure (setup.py, base/\_\init\\_.py) that exposes test components and configures their JavaScript distribution, alongside a build system (webpack.config.js, babel.config.js) to compile the React-based source code into browser-compatible bundles. The package supports async lazy loading for specific test components and is configured to be included in the distribution via MANIFEST.in.

@plotly/dash-test-components · high confidence

This change introduces the \@plotly/dash-jupyterlab\ package, providing a JupyterLab extension that embeds Dash applications directly within the JupyterLab interface. The extension registers a kernel communication target to receive display commands from Dash backends, creating and managing iframe widgets in the main work area for both notebook and console sessions. It includes the necessary TypeScript source, compiled JavaScript, type definitions, CSS styling for the widgets, and build configuration files to support this integration.

@plotly/dash-jupyterlab · high confidence

Dash apps can now expose their internal state and logic to external AI agents via the Model Context Protocol. This change adds a new \dash.mcp\ module that provides \enable\_mcp\_server\ to wire the MCP server into a Dash app, \configure\_mcp\_server\ to control which resources (layout, components, pages, callbacks) and tools are exposed, and an \@mcp\_enabled\ decorator to mark specific Python functions as MCP tools. The server handles session management, supports hot-reload notifications to connected clients, and implements the MCP transport layer.

dash/mcp · high confidence

This change adds a new \@plotly/dash-websocket-worker\ package that implements a SharedWorker to manage WebSocket connections for Dash callbacks. The worker centralizes connection management with automatic reconnection, configurable heartbeats, and inactivity timeouts, while routing messages between multiple browser tabs (renderers) and the server. It supports batched \set\_props\ updates for efficiency and allows renderers to request partial property reads, enabling more responsive and scalable real-time Dash applications.

@plotly/dash-websocket-worker · high confidence

Dash now includes a new shared storage system that provides a common key/value store and ordered publish/subscribe channel across worker processes. The system is backend-agnostic, offering three implementations: LocalSharedStorage (default, in-memory with owner election for single-machine use), DiskcacheSharedStorage (on-disk persistence for single-machine multi-process scenarios), and RedisSharedStorage (for multi-container deployments). All backends support JSON-compatible values, optional TTLs, and replayable pub/sub subscriptions that handle buffer overruns gracefully. The storage layer uses msgspec for efficient, safe serialization and includes features like chunked disk writes and atomic operations to ensure data integrity.

_dash/\_shared\storage · high confidence

Dash now supports running callbacks in the background to prevent blocking the main application thread. This change introduces a new \dash.background\_callback\ module containing a \BaseBackgroundCallbackManager\ and two concrete implementations: \CeleryManager\ for distributed task queues and \DiskcacheManager\ for local subprocess execution. Users can now offload long-running logic to these managers, which handle result storage, progress tracking, and job termination, with optional caching capabilities via the \cache\_by\ parameter.

_dash/background\callback · high confidence

The \dash\_table\base\ package now exposes \Format\ and \FormatTemplate\ as first-class components, allowing users to programmatically define cell appearance. The \Format\ class provides a fluent API for configuring alignment, grouping, padding, precision, numeric schemes (such as decimal, exponent, or hexadecimal), signs, and symbols. The \FormatTemplate\ module offers convenient factory functions like \money\ and \percentage\ to quickly apply common formatting patterns, which are now included in the package's public API via \\\all\\_\.

_components/dash-table/dash\_table\base · high confidence

Dash now uses a pluggable backend system in the \dash/backends\ package, replacing the previous monolithic server implementation with distinct adapters for Flask, FastAPI, and Quart. This change introduces native WebSocket support for persistent callbacks, allowing real-time bidirectional communication and streaming updates without relying on HTTP polling. The new architecture also standardizes request and response handling through dedicated adapter classes, ensuring consistent behavior across all supported web frameworks.

dash/backends · high confidence

A new standalone benchmark suite has been added to measure renderer performance for hot paths such as initial hydration, callbacks, wildcards, and patching. This harness runs scenarios via a Python runner that launches a production-renderer Dash app and drives headless Chrome to collect in-browser timing metrics (median, p90, max). It includes a committed baseline file for CI regression gating, a machine-independent comparison strategy, and support for CPU profiling to identify performance bottlenecks.

benchmarks · high confidence

The CallbackGraph component has been introduced to visualize the dependency structure of Dash callbacks. This interactive graph displays nodes for components, properties, and callbacks, with edges indicating input, output, and state relationships. It supports two layout modes (top-down and left-right) and provides real-time visual feedback: callback nodes show execution count and average time, while nodes flash to indicate loading states, errors, or triggered updates. The view uses a Verdana font and specific color coding to distinguish client-side versus server-side callbacks and to highlight inactive parts of the graph when a node is selected.

dash/dash-renderer/src/components/error/CallbackGraph · high confidence

The dash-table demo has been rewritten as a standalone React application located in components/dash-table/demo. This new demo provides an interactive playground for testing various table configurations, including editable cells, native filtering, markdown rendering, tooltips, and virtualized rendering. It utilizes React 16.14.0 development bundles and includes comprehensive mock data generation for different column types and data scenarios, allowing users to easily visualize and interact with the component's features.

components/dash-table/demo · high confidence

This release introduces several new dash-core-components and refactors existing ones for better performance and maintainability. New components include Button, Checklist, ConfirmDialog (with ConfirmDialogProvider), DatePickerSingle, DatePickerRange, Download, Geolocation, and Link. Existing components have been significantly updated: Dropdown is now a custom/Radix-based implementation with virtualized lists for large option sets and support for Enter key selection; Input is rewritten in TypeScript with fixes for floating-point precision in steppers and default autoComplete behavior; Slider is refactored to use RangeSlider under the hood and converted to TypeScript; Tabs are refactored with improved className composition and auto-expanding flex support; Graph supports MathJax rendering and loading from plotly.py; Clipboard now supports text/html MIME type; and Loading is rewritten in TypeScript with a new data-dash-is-loading attribute. These changes enhance usability, accessibility, and visual consistency across the component library.

components/dash-core-components/src/components · high confidence

A new debug menu component has been added to the bottom-right corner of the application, providing developers with a collapsible interface for monitoring errors, viewing callback graphs, and managing version updates. The menu now includes a version info section that checks for new Dash releases, displaying upgrade notifications with options to skip, remind me later, or opt out entirely, while caching results in localStorage to avoid excessive requests. Additionally, a Plotly Cloud button has been introduced to help users install the necessary extension for publishing to Plotly Cloud, featuring a copy-to-clipboard function for the installation command. The menu also supports custom devtools via a context provider, allowing for extensible debugging experiences.

dash/dash-renderer/src/components/error/menu · high confidence

The renderer now includes dedicated React components for handling errors: ComponentErrorBoundary catches component-level crashes and dispatches error actions, while GlobalErrorContainer wraps the application content with a debug menu and error state integration. A passthrough variant is also provided for non-debug contexts. Additionally, custom CSS styles are injected to format Werkzeug traceback errors within iframes, ensuring consistent visual presentation of error messages.

dash/dash-renderer/src/components/error · high confidence

A new React component (FrontEndError) and its container have been added to render front-end errors in the Dash developer tools. This component displays error messages, stack traces, and backend HTML errors (via iframe or inline) with a collapsible UI, styling consistent with the new design system, and support for an 'alerts tray' view.

dash/dash-renderer/src/components/error/FrontEnd · high confidence

The \dash\_core\_components\_base\ package now includes \express.py\, which provides convenience functions (\send\_file\, \send\_bytes\, \send\_string\, and \send\_data\_frame\) to simplify creating download callbacks. These helpers automatically format file content (including base64 encoding for binary data) and metadata into the structure expected by the Download component, supporting various data sources like local files, bytes, strings, and pandas DataFrames.

_components/dash-core-components/dash\_core\_components\base · high confidence

The renderer now supports streaming callbacks via a multiplexed HTTP transport (streamClient.ts) that shares a single downlink connection across all streaming callbacks and browser tabs using a SharedWorker, improving performance and avoiding browser connection limits. A new clientside API (clientsideFunctions.ts) exposes set\_props and clean\_url on window.dash\_clientside, allowing JavaScript to update component props and sanitize URLs. Additional utility modules (propPath.ts, rendererId.ts, stores.ts, libraries.ts, wait.ts) support path-based prop resolution, unique renderer identification, library loading, and store management.

dash/dash-renderer/src/utils · high confidence

This change introduces a suite of new utility modules in the components/dash-core-components/src/utils directory to support enhanced component behavior. DatePickerPersistence handles date formatting and parsing using date-fns. LoadingElement manages the data-dash-is-loading attribute for CSS styling during component loading states. ResizeDetector provides a debounced ResizeObserver for responsive layout handling. computeSliderMarkers and sliderRendering contain logic for calculating, truncating, and positioning slider marks and dots, including support for reversed sliders and styling marks outside the selected range. dropdownSearch implements optimized search indexing and filtering for dropdown options, including a mechanism to preserve original option order. optionRendering and optionTypes handle the rendering and sanitization of dropdown options, supporting virtualized lists and dynamic label sizing. formatSliderTooltip and sliderTooltip manage the display and transformation of slider tooltip content. Finally, sliderSnapToMark provides logic for snapping slider values to the nearest defined mark.

components/dash-core-components/src/utils · high confidence

The \components/dash-table\ directory has been restructured to establish a modern development environment. This includes adding configuration files for TypeScript (\tsconfig.json\, \tsconfig.base.json\, \tsconfig.lint.json\), ESLint (\.eslintrc.js\), Prettier (\.prettierrc\), and Python linting (\.flake8\, \.pylintrc\). Build and test tooling is now defined via \babel.config.js\, \karma.conf.js\, and \pytest.ini\ (which enforces \xunit1\ JUnit family for CI compatibility). A \dash\_prop\_typing.py\ file was added to generate Python type hints for conditional style props, and a \renovate.json\ file configures automated dependency updates. The directory also now contains standard project metadata files such as \LICENSE\, \README.md\, \CHANGELOG.md\, and \MANIFEST.in\.

components/dash-table · high confidence

The component generation logic has been reorganized into distinct, dedicated modules for Python, R, and Julia, replacing the previous monolithic structure. This change introduces specialized generators (e.g., \\_py\_components\_generation.py\, \\_r\_components\_generation.py\, \\_jl\_components\_generation.py\) that handle language-specific code output, while shared utilities like keyword lists (\\_all\_keywords.py\) and node collection (\\_collect\_nodes.py\) are centralized. This modularization improves maintainability and allows for more precise handling of language-specific requirements, such as Julia's \Project.toml\ generation and R's \DESCRIPTION\ file creation, within the \dash/development\ package.

dash/development · high confidence

The Dash renderer now includes a dedicated styles module that applies specific visual formatting to internal interface elements, such as loading messages and login screens. This change introduces a new TypeScript declaration for the 'cookie' module to support CSRF token parsing and adds a JavaScript styles file defining base typography, button, and layout styles for these core renderer components, ensuring they have a consistent appearance independent of the user's app styling.

dash/dash-renderer/@Types, dash/dash-renderer/src/styles · high confidence

The Dash Table component now supports syntax highlighting for F\# (fsharp), C\# (csharp), and MATLAB (matlab) in addition to the previously supported languages. This change updates the bundled highlight.js configuration to register these three new language definitions, allowing users to display code blocks in these languages with proper visual formatting within the table cells.

components/dash-table/src/third-party · high confidence

The renderer now includes a visual undo/redo toolbar (Toolbar.react.js, Toolbar.css) that appears in the bottom-left corner during development, allowing users to step back and forward through state changes. Additionally, the hot-reload mechanism (Reloader.react.js) has been updated to provide better feedback when reloads fail; specifically, it now displays a persistent alert after a configurable number of retries, helping users identify and fix errors that prevent successful reloading.

dash/dash-renderer/src/components/core · high confidence

The build process for the dash-html-components package has been restructured to use a new set of Node.js scripts that automatically generate React components from MDN HTML specifications. This change introduces scripts to extract HTML attributes and elements, generate the corresponding React component files with correct PropTypes (including support for boolean and numeric prop types), and create the main index export. It also adds an ESLint configuration for the build scripts to allow Node.js module imports and console logging during the generation phase.

components/dash-html-components/scripts · high confidence

The calendar utility components have been completely rewritten to replace the previous moment.js dependency with date-fns, ensuring better performance and smaller bundle size. This change introduces improved localization support by detecting and applying user-preferred locales for month and day labels. Additionally, the calendar now features enhanced accessibility with proper focus management, keyboard navigation (arrow keys, page up/down, home/end), and correct CSS variable capture for portaled content, ensuring consistent styling and behavior when the calendar dropdown is rendered outside its parent container.

components/dash-core-components/src/utils/calendar · high confidence

The dash-core-components package has been restructured, introducing a new set of configuration files including .editorconfig, .eslintignore, .eslintrc, .flake8, .gitignore, .lib.babelrc, .npmrc, and .prettierrc to standardize code quality and build processes. A comprehensive .test\_durations file has been added to track integration test performance across components like DatePickers, Dropdowns, and Graphs, while the CHANGELOG.md has been updated to reflect historical changes up to v1.17.1 and note that future changes are recorded in the main Dash changelog. The package metadata (dash-info.yaml) and documentation (README.md, CONTRIBUTING.md) have been refreshed to align with current development workflows.

components/dash-core-components · high confidence

The \components/dash-table/src/core\ directory has been restructured to introduce a suite of foundational utilities and services for the Dash Table component. This includes a new logging system (\core/Logger\) with configurable debug and log levels, a \Clipboard\ utility for handling copy/paste operations, and a \Stylesheet\ manager for dynamic CSS rule injection. Core logic for data handling has been centralized, featuring new modules for sorting (\core/sorting\), memoization (\core/memoizer\), and caching (\core/cache\). Additionally, the diff adds browser-specific helpers (\core/browser\), a syntax tree parser for filtering queries (\core/syntax-tree\), and various mathematical and generic utility functions (e.g., \arrayZipMap\, \objPropsToCamel\), establishing a robust internal API layer for the table's behavior.

components/dash-table/src/core · high confidence

The @plotly/webpack-dash-dynamic-import plugin now supports Internet Explorer 11 by injecting a shim for \document.currentScript\ that falls back to scanning the script tag stack for non-async, non-inline scripts. This ensures dynamic chunk loading works in older browsers. Additionally, the plugin now prevents JavaScript code from being appended to CSS chunks generated by mini-css-extract-plugin, and includes a new MIT license file.

@plotly/webpack-dash-dynamic-import · high confidence

The \dash/mcp/types\ module now provides the foundational type definitions for the MCP integration, including TypedDicts for callback inputs/outputs (\MCPInput\, \MCPOutput\) and component data (\ComponentPropertyInfo\, \ComponentQueryResult\), as well as a comprehensive set of protocol models (e.g., \Tool\, \Resource\, \Task\) and JSON-RPC error classes. This change consolidates these types into the package, replacing the previous external \mcp\ package dependency with inline protocol definitions to reduce external coupling.

dash/mcp/types · high confidence

This release adds a new performance benchmark harness (benchmarks/scenarios.py) to monitor platform metrics like initial render and patch append times, while internally refactoring the codebase to remove the external mcp package dependency by inlining protocol types (dash/mcp/types/protocol.py) and introducing a new shared storage engine (dash/\_shared\_storage/\_engine.py) with a lower default buffer size. It also centralizes component prop definitions in a new registry (dash/mcp/primitives/tools/prop\_roles.py) to standardize how semantic roles are matched and formatted.

python · high confidence

The Dash renderer now includes formal TypeScript interfaces for callback definitions (including support for background, streaming, and dynamic callbacks) and component properties. This adds static typing for the callback execution lifecycle, payload structures, and the global \dash\_component\_api\ exposed to the browser, improving type safety and developer experience for the renderer's internal logic.

dash/dash-renderer/src/types · high confidence

The application now supports lazy loading for several Dash Core Components, including DatePickerRange, DatePickerSingle, Dropdown, Graph, Markdown, RangeSlider, Slider, and Upload. New loader modules have been added in the \components/dash-core-components/src/utils/LazyLoader\ directory to dynamically import the corresponding component fragments (e.g., \DatePickerRange\, \Dropdown\) only when needed. Additionally, a new loader for \plotly.js\ has been introduced, which dynamically injects the Plotly script from a configurable URL (\window.\_dashPlotlyJSURL\) with a 30-second timeout, ensuring that the visualization library is loaded on demand rather than at initial page load.

components/dash-core-components/src/utils/LazyLoader · high confidence

The Loading component's spinner implementations (Circle, Cube, Default, Dot, and Graph) and their shared type definitions have been migrated from JavaScript to TypeScript. This change improves type safety and developer experience for the internal spinner components without altering the visual behavior or user-facing API of the Loading indicator.

components/dash-core-components/src/fragments/Loading · high confidence

The dcc.Markdown component's underlying rendering engine has been rewritten in TypeScript and updated to use modern markdown libraries, including the addition of the remark-gfm plugin. This enables native support for GitHub Flavored Markdown features such as tables, strikethrough, task lists, and autolinks. The rewrite also refines math rendering (supporting both inline and display modes via MathJax) and improves raw HTML handling by explicitly stripping script and style tags while allowing specific Dash components like dcc.Link within markdown content.

components/dash-core-components/src/utils/markdown · high confidence

The renderer now uses a set of dedicated store observers (documentTitle, executedCallbacks, executingCallbacks, isLoading, prioritizedCallbacks, requestSlot, requestedCallbacks, storedCallbacks, and websocketObserver) to manage the callback lifecycle and UI state. This introduces support for WebSocket-based callbacks, allowing callbacks to be routed over a multiplexed WebSocket transport instead of individual HTTP requests, which reduces connection overhead. The system now enforces a concurrency limit (MAX\_CONCURRENT\_HTTP\_CALLBACKS) for HTTP-based callbacks while exempting clientside, streaming, and WebSocket-routed callbacks from this slot. Callback execution is more robust, with better handling of persistence pruning, patch analysis for efficient DOM updates, and improved error handling. The loading indicator now correctly excludes persistent callbacks. WebSocket connections are managed efficiently, opening lazily when needed and handling disconnection.

dash/dash-renderer/src/observers · high confidence

This change introduces a comprehensive set of new CSS files for Dash Core Components, establishing a unified visual design system. It defines global CSS variables (e.g., --Dash-Fill-Interactive-Strong, --Dash-Spacing) in dcc.css to standardize colors, spacing, and shading across the library. New styles are provided for core components including Button, Input, Textarea, Dropdown, DatePicker, Calendar, Slider, Tabs, Checklist, RadioItems, and Tooltips, ensuring consistent appearance and behavior. The styles also incorporate fixes for third-party libraries like react-dates, react-select, and react-virtualized to ensure compatibility and correct rendering within the new design system.

components/dash-core-components/src/components/css · high confidence

The Dash renderer's state management has been restructured from a monolithic reducer into a modular, component-based architecture. This change introduces dedicated reducers for distinct application concerns—including app lifecycle, callback job tracking, dependency graphs, error handling, and layout history—combined via Redux's \combineReducers\. A new \layoutHashes\ mechanism tracks prop changes using path sums to optimize re-rendering performance, while the \config\ reducer now supports custom HTTP headers and stores children props on the window object for side effects. Additionally, the system now manages callback job states (add, remove, outdated) and exposes lifecycle hooks (pre/post layout, request, callback resolved) to allow for more granular control over the rendering and callback execution flow.

dash/dash-renderer/src/reducers · high confidence

This release introduces significant updates to several Dash Core Components. The Dropdown component has been rebuilt using Radix UI, adding support for virtualized lists to handle large option sets efficiently, enabling search-by-typing without opening the menu, and improving keyboard navigation and accessibility. Date pickers (Single and Range) are now implemented with Radix UI, featuring better portal rendering, focus management, and support for portal modes to prevent clipping in embedded apps. The Graph component now includes xPixel and yPixel coordinates in hover and click events, supports customdata in point events, and handles responsive resizing more robustly. The Markdown component has been rewritten in TypeScript with updated libraries, adding support for GitHub Flavored Markdown (GFM) via the remark-gfm plugin. The Upload component now supports folder uploads when multiple files are selected, preserving folder structure in file names. The Slider component has been refactored to use Radix UI, with improved styling for markers outside the selected range and support for reverse direction.

components/dash-core-components/src/fragments · high confidence

The Dash renderer wrapper has been rewritten to improve rendering performance and reliability. A new \DashContext\ provides \useLoading\ and \isLoading\ hooks for granular loading state tracking, while \DashWrapper\ now uses path-sum hashes to efficiently detect prop changes and avoid unnecessary re-renders. The introduction of \ExternalWrapper\ allows components outside the main layout tree to be managed correctly, and \CheckedComponent\ adds runtime prop-type validation. These changes ensure that component identity changes trigger remounts while prop updates reconcile in place, fixing issues with stale state and performance bottlenecks.

dash/dash-renderer/src/wrapper · high confidence

The codebase now uses dedicated TypeScript modules to manage the lazy loading of highlight.js and MathJax. Syntax highlighting is handled by a new module that explicitly registers a specific set of languages (including bash, csharp, python, sql, and others) via highlight.js, replacing previous generic loading. Math rendering utilizes a new lazy loader that respects a \mathjax\ configuration flag to conditionally load the tex-svg engine, while also checking for an existing global MathJax instance. These changes improve modularity and allow the Dash application to reuse existing global instances of these libraries if they are already present on the page.

components/dash-core-components/src/utils/LazyLoader/third-party · high confidence

The build configuration for the dash-table component has been restructured to improve maintainability and build performance. A new base webpack configuration file centralizes entry points, output settings, and module rules, while a separate preprocessing module standardizes build-time variable definitions. The output library configuration now uses an object format to explicitly define the library name and type. Additionally, filesystem caching has been enabled to speed up subsequent builds, and the jsx-runtime external is now shared and imported from the dash-renderer to ensure compatibility with older Dash versions.

components/dash-table/.config · high confidence

The \dash/dash-renderer/src/actions\ directory has been migrated from JavaScript to TypeScript, introducing a new \Patch\ API that allows callbacks to partially update component props (e.g., \append\, \insert\, \assign\) instead of replacing entire objects, which improves performance and reduces network payload. The callback resolution logic has been optimized to use O(1) lookups for pattern-matching IDs (MATCH/ALL) via a new \objIndex\ in the paths store, and the dependency graph handling has been split into \dependencies.js\ and \dependencies\_ts.ts\ to reduce overhead. Additionally, the API layer now supports configurable CSRF cookie/header names and includes robust JWT retry logic for authentication refresh.

dash/dash-renderer/src/actions · high confidence

The Dash renderer has been merged with DashPy, introducing a unified architecture that supports React 19 (via a compatibility shim), WebSocket callbacks, and a generalized component persistence system. Users can now leverage hooks for layout and request lifecycle events, benefit from improved error handling and prop-type validation, and utilize configurable CSRF tokens. The renderer also supports layout as a list of components, dynamic callbacks, and improved performance for context component re-rendering.

dash/dash-renderer/src · high confidence

The Dash renderer has been restructured to support React 19 and introduce WebSocket-based callbacks. A new compatibility shim ensures backward compatibility with older Dash versions by providing a fallback for the JSX runtime. The build system now includes dedicated workers for WebSocket transport and streaming downlinks, enabling real-time updates. Additionally, the renderer's configuration and build scripts have been updated to support these new capabilities.

dash/dash-renderer · high confidence

MCP tools now generate more precise JSON schemas and detailed parameter descriptions for Dash callback inputs. Schema generation uses a prioritized pipeline: explicit callback type annotations take precedence, followed by component property overrides, component introspection, and pattern-matching detection (producing arrays for ALL/ALLSMALLER and objects for MATCH). Descriptions are assembled from multiple sources, including component property values, docstrings, HTML labels, and pattern-matching context, providing users with clearer guidance on expected inputs and their current states.

_dash/mcp/primitives/tools/input\schemas · high confidence

The base initialization module for the Dash HTML components library has been restructured to remove Python 2/3 compatibility shims and future imports. It now explicitly loads the package version from package-info.json, validates that the Dash framework is correctly installed (checking for plotly\_dash or development attributes), and configures the JavaScript distribution paths to point to the specific versioned release on unpkg.com.

_components/dash-html-components/dash\_html\_components\base · high confidence

MCP tool descriptions are now generated by combining output summaries, optional docstrings, and background-task polling instructions. Users will see clearer, structured descriptions that list what each callback outputs and, for long-running background callbacks, instructions on how to poll for results. Docstrings are disabled by default to prevent exposing sensitive implementation details; they can be enabled globally or per-callback via the new \\mcp\_expose\_docstring\\ flag.

dash/mcp/primitives/tools/descriptions · high confidence

The pre-commit hook in .husky has been updated to execute lint-staged via npx, replacing the previous implementation. This change ensures that staged files are linted before each commit, with the --no-revert flag configured to prevent automatic reverting of changes if linting fails.

.husky · high confidence

The dash-html-components build process has been updated to support React 19 and ensure backward compatibility with older versions of Dash. This is achieved by externalizing the JSX runtime via a shared configuration and adjusting the webpack output library settings. Additionally, the project now uses the minified plotly.js distribution and enforces stricter linting rules to improve code quality and consistency.

components/dash-html-components · high confidence

Added TypeScript component test fixtures; Added backend integration and regression tests; Added comprehensive test suite for background callbacks; Added integration and unit tests for dash-html-components; Added integration test assets for clientside callbacks; Added integration test for dcc.Tooltip behavior; Added integration tests for @mcp\_enabled decorator functionality; Added integration tests for Dash Core Components; Added integration tests for Dash DevTools; Added integration tests for Dash Tabs component behavior; Added integration tests for Dash import consistency; Added integration tests for French locale support in DatePicker; Added integration tests for Location component navigation and callbacks; Added integration tests for XSS and URL injection protections; Added integration tests for asset filtering and external resource attributes; Added integration tests for async and background callbacks; Added integration tests for clientside callbacks; Added integration tests for dcc.Link component; Added integration tests for dcc.Upload component behavior; Added integration tests for multi-page layout, ordering, and path handling; Added integration tests for multi-page routing and page registration; Added integration tests for option title attributes; Added integration tests for the Geolocation component; Added test asset styles for input and tab components; Added test assets for Dash callback grouping and standard app patterns; Added test assets for dash integration tests; Added test assets for upload component integration tests; Added test coverage for renderer internals and streaming transport; Added test fixtures for asset path ignore functionality; Added test infrastructure and CI safety nets; Added test infrastructure for Dash Core Components; Added tests for shared storage backends and streaming integration; Added tests for streaming callback functionality; Added type-compliance tests for Dash callbacks; Added unit tests for Dash MCP tool integration; Added unit tests for Dash Pages configuration and path inference; Added unit tests for Dash Table clipboard, query syntax, and date handling; Added unit tests for MCP resource providers; Added unit tests for MCP server configuration, session management, and tool dispatch; Added unit tests for Markdown text utility functions; Added unit tests for component generation and metadata handling; Added unit tests for library grouping, validation, and serialization; Added unit tests for slider mark density logic; Added unit tests for the new Calendar component implementation; Expanded integration test coverage for Dash Graph component; Expanded integration test coverage for the Dash renderer; Expanded unit test coverage for Dash core features; Initial release of dash.testing integration test framework; Integration tests for dcc.Markdown component; Integration tests for the MCP server feature; New integration test suite for Dash core features; Test components now support nested artifacts and arbitrary file extensions.

Added package.json and package-lock.json (or yarn.lock) files for several internal development and test packages, including @plotly/dash-component-plugins, the dash-generator-test-component suites (standard, nested, typescript), @plotly/dash-jupyterlab, and @plotly/dash-test-components. These files establish the build toolchain (Webpack, Babel, TypeScript, Jest) and runtime dependencies (React 16, prop-types) required to build and test these internal components.

(dependencies) · high confidence

Added placeholder files for Dash component directories; New development tooling and configuration files.

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

• First survey — no prior run to compare against. CAI 40.

• Code Health 75
• Architecture 65
• Maturity 40
• Readiness 56
• Security 57
• Accessibility 29

• 300 commits — 209 feature/other, 91 fixes

• (repo) — 115 commits
• (root) — 35 commits
• dash/dash-renderer — 32 commits
• components/dash-core-components — 28 commits
• dash/backends — 15 commits
• dash/_shared_storage — 13 commits
• tests/integration — 7 commits
• tests/unit — 6 commits
• .github/workflows — 5 commits
• .ai/ARCHITECTURE.md — 4 commits
• dash/_stream_hub.py — 3 commits
• dash/testing — 3 commits
• requirements/ci.txt — 3 commits
• .ai/PERFORMANCE.md — 2 commits
• .github/dependabot.yml — 2 commits
• @plotly/dash-component-plugins — 2 commits
• components/dash-html-components — 2 commits
• components/dash-table — 2 commits
• dash/_callback.py — 2 commits
• dash/extract-meta.js — 2 commits

• fix: Apply prettier formatting to renderer append-perf fix
• fix: Extend Patch append perf fix to nested and non-tail locations
• fix: Fix ActionChains offsets for selenium 4.3+ center-origin change
• fix: Fix Ctrl+C and restart handling for streaming callbacks on FastAPI
• fix: Fix Ctrl+C hang with active streaming downlink on Flask
• fix: Fix FastAPI startup crash: replace removed add_event_handler
• fix: Fix Flask-WTF/Quart-WTF CSRF exemptions broken by backend refactor
• fix: Fix O(total) Patch().append() slowdown into a growing container
• fix: Fix arb008 stale-element-on-click race
• fix: Fix callbacks double-registered when app file is loaded by import string
• fix: Fix ddso002 dropped-keystroke race in dropdown keyboard nav
• fix: Fix dev CI after the pip dependency bump
• fix: Fix error exposed by MCP server when chrome not available for kaleido
• fix: Fix flaky callback-count tests with deterministic keystroke gating
• fix: Fix flaky grbs007 clickData race; mark dvcv003 flaky
• fix: Fix multiple file drag-and-drop in dcc.Upload
• fix: Fix mypy errors in shared-storage typing compliance
• fix: Fix mypy int|None type error in ChunkedStore.put_batch flush loop
• fix: Fix mypy typing errors in shared-storage async client poll
• fix: Fix number input spinner when only min is set
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

plotly/dash 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.