teechart.js 4.0.5 → 5.0.0-beta.1

package/3D-COMPATIBILITY.md

@@ -0,0 +1,45 @@
+# Native 3D compatibility and implementation contract
+
+`TeeChart3D` runs the canonical `Chart` engine and full `ChartOptions` API through the existing Three.js
+drawing context. It covers the registered series, axis, legend, theme, palette, plugin and tool APIs
+through the same code paths as a 2D chart. `Chart3D` and `createChart3DScene` are separate low-level,
+data-only scene APIs. This matrix tracks their direct `Chart3DOptions` geometry coverage; it does not
+limit the complete `TeeChart3D` API. A native-scene feature is complete only when its behavior, public
+types, tests and an example are present.
+
+| Capability | Status | Contract or outstanding work |
+| --- | --- | --- |
+| Lifecycle | Partial | Create, replace scene, resize, destroy; test WebGL and resource ownership in browser. |
+| Full `ChartOptions` adapter | Supported | `TeeChart3D` applies normal `ChartOptions` to `Chart`, forces `aspect.view3d`, redraws through the Three context and cleans up chart, renderer and resize observer. Optional built-ins follow `Chart` and require `registerAll()` or individual registration. |
+| Camera and interaction | Partial | Perspective or orthographic projection, position updates, orbit controls and click picking for bar, point, line, area, circular and surface points; other events pending. |
+| Scene and lighting | Partial | Background, dimensions, ambient and directional lights, optional back wall and floor; configurable lights and wall styles pending. |
+| Axes and grids | Partial | Linear vertical range, inversion, grid, ticks, numeric and category labels; log/date axes, clipping and multiple axes pending. |
+| Title, subtitle, footer | Partial | Plain title, subtitle and footer text, plus title visibility; typography and layout options pending. |
+| Legend | Partial | Plain series labels; layout, symbols, style and interactions pending. |
+| Marks | Partial | Cartesian value labels and visibility; placement, connectors, styles and circular/surface marks pending. |
+| Series styles | Partial | Color, visibility and transparency; stroke, gradients, textures and palette pending. |
+| Bar | Partial | Signed values, depth rows and absolute or percentage stacking; horizontal bars and sizing options pending. |
+| Line | Partial | Numeric values, explicit numeric/date X positions and gaps; null modes, interpolation, pointers and styles pending. |
+| Point | Partial | Numeric points and visibility; pointer options, x coordinates and hit testing pending. |
+| Area | Partial | Numeric values, gaps and zero crossings; stacking, x coordinates and styles pending. |
+| Bubble | Partial | Cartesian X/Y points and relative 3D radii from object data; full pointer styling and radius axis semantics pending. |
+| Volume | Partial | Signed narrow volume columns; financial volume row semantics and styling pending. |
+| Pie, donut | Partial | Extruded slices and point identity; labels, placement and series options pending. |
+| Sliced | Partial | Proportional extruded blocks and point identity; labels and layout options pending. |
+| Activity gauge | Pending | Gauge geometry, labels, hit testing and options. |
+| Surface | Partial | Rectangular numeric grids, wireframe and nearest-vertex picking; palettes and existing options mapping pending. |
+| Color grid | Partial | Rectangular numeric grids render as individually colored, pickable 3D cells; palette integration and cell labels remain pending. |
+| Polar, financial, statistical, Gantt, histogram, bullet | Pending | Geometry, data semantics and options for each registered series type. |
+| Circular, linear, numeric and arc gauges | Pending | Gauge geometry and configuration. |
+| Treemap, Sankey, map | Pending | Hierarchical, flow and geographic geometry and options. |
+| Tools | Pending | Tooltip, cursor, drag, annotations and animations; decide 3D behavior per tool. |
+| `ChartOptions` | Partial | Explicit conversion of a small subset; unsupported settings are rejected. |
+| Plugins, themes and palettes | Pending | Establish scene lifecycle hooks and reuse applicable chart configuration. |
+| Bundles and public types | Partial | Root and `/3d` exports; `/core` must not include Three.js. |
+| Demos and migration | Pending | Replace existing demos and document breaking changes before removing the bridge. |
+
+The canonical inventory is `src/chart-options.ts` (`ChartOptions`, `AxisOptions`,
+`SeriesOptionsRegistry`, `ToolsOptions`) plus the public imperative objects exported from
+`src/core.ts`. Each option needs either implemented behavior with a test or a documented,
+explicit rejection/alternative. The renderer must never silently approximate a complete
+TeeChart chart while presenting itself as compatible with those options.

package/README.md

@@ -1,42 +1,478 @@
 # TeeChart.js
 
-<a href="https://www.steema.com/product/js">
-<img align="right" src="http://www.steema.com/img/logos/teechartjs.png">
-</a>
+JavaScript charting with Canvas, TypeScript declarations, maps, gauges and optional 3D rendering.
 
-Powerful yet flexible JavaScript charting for designers & developers.
+## Installation
 
-[![npm](https://img.shields.io/npm/v/teechart.js)](https://www.npmjs.com/package/teechart.js)
-[![License](https://img.shields.io/badge/license-Steema-blue)](https://www.steema.com/licensing/js)
+```sh
+pnpm add teechart.js
+```
 
-## Documentation
+## Usage
 
-All links point to the latest version of the library.
+Create a canvas in your page:
 
-- [Product Page](https://www.steema.com/product/js)
-- [Getting Started](https://teechartjs.steema.com/getting-started)
-- [API Reference](https://www.steema.com/docs/TeeChartHTML5Reference.htm)
-- [Demos](https://teechartjs.steema.com/demos)
-- [Legacy Demos](https://www.steema.com/files/public/teechart/html5/latest/demos/index.html)
-- [Release Notes](https://teechartjs.steema.com/release-notes)
-- [Migration Guide](https://teechartjs.steema.com/migration)
+```html
+<canvas id="chart" width="640" height="400"></canvas>
+```
+
+Create the chart with a declarative configuration. The chart type, data and common
+presentation options live together. Call `draw()` to render the initial state;
+`setOptions()` applies later changes and redraws automatically:
+
+```js
+import { Chart } from "teechart.js"
+
+const chart = new Chart("chart", {
+	title: { text: "Weekly sales", visible: true },
+	data: {
+		labels: ["Mon", "Tue", "Wed", "Thu"],
+		series: [{ type: "line", data: [10, 20, 15, 30], label: "Sales" }]
+	}
+})
+chart.draw()
+
+// Update the chart later without rebuilding it:
+chart.setOptions({
+	data: {
+		labels: ["Mon", "Tue", "Wed", "Thu"],
+		series: [{ type: "line", data: [12, 18, 22, 28], label: "Sales" }]
+	}
+})
+
+// When the host component or page is removed:
+// chart.destroy()
+```
+
+Axes can also be configured and updated declaratively. For example,
+`axes: { left: { position: 50, innerTicksVisible: true, minorTicksVisible: true,
+grid: { bandColor: "#ffffe6" } } }` positions the left axis at 50% and styles its ticks
+and alternating grid bands. Set `bandColor` to an empty string to remove the fill.
+
+Cartesian series also accept point objects when each value has its own position. This is
+useful for irregularly spaced or date-based data:
+
+```js
+const chart = new Chart("chart", {
+	data: {
+		series: [
+			{
+				type: "line",
+				data: [
+					{ x: new Date("2026-04-01"), y: 12 },
+					{ x: new Date("2026-04-08"), y: 18 },
+					{ x: new Date("2026-04-20"), y: 15 }
+				]
+			}
+		]
+	}
+})
+```
+
+Pie and donut marks can be styled and positioned in the same declarative series options.
+`maxRadius` controls the pie size; `marks` supports label placement, connector, fill,
+border, text color and size, corner radius, and margins:
+
+```js
+const chart = new Chart("chart", {
+	type: "pie",
+	data: {
+		labels: ["Apples", "Pears", "Plums"],
+		series: [{
+			data: [15, 10, 8],
+			maxRadius: 85,
+			marks: {
+				visible: true,
+				style: "labelvalue",
+				placement: "outside",
+				connector: "straight",
+				backgroundColor: "#f8fafc",
+				borderColor: "",
+				fontSize: 11,
+				fontColor: "#0f172a",
+				borderRadius: 7,
+				margins: { left: 7, right: 7, top: 4, bottom: 4 }
+			}
+		}]
+	}
+})
+chart.draw()
+```
+
+`registerAllSeriesTypes()` also enables `colorGrid` and `surface` with a matrix of
+numbers (one array per row), and `linearGauge` with a numeric `data` value and optional
+`min` and `max`. Matrix rows are copied, so updating a chart does not mutate your data.
+Surface options accept `wireFrame`; rendering in WebGL still requires a `Three` adapter.
+
+Canvas maps are registered separately to keep SVG maps outside the core runtime graph.
+The map data is a factory, called when the chart creates or updates its series. This
+lets React applications declare the options before browser APIs are available:
+
+```js
+import { Chart, registerSeriesType } from "teechart.js/core"
+import { mapSeriesType, WorldMap } from "teechart.js/maps"
+
+registerSeriesType("map", mapSeriesType)
+const chart = new Chart("chart", {
+	data: { series: [{ type: "map", data: () => new WorldMap() }] },
+	tooltip: { enabled: true }
+})
+chart.draw()
+```
+
+For applications that prefer every built-in optional series and chart option, the
+`registerAll()` function registers them, including the map series type. It also leaves the Three
+integration available through its regular direct API:
+
+```js
+import { Chart, WorldMap, registerAll } from "teechart.js"
+
+registerAll()
+
+const chart = new Chart("chart", {
+	data: { series: [{ type: "map", data: () => new WorldMap() }] },
+	responsive: true
+})
+```
+
+Use the regular `teechart.js` or `teechart.js/core` entry and register selected features
+manually when bundle size is a priority. The `auto` entry includes optional features in
+the consuming application's bundle.
+
+The React demos use `options` for their chart data and supported settings. They keep
+`configure` for custom canvas drawing, additional gauge hands, geographic projections,
+data-source adapters and animation controls that need the live chart instance.
+
+For application data that uses different property names, set `xKey` and `yKey` on the
+series. They default to `x` and `y`:
+
+```js
+const chart = new Chart("chart", {
+	data: {
+		series: [{
+			type: "line",
+			data: [{ date: new Date("2026-04-01"), revenue: 12 }],
+			xKey: "date",
+			yKey: "revenue"
+		}]
+	}
+})
+```
+
+The existing `number[]` form with a parallel `x` array remains supported. Do not provide
+both forms of horizontal position in the same series. These keys apply to Cartesian series
+using object rows; specialized series keep their own data shapes.
+
+`setOptions()` is a patch: omitted options keep their current values, and removing an
+option from a later object does not reset it to its default. When `data.series` is
+provided, it describes the complete series list and entries missing from the new list
+are removed. Give series an `id` to keep their instances matched across reordering and
+updates; series without an `id` continue to match by position. The `plugins` option is
+creation-only, so changing plugin definitions requires destroying and recreating the chart.
+Toggle an attached plugin in place with `chart.setPluginEnabled(id, enabled)`. Its init and
+cleanup hooks run on each transition, and its configured options are retained when toggled
+through this method.
+
+Use `resetOptions()` to restore every resettable declarative section to TeeChart.js defaults,
+or pass section names to reset only those parts. Plugin definitions are fixed when the chart
+is created and cannot be reset:
+
+```js
+chart.resetOptions(["title", "data"])
+chart.resetOptions() // reset all supported sections
+```
+
+Use `compareChartOptions()` when an integration needs to decide whether new declarative
+options can be patched or require a new chart:
+
+```js
+import { Chart, compareChartOptions } from "teechart.js"
+
+let chart = new Chart("chart", {
+	type: "line",
+	data: { series: [{ data: [10, 20, 15, 30] }] }
+})
+chart.draw()
+
+const nextOptions = { title: { text: "Updated", visible: true }, data: { series: [{ type: "line", data: [12, 18, 22, 28] }] } }
+const change = compareChartOptions(chart.getOptions(), nextOptions)
+
+if (change.change === "patch") chart.setOptions(change.patch)
+if (change.change === "recreate") {
+	chart.destroy()
+	chart = new Chart("chart", change.patch)
+	chart.draw()
+}
+```
+
+The comparison returns `"none"` when the applied options already match, `"patch"`
+when `setOptions()` can apply the changes, and `"recreate"` when an option value was
+removed, the plugin list changed, or a plugin's enabled state changed. Series with ids
+can be reordered in a patch without replacing their instances. For `"recreate"`, `patch`
+contains the complete new configuration for the replacement chart.
+
+Plugins can provide `defaults` and receive their resolved options after the hook's chart
+arguments. A plugin can create state for each chart with `create`; that state is passed
+to every hook and `destroy`. An `afterInit` hook can also return a cleanup function.
+Use `order` to control execution when plugins depend on one another; lower values run
+first and ties retain registration order. Configure a plugin by id with `pluginOptions`;
+use `false` to disable a registered plugin for one chart:
+
+```js
+const chart = new Chart("chart", {
+	pluginOptions: { watermark: { text: "Internal preview" } }
+})
+```
+
+Applications can add known plugin ids to `PluginOptionsRegistry` for option autocomplete
+and type checking while keeping other ids available for dynamic plugins:
+
+```ts
+import { Chart } from "teechart.js"
+
+declare module "teechart.js" {
+	interface PluginOptionsRegistry {
+		watermark: { text?: string; opacity?: number }
+	}
+}
+
+new Chart("chart", {
+	pluginOptions: { watermark: { text: "Internal preview", opacity: 0.5 } }
+})
+```
 
-## History
+The core includes a built-in `quadrants` plugin that stays inert until configured. It paints
+four background regions behind the series, split at `split.x` and `split.y` (axis values, or `"mean"` /
+`"median"` of the chart data). Areas (`topLeft`, `topRight`, `bottomLeft`, `bottomRight`)
+take a `backgroundColor` and a corner `text`; `divider` styles the split lines:
 
-[teechart.js](https://teechartjs.steema.com/) comes from TeeChart JavaScript/HTML5, a library initially written by [David Berneda](https://github.com/davidberneda) in 2012 and maintained by the team at [Steema Software](https://www.steema.com).  
-Steema Software open-sourced the library in March 2018 but still offers [paid support subscriptions](https://www.steema.com/product/js#pricing).
+```js
+const chart = new Chart("chart", {
+	pluginOptions: {
+		quadrants: {
+			split: { x: 0, y: "mean" },
+			areas: {
+				topLeft: { backgroundColor: "rgba(255, 99, 132, 0.2)", text: "Q2" },
+				bottomRight: { backgroundColor: "rgba(75, 192, 192, 0.2)", text: "Q4" }
+			},
+			divider: { color: "#888", width: 1 }
+		}
+	}
+})
+```
 
-## Contributing
+Global plugin registration is keyed by `id`. Registering another plugin object with an
+existing id replaces its definition for newly created charts. Existing charts retain
+their original plugin lifecycle until destruction. Unregister the currently registered
+object to remove its hooks and owned themes or palettes; when multiple plugins provide
+the same resource name, the previous owner or base registry becomes active again after
+unregistration. Plugins passed in `ChartOptions.plugins` keep their hooks, themes, and
+palettes scoped to that chart. Their resources are available while the initial options
+are applied, and never enter the global theme or palette registry.
 
-Before submitting an issue, please check the [Issue Tracker](https://www.steema.com/bugs/buglist.cgi?product=HTML5%20JavaScript%20TeeChart&query_format=advanced&resolution=---) first. For support, please contact [Steema Software](https://www.steema.com/support).
+The imperative API is also available when you need to work directly with series and
+chart components:
+
+```js
+import { Chart, Line } from "teechart.js"
+
+const chart = new Chart("chart")
+chart.addSeries(new Line([10, 20, 15, 30]))
+chart.draw()
+
+const series = chart.series.items[0]
+const pointPosition = series.getPointPosition(2) // canvas pixel coordinates
+```
+
+`getPointPosition(index, point?)` uses the series' axes and point calculation to return
+canvas coordinates. Call it after the chart has calculated its axes, such as inside
+`afterSeriesDraw`; pass a reusable `Point` when querying many positions.
+`getCanvasBounds(rectangle?)` returns the series bounds in canvas coordinates and can
+reuse a supplied `Rectangle`. The legacy `bounds(rectangle)` method remains available;
+Gantt's `bounds(index, rectangle?)` overload still calculates an individual task's bounds.
+
+Destroying a chart releases its slider touch handlers, tooltip callbacks and
+pointer animations, including sliders created without `chart.tools.add`.
+Use `chart.tools.remove(tool, true)` to dispose a slider or tooltip earlier.
+Each `Series` belongs to one chart at a time; `chart.addSeries(series)` transfers it
+from its previous chart. Tools are bound to the chart passed to their constructor and
+cannot be added to another chart; create a new tool for the destination chart.
+Hiding or destroying a tooltip discards pending asynchronous text updates.
+DOM tooltips preserve application-owned `document.onmousemove` handlers and
+listeners. Canvas cleanup restores application handlers even when chart lifetimes
+overlap on the same canvas.
+The legacy DOM renderer still shares one active tooltip across charts.
+
+The package exports constructors and helpers as named ESM exports. For namespace-style
+usage, write `import * as Tee from "teechart.js"`. There is no default export.
+TypeScript declarations are included; no separate TeeChart types package is needed.
+
+Known `Series` properties such as visibility, axis selectors, date formats and
+animation hooks have explicit types. `SeriesData.source` is `unknown`; narrow it
+to the expected source element before accessing its properties.
+`DataEngine.onclickseries` is typed as a callback accepting a `Series` and a
+numeric point index, or `null`/`undefined` when unset. Check it before calling it.
+`Series` and `SeriesData` no longer have an index signature: reading or assigning a property
+that the class does not declare is a compile-time error. Series types declare the properties
+they use, and `SeriesData` lists the arrays that specific series fill (`x`, `open`, `high`,
+`low`, `close`, `start`, `end`...). Series constructors accept `number[]`, a chart or a data
+source object, and an optional labels array, instead of `unknown`.
+
+### Updating data
+
+`series.append(value, label)` associates the label with the appended point's index,
+including when earlier points have no labels. Numeric text rows with a value of
+zero retain their labels. `DataDimension.selected` accepts scalar values or arrays,
+including `0`, `false`, and `""`. Set `selectedInclude = false` to exclude the selected
+categories; use `null`, `undefined`, or `[]` to clear a selection. Queries preserve the
+selection and filter mode, including when a metric throws. With `nulls = false`, zero
+and false remain valid categories, while missing and empty categories are hidden.
+Empty categories are removed after considering all metrics; numeric array indices
+and string object keys retain their types. Query charts retain zero group titles and
+use primitive category ids as labels when later series introduce new categories.
+
+### Bullet orientation
+
+`Bullet` is horizontal by default. Set `yMandatory = true` for vertical bullets:
+
+```js
+import { Bullet } from "teechart.js"
+
+const bullet = new Bullet([85], ["Revenue"])
+bullet.yMandatory = true
+bullet.states.values = [70, 20, 40] // consecutive range widths from the origin
+bullet.limit.origin = 100 // target, relative to the origin
+chart.addSeries(bullet)
+chart.draw()
+```
+
+Each point occupies its own row (horizontal) or column (vertical), grouped by category
+axis across visible Bullet series. Ranges, measures, target markers and tooltips follow
+the orientation. `states.barSize`, `barSize` and `limit.height` are percentages of the
+slot perpendicular to the value axis; `limit.width` is the marker thickness along the
+value axis, in axis units. Use `minValue()` and `maxValue()` for the value range in
+either orientation. Change `yMandatory` and call `chart.draw()` to switch orientation;
+move any manually configured value-axis range to the new value axis as well.
+
+## Optional ESM entries
+
+```js
+import { Chart, Line } from "teechart.js/core"
+import { Map as MapSeries, WorldMap } from "teechart.js/maps"
+import { Three } from "teechart.js/3d"
+```
+
+`/core` contains the engine, series and utilities without loading maps or Three.js.
+`/maps` provides SVG/geographic maps and the map series; `/3d` provides the Three.js
+bridge and parametric geometry. The root entry keeps the complete API. All ESM entries
+share their base classes and plugin/theme registries and include TypeScript declarations.
+`registerAll()` from the root entry registers built-in optional series and chart options when
+called, including the map series type. Its optional feature code is included in the consumer's
+bundle when the function is used.
+
+The new native 3D renderer is available alongside the existing `Three` bridge:
+
+```js
+import { TeeChart3D } from "teechart.js/3d"
+
+const chart = new TeeChart3D(document.querySelector("canvas"), {
+  theme: "modernDark",
+  palette: "excel",
+  type: "bar",
+  data: { labels: ["North", "South", "West"], series: [{ data: [2, -1, 4] }] },
+  axes: { left: { minimum: -2, maximum: 5 }, bottom: { visible: true } },
+  legend: { visible: true, position: "right" },
+  tooltip: { enabled: true }
+})
+
+// TeeChart3D.chart exposes the complete imperative Chart API.
+chart.setOptions({ theme: "modern", data: { labels: ["North", "South", "West"], series: [{ data: [4, 2, 1] }] } })
+chart.destroy()
+```
+
+`TeeChart3D` runs the regular TeeChart chart engine and its full `ChartOptions` through the Three.js
+drawing context. Series, axes, themes, palettes, plugins, tools, tooltips and chart events therefore
+use the same public APIs as a 2D `Chart`. `chart.chart` exposes the underlying `Chart` instance and
+all imperative methods. As with `Chart`, call `registerAll()` when using optional built-in series
+types or option sections such as annotations and animation. `TeeChart3D` forces `aspect.view3d` on
+and observes canvas resizing by default.
+
+`Chart3D` and `createChart3DScene` remain lower-level, data-only scene APIs. Their supported subset
+and outstanding native geometry work are tracked in [3D-COMPATIBILITY.md](3D-COMPATIBILITY.md).
+`chart3DOptionsFromChartOptions` is a strict converter for that subset; use `TeeChart3D` when you need
+the complete TeeChart options and series registry.
+
+Cartesian series can show value marks with `marks: true` and accept a `transparency` from 0
+to 1. Set `camera.projection` to `"perspective"` or `"orthographic"`, and optionally provide
+`camera.position` as an `[x, y, z]` tuple. `setOptions()` can update the projection and position.
+Bar series can use positive and negative stacks with `stacked: true`, or percentage stacks
+with `stacked: "100"`. The `ChartOptions` converter accepts `"yes"` and `"100"` respectively.
+The vertical `axis` supports `inverted`, `increment`, `decimals` and `fixedDecimals` in addition
+to its range and visibility options.
+Cartesian series also accept numeric `x` positions. The `ChartOptions` converter accepts numeric
+positions or JavaScript `Date` values and converts dates to timestamps. It also accepts object
+points with `x` and `y` fields or custom `xKey` and `yKey` fields. Date-axis label formatting is
+not yet implemented.
+
+ESM uses shared chunks. If you serve the files directly, copy all of `dist`, including
+`dist/chunks`, and preserve relative paths. Optional imports reduce the JavaScript loaded
+by the application; they do not change the npm package's installed dependencies.
+
+The browser bundle `dist/teechart.js` exposes the global `Tee` namespace when loaded
+with a classic script tag. ESM consumers should use the root or documented optional entries;
+deep imports into `teechart.js/src` are unsupported.
+
+## Grouping remaining values
+
+`DataEngine.groupRemaining(data, max, label)` and charts created by
+`DataEngine.createChart()` using `groupOther(max)` limit each series in place,
+reserving the last slot for the sum of all remaining values. For example,
+`[10, 8, 5, 2]` with a limit of `3` becomes `[10, 8, 7]`. Labels and codes stay
+aligned; the aggregate code is `null`. Series at or below the limit stay unchanged.
+
+Use a positive integer limit, including the aggregate item; a limit of `1` groups
+all values into that item when the series has more than one value. Grouping keeps
+the current order, so sort the chart by values in descending order first to retain
+the largest values.
+`groupRemaining()` returns the original length minus the limit when grouping,
+or `-1` when the series is unchanged.
+
+## Shared tooltips
+
+Set `tooltip: { enabled: true, shared: true }` in `ChartOptions` to show the visible
+cartesian series at the hovered category or x value together. The default DOM
+tooltip keeps each series' color, name and formatted value. Numeric and date x
+values are matched by value, so a missing point is omitted instead of showing a
+different category. Hidden series and null or non-finite values are omitted.
+Series must share the category axis and orientation. Canvas tooltips show one
+text line per matching series. A custom `tooltip.format` still overrides the body.
+The imperative equivalent is `toolTip.shared = true`.
+
+## Cursor rendering
+
+`CursorTool` uses `render = "copy"` by default. It saves the chart bitmap and
+restores it when the cursor moves, including transparent pixels. Each chart redraw
+replaces the saved bitmap so animation frames do not accumulate. The snapshot
+follows the canvas backing size when the chart is resized or its pixel ratio changes.
+
+## Documentation
+
+- [Getting started](https://teechartjs.steema.com/getting-started)
+- [Demos](https://teechartjs.steema.com/demos)
+- [Framework integrations](https://teechartjs.steema.com/integrations)
+- [Migration guide](https://teechartjs.steema.com/migration)
+- [Release notes](https://teechartjs.steema.com/release-notes)
+- [Support](https://www.steema.com/support)
 
 ## License
 
-Copyright (c) 2012-2026 Steema Software SL. All Rights Reserved.  
-See the [licensing details](https://www.steema.com/licensing/js).
+Copyright (c) 2012-2026 Steema Software SL. All Rights Reserved.
+
+See [LICENSE.md](LICENSE.md) for the Steema non-commercial license.
+Commercial use requires authorization from Steema; see the
+[licensing details](https://www.steema.com/licensing/js).
+
+## Native 3D compatibility
 
-<p align="center">
-<a href="https://www.steema.com/">
-<img src="https://raw.githubusercontent.com/wiki/Steema/TeeChartJS/logo-steema.png">
-</a>
-</p>
+The current native renderer is experimental. See [3D-COMPATIBILITY.md](3D-COMPATIBILITY.md)
+for the feature matrix and the work required before it can replace the existing bridge.