Charts grown from code.

THE FRONT DOOR — build a chart and let the library pick the machine.

Render a chart's poster frame OFF-SCREEN and return it as a PNG data URL — the placeholder-image pattern: show it in an `<img>` at page load and build the live chart only when the window scrolls into view, so a page of many charts spends no live GL context until it needs one. The scratch world renders on a hidden staged canvas (sizing reads `clientWidth`, so it must be in the DOM) and its context is released before returning.

Everything `createChart` accepts. Only `canvas` is required; every other field has a stated default carried on its own doc below.

The common surface both renderers satisfy — what a chart recipe writes against.

Which renderer a chart is actually running on — `"2d"` is the CPU canvas, `"3d"` the WebGL one. Read it back off `world.mode` after `createChart`: with `renderer: "auto"` (the default) the answer is decided at build time by GPU availability and the page-wide budget, so it is a RESULT, never a setting.

Is a WebGL context obtainable right now? Probed on a scratch canvas (freed at once), so the caller's canvas is never touched by a failed attempt.

How many GPU chart worlds are currently live on this page (budget bookkeeping).

⛔ IT IS NOT `1 − rgb`. The complement does invert lightness, but it also rotates hue by 180° — red comes back cyan — which is why the obvious one-liner is wrong.

The same rule on a CSS colour STRING — the form the CPU renderer works in.

Build a CPU-renderer {@link World} directly. Exported openly — the facade is the front door, not a wall — but prefer `createChart({ renderer: "2d" })` from the package root unless you specifically want to bypass renderer selection and the GPU budget.

THE CPU RENDERER — the same recipe vocabulary as the 3D world, drawn with additive compositing on a plain 2D canvas. It runs anywhere, needs no GL context, and is what `createChart` falls back to when the GPU is unavailable or the page is over its context budget.

Everything this renderer's `createWorld` accepts. Only `canvas` is required; the trailing comment on each field carries its default. Most callers should use `createChart` from the package root instead and let the facade pick the renderer.

A per-frame callback: elapsed seconds `t`, seconds since the last frame `dt`, and the world. ⚠ `settle(t)` calls this with `dt = 0`, so a recipe that INTEGRATES will render a different still than the live view at the same `t`. Write scene content as a function of `t`.

no note in the package

Build a GPU-renderer {@link World} directly. Exported openly — the facade is the front door, not a wall — but prefer `createChart` from the package root: it budgets live GL contexts page-wide and falls back to the CPU renderer rather than throwing when one cannot be had.

THE GPU RENDERER — the same recipe vocabulary as the CPU world, drawn through WebGL with real lighting and depth. Richer, and it costs a live GL context, which browsers cap per page.

Everything this renderer's `createWorld` accepts. Only `canvas` is required. Most callers should use `createChart` from the package root instead and let the facade pick the renderer.

A per-frame callback: elapsed seconds `t`, seconds since the last frame `dt`, and the world. ⚠ `settle(t)` calls this with `dt = 0`, so a recipe that INTEGRATES will render a different still than the live view at the same `t`. Write scene content as a function of `t`.

no note in the package

The running model-space bounds of everything a world has been asked to draw.

A screen-space box, accumulated in px.

The frame's camera basis, as both engines can report it.

A projected point. ⚠ `s` IS THE PER-UNIT SCREEN SCALE AT THAT POINT (`focal / z`), which is what makes a depth-scale reading possible at all — measured 2026-09-01 across the shipped corpus: median depth error 0.07%, and 15 of 31 charts exactly 0 because they draw in one z-plane.

How a drawing is fitted into its plate — how much of the box to span, what edge space to keep, and the aspect discipline. All optional with stated defaults; the point is that a recipe states its intent once and the fit survives a resize rather than being recomputed by the caller.

What a fit attempt returns. ⛔ A REFUSAL IS DATA, NOT A THROW — check `ok` and read `reason`. On a refusal the camera fields carry the caller's own UNCHANGED values, so a caller that applies them regardless is left exactly where it was rather than somewhere wrong.

Reserved edge space, in CSS px, that the drawing must stay out of — axis labels live here.

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

no note in the package

Deterministic pseudo-random in [0,1) — a fixed field that doesn't churn on resize.

no note in the package

FaceOpts across both renderers (gloss/blood are 3D-only material extras; 2D ignores them).

A line's ink. `light` is stated in the DARK edition and flipped at draw time (see `ink.ts`).

A glow's ink and size. `white: true` takes the sheet's achromatic sprite.

A steerable place, not a direction: Lambert x inverse-square falloff, plus a facet glint.