perspective-dev/perspective

This system is a high-performance, cross-platform data visualization engine that renders interactive tables, charts, and dashboards for large datasets. It provides a unified core written in Rust and compiled to WebAssembly, exposing native bindings for JavaScript, Python, and Rust to enable real-time data streaming and manipulation. The platform supports extensive integration via virtual servers for databases like DuckDB and PostgreSQL, and offers embeddable components for React, Jupyter, and VS Code environments.

69 changes.

The project underwent a comprehensive migration of its core components, including the viewer, client, and server, from JavaScript and C++ to Rust. This period established a unified pnpm monorepo structure and introduced native Python bindings, replacing previous build tooling and language implementations. The work focused on rebuilding the visualization engine and data handling infrastructure to improve performance and type safety across all supported platforms.

66 changes.

This period focused on expanding data connectivity through a new Rust-based Virtual Server architecture, enabling direct integration with databases like DuckDB, ClickHouse, and PostgreSQL. The project simultaneously modernized its development ecosystem by introducing a CMake build system, comprehensive CLI and JupyterLab extensions, and a new React package. Significant effort was also directed toward enhancing the viewer with WebGL charting, TypeScript migration, and robust Playwright-based testing.

New Virtual Server handlers for ClickHouse and DuckDB are now available, enabling users to connect Perspective to these specific database engines. These implementations provide database-specific support for window aggregates (such as \sum\, \avg\, \lag\, \lead\, and ranking functions), string filter operations (including \contains\, \matches\, and \LIKE\ variants), and type mapping from database schemas to Perspective column types.

_rust/perspective-js/src/ts/virtual\servers · high confidence

Introduces a new \@perspective-dev/anywidget\ package that bundles the Perspective viewer for use in Python environments like VS Code and Jupyter. The build process compiles the JavaScript entry point and CSS into static assets within the Python package, while the widget implementation handles bidirectional synchronization of persistent attributes (such as \split\_rollup\_mode\, \group\_by\, and \plugin\_config\) between the Python model and the browser-based viewer.

packages/anywidget · high confidence

New handler classes are introduced in the \perspective-python\ package to enable server-side Perspective integration with popular Python web frameworks. \PerspectiveTornadoHandler\ allows Tornado applications to proxy WebSocket messages to a Perspective server, supporting custom event loops and executors for large payloads. \PerspectiveAIOHTTPHandler\ and \PerspectiveStarletteHandler\ provide similar drop-in WebSocket support for aiohttp and Starlette (FastAPI) applications, respectively. These handlers facilitate real-time data visualization by bridging JavaScript front-ends with Python-based data processing.

rust/perspective-python/perspective/handlers · high confidence

The \examples/python-tornado\ directory now includes a complete Tornado server example (\server.py\) that serves static assets and handles WebSocket connections for the Perspective viewer. This example demonstrates three integration modes: a basic client/server replicated setup (\index.html\), a server-only mode (\server\_mode.html\), and a new collaborative editing mode (\client\_server\_editing.html\) that synchronizes cell edits between multiple clients and the server in real time.

examples/python-tornado · high confidence

A new example project has been added to the \examples/vite-example\ directory, demonstrating how to integrate Perspective with the Vite build tool. This example includes a Vite configuration targeting ESNext, an HTML entry point, and source files that initialize the Perspective server and client WASM modules, load a sample Arrow dataset, and render the viewer component.

examples/vite-example · high confidence

A new example project demonstrates how to bundle Perspective components using esbuild. It includes a build configuration that handles WebAssembly and Arrow file assets, and a sample application that initializes the Perspective server and client WASM modules, loads the Superstore dataset, and renders a viewer component.

examples/esbuild-example · high confidence

A new example application demonstrating a Perspective virtual server connected to a ClickHouse database has been added to the examples directory. This example uses esbuild for bundling and includes a simple HTTP server to serve the static assets. The application initializes the Perspective client and server WASM modules, connects to a local ClickHouse instance via the @clickhouse/client-web library, and loads the data into a perspective-viewer component using a ClickhouseHandler.

examples/esbuild-clickhouse-virtual, examples/esbuild-duckdb-virtual · high confidence

A new example demonstrating how to use Perspective with esbuild and remote server-side tables has been added to the \examples/esbuild-remote/client\ directory. This example includes the necessary HTML, CSS, and JavaScript files to initialize the Perspective viewer, load WASM modules, and connect to a remote server via WebSocket to display a table hosted on the server.

examples/esbuild-remote/client · high confidence

A new benchmarking infrastructure has been added for the perspective-python runtime, allowing developers to measure performance across different versions (from 2.2.0 through master). The suite includes Python scripts to run benchmarks against a Superstore dataset, covering table creation (Arrow, CSV), view generation with various pivot configurations, and data export formats. It also provides HTML interfaces to visualize benchmark results locally or via a hosted WebSocket connection.

rust/perspective-python/bench · high confidence

A new webpack-based example project has been added to demonstrate how to integrate Perspective into a build pipeline. The example uses the \@perspective-dev\ namespace for its viewer, client, and plugin imports, loads the superstore dataset via Arrow, and configures webpack to handle CSS, WASM files, and Arrow data.

examples/webpack-example · high confidence

Developers can now use the provided devcontainer setup to quickly spin up a consistent development environment. The configuration installs essential tools including Rust, pnpm, and cmake, and runs a post-create script to set up the repository dependencies via pnpm.

.devcontainer · high confidence

A new example named \esbuild-remote\ has been added to the examples directory, including a \build.js\ script that uses esbuild to bundle the client application into an ESM format targeting ES2022, handling specific file loaders for fonts, Arrow data, and WebAssembly, and copying the HTML output to the dist folder.

examples/esbuild-remote · high confidence

A new HTML template (\exported\_widget.html.template\) is introduced to support exporting Perspective views as standalone, self-contained widgets. This template embeds the necessary Perspective JavaScript modules, loads Arrow data from a base64-encoded script tag, initializes a worker, and restores the viewer state, enabling users to share or embed interactive data visualizations independently of the main application.

rust/perspective-python/perspective/templates · high confidence

A new Rust-based metadata tool has been added to the build process to automatically generate TypeScript type bindings for the JavaScript and viewer packages, as well as ExprTK documentation and Python license files. This ensures that type definitions and documentation stay synchronized with the underlying Rust configuration and API structures without manual intervention.

rust/metadata · high confidence

The Generic SQL model implementation has been updated to generate SQL queries that include window functions (such as \sum\, \avg\, \rank\, \lag\, etc.) and handle complex view configurations involving \group\_by\, \split\_by\, and sorting. This allows users to perform advanced aggregations and ordered calculations directly through the virtual server, with specific logic to handle \ROLLUP\ grouping, pivot operations, and sort ordering within grouped contexts.

_rust/perspective-client/src/rust/virtual\_server/generic\_sql\model · high confidence

This change introduces the \@perspective-dev/jupyterlab\ package, a pure JupyterLab plugin that registers Perspective as a viewer for \.csv\, \.json\, and \.arrow\ files directly in the JupyterLab file browser. The extension lazy-loads the Perspective runtime from \@perspective-dev/anywidget\ upon opening a file, allowing charts to be in-lined in notebooks without requiring ipywidgets or a separate \PerspectiveWidget\. The package includes build scripts (\build.mjs\, \clean.mjs\) to bundle the extension and copy it into the \perspective-python\ wheel, along with documentation and integration tests.

packages/jupyterlab · high confidence

The \@perspective-dev/viewer-datagrid\ package is now available, providing a virtual-scrolling, editable data grid and pivot table plugin for the \\<perspective-viewer\>\ component. Built on \regular-table\, it enables smooth rendering of large datasets (including millions of rows) with features such as row/column pivoting, live streaming updates, per-column formatting, conditional styling, cell editing, and selection. This entry covers the package's source structure, TypeScript conversion, build configuration, and documentation.

packages/viewer-datagrid · high confidence

This change adds the \@perspective-dev/react\ package, providing a declarative \\<PerspectiveViewer\>\ React component that wraps the underlying \\<perspective-viewer\>\ custom element. The component manages the imperative lifecycle (load, restore, delete) of the viewer and exposes props for data sources (\client\), declarative configuration (\config\), and user interaction events (\onClick\, \onSelect\). The package includes build scripts, TypeScript configuration, and documentation to support integration with the Perspective analytics engine.

packages/react · high confidence

The \packages/cli\ directory now provides a command-line interface for Perspective.js, enabling users to convert data files between formats (Arrow, CSV, JSON, columns) and host a local web server to visualize data. The CLI includes a \convert\ command for format transformation and a \host\ command that serves a web interface using the Perspective viewer, with support for opening the browser automatically. This change adds the core CLI implementation, utility functions, and associated tests, while removing D3FC dependencies.

packages/cli · high confidence

The \perspective-python\ package now includes a \PerspectiveWidget\ class, enabling users to render interactive Perspective visualizations directly within JupyterLab and Jupyter Notebook environments. This widget extends the functionality of the standard \PerspectiveViewer\ and supports both synchronous and asynchronous data tables, allowing for real-time updates and transformations of datasets such as Pandas DataFrames, JSON, or CSV files within the notebook interface.

rust/perspective-python/perspective/widget · high confidence

Added a new Rust-based Virtual Server implementation that allows Perspective to connect to custom data backends via a pluggable handler trait. This change introduces the core server logic, a generic SQL model for generating dialect-specific queries, and support for Arrow IPC data transfer, enabling users to integrate external data sources like DuckDB, Postgres, and ClickHouse with full view and aggregation capabilities.

_rust/perspective-client/src/rust/virtual\server · high confidence

This change adds the \perspective-client\ Rust crate, providing the core asynchronous client implementation for connecting to a Perspective server. It introduces the \Client\ and \Session\ types for managing connections, along with \Table\ and \View\ abstractions for data manipulation and querying. The library supports multiple data ingestion formats (CSV, JSON, Arrow, NDJSON) and includes features like on-disk storage, table joining, and configurable update modes, serving as the foundation for higher-level bindings in JavaScript and Python.

rust/perspective-client/src/rust · high confidence

The \perspective-python\ package now uses a new Rust implementation (replacing the previous C++ bindings) to expose the Perspective client and server to Python. This change introduces a comprehensive API including synchronous and asynchronous clients (\Client\, \AsyncClient\), tables, views, and sessions, along with new capabilities such as Virtual Servers and generic SQL models. Users gain access to native async support via \pyo3\ and improved performance through the Rust-based core.

rust/perspective-python/src · high confidence

The perspective-server crate now provides a Rust-native server implementation that wraps the underlying C++ logic via FFI, enabling in-process communication between a Rust client and the server through LocalClient and LocalSession. This change introduces a new threading and conflation model, allowing users to create sessions with custom response handlers or closures, and supports polling for updates with configurable CPU thread counts. The build system has been updated to use Rust's build.rs for CMake integration, supporting both wasm32 and wasm64 targets, and includes cleanup scripts for build artifacts.

rust/perspective-server · high confidence

The \perspective-python\ package is now available as a single distribution that bundles the streaming query engine, the \PerspectiveWidget\ for Jupyter/VS Code notebooks, and WebSocket handlers for Tornado, Starlette, and aiohttp. This replaces the previous split between C++ and Rust bindings, allowing users to install the full suite via \pip install perspective-python\ and enabling features like virtual servers against DuckDB and ClickHouse.

rust/perspective-python · high confidence

This change adds the \perspective-python\ package (version 5.5.1), providing Python language bindings for the Perspective data visualization engine. The module exposes core classes including \Server\, \Client\, \Table\, \View\, and \AsyncClient\, enabling users to create tables from Pandas DataFrames, Polars DataFrames, NumPy arrays, and Apache Arrow bytes. It also includes a JupyterLab widget (\PerspectiveWidget\) and WebSocket handlers for Tornado, AIOHTTP, and Starlette/FastAPI, allowing Perspective to be hosted on server-side Python systems for interactive web-based visualization.

rust/perspective-python/perspective · high confidence

The viewer now supports master/detail relationships where selecting data in a master panel filters the details across the workspace. Users can toggle panels between master and detail roles, and the global filter bar displays active filters with the ability to remove or clear them. The component also introduces a new menu for creating panels, including duplicating existing ones or creating new ones from specific clients and tables, along with improved panel closing and restoration logic.

rust/perspective-viewer/src/rust/components/viewer · high confidence

The viewer now includes a built-in AI agent chat interface that allows users to interact with LLMs to analyze data and modify the view. This feature supports both remote OpenAI-compatible APIs and local in-page engines (such as WebLLM), enabling streaming responses with real-time progress updates. The agent can execute tools to manipulate the visualization (e.g., adding filters, changing views) and includes a local BM25 search engine to retrieve relevant documentation context for the conversation. Markdown rendering is handled by a custom, lightweight parser to display agent responses efficiently.

rust/perspective-viewer/src/rust/components · high confidence

The \rust/perspective-server/cpp\ location now includes a complete CMake build system (CMakeLists.txt) and development tooling configuration (.clangd.in) for the C++ component of the perspective-server. This change introduces build options for WASM and native C++ targets, enforces C++17, and configures platform-specific settings for Windows, macOS, and Linux. It also adds patches to fix compatibility issues with the Arrow library on Emscripten and macOS, and establishes a CMake build for protobuf generation, enabling the C++ code to be compiled and integrated into the Rust-based server.

rust/perspective-server/cpp · high confidence

Added a new example in the examples/cdn directory that demonstrates using Perspective via CDN links without a server-side component. The example loads the Perspective viewer, charts, and datagrid modules directly from node\_modules, fetches superstore Arrow data, and enables runtime editability (edit\_mode: EDIT) within the browser session. A simple Node.js server script (server.mjs) is also included to serve the static assets and provide WebSocket support for the Perspective client.

examples/cdn · high confidence

The build system now includes new CMake modules in the perspective-server directory to streamline dependency resolution and development environment setup. These additions provide automated finding and configuration for key libraries including ExprTk, RE2, and Protobuf (with automatic protoc download and version checking), as well as a helper for building bundled dependencies like Arrow and RapidJSON. Additionally, new modules configure Clangd for IDE integration and support LLVM toolchains, improving the developer experience for C++ code within the Rust workspace.

rust/perspective-server/cmake/modules · high confidence

The viewer now supports a new theming system built on CSS variables, introducing several new dark and light themes including Blueprint, Dracula, Botanical, Eggplant, Gruvbox Dark, and Gruvbox Light. These themes provide distinct visual styles for the interface, datagrids, charts, and code editors, allowing users to customize the appearance of the Perspective viewer to their preference.

rust/perspective-viewer/src/themes · high confidence

The JupyterLab package now includes a new extension that integrates the Perspective viewer directly into the JupyterLab interface. This allows users to open CSV, JSON, and Arrow files as interactive, live-updating data tables within the notebook environment. The extension handles lazy-loading of the Perspective runtime, manages document widgets for these file types, and automatically applies the current JupyterLab theme (Pro Light/Pro Dark) to the viewer. It also supports bidirectional updates, where changes made in the viewer can be saved back to the source file.

packages/jupyterlab/src · high confidence

This change introduces the \PerspectiveViewer\ Python class, located in \perspective/widget/viewer\, which serves as the backend component for the Perspective Jupyter/Python widget. It exposes a configuration API allowing users to define view settings such as \group\_by\, \split\_by\, \aggregates\, \sort\, \filter\, and \expressions\ directly in Python. The viewer synchronizes these state attributes with the frontend via traitlets, supporting both synchronous \Table\ and asynchronous \AsyncTable\ data sources, and enables features like persistent configuration saving and restoration.

rust/perspective-python/perspective/widget/viewer · high confidence

The \perspective-python\ client has been restructured to provide both synchronous and asynchronous Python APIs. The new \AsyncClient\ enables integration with Python event loops like \asyncio\, while the synchronous \Client\ wraps it for standard script usage. This change also adds native support for Polars DataFrames and LazyFrames, allowing users to pass Polars objects directly to Perspective tables alongside existing support for Pandas and PyArrow.

rust/perspective-python/src/client · high confidence

Added example applications demonstrating how to use Perspective's virtual server capabilities with DuckDB and ClickHouse. The DuckDB example (\examples/python-duckdb-virtual\) loads a Parquet file into an in-memory database and serves it via a Tornado server, while the ClickHouse example (\examples/python-clickhouse-virtual\) connects to a local ClickHouse instance, maps Arrow types to ClickHouse types, and serves the data. Both examples include the necessary frontend HTML and backend Python scripts to run the virtual server integration.

examples/python-duckdb-virtual · high confidence

This change introduces a new server module in \perspective-python\ that exposes synchronous and asynchronous server and session classes (\Server\, \AsyncServer\, \PySession\, \PyAsyncSession\) to Python, enabling users to host Perspective data via custom handlers. It also adds \GenericSQLVirtualServerModel\ and \virtual\_server\_sync\ support, allowing Python code to define virtual server backends (such as DuckDB or Clickhouse) that serve data on-demand through SQL queries, with methods for describing tables, managing views, and retrieving data slices.

rust/perspective-python/src/server · high confidence

Added a new example application in the \examples/python-postgres-virtual\ directory that demonstrates connecting the Perspective viewer to a PostgreSQL database using a virtual server. The Python backend (\server.py\) uses Tornado to serve the frontend and \psycopg\ to load sample data from a Parquet file into a local Postgres instance, while the HTML frontend (\index.html\) connects to the WebSocket endpoint to visualize the \public.superstore\ table.

examples/python-postgres-virtual · high confidence

This change introduces the \@perspective-dev/react\ package, providing a declarative \PerspectiveViewer\ component that wraps the underlying \\<perspective-viewer\>\ web component. For React users, this allows managing the viewer's lifecycle—loading data via the \client\ prop, applying configuration updates, and handling user interactions like clicks and selections—entirely through standard React props and state, rather than imperative DOM manipulation.

packages/react/src · high confidence

The \examples/react-example\ directory now provides a complete, buildable React application demonstrating the new \@perspective-dev/react\ bindings. The example uses esbuild for bundling (configured in \build.js\) and TypeScript (configured in \tsconfig.json\) to render multiple \\<PerspectiveViewer\>\ components, including a multi-panel workspace layout, within a React application.

examples/react-example · high confidence

The \rust/js\ module now includes Rust bindings for the Clipboard API, IntersectionObserver, ResizeObserver, and the \regular-layout\ custom element, enabling the viewer to handle clipboard operations, detect visibility/resizing, and manage panel layout via the \regular-layout\ engine.

rust/perspective-viewer/src/rust/js · high confidence

A new \perspective\ Rust crate has been introduced, providing a unified library that re-exports the existing client and server components. This crate adds optional Axum-based WebSocket handlers (enabled via the \axum-ws\ feature), allowing users to integrate Perspective's data processing capabilities directly into Axum web applications. The implementation includes a local session handler for standard server usage and a virtual server handler for custom integration, along with a build script (\build.mjs\) that configures Cargo builds for various platforms, including manylinux compatibility.

rust/perspective · high confidence

The \perspective-client\ crate has been introduced, providing a Rust implementation for client-side interactions with the Perspective engine. This change establishes a new communication layer using \perspective.proto\ and \prost\_build\ to generate strongly-typed Rust bindings from Protocol Buffer definitions. For users, this means a new, native Rust API is now available for managing tables, views, and data updates, replacing or supplementing previous JavaScript-centric or ad-hoc communication methods with a structured, compile-time verified client interface.

rust/perspective-client · high confidence

The \rust/perspective-client/src/rust/utils\ directory now includes new utility modules that support the Rust client implementation. The \clone\ module provides \clone!\ and \asyncfn!\ macros to simplify capturing variables in async closures, while the \logging\ module implements custom \Display\ traits for \Request\ and \Response\ types to redact sensitive data in logs. Additionally, a comprehensive \ClientError\ enum is introduced to standardize error handling, and helper utilities like \IDGen\ for unique ID generation and a custom \RandomSequence\ are added to support client operations.

rust/perspective-client/src/rust/utils · high confidence

The \rust/perspective-client/src/rust/config\ directory now contains the Rust implementation for view configuration and data type definitions. This includes \ViewConfig\ and \ViewConfigUpdate\ structs that manage grouping, splitting, sorting, filtering, expressions, and window functions, along with dedicated modules for aggregates, column types, filters, sort directions, and window specifications. These types provide the serialization and deserialization logic required to translate between the Rust client and the underlying protocol buffers.

rust/perspective-client/src/rust/config · high confidence

The \rust/perspective-viewer/src/rust/queries\ module introduces a new read-only query layer that centralizes data-fetching and configuration logic for the viewer. This change adds utilities for exporting data in multiple formats (Arrow, CSV, JSON, NDJSON), retrieving column statistics and values, validating expressions, and managing column configuration schemas. It also includes helpers for generating standalone HTML export apps and resolving CSS palette sets across the workspace, providing a structured foundation for viewer interactions without mutating engine state.

rust/perspective-viewer/src/rust/queries · high confidence

The \rust/perspective-viewer/src/rust/utils\ module has been introduced, providing a suite of internal helpers that underpin the viewer's rendering, styling, and interaction logic. This includes a \DebounceMutex\ to coalesce and serialize rendering tasks, an \EffectLedger\ to track in-flight UI effects, and utilities for CSS variable management, color/gradient parsing, and datetime formatting. It also adds support for the browser's Local Font Access API, robust pub/sub messaging, and helpers for registering Web Components and positioning modals, forming the foundational layer for the viewer's UI behavior.

rust/perspective-viewer/src/rust/utils · high confidence

The JavaScript client library now uses a new Rust implementation (in \rust/perspective-js/src/rust\) to expose core data structures and operations to the browser and Node.js. This change introduces WASM bindings for the \Client\, \Table\, \View\, and \ProxySession\ objects, allowing users to interact with Perspective's data engine via a modern async API. It also adds support for typed arrays in view data retrieval, enabling zero-copy access to column data for better performance, and provides a \VirtualServerHandler\ interface for connecting to custom data sources like DuckDB.

rust/perspective-js/src/rust · high confidence

Added a new example in \examples/rust-axum\ that demonstrates a Rust backend using the Axum web framework to serve a Perspective.js frontend. The example includes a \main.rs\ server that loads Apache Arrow data into a Perspective table and exposes it via a WebSocket endpoint at \/ws\, alongside an \index.html\ client that connects to this server to render the data in a \perspective-viewer\ component.

examples/rust-axum · high confidence

Added example implementations for serving Perspective in Python web applications using Starlette (with FastAPI) and aiohttp. These examples demonstrate how to integrate the Perspective server with these frameworks, including WebSocket handling for real-time data updates and static file serving for the frontend assets.

examples/python-starlette · high confidence

The viewer now includes Sunburst and Treemap charts, both of which use WebGL for rendering and support faceted views, drill-down interactions, and breadcrumb navigation. These charts are built on a shared tree-storage and streaming pipeline, allowing them to handle large datasets efficiently through level-of-detail filtering.

packages/viewer-charts/src/ts/charts/sunburst, packages/viewer-charts/src/ts/charts/treemap · high confidence

Added a new Python/Tornado example that demonstrates streaming data updates via WebSocket. The server implementation introduces an \on\_poll\_request\ callback to optimize performance by deferring overlapping table updates using a thread pool and lock, ensuring efficient handling of high-frequency data streams.

examples/python-tornado-streaming · high confidence

The \perspective-viewer\ crate now exposes a dedicated TypeScript API layer (\bootstrap.ts\, \plugin.ts\, \extensions.ts\) to support external WebAssembly projects and plugin development. This change introduces a new \init\_client\ function for bootstrapping the viewer, a formalized \IPerspectiveViewerPlugin\ interface with a defined lifecycle (\draw\, \update\, \restyle\, \restore\), and a plugin registry system. It also adds LLM provider presets (\providers.ts\) for agent configuration and a shared \column-format.ts\ module to ensure consistent number and date formatting across viewer plugins.

rust/perspective-viewer/src/ts · high confidence

The \perspective.virtual\_servers\ module now includes concrete implementations for connecting to external data sources via the Virtual Server API. This release adds handlers for DuckDB, ClickHouse, Polars, and PostgreSQL, each exposing their respective capabilities (such as specific aggregates, window functions, and filter operations) to the Perspective UI. These handlers allow users to query live data from these backends directly within the visualization interface, supporting features like grouping, sorting, and expressions as defined by each source's specific feature set.

_rust/perspective-python/perspective/virtual\servers · high confidence

The \@perspective-dev/viewer-charts\ package introduces a new set of WebGL-accelerated charting plugins for the \\<perspective-viewer\>\ component, enabling interactive rendering of large and streaming datasets. Users can now visualize data using X Bar, Y Bar, Y Line, Y Area, Y Scatter, X/Y Scatter, X/Y Line, Heatmap, Treemap, Sunburst, Candlestick, OHLC, and tile-based Map Scatter, Map Line, and Map Density charts. These charts redraw incrementally as the underlying Table updates in real time and share the same pivot, filter, sort, and expression configuration as the data grid. The package includes build tooling for bundling and minification of GLSL shaders and CSS, and registers itself as a plugin to be imported alongside the core viewer.

packages/viewer-charts · high confidence

The \packages/viewer-charts/src/ts/charts/cartesian/glyphs\ directory now includes new implementations for density, line, and point glyphs, replacing or supplementing previous rendering logic with WebGL-based rendering. The density glyph supports multiple color modes (density, mean, extreme, signed) and uses multi-render-target (MRT) or fallback accumulation for performance. The line glyph renders instanced polylines per series, and the point glyph renders individual points with size and color driven by data values. These changes enable more performant and flexible visualizations for cartesian charts.

packages/viewer-charts/src/ts/charts/cartesian/glyphs · high confidence

The \tools/bench\ directory now includes a comprehensive benchmarking suite to measure and track performance across different versions of the Perspective library. This suite introduces new test cases for chart rendering (including Y Line, Y Bar, Heatmap, Treemap, and Candlestick), window functions (cumulative sum, simple moving average), and data export operations (to\_arrow, to\_csv, to\_columns). It supports cross-platform testing via Node.js, Python, and browser-based execution using Playwright and Puppeteer, allowing developers to compare performance across multiple library versions and environments.

tools/bench · high confidence

The \rust/perspective-viewer/src/rust/utils/browser\ module now includes new utilities to support richer browser interactions. A new \AsBlob\ trait standardizes conversions of JavaScript types (ArrayBuffer, JsValue, String, Object) to \web\_sys::Blob\, enabling consistent data handling for downloads and clipboard actions. A \download\ function allows triggering browser download popups from Rust code. Drag-and-drop support is introduced via \DragTarget\ and \DragEffect\ enums, defining targets like GroupBy, SplitBy, and Window functions. Additionally, async wrappers for browser timing APIs (\requestAnimationFrame\, \set\_timeout\, \queueMicrotask\, and DOM load events) are provided to facilitate smoother UI updates and event handling in the WASM environment.

rust/perspective-viewer/src/rust/utils/browser · high confidence

The \tools/scripts\ directory has been refactored to include a comprehensive suite of new Node.js-based utility scripts for managing the project's build lifecycle. These scripts provide standardized commands for setting up the environment (\setup.mjs\), building components (\build.mjs\), running benchmarks (\bench.mjs\), and cleaning artifacts (\clean.mjs\). The tooling also automates the installation and management of critical native toolchains, including Emscripten (\install\_emsdk.mjs\), LLVM (\install\_llvm.mjs\), Binaryen (\install\_binaryen.mjs\), and Pyodide (\install\_pyodide.mjs\), ensuring consistent development environments across platforms. Additionally, the suite introduces robust linting capabilities (\lint.mjs\, \lint\_headers.mjs\) that enforce code style and license headers, a pre-push hook (\prepush.mjs\) for DCO compliance, and a release publishing workflow (\publish.mjs\) that handles asset distribution to npm, PyPI, and crates.io.

tools/scripts · high confidence

The \@perspective-dev/esbuild-plugin\ is now available to help applications bundle Perspective with esbuild. It automatically handles Web Worker compilation, allowing developers to choose between embedding the worker source as a Blob URL (default, for production) or emitting it as a separate file with source maps (for debugging). The plugin also manages WebAssembly (WASM) loading, supporting both inline binary embedding and external file fetching, and includes utilities for resolving module aliases and handling AMD dependencies.

tools/esbuild-plugin · high confidence

Added a new server-side example in \examples/esbuild-remote/server\ that demonstrates real-time data visualization using Node.js. The server (\index.mjs\) serves static files and manages WebSocket connections to stream Perspective protocol messages to clients. The accompanying \securities.mjs\ module generates mock financial data (securities and clients) and provides a table that can be updated either dynamically or from a pre-cached Arrow buffer, allowing users to test high-frequency updates over a remote connection.

examples/esbuild-remote/server · high confidence

This change introduces the core TypeScript infrastructure for the new Perspective architecture in the \rust/perspective-js/src/ts\ directory. It adds \perspective-server.worker.ts\ to handle session management and polling within Web Workers, and \virtual\_server.ts\ to provide the API for implementing custom data sources (like DuckDB or Clickhouse) via the VirtualServer pattern. Additionally, \perspective.node.ts\ adds Node.js support with synchronous disk I/O bridging, \perspective.browser.ts\ and \perspective.cdn.ts\ implement the new dual-bitness (wasm32/wasm64) server initialization logic, and \websocket.ts\ provides a new transport layer for connecting to remote Perspective clients.

rust/perspective-js/src/ts · high confidence

The Perspective JavaScript client has been restructured into a modular, unbundled architecture that supports connecting to the WASM engine via Web Workers (including SharedWorker and ServiceWorker) or WebSocket. New files in this location implement the core runtime: \browser.ts\ handles worker and websocket connections, \engine.ts\ manages the server-side polling and session lifecycle, \emscripten\_api.ts\ and \perspective-server.poly.ts\ provide the Emscripten runtime and OPFS-based disk bridging, and \cdn.ts\ assists in resolving WASM binary URLs. This change enables better performance through off-main-thread execution and allows the client to run in environments without traditional worker support by falling back to WebSocket or handling errors gracefully.

rust/perspective-js/src/ts/wasm · high confidence

The C++ header files for the Perspective core library (including aggregate implementations, Arrow I/O, column storage, and binding utilities) have been relocated to the \rust/perspective-server/cpp/perspective/src/include\ directory. This change reorganizes the source tree to better align the C++ component with the Rust-based \perspective-server\ crate, establishing a new location for the public C++ API headers used by language bindings.

rust/perspective-server/cpp/perspective/src/include · high confidence

The C++ source files for the perspective-server core (including aggregation, Arrow I/O, sorting, and base utilities) have been moved into the \rust/perspective-server/cpp/perspective/src/cpp\ directory. This change reorganizes the existing C++ implementation within the Rust crate structure without altering the public API or user-facing behavior.

rust/perspective-server/cpp/perspective/src/cpp · high confidence

The \@perspective-dev/viewer\ package has been moved into the \rust/perspective-viewer\ directory and re-architected to use a Rust-based build pipeline. The build process now compiles the underlying WASM via \cargo bundle\ and bundles the JavaScript/TypeScript sources using esbuild, replacing previous tooling. CSS theming is handled by Lightning CSS, enabling a new set of themes (including Gruvbox, Dracula, and Nord) and internationalization support. The package now ships as a framework-free Web Component with explicit ESM and CDN distribution targets, and includes generated TypeScript declaration files for better integration.

rust/perspective-viewer · high confidence

The build configuration for the perspective-server crate has been updated to fetch C++ libraries (Boost, pybind11, Arrow, date, exprtk, hopscotch-map, ordered-map, protobuf, rapidjson, and re2) via CMake ExternalProject commands rather than relying on pre-existing system installations or submodules. This change ensures that the build process automatically retrieves specific versions of these dependencies during compilation, standardizing the build environment and reducing local setup friction for users.

rust/perspective-server/cmake · high confidence

The \viewer-charts\ package has been refactored to support categorical (string) axes on X and Y dimensions, allowing string columns to be used directly as axis inputs. Additionally, charts now support faceted layouts, where split-by groups are rendered as a grid of sub-plots rather than a single overlay, and the rendering pipeline has been restructured to support pluggable glyphs (scatter, line, density) and improved interaction handling for tooltips and hover states.

packages/viewer-charts/src/ts/charts/cartesian · high confidence

The column selector interface in the Rust-based perspective-viewer has been completely rewritten using the Yew framework. This change introduces a new set of components (including ActiveColumn, InactiveColumn, FilterColumn, SortColumn, and PivotColumn) that handle the display and interaction of columns, filters, sorts, and pivots. Users will see a more responsive and consistent UI for managing view configurations, with improved drag-and-drop support, inline editing for expressions, and better handling of column types and aggregates.

_rust/perspective-viewer/src/rust/components/column\selector · high confidence

The \viewer-datagrid\ component's data listener has been converted to TypeScript, introducing new modules for formatting cell content (\format\_cell\), column headers (\format\_column\_header\), and tree headers (\format\_tree\_header\), along with a \FormatterCache\ for optimized date, number, and boolean formatting. This change ensures consistent rendering of split-by column labels and group-by tree paths, while also addressing previous rendering glitches and null group handling issues.

_packages/viewer-datagrid/src/ts/data\listener · high confidence

The event handling logic for the datagrid plugin has been converted from JavaScript to TypeScript. This refactoring introduces stricter type safety for user interactions, including cell editing (clicks, keydown, focus), row expansion/collapse, column sorting, and region selection. The change ensures that edit modes, selection states, and table metadata are handled with explicit type definitions, reducing runtime errors in these core interaction flows.

_packages/viewer-datagrid/src/ts/event\handlers · high confidence

The \viewer-datagrid\ model layer has been converted to TypeScript, introducing a new \SELECT\_ROW\TREE\ edit mode that enables hierarchical row selection when grouping is active, and implementing logic to persist column widths in the configuration so user-resized columns are preserved across sessions. The refactoring also adds a robust helper to correctly filter internal metadata columns (such as \\\_ROW\PATH\\_\ variants) from the user-visible grid, preventing them from appearing as stray data columns.

packages/viewer-datagrid/src/ts/model · high confidence

The \viewer-datagrid\ plugin now exposes a comprehensive configuration schema for both the grid and individual columns, allowing users to control font family, size, bold/italic styles, alignment, word wrapping, row height, and zebra striping. The plugin also introduces new selection modes, including \SELECT\_ROW\_TREE\ for hierarchical row selection, and adds support for persisting column widths in the configuration. These changes are implemented through new TypeScript modules for activation, drawing, and state restoration within the plugin directory.

packages/viewer-datagrid/src/ts/plugin · high confidence

The \viewer-datagrid\ custom elements (\datagrid.ts\ and \toolbar.ts\) have been rewritten in TypeScript. This change introduces a new behavior where column widths are now persisted in the columns configuration; when a user resizes a column, the new width is saved and restored upon workspace reload, ensuring layout consistency across sessions.

_packages/viewer-datagrid/src/ts/custom\elements · high confidence

The \viewer-datagrid\ plugin source has been converted from JavaScript to TypeScript, introducing stricter typing and new configuration capabilities. Users can now utilize a \SELECT\_ROW\_TREE\ selection mode alongside existing options like \SELECT\_COLUMN\ and \SELECT\_REGION\, allowing for more granular interaction with row hierarchies. The plugin also supports enhanced cell styling through new foreground and background modes (such as \label-bar\ and \gradient\) and exposes configuration for alignment, font, striping, and text wrapping. Additionally, the internal logic for cell configuration has been updated to correctly handle multi-level group-by filters and meta-columns, ensuring accurate data presentation in complex views.

packages/viewer-datagrid/src/ts · high confidence

The \viewer-datagrid\ component's styling has been replaced with a new set of CSS files (replacing the previous LESS-based approach), introducing a mitered header border system that uses CSS custom properties to create gapped, independent cell edges. This change also adds specific styles for row hover states, sub-cell scrolling, and a toolbar with distinct edit modes (Read Only, Edit, Row Select, Column Select, Region Select, Tree Select).

packages/viewer-datagrid/src/css · high confidence

The \viewer-datagrid\ style handlers have been rewritten in TypeScript to consolidate cell styling into a single pass, eliminating redundant DOM traversals and reducing layout thrashing. This change introduces a new \border\_model\ that calculates mitered header borders based on column path depth, ensuring correct visual grouping for split and rollup modes. Additionally, column alignment is now managed via a dedicated \CSSStyleSheet\ for improved performance, and the styling logic now supports the new \LabelBar\ formatting mode alongside existing bar and gradient visualizations.

_packages/viewer-datagrid/src/ts/style\handlers · high confidence

The expression editor in the Perspective viewer now correctly handles escaped characters (such as \\n, \\t, \\u{...}) and nested strings within expressions. This change, implemented in the Rust-based tokenizer, fixes previous bugs where escaped characters were not parsed correctly and syntax highlighting failed for nested string literals, ensuring that complex expressions are evaluated and displayed accurately.

rust/perspective-viewer/src/rust/exprtk/tokenize · high confidence

The expression editor now uses a custom Rust-based tokenizer (ExprTK) to parse and syntax-highlight expressions. This change introduces a \Cursor\ for tracking position and errors, and a \tokenize\ function that breaks expressions into semantic tokens (comments, strings, symbols, operators, etc.) to enable visual feedback in the editor.

rust/perspective-viewer/src/rust/exprtk · high confidence

The \rust/perspective-js/src/rust/utils\ directory now contains a suite of new Rust modules that underpin the JavaScript client's runtime behavior. This includes \browser.rs\ for safe access to browser globals, \console\_logger.rs\ for structured logging to the browser console, and \errors.rs\ which introduces a comprehensive \ApiError\ type for chaining and formatting errors across the WASM boundary. Asynchronous operations are now managed via \futures.rs\, which wraps Rust futures into JavaScript Promises and supports Chrome's Async Stack Tagging API for better debugging. Additional utilities include \json.rs\ for a custom JSON macro, \local\_poll\_loop.rs\ for bridging non-thread-safe callbacks, \serde.rs\ for serialization extensions, and \trace\_allocator.rs\ for optional memory usage tracking.

rust/perspective-js/src/rust/utils · high confidence

The \rust/bundle\ directory now contains a new Rust CLI (\main.rs\) and build script (\build.rs\) that replace previous JavaScript-based bundling logic. This tool automates the compilation of Rust libraries to WASM (\wasm32-unknown-unknown\), generates JavaScript/TypeScript bindings via \wasm-bindgen\, and optimizes the output using \wasm-opt\ (Binaryen). It enforces specific compiler flags (SIMD, bulk memory) and requires Binaryen version 118+ to ensure compatibility with \table.fill\ instructions, providing a unified, Rust-native entry point for building the project's WASM bundles.

rust/bundle · high confidence

The viewer's configuration system has been rewritten in Rust to provide a structured, serializable schema for column styles, export methods, and plugin settings. This change introduces a formal \ColumnConfigSchema\ that defines specific control types (such as font, alignment, and datetime formats) and supports both simple presets and custom \Intl.DateTimeFormat\ options for date columns. It also standardizes numeric formatting via \Intl.NumberFormat\ options (currency, units, notation) and defines explicit export methods including new Arrow formats with LZ4 and ZSTD compression. These Rust types are automatically generated into TypeScript definitions, ensuring the viewer's internal state model is strictly typed and consistent across the boundary.

rust/perspective-viewer/src/rust/config · high confidence

The \viewer-datagrid\ now uses dedicated TypeScript modules to style individual table cells, replacing the previous implementation. This change introduces specific handlers for boolean, datetime, numeric, row header, and string columns, enabling more granular control over cell appearance. Users benefit from improved rendering logic, including independent foreground/background mode parsing for datetime and string columns, series-based color palettes for string values, and robust bar/label rendering for numeric data. The new structure also supports visual enhancements like cell flashing (pulse animations) for numeric changes and proper tree-indentation styling for row headers.

_packages/viewer-datagrid/src/ts/style\_handlers/table\cell · high confidence

The \viewer-charts\ component now uses a new canvas-based rendering engine that provides more accurate and flexible axis rendering, including support for categorical and numeric axes, as well as improved legend handling. This change introduces new CSS styles for better visual consistency and performance, along with enhanced interaction capabilities for tooltips and zoom controls.

packages/viewer-charts/src · high confidence

The Style tab in the column settings sidebar now uses a set of new, schema-driven generic widgets (AggregateDepthSelector, AlignmentField, FontField, EnumField, BoolField, NumberFieldPrimitive, and SymbolStyle) to render column styling options. These components replace the previous ad-hoc implementations, providing a consistent, configurable interface for adjusting aggregate depth, text alignment, font family/size/style, and symbol attributes directly within the sidebar.

_rust/perspective-viewer/src/rust/components/column\_settings\_sidebar/style\tab · high confidence

The Symbol tab in the column settings sidebar now features a redesigned interface for configuring symbol-based styles. This change introduces new components (RowSelector, SymbolSelector, PairsList, and PairsListItem) that allow users to manage key-value pairs for symbol styling, select specific symbols from a dropdown, and edit or remove individual style rules directly within the sidebar.

_rust/perspective-viewer/src/rust/components/column\_settings\_sidebar/style\tab/symbol · high confidence

The column settings sidebar has been restructured into distinct, modular components for each tab: \attributes\_tab.rs\ now hosts the expression editor and save controls, \style\_tab.rs\ manages column styling options (including alignment, fonts, and gradients), \window\_tab.rs\ handles window function configuration, and \save\_settings.rs\ provides a reusable save/reset/delete UI. This change improves maintainability and allows each tab's settings to be managed independently within the sidebar.

_rust/perspective-viewer/src/rust/components/column\_settings\sidebar · high confidence

The presentation layer has been restructured to support more granular column configuration and improved UI state management. A new \ColumnLocator\ enum distinguishes between table columns, saved expressions, and window functions, enabling the UI to handle new expression creation and window function editing specifically. The column settings drawer now supports multiple tabs (Attributes, Window, Style) and can target either existing columns or unsaved new expressions. Additionally, theme detection logic has been extracted into a dedicated module that scans document stylesheets for the \--psp-theme-name\ custom property, and drag-and-drop visual feedback is now managed via a dedicated \DragDropProps\ struct threaded through the component tree.

rust/perspective-viewer/src/rust/presentation · high confidence

The viewer's session logic has been restructured to improve state consistency and update handling. A new \OpQueue\ serializes all configuration changes (edits, restores, loads) to prevent race conditions, while \PanelState\ provides immutable snapshots of the panel's binding and plugin configuration. Configuration updates are now handled by specialized modules: \column\_defaults\_update\ ensures rollup modes and column selections align with plugin capabilities, \drag\_drop\_update\ manages column movements, and \replace\_expression\_update\ correctly propagates expression renames across all config slots. Additionally, \SessionMetadata\ and \SessionProps\ provide efficient, non-async access to table schema and view statistics for the UI.

rust/perspective-viewer/src/rust/session · high confidence

The \<perspective-viewer\> component has been completely reimplemented in Rust using the Yew framework, replacing the previous JavaScript implementation. This change introduces a new \MainPanel\ architecture that manages the multi-panel workspace, including layout reconciliation, panel resizing, and theme synchronization. The viewer now uses a \\<regular-layout\>\ element for grid management, supporting features like panel maximization, context menus, and drag-and-drop resizing with pre-sizing to prevent visual shear. The implementation also includes a new event system that wires engine PubSub to JavaScript CustomEvents, ensuring proper bubbling and target identification for panel-specific events.

rust/perspective-viewer/src/rust · high confidence

The \\<perspective-viewer\>\ custom element has been reimplemented in Rust (Yew/WASM), introducing a new default debug plugin that displays table data as CSV. This change brings a complete rewrite of the viewer's internal state model, workspace management, and plugin architecture, while maintaining the existing JavaScript API surface for compatibility.

_rust/perspective-viewer/src/rust/custom\elements · high confidence

The \@finos\ npm namespace has been renamed to \@perspective-dev\, requiring users to update their imports to \@perspective-dev/client\ and \@perspective-dev/server\. This location also introduces virtual server support for DuckDB and ClickHouse, which translates view configurations into native SQL, and provides new build and documentation tooling to support these changes.

rust/perspective-js · high confidence

The viewer's render timer now listens for the \visibilitychange\ event and resets its throttle state when the tab becomes hidden. This prevents the renderer from accumulating stale timing data while the tab is inactive, ensuring that the first frame after the user returns to the tab is rendered immediately without delay.

rust/perspective-viewer/src/rust/renderer · high confidence

The CSS styling for the Rust Perspective Viewer has been refactored from a preprocessor-based system (Less) to standard CSS. This change introduces a new modular file structure in \rust/perspective-viewer/src/css\, replacing the previous monolithic or preprocessed styles with individual, importable CSS files for components like the column selector, filter dropdown, and expression editor. A new \viewer\_bundle.css\ acts as the central entry point, importing these modules to assemble the final stylesheet. This migration ensures that the Rust viewer's UI styling is consistent with the JavaScript implementation and removes the build-time dependency on Less.

rust/perspective-viewer/src/css · high confidence

The Rust lint utility in the project has been updated to automatically pass the \--edition 2024\ flag to the underlying \yewfmt\ formatter, ensuring compatibility with the Rust 2024 edition. This change allows developers to lint and format code using the latest Rust edition features without manual configuration, while still respecting explicit edition flags if provided.

rust/lint · high confidence

The viewer's core business logic for state mutations and rendering has been moved into a new Rust task system located in \rust/perspective-viewer/src/rust/tasks\. This change introduces dedicated modules for managing global filter broadcasting, automatic session pausing when the viewer is hidden, panel creation and lifecycle management, and export/copy operations (including new LZ4 and Zstd compression support for Arrow exports). It also centralizes the rendering pipeline, expression and window configuration editing, and workspace teardown, providing a unified, async-driven backend for these user-facing interactions.

rust/perspective-viewer/src/rust/tasks · high confidence

The project has migrated its Git hooks from the pre-commit stage to the pre-push stage, meaning validation checks now run when pushing code rather than when committing locally. Additionally, the hook execution has been updated to use pnpm instead of npm or yarn, ensuring consistent package manager behavior during the push process.

.husky · high confidence

Add CSS test snapshot for demo viewer styling; Added HTML test pages for Worker, SharedWorker, and ServiceWorker integration; Added HTML-based UI integration tests for perspective-viewer; Added JavaScript test suite for DuckDB virtual server integration; Added JavaScript test suite for perspective-js core features; Added JupyterLab integration tests for the Perspective widget; Added Playwright integration tests for the settings panel; Added Playwright integration tests for window columns and test infrastructure; Added Python tests for perspective-python Table operations; Added React component tests for basic viewer and workspace scenarios; Added Superstore CSV test fixture; Added UI integration test suite and fixtures; Added UI integration tests for column drag-and-drop behavior; Added UI integration tests for the Perspective viewer; Added UI integration tests for viewer configuration; Added comprehensive test suite for Perspective expressions; Added concurrency test for multi-client table updates; Added end-to-end tests for the viewer API; Added multi-threaded concurrency tests for Perspective Python; Added server-side integration tests for table hosting, views, and proxy sessions; Added smoke and integration tests for the Pyodide wheel; Added snapshot tests for viewer-charts rendering and interactions; Added stability tests for the Perspective viewer; Added test coverage for client-side join operations; Added test coverage for table constructors; Added test coverage for the Python Perspective widget; Added test coverage for view export formats and typed array access; Added test coverage for viewer-datagrid activation, styling, and configuration; Added test fixtures for Arrow entity type handling; Added tests for Python AsyncClient and WebSocket integration; Added tests for Python virtual server integrations; Added tests for async client and server interactions; Added tests for multi-panel workspace management and LLM agent integration; Added unit tests for pubsub and request\_animation\_frame utilities; Added visual regression and stability tests for viewer-charts; Expanded UI integration tests for the column settings sidebar.

This entry introduces the initial dependency and build configuration for Perspective version 5.5.1, establishing a new Rust workspace (Cargo.toml) and a pnpm-based JavaScript monorepo (package.json, pnpm-lock.yaml). The Rust side defines a workspace with default members including \perspective\, \perspective-client\, \perspective-js\, \perspective-python\, \perspective-server\, and \perspective-viewer\, alongside build utilities like \perspective-bundle\ and \perspective-lint\. The JavaScript side configures workspaces for core packages (\@perspective-dev/viewer\, \@perspective-dev/react\, \@perspective-dev/jupyterlab\, etc.) and various examples (esbuild, vite, webpack, python integrations), utilizing a \catalog:\ system for shared dependency versions. This change sets the foundational build environment for the project, replacing previous structures with a unified Rust/JS workspace managed by pnpm.

(dependencies) · high confidence

The repository has been initialized with essential configuration files to standardize development workflows. This includes \.clang-format\ and \.clang-tidy\ for C++ code style and static analysis, \.gitattributes\ and \.gitignore\ for repository hygiene, and \.pnpmrc\ and \.prettierrc.json\ for JavaScript/TypeScript formatting and package management. Additionally, foundational project documentation such as \LICENSE.md\, \CONTRIBUTING.md\, \CODE\_OF\_CONDUCT.md\, \GOVERNANCE.md\, and \PROJECT\_CHARTER.md\ have been added to establish the project's legal and operational framework.

(repo-wide) · high confidence

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

• CAI 56 → 44 (-12.3)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 69 → 67 (-1.7)
• Architecture 58 → 61 (+2.6)
• Maturity 73 → 73 (+0.2)
• Readiness 59 → 44 (-15.7)
• Security 48 → 61 (+12.9)
• Accessibility 33 (new)
• Performance 60 (new)

• Critical CVE: [CVE redacted] (pnpm-lock.yaml)
• Duplicated block (11 lines × 2) (rust/perspective-viewer/src/rust/custom_elements/viewer.rs)
• Duplicated block (11 lines × 2) (rust/perspective-viewer/src/rust/tasks/send_plugin_config.rs)
• Duplicated block (13 lines × 2) (rust/perspective-viewer/src/rust/queries/plugin_column_styles.rs)
• Duplicated block (17 lines × 2) (rust/perspective-viewer/src/rust/custom_elements/viewer.rs)
• Duplicated block (24 lines × 2) (rust/perspective-viewer/src/rust/session.rs)
• Duplicated block (7 lines × 2) (rust/perspective-viewer/src/rust/tasks/send_plugin_config.rs)
• FunctionTooLong: column_config_schema.column_config_schema (packages/viewer-datagrid/src/ts/plugin/column_config_schema.ts)
• FunctionTooLong: column_header.styleColumnHeaderRow (packages/viewer-datagrid/src/ts/style_handlers/column_header.ts)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• High CVE: [CVE redacted] (pnpm-lock.yaml)
• …and 89 more

• ActiveColumn::view (cyclomatic 16) (rust/perspective-viewer/src/rust/components/column_selector/active_column.rs)
• Ambiguous session creation methods. Two methods exist for creating a LocalSession with a callback/handler. The parameter names (send_response vs session_handler) and the lack of clear distinction in the signature suggest they may accept similar or identical callback types, or one is a deprecated alias for the other. This creates confusion for users trying to instantiate a session.
• Change coupling: table_make_view.rs ↔ duckdb.ts (rust/perspective-client/src/rust/virtual_server/generic_sql_model/table_make_view.rs)
• Duplicated block (10 lines × 2) (rust/perspective-js/src/rust/generic_sql_model.rs)
• Duplicated block (10 lines × 2) (rust/perspective-python/perspective/virtual_servers/polars.py)
• Duplicated block (10 lines × 3) (rust/perspective-python/bench/runtime/perspective_benchmark.py)
• Duplicated block (11 lines × 3) (rust/perspective-python/perspective/virtual_servers/polars.py)
• Duplicated block (12 lines × 2) (rust/perspective-python/perspective/virtual_servers/polars.py)
• Duplicated block (13 lines × 2) (rust/perspective-viewer/src/rust/session/panel_state.rs)
• Duplicated block (18–19 lines × 2) (rust/perspective-viewer/src/rust/components/column_settings_sidebar/style_tab/font_field.rs)
• Duplicated block (20 lines × 2) (rust/perspective-viewer/src/rust/session.rs)
• Duplicated block (29–32 lines × 2) (rust/perspective-python/perspective/virtual_servers/polars.py)
• Duplicated block (5 lines × 2) (rust/perspective-js/src/rust/table.rs)
• Duplicated block (5 lines × 2) (rust/perspective-python/perspective/virtual_servers/clickhouse.py)
• Duplicated block (6 lines × 2) (rust/perspective-python/src/server/generic_sql_model.rs)
• Duplicated block (7 lines × 2) (rust/perspective-viewer/src/rust/session.rs)
• Duplicated block (8 lines × 2) (rust/perspective-viewer/src/rust/components/export_dropdown.rs)
• Duplicated block (8–9 lines × 2) (rust/perspective-viewer/src/rust/custom_elements/viewer.rs)
• Duplicated block (8–9 lines × 2) (rust/perspective-viewer/src/rust/tasks/send_plugin_config.rs)
• Duplicated block (9 lines × 2) (rust/perspective-python/perspective/virtual_servers/clickhouse.py)
• …and 358 more

• 27 commits — 16 feature/other, 11 fixes

• (repo) — 8 commits
• rust/perspective-viewer — 7 commits
• rust/perspective-python — 3 commits
• (root) — 2 commits
• packages/viewer-datagrid — 2 commits
• rust/perspective-js — 2 commits
• docs/md — 1 commit
• packages/viewer-charts — 1 commit
• rust/perspective-server — 1 commit

• fix: Fix worker.terminate()
• fix: Fix arrow null type updates
• fix: Fix column value escape in GenericSQLModel header
• fix: Fix export & copy menus, add lz4 and zstd arrow options
• fix: Fix null groups and column group formatting in viewer-datagrid
• fix: Fix project metadata, add user cases, docs seo
• fix: Fix tooltip + axis rendered value
• fix: Fix ts imports
• fix: Increase node bounds to <27, fix memory64 node bug
• fix: Merge pull request #3232 from perspective-dev/fix-exports
• fix: Merge pull request #3242 from perspective-dev/fix-sql-escape
• change: Add Table::describe
• change: Add wait_for_table restore API option, alignment and font controls
• change: Add alignment, font, stripe, wrap, dimensions support to viewer-datagrid config
• change: Add zstd support to view.to_arrow()
• change: Make restoreWorkspace incremental, add getView({mode}) fallback
• change: Merge pull request #3229 from perspective-dev/datagrid-config
• change: Merge pull request #3231 from perspective-dev/cleanup-columns-config
• change: Merge pull request #3234 from perspective-dev/null-groups
• change: Merge pull request #3239 from perspective-dev/describe
• …and 7 more

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

perspective-dev/perspective 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.