openalgo-charts 2.5.1 → 2.5.3

package/dist/draw/index.d.ts

@@ -1,4 +1,4 @@
-import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, IPrimitive, PrimitiveHost, ZOrder, PrimitiveHit, DataLayer, AlertDrawingInfo } from 'openalgo-charts';
+import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, IPrimitive, DataLayer, AlertDrawingInfo, PrimitiveHost, ZOrder, PrimitiveHit } from 'openalgo-charts';
 
 /**
  * The per-tool settings schema: what a host may show in a drawing's settings
@@ -35,6 +35,8 @@ interface SettingsField {
         label: string;
     }>;
     group?: FieldGroup;
+    /** Value displayed when the drawing has not overridden this setting. */
+    defaultValue?: string | number | boolean;
 }
 interface SettingsSchema {
     fields: SettingsField[];
@@ -111,9 +113,8 @@ declare function composeSettings(parts: ReadonlyArray<readonly SettingsField[] |
 /** The value at a dot path, or `undefined` when unset or the path is not one the model has. */
 declare function readDrawingSetting(d: Drawing, path: string): unknown;
 /**
- * Every field of a schema read off a drawing, keyed by path. Absent values
- * are present as `undefined`, so a host can iterate the schema and render
- * each control in its "default" state rather than guessing.
+ * Every field of a schema read off a drawing, keyed by path. Unset fields use
+ * their declared default value, or remain `undefined` when no default exists.
  */
 declare function readDrawingSettings(d: Drawing, schema: SettingsSchema): Record<string, unknown>;
 /**
@@ -295,9 +296,16 @@ declare const DRAWING_STATE_VERSION = 2;
  * What `toJSON` returns and `ChartState.drawings` carries. Versioned so a 1.9.x
  * save (a bare `Drawing[]`) is recognisable and upgraded rather than misread.
  */
+/** A named set of drawing ids. A drawing belongs to at most one group. */
+interface DrawingGroup {
+    id: string;
+    name: string;
+    members: string[];
+}
 interface DrawingsDocument {
     version: 2;
     drawings: Drawing[];
+    groups?: DrawingGroup[];
 }
 /** A point mapped to the pane, in media px. */
 interface ScreenPoint {
@@ -424,849 +432,296 @@ interface DrawingTool {
     distance(x: number, y: number, c: HitContext): number | null;
 }
 
-/**
- * Built-in drawing tools + the tool registry. Same philosophy as the chart-type
- * and indicator registries: a tool is a descriptor, the layer just runs it, and
- * `registerDrawingTool` makes a custom one first-class.
- *
- * `draw` receives anchors already in device px; `distance` receives them in
- * media px, the same space as the incoming cursor.
- *
- * Text lives in `drawing.text` (a `DrawingText`), never in the style bag: a
- * shape's outline colour and its label colour are two decisions, and a tool
- * that prints only a readout (a fib ladder, a measure chip) still reads its
- * face from there. Ladders read `FibLevel[]` and stroke each level in its own
- * colour, taken from the shared palette in levels.ts.
- *
- * Every tool declares `settings`: the fields a host may show for it. The
- * schema is a contract, not a wish list. A field is declared only when this
- * file reads it, because a control with nothing behind it is a defect.
- */
+/** Time-anchored analysis drawings use the owning pane's bars, never a tier cache. */
 
-declare function registerDrawingTool(tool: DrawingTool): void;
-declare function getDrawingTool(id: string): DrawingTool;
-declare function hasDrawingTool(id: string): boolean;
-declare function registeredDrawingTools(): DrawingTool[];
-/** Keyboard event fields a shortcut is matched against. */
-interface ShortcutEvent {
-    key: string;
-    altKey?: boolean;
-    ctrlKey?: boolean;
-    metaKey?: boolean;
-    shiftKey?: boolean;
+declare const ANCHORED_VWAP: DrawingTool;
+declare const FIXED_RANGE_VOLUME_PROFILE: DrawingTool;
+
+/** Pure OHLCV analysis. Inputs are sorted by ascending UTC timestamp. */
+
+/** Partial results have unavailable anchor history, missing volume or unusable prices. */
+type AnalysisStatus = 'ready' | 'partial' | 'missing-volume' | 'zero-volume' | 'empty' | 'invalid-data';
+type AnchoredVwapSource = 'hlc3' | 'close' | 'hl2' | 'ohlc4';
+interface AnchoredVwapOptions {
+    source?: AnchoredVwapSource;
+}
+interface AnchoredVwapPoint {
+    time: number;
+    value: number;
+    /** Volume-weighted population standard deviation of the selected source. */
+    deviation: number;
+    /** Do not connect a line across an omitted observation. */
+    breakBefore: boolean;
+}
+interface AnchoredVwapResult {
+    status: AnalysisStatus;
+    /** The requested anchor precedes the earliest supplied bar. */
+    historyPartial: boolean;
+    points: AnchoredVwapPoint[];
+    missingVolumeBars: number;
+    invalidPriceBars: number;
+}
+interface FixedRangeVolumeProfileOptions {
+    /** Requested price rows, rounded and clamped to 4..200. Fewer rows are used when prices cannot represent distinct edges. Default 48. */
+    rows?: number;
+    /** Percentage of volume in the contiguous area around the POC, 1..100. Default 70. */
+    valueArea?: number;
+}
+interface AnalysisProfileRow {
+    low: number;
+    high: number;
+    volume: number;
+    valueArea: boolean;
+}
+interface FixedRangeVolumeProfileResult {
+    status: AnalysisStatus;
+    /** The requested range begins before the earliest supplied bar. */
+    historyPartial: boolean;
+    rows: AnalysisProfileRow[];
+    totalVolume: number;
+    /** Midpoint of the largest row. Ties choose the lower price. */
+    poc: number | null;
+    valueAreaLow: number | null;
+    valueAreaHigh: number | null;
+    missingVolumeBars: number;
+    invalidPriceBars: number;
 }
 /**
- * The id of the tool whose `shortcut` matches this key event, or `null`.
- *
- * Pure, so a host can bind one `keydown` listener and decide for itself when
- * shortcuts apply. The library installs no listener, because only the host
- * knows whether the chart has focus, a dialog is open, or the user is typing.
- *
- * Modifiers must match exactly: `Alt+T` will not fire for `Ctrl+Alt+T`, so a
- * tool shortcut cannot shadow a browser or host chord. `metaKey` (Cmd) is
- * treated as Ctrl, which is what a Mac user expects.
- */
-declare function matchDrawingShortcut(e: ShortcutEvent): string | null;
-/** Every registered tool that has a shortcut, as `id -> shortcut`. */
-declare function drawingShortcuts(): Record<string, string>;
-/**
- * The settings a host may show for a tool: the tool's own declaration, else
- * the line fields, which every stroked custom tool reads. This is a registry
- * lookup, which is why it lives here and not in schema.ts: that module stays
- * free of any import that could loop back into this one.
- */
-declare function drawingSettingsSchema(toolId: string): SettingsSchema;
-declare const TREND_LINE: DrawingTool;
-declare const RAY: DrawingTool;
-declare const EXTENDED_LINE: DrawingTool;
-declare const ARROW: DrawingTool;
-declare const HORIZONTAL_LINE: DrawingTool;
-declare const HORIZONTAL_RAY: DrawingTool;
-declare const VERTICAL_LINE: DrawingTool;
-declare const CROSS_LINE: DrawingTool;
-declare const RECTANGLE: DrawingTool;
-declare const ELLIPSE: DrawingTool;
-declare const PARALLEL_CHANNEL: DrawingTool;
-declare const FIB_RETRACEMENT: DrawingTool;
-declare const FIB_EXTENSION: DrawingTool;
-declare const MEASURE: DrawingTool;
-declare const LONG_POSITION: DrawingTool;
-declare const SHORT_POSITION: DrawingTool;
-declare const TEXT: DrawingTool;
-/**
- * Path: click each vertex, double-click to finish, arrowhead on the last leg.
- * The arrow is what separates it from `polyline`: a path points somewhere.
- */
-declare const PATH: DrawingTool;
-/**
- * Brush: freehand ink. Press, drag, release. The anchors are the thinned
- * samples of the gesture and the spline between them is what is stroked, so
- * the ink stays a curve after the thinning that keeps a stroke small.
- */
-declare const BRUSH: DrawingTool;
-/**
- * Rotated rectangle: anchors 0 and 1 lay out one edge (and so the rotation),
- * and anchor 2 sets the depth perpendicular to it. An axis-aligned `rectangle`
- * cannot follow a trend channel; this can.
+ * Accumulate from the first bar at or after the anchor, including the live tail.
+ * Missing volume is omitted and reported; zero volume adds no statistical weight.
+ * Recompute on each call so mutations of the forming candle are always visible.
  */
-declare const ROTATED_RECTANGLE: DrawingTool;
+declare function anchoredVwapAnalysis(bars: readonly Bar[], anchorTime: number, options?: AnchoredVwapOptions): AnchoredVwapResult;
 /**
- * Double curve: an S through three anchors. `curve` bends one way off a single
- * control; this mirrors that control about the midpoint so the second half bends
- * back, which is the shape a rounded top-then-bottom actually needs.
+ * Estimate a volume histogram over the inclusive timestamp range. Each candle's
+ * volume is uniform over low..high; this is not trade-by-trade volume. Difference
+ * arrays distribute interior rows without visiting each row per candle. Row
+ * lookup is bounded by 200 edges: O(bars log(rows) + rows).
  */
-declare const DOUBLE_CURVE: DrawingTool;
+declare function fixedRangeVolumeProfileAnalysis(bars: readonly Bar[], fromTime: number, toTime: number, options?: FixedRangeVolumeProfileOptions): FixedRangeVolumeProfileResult;
+
 /**
- * Cyclic lines: vertical lines repeating at the interval the two anchors set,
- * for reading a rhythm forward off a measured swing.
+ * Clipboard transfer for drawings: the layer between the drawing model and the
+ * OS clipboard.
+ *
+ * Two things make this more than `JSON.stringify`:
+ *
+ * 1. **The OS clipboard is shared with everything else on the machine.** A
+ *    paste can arrive from a spreadsheet, another application, or a hand-edited
+ *    copy of our own payload. So the payload is written under a namespaced key
+ *    and everything read back is validated field by field before it can reach
+ *    the model. Foreign text is *not ours* and is ignored, never an exception
+ *    the host has to catch on every Ctrl+V.
+ * 2. **Clipboard access is async and permission-gated.** `navigator.clipboard`
+ *    rejects when the document is not focused, the page is not secure, or the
+ *    user denied the permission. Copy must still work inside the tab, so every
+ *    write also lands in a module-level in-memory clipboard which is shared by
+ *    every controller in the page. That is what makes chart-to-chart paste work
+ *    with the permission denied, and it is why the memory store is a singleton
+ *    rather than per-controller state.
+ *
+ * The payload body is a drawings document (`DrawingsDocument`), so a copy made
+ * by a 1.9.x build (a version 1 body carrying the old style-bag text fields)
+ * is upgraded by the same migration a saved layout goes through.
  */
-declare const CYCLIC_LINES: DrawingTool;
+
 /**
- * Time cycles: semicircles of the anchors' width repeating along the axis, the
- * classic cycle-projection overlay.
+ * Top-level key of the JSON payload. Namespaced so a paste of arbitrary text,
+ * or of JSON belonging to some other application, is recognisable as not ours
+ * by looking at one property.
  */
-declare const TIME_CYCLES: DrawingTool;
+declare const DRAWING_CLIPBOARD_KEY = "openalgo-charts/drawings";
 /**
- * Sine line: a full wave between the anchors. The horizontal span is one
- * period, the vertical offset its amplitude.
+ * Payload format version. Tracks the model version, since the body *is* a
+ * drawings document: version 1 carried 1.9.x drawings, version 2 carries the
+ * split text and levelled fibs.
  */
-declare const SINE_LINE: DrawingTool;
+declare const DRAWING_CLIPBOARD_VERSION: number;
+/** The async slice of `navigator.clipboard` this module uses. */
+interface ClipboardPort {
+    writeText(text: string): Promise<void>;
+    readText(): Promise<string>;
+}
+/** Test seam: drop whatever the in-memory clipboard is holding. */
+declare function clearMemoryClipboard(): void;
+/** `navigator.clipboard` when the browser exposes it, else null. */
+declare function systemClipboard(): ClipboardPort | null;
+/** Deep copy of the persisted fields, so a clone shares nothing with its source. */
+declare function cloneDrawing(d: Drawing): Drawing;
+/** Serialise drawings into the namespaced payload written to the clipboard. */
+declare function encodeClipboardPayload(drawings: readonly Drawing[]): string;
 /**
- * Price label: a pill of the anchored price with a tail pointing at the bar.
- * Reads its value off the anchor, so dragging it re-reads rather than going
- * stale the way a typed-in text would. Text, when given, replaces the price.
+ * Validate one entry into a drawing with no id. Returns null for anything that
+ * cannot be rendered: an unknown tool would throw inside the controller, and a
+ * NaN anchor produces a drawing that can never be drawn or hit-tested again.
+ * Accepts the 1.9.x shape too, lifting its text fields into `text`.
  */
-declare const PRICE_LABEL: DrawingTool;
+declare function sanitizeDrawing(value: unknown): Omit<Drawing, 'id'> | null;
 /**
- * Callout: a text bubble on its own anchor with a tail back to the point it
- * annotates, so the note can sit clear of the price action it refers to.
+ * Parse clipboard text into drawings, or null when the text is not ours or is
+ * not usable. All-or-nothing on purpose: a payload with one corrupt entry is a
+ * corrupt payload, and pasting the other nine silently would be worse than
+ * pasting none.
  */
-declare const CALLOUT: DrawingTool;
-/** Flag mark: a pennant on a pole at one anchor, for tagging a bar. */
-declare const FLAG_MARK: DrawingTool;
+declare function decodeClipboardPayload(text: unknown): Omit<Drawing, 'id'>[] | null;
+interface DrawingClipboardOptions {
+    /** Where to read and write. Defaults to `navigator.clipboard` when present. */
+    port?: ClipboardPort | null;
+    /**
+     * Keep a copy in the shared in-memory clipboard so copy and paste keep
+     * working when the OS clipboard is unavailable or the permission is refused.
+     * Default true. Set false to make a failed system write a failed copy, which
+     * a host that must not silently lose cross-tab transfer may prefer.
+     */
+    fallbackToMemory?: boolean;
+}
 /**
- * Note: a pin at the bar with its text to the upper right.
- *
- * The pin is the point being annotated and the plate is the annotation, which
- * is why the two are drawn as separate marks joined by a stem rather than as
- * one bubble: the reader needs to see exactly which bar is meant, and a bubble
- * wide enough to hold a sentence covers several.
+ * The clipboard as the controller sees it: drawings in, drawings out, no
+ * exceptions escaping. Every failure mode (no clipboard API, refused
+ * permission, foreign text, corrupt payload) reduces to `false` or `null`.
  */
-declare const NOTE: DrawingTool;
+declare class DrawingClipboard {
+    private _port;
+    private _fallback;
+    /** Why the last operation did not reach the OS clipboard, if it did not. */
+    private _lastError;
+    constructor(options?: DrawingClipboardOptions);
+    /** Swap the port at runtime (a host granting permission later, or a test). */
+    setPort(port: ClipboardPort | null): void;
+    /**
+     * Turn the in-memory backstop off or on. With it off, a refused system write
+     * is a failed copy, which is what a host wants when a cut that cannot reach
+     * the OS clipboard must not delete the drawing.
+     */
+    setFallbackToMemory(enabled: boolean): void;
+    /**
+     * Why the OS clipboard was not used by the last call, or null when it was.
+     * Set on a successful copy too, when the payload reached memory but not the
+     * system clipboard: that copy works in this tab and will not appear in
+     * another, which is exactly what a host wants to be able to tell the user.
+     */
+    lastError(): string | null;
+    /**
+     * Write drawings out. Resolves true when the payload is retrievable by a
+     * later `read()` (through the system clipboard, or through memory when the
+     * fallback is on), false when it is not, so a caller doing a cut knows
+     * whether it is safe to delete the original.
+     */
+    write(drawings: readonly Drawing[]): Promise<boolean>;
+    /**
+     * Read drawings back, or null when there is nothing of ours to paste. The
+     * system clipboard wins when it holds our payload, so a copy made in another
+     * tab beats a stale in-tab one; memory is consulted when the read fails or
+     * returns something that is not ours. That last case can paste an older copy
+     * after the user has copied unrelated text elsewhere, which is the deliberate
+     * trade: losing the copy whenever a browser refuses the read half of the
+     * permission would be the worse surprise.
+     */
+    read(): Promise<Omit<Drawing, 'id'>[] | null>;
+}
+
 /**
- * Balloon: a speech bubble sitting above its anchor, tail pointing down.
+ * Drawing controller: the interaction and persistence layer over
+ * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
+ * active tool (from its own button, a shortcut, a command palette) and the
+ * controller runs placement, selection, dragging, undo, and serialisation.
  *
- * One anchor rather than the callout's two: a balloon is for saying something
- * *about this bar*, so letting the bubble be dragged away from what it labels
- * would only invite it to drift.
- */
-declare const BALLOON: DrawingTool;
-/**
- * Comment: a small square-cornered box with a tail off its bottom left.
+ * It listens on the chart's event bus (`click`, `crosshair:move`, `drag`,
+ * `drag:end`) rather than the single-slot `subscribeClick`/`subscribeDrag`
+ * callbacks, so a host keeps using those for its own order lines.
  *
- * Deliberately plainer than the balloon: a chart that says something at every
- * other bar needs one of these marks to be quiet, and the shape is the only
- * thing distinguishing them once both are the user's own colour.
+ * Selection is a list. Every method that edits takes the whole list into one
+ * undo entry, so a multi-drag, a batch delete or a paste of ten shapes is one
+ * Ctrl+Z, which is what the hand that did it expects.
  */
-declare const COMMENT: DrawingTool;
+
 /**
- * Signpost: a post standing on the bar with its plate at the top.
+ * The slice of the chart this controller needs.
  *
- * The one annotation anchored to *time* rather than to a level: the post is
- * vertical so the plate can clear the price action entirely while the foot
- * still names an exact bar. Useful for events, which happen at a moment and
- * not at a price.
- */
-declare const SIGNPOST: DrawingTool;
-/**
- * Price note: the anchored price, with the user's text under it.
- *
- * The price is read off the anchor rather than typed, so dragging the note
- * re-reads it. A typed price is a number that was true once, which on a chart
- * is worse than no number at all.
- */
-declare const PRICE_NOTE: DrawingTool;
-/**
- * Table: rows of text in a grid, anchored top-left.
- *
- * Cells come from the text: a newline starts a row and a pipe separates
- * columns, so a whole table is one editable string and survives `getState`
- * with no new shape in the drawing model. The first row is drawn as a header
- * because a table on a chart is nearly always labelled.
- */
-declare const TABLE: DrawingTool;
-/**
- * Measurers. `measure` reports price *and* time together; these two constrain it
- * to one axis, which is what you want when the other one is noise: sizing a
- * retracement without caring how long it took, or counting bars to an event
- * without caring where price went.
- */
-declare const PRICE_RANGE: DrawingTool;
-declare const DATE_RANGE: DrawingTool;
-/**
- * Position forecast: project a move from an anchor. Two anchors give the
- * projected leg; the shape extends the same slope past the target as a dashed
- * cone, so the drawing says "if this continues" rather than just marking a line.
- */
-declare const FORECAST: DrawingTool;
-/**
- * Circle from centre + a radius handle. The radius is measured in *pixels*, so
- * it stays a circle on screen instead of the ellipse the two axes' differing
- * scales would otherwise produce.
- */
-declare const CIRCLE: DrawingTool;
-declare const TRIANGLE: DrawingTool;
-/** Free-form polyline: click each vertex, double-click to finish. */
-declare const POLYLINE: DrawingTool;
-/** Arc through three anchors: the middle one is on the curve, not a handle. */
-declare const ARC: DrawingTool;
-/** Quadratic curve: the middle anchor is a control handle, off the curve. */
-declare const CURVE: DrawingTool;
-declare const ARROW_UP: DrawingTool;
-declare const ARROW_DOWN: DrawingTool;
-declare const ARROW_LEFT: DrawingTool;
-declare const ARROW_RIGHT: DrawingTool;
-/** Highlighter: the brush with a fat, translucent stroke. */
-declare const HIGHLIGHTER: DrawingTool;
-/** Fib channel: fib levels spread across a trend leg, parallel to it. */
-declare const FIB_CHANNEL: DrawingTool;
-/**
- * Fib time zone: vertical lines at Fibonacci multiples of the base leg's width.
- * Its levels count bars rather than divide a leg, so they carry no convention
- * colour and fall back to the drawing's own.
- */
-declare const FIB_TIME_ZONE: DrawingTool;
-/** Rays from the anchor at fib fractions of the leg: the speed resistance fan. */
-declare const FIB_FAN: DrawingTool;
-/**
- * Gann fan: rays from one anchor at the classic price/time angles. A level's
- * ratio is price per unit of time, so the 1x1 is 1, the 1x2 is 0.5 and the
- * 2x1 is 2; each angle keeps its own colour from the cycle palette.
- */
-declare const GANN_FAN: DrawingTool;
-/**
- * Gann box: the drawn rectangle divided at its levels on both axes, plus the
- * 1x1 diagonal. Ratio 0 is the first anchor's price and time, ratio 1 the
- * second's, so the box reads like a retracement laid over a date range.
- */
-declare const GANN_BOX: DrawingTool;
-declare const BUILTIN_DRAWING_TOOLS: readonly DrawingTool[];
-/** Register every built-in tool. Idempotent; called on tier import. */
-declare function registerBuiltinDrawingTools(): void;
-
-/**
- * The shared level palette for the Fibonacci and Gann family.
- *
- * Every ladder tool (retracement, extension, channel, fan, time zone, the Gann
- * fan and box) strokes a list of ratios, and each ratio has a colour the eye
- * expects: 0.618 reads as one thing across every tool, not a different hue per
- * tool. Before this module each tool would have restated those colours, and
- * restated colours drift. This is the one statement; tools take their defaults
- * from it and hosts seed a newly added level from it.
- *
- * Pure: no DOM, no registry. Safe to import from a worker or a settings panel.
- */
-
-/**
- * The colour of a ratio that is an anchor rather than a level (0, 1, 2, 3 are
- * where the measured leg starts and ends, or whole multiples of it) and of any
- * ratio the convention does not name. Neutral on purpose: it is the reference
- * the coloured levels are read against.
- */
-declare const LEVEL_NEUTRAL = "#787b86";
-/**
- * The conventional colour for a Fibonacci ratio. Anchors (0, 1, 2, 3) and any
- * ratio without a convention come back {@link LEVEL_NEUTRAL}, so a host can call
- * this for every new level and always get a usable colour.
- */
-declare function levelColor(ratio: number): string;
-/**
- * A short sequence of colours that stay distinguishable side by side, for
- * tools whose levels are positions rather than ratios: the angles of a Gann
- * fan, the repeats of a cycle. Index `i` wraps, so any count is safe.
- */
-declare const CYCLE_PALETTE: readonly string[];
-/** The `i`th cycle colour. Wraps in both directions; a negative index is fine. */
-declare function cycleColor(i: number): string;
-/** `0.618` as `61.8%`: the text a level prints when it carries no label. */
-declare function formatRatio(ratio: number): string;
-/**
- * The label for a Gann angle stored as a price-per-time ratio: `1` is the 1x1,
- * `0.5` the 1x2, `2` the 2x1. Ratios that are not clean reciprocals fall back
- * to the ratio itself, which is still true, just less idiomatic.
- */
-declare function gannLabel(ratio: number): string;
-/** A mutable copy of a default ladder, for a fresh drawing's own `style.levels`. */
-declare function cloneLevels(levels: readonly FibLevel[]): FibLevel[];
-/** Retracement and extension: the classic ladder, coloured by convention. */
-declare const DEFAULT_FIB: readonly FibLevel[];
-/** Speed fan: rays at the fractions of the leg. No 0 ray, it would be flat. */
-declare const DEFAULT_FIB_FAN: readonly FibLevel[];
-/** Gann box: quarters plus the golden pair, applied to both axes of the box. */
-declare const DEFAULT_GANN_BOX: readonly FibLevel[];
-/**
- * Gann fan: the classic angles as price-per-time ratios, 1x8 up to 8x1. These
- * are positions in a sequence rather than Fibonacci ratios, so they take the
- * cycle palette.
- */
-declare const DEFAULT_GANN_FAN: readonly FibLevel[];
-/**
- * Time zones count bars along the Fibonacci sequence, so `ratio` here is a
- * multiple of the anchor leg, not a fraction of it. No colour is set: there is
- * no convention for "the 13 line", so every zone takes the drawing's own colour
- * until the user gives one its own.
- */
-declare const DEFAULT_FIB_TIME_ZONE: readonly FibLevel[];
-
-/**
- * Glyphs for the drawing tools and for host chrome, as path data.
- *
- * The engine ships no DOM, and this does not change that: an icon here is a
- * string of SVG path commands, not an element. The host still builds its own
- * toolbar, flyouts and rail; what it no longer has to do is draw every glyph
- * before it can show them. `icon-svg.ts` turns these into markup strings for a
- * host that wants the convenience; this file is the single source both of them
- * and every other surface read from.
- *
- * That was the real cost of leaving them out. Every adopter drew their own set,
- * each drifted on stroke weight, grid and visual density independently, and the
- * result read as sixty icons rather than as one set, however carefully any
- * single glyph was made. A shipped set is worth more than a better glyph.
- *
- * # Two tiers, one weight
- *
- * Tool glyphs live on a 24-unit grid and are shown at 24px in the rail. Host
- * chrome (undo, close, the settings tab rail) is shown at 16px beside them, and
- * a 24-grid glyph scaled to 16 lands its 2-unit stroke on 1.33 pixels, blurred
- * across two rows on every edge. So chrome has its own registry drawn on a
- * 16-unit grid with a 1.5 stroke. The two strokes are deliberately not in exact
- * proportion: a small glyph needs a slightly heavier relative stroke than a
- * large one to read as the same weight, and `tests/draw-icons.test.ts` holds
- * the chrome tier inside that band rather than at parity.
- *
- * # The grid
- *
- * Every glyph is authored to the same constraints, and `tests/draw-icons.test.ts`
- * enforces all of them mechanically, because a set of this size cannot be kept
- * consistent by review:
- *
- *  - **One viewBox per tier.** 24 by 24 for tools, 16 by 16 for chrome, so a
- *    host sets the size once per surface.
- *  - **A margin all round.** Live area 2 to 22 on the tool grid, 1 to 15 on the
- *    chrome grid. Without it, glyphs that happen to reach the edge look larger
- *    than their neighbours and the rail reads as ragged.
- *  - **Integer coordinates.** With `STROKE` of 2, an orthogonal edge centred on
- *    an integer covers exactly two device pixels at 1:1, which is what makes it
- *    crisp. Half-unit coordinates were the previous set's crispness bug: at a
- *    1.5 stroke on integers, nothing landed on a pixel boundary at any size.
- *  - **One stroke weight per tier.** Three different weights across identically
- *    sized boxes is the single most visible tell of a set assembled rather than
- *    drawn.
- *
- * # Rendering
- *
- * Tool glyphs are crispest at 24px, and at any integer multiple of it. At 18px
- * the 0.75 scale puts a 2-unit stroke on 1.5 device pixels and every edge is
- * anti-aliased across two rows: that is a host sizing choice, not something the
- * path data can fix. Prefer 24, or 12 with a heavier weight. Chrome glyphs are
- * drawn for 16px and its multiples.
- */
-/** The viewBox every glyph is authored in. */
-declare const ICON_VIEWBOX = "0 0 24 24";
-/**
- * Stroke width in viewBox units. Paths carry no presentation attributes, so a
- * host that wants a lighter set overrides this once rather than editing glyphs.
- */
-declare const ICON_STROKE = 2;
-/**
- * The attribute bag a tier hands its host. Structural, so the markup builders
- * in `icon-svg.ts` take either tier's bag through one signature.
- */
-interface IconAttrs {
-    readonly viewBox: string;
-    readonly fill: 'none';
-    readonly stroke: 'currentColor';
-    readonly strokeWidth: number;
-    readonly strokeLinecap: 'round';
-    readonly strokeLinejoin: 'round';
-}
-/** Attributes a host should apply to the `<svg>`, so every set matches. */
-declare const ICON_ATTRS: {
-    readonly viewBox: "0 0 24 24";
-    readonly fill: "none";
-    readonly stroke: "currentColor";
-    readonly strokeWidth: 2;
-    readonly strokeLinecap: "round";
-    readonly strokeLinejoin: "round";
-};
-/**
- * Path data by tool id, plus a few keys a host toolbar needs that are not
- * themselves tools (`cursor`, the group headers).
- *
- * Values are the `d` attribute of one `<path>`. Multiple subpaths are joined
- * into the same string rather than split across elements, so a host renders one
- * node per glyph.
- */
-declare const DRAWING_TOOL_ICONS: Readonly<Record<string, string>>;
-/**
- * The glyph for a tool, or `undefined` when it has none.
- *
- * Undefined rather than a placeholder: a host that renders an empty box has a
- * visible gap to fix, while one handed a question mark ships it.
+ * Declared structurally rather than as `Chart` on purpose. Each tier ships its
+ * own bundled `.d.ts`, so naming the class here made the draw tier re-declare
+ * `Chart`, and because `Chart` has private members, TypeScript treats the two
+ * declarations as *different* types. A TS consumer passing the chart from
+ * `createChart()` got "separate declarations of a private property", which made
+ * the tier unusable from TypeScript at all. An interface with no private
+ * members is structural, so the real `Chart` satisfies it with nothing to cast.
  */
-declare function drawingToolIcon(toolId: string): string | undefined;
-/** Every id this set covers, for a host building a palette from it. */
-declare function drawingToolIconIds(): string[];
-/** The viewBox every chrome glyph is authored in. */
-declare const CHROME_ICON_VIEWBOX = "0 0 16 16";
-/**
- * Chrome stroke width in viewBox units. Not the tool stroke scaled (that would
- * be 1.33): at 16px a glyph needs a touch more relative weight than at 24px to
- * read as the same line, and 1.5 is where the two rails match by eye.
- */
-declare const CHROME_ICON_STROKE = 1.5;
-/** Attributes a host should apply to the `<svg>` around a chrome glyph. */
-declare const CHROME_ICON_ATTRS: {
-    readonly viewBox: "0 0 16 16";
-    readonly fill: "none";
-    readonly stroke: "currentColor";
-    readonly strokeWidth: 1.5;
-    readonly strokeLinecap: "round";
-    readonly strokeLinejoin: "round";
-};
-/**
- * Path data for host chrome: the buttons around the chart rather than the
- * tools in it. Same rules as the tool tier (one path per glyph, no presentation
- * attributes, integer coordinates) on the 16 grid with a 1..15 live area.
- *
- * The pair `cursor` / `magnet` / `text` also exist in the tool registry, at 24.
- * They are drawn twice on purpose: a rail button and a toolbar button are
- * different sizes, and the whole point of a second grid is not scaling one
- * drawing to both.
- */
-declare const CHROME_ICONS: Readonly<Record<string, string>>;
-/**
- * Chrome glyphs meant to be painted solid. Paths carry no presentation
- * attributes, so the fill is applied by the wrapper (`chromeIconSvg` does it,
- * a host with its own wrapper reads this set) and the registry stays pure.
- */
-declare const CHROME_ICON_FILLED: ReadonlySet<string>;
-/** The chrome glyph for an id, or `undefined` when there is none. */
-declare function chromeIcon(id: string): string | undefined;
-/** Every id the chrome tier covers. */
-declare function chromeIconIds(): string[];
-
-/** Prefix of every `<symbol id>` in the sprite, and of every `<use href>`. */
-declare const ICON_SYMBOL_PREFIX = "oac-icon-";
-/** Options shared by the inline builders. */
-interface IconSvgOptions {
+interface DrawingChartHost {
+    readonly isDestroyed?: boolean;
     /**
-     * Width and height. A number is CSS pixels; a string is written verbatim, so
-     * `'1em'` sizes the glyph with the surrounding text. Default: the grid's
-     * native size (24 for tools, 16 for chrome), where the stroke is crispest.
+     * The event bus. The controller listens for `click`, `crosshair:move`,
+     * `drag`, `drag:end` and `dblclick`, and for `hover` (`{ id }`, the hit id
+     * under the pointer whenever it changes), which is what drives the hover
+     * state: the chart has already hit-tested the move, so the controller
+     * reads its answer rather than testing a second time. A host that never
+     * emits `hover` has drawings that select and drag but do not light up.
      */
-    size?: number | string;
-    /** Stroke width in viewBox units. Default: the tier's `*_STROKE`. */
-    stroke?: number;
-    /** A class for the host's own styling. */
-    className?: string;
-}
-/** Options for `toolCursor`. */
-interface ToolCursorOptions {
-    /** Cursor image size in CSS pixels. Default 20. Browsers reject images over 128. */
-    size?: number;
-    /** The pointer's active pixel, from the image's top-left. Default: the centre. */
-    hotspot?: readonly [number, number];
-    /** Glyph colour. Default white. */
-    color?: string;
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    emit(event: string, payload: unknown): void;
+    addPrimitive(primitive: IPrimitive, paneIndex?: number): void;
+    removePrimitive(primitive: IPrimitive): void;
+    readonly dataLayer: DataLayer;
+    getVisibleLogicalRange(): {
+        from: number;
+        to: number;
+    } | null;
+    drawingState(): unknown;
+    setDrawingState(state: unknown): void;
+    setPlacementMode?(active: boolean): void;
     /**
-     * Halo colour. Default: black under a light `color`, white under a dark one,
-     * judged from a hex colour. A non-hex `color` gets a black halo unless this
-     * is set.
+     * Optional, and used only to move a drawing by a fixed screen distance (a
+     * paste offset, an arrow-key nudge, a multi-drag across panes). Going
+     * through pixels rather than adding a price delta keeps the offset the same
+     * visible nudge on a log scale as on a linear one, and the same on an RSI
+     * pane as on the price pane. A host without them still gets the time half.
      */
-    halo?: string;
-    /** The keyword after the image, for a browser that will not take it. Default `crosshair`. */
-    fallback?: string;
-}
-/**
- * A complete inline `<svg>` for one tool glyph, stroked in `currentColor`.
- *
- * ```ts
- * button.innerHTML = iconSvg('trend-line');
- * button.innerHTML = iconSvg('trend-line', { size: '1em' });
- * ```
- */
-declare function iconSvg(id: string, opts?: IconSvgOptions): string;
-/**
- * A complete inline `<svg>` for one chrome glyph, on the 16 grid. Glyphs in
- * `CHROME_ICON_FILLED` are painted solid as well as stroked.
- */
-declare function chromeIconSvg(id: string, opts?: IconSvgOptions): string;
-/**
- * One hidden `<svg>` of `<symbol>`s, for a host that shows many glyphs and
- * wants each path in the document once. Inject it once, then place glyphs with
- * `iconUse`. Symbols carry the path and viewBox only; stroke and fill inherit
- * from the `<svg>` around each `<use>`, so one sprite serves every weight.
- *
- * Default: every tool glyph. Repeated ids collapse to one symbol, since a
- * duplicate element id is an invalid document.
- */
-declare function iconSprite(ids?: readonly string[]): string;
-/** An `<svg>` that references a symbol from `iconSprite`. Same frame as `iconSvg`. */
-declare function iconUse(id: string, opts?: IconSvgOptions): string;
-/**
- * A CSS `cursor` value carrying the tool's glyph, for the canvas while that
- * tool is armed.
- *
- * The glyph is drawn twice: once in `halo`, one pixel wider on each side, and
- * once in `color` on top, so it reads on a light chart and a dark one without
- * the host choosing per theme. The value is `url("data:image/svg+xml,...") x y,
- * fallback`, ready for `canvas.style.cursor`.
- */
-declare function toolCursor(id: string, opts?: ToolCursorOptions): string;
-
-/**
- * A `DrawingLayer` renders the drawings of one pane and answers the chart's
- * hit-test. Anchors live in `{ time, price }`, so the layer maps them through
- * the *fractional* index helpers: the gapless axis means an anchor can sit
- * between bars (inside a collapsed weekend) or past the last one (a forward
- * projection), and whole-index lookups have nothing to return there.
- *
- * Each pane carries **two** layers, one at z-order `bottom` for drawings with a
- * negative `zIndex` (under the series) and one at `top` for the rest. The top
- * one takes over handles and hit-testing for the pair through `setBelow`, so a
- * shape parked under the candles still shows its grab handles above them and
- * a click lands on whatever the eye sees on top.
- *
- * Hit ids are `draw:<id>` for the body and `draw:<id>#<n>` for anchor `n`, so
- * the controller can tell "move the whole shape" from "move this handle".
- *
- * The hover ring, the magnet ring and the hover handles are all overlay
- * state: they change on every pointer move, so they must only ever cost the
- * top canvas. The layer that paints them is the one whose `requestUpdate`
- * the chart maps to the cursor tier, which is why the bottom layer of a pair
- * stores that state and asks for nothing.
- */
-
-/** Which side of the series a layer paints on. */
-type DrawingLayerOrder = 'bottom' | 'top';
-/** The pointer kinds the layer sizes its targets for. */
-type DrawingPointerKind = 'mouse' | 'touch' | 'pen';
-/**
- * Paint order: by `zIndex`, ties by array position. `Array.prototype.sort` is
- * stable, which is what makes the tie rule hold without a second key.
- */
-declare function sortByZIndex(drawings: readonly Drawing[]): Drawing[];
-declare class DrawingLayer implements IPrimitive {
-    private readonly _order;
-    /** In paint order. */
-    private _drawings;
-    private _host;
-    private _selected;
-    /** The drawing under the pointer, whether or not it is selected. */
-    private _hovered;
-    /** Where the next click will land while the magnet is pulling it. */
-    private _snap;
-    /** Anchors of the in-progress drawing, plus the live cursor point. */
-    private _preview;
-    /** The layer under this one, whose handles and hits this layer answers for. */
-    private _below;
-    /** The layer that has taken over this one's handles and hit-testing. */
-    private _above;
-    /** Sizes grab targets for the device last seen. */
-    private _touch;
-    constructor(order?: DrawingLayerOrder);
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    zOrder(): ZOrder;
-    /** Drawings overlay the price range; they never drive it. */
-    autoscaleInfo(): null;
-    setDrawings(drawings: readonly Drawing[]): void;
-    setSelected(ids: readonly string[]): void;
+    priceToCoordinate?(price: number, paneIndex?: number): number | null;
+    coordinateToPrice?(y: number, paneIndex?: number): number | null;
     /**
-     * The drawing under the pointer. Its handles paint at a lighter weight than
-     * a selection's, as the hint that it can be grabbed. Repaints only from the
-     * layer that paints handles: the adopted bottom layer keeps the id for its
-     * own bookkeeping and asks for nothing, since its repaint costs the series.
+     * Optional, the time-axis half of the same conversion. coordinateToTime also
+     * keeps previews and freehand strokes active in empty space beyond the bars.
+     * Without these methods a horizontal nudge assumes the default bar spacing.
      */
-    setHovered(id: string | null): void;
-    hovered(): string | null;
+    timeToCoordinate?(time: number): number;
+    coordinateToTime?(x: number): number;
     /**
-     * The point the magnet will snap the next click to, or null when it is not
-     * pulling. Painted as a hollow ring so the user sees the anchor land before
-     * committing to it.
+     * Optional, and used only to keep a paste from a chart with more panes than
+     * this one landing on a pane the user cannot see. Adding a primitive creates
+     * the pane it names, so without this a drawing copied out of an indicator
+     * pane would conjure an empty pane in a single-pane chart.
      */
-    setSnapPoint(point: DrawingPoint | null): void;
-    snapPoint(): DrawingPoint | null;
+    panes?(): readonly unknown[];
+}
+interface DrawingControllerOptions {
     /**
-     * Size the grab targets for the device in use. Touch doubles the radii; a
-     * mouse or a pen keeps the desktop sizes. The render context may carry the
-     * same fact (`pointerType`), and when it does that wins per call, so a
-     * first touch on a fresh chart is already sized right.
+     * Snap new anchors to the O/H/L/C of the bar under the cursor. `'strong'`
+     * always takes the nearest of the four; `'weak'` only when one sits within
+     * a few pixels of the pointer, so a click on open space stays where it was
+     * made. `true` means `'strong'` and `false` means `'off'`, which is what
+     * the boolean meant before the modes existed. Default `'off'`. While a
+     * tool is armed the layer paints a ring where the next click will land.
      */
-    setPointerType(kind: DrawingPointerKind | null | undefined): void;
-    setPreview(drawing: Drawing | null): void;
+    magnet?: boolean | MagnetMode;
+    /** Style merged under every tool's own defaults. */
+    defaultStyle?: DrawingStyle;
+    /** Stay in the active tool after finishing a drawing. Default false. */
+    stayInDrawingMode?: boolean;
+    /** Undo depth. Default 50. */
+    historyLimit?: number;
     /**
-     * Adopt the layer under this one. From then on this layer paints the handles
-     * of both and answers `hitTest` for both, and the adopted layer paints bodies
-     * only. Handles have to live up here: a selected drawing under the series
-     * would otherwise have its handles buried under the candles, and a handle
-     * you cannot see is a handle you cannot grab. Pass null to release.
+     * Where copy and paste move text. Defaults to `navigator.clipboard`; pass a
+     * port to route through a host's own transfer, or `null` to stay in the
+     * process-local clipboard entirely.
      */
-    setBelow(layer: DrawingLayer | null): void;
-    /** Repaint for overlay-only state, from the layer that paints it. */
-    private _requestOverlay;
-    /** Whether targets are sized for a fingertip on this call. */
-    private _isTouch;
-    private _grabRadius;
-    private _handleRadius;
-    /** Map an anchor to media px on this pane. */
-    private _project;
-    private _points;
-    /** Selected, unlocked drawings of this layer, in paint order. */
-    private _handled;
+    clipboard?: ClipboardPort | null;
     /**
-     * The hovered drawing of this layer, when it is one that could be grabbed
-     * and is not already showing selection handles.
-     */
-    private _hoverHandled;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    private _drawingContext;
-    private _drawContent;
-    private _drawPlacementGuide;
-    /**
-     * Anchor handles. A hover shows them light (thin, translucent) as a hint
-     * that the shape can be grabbed; a selection shows them at full weight.
-     */
-    private _drawHandles;
-    /** The magnet ring: hollow, in the axis text colour, at the snap point. */
-    private _drawSnapRing;
-    hitTest(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
-    private _hitHandle;
-    private _hitBody;
-}
-
-/**
- * Clipboard transfer for drawings: the layer between the drawing model and the
- * OS clipboard.
- *
- * Two things make this more than `JSON.stringify`:
- *
- * 1. **The OS clipboard is shared with everything else on the machine.** A
- *    paste can arrive from a spreadsheet, another application, or a hand-edited
- *    copy of our own payload. So the payload is written under a namespaced key
- *    and everything read back is validated field by field before it can reach
- *    the model. Foreign text is *not ours* and is ignored, never an exception
- *    the host has to catch on every Ctrl+V.
- * 2. **Clipboard access is async and permission-gated.** `navigator.clipboard`
- *    rejects when the document is not focused, the page is not secure, or the
- *    user denied the permission. Copy must still work inside the tab, so every
- *    write also lands in a module-level in-memory clipboard which is shared by
- *    every controller in the page. That is what makes chart-to-chart paste work
- *    with the permission denied, and it is why the memory store is a singleton
- *    rather than per-controller state.
- *
- * The payload body is a drawings document (`DrawingsDocument`), so a copy made
- * by a 1.9.x build (a version 1 body carrying the old style-bag text fields)
- * is upgraded by the same migration a saved layout goes through.
- */
-
-/**
- * Top-level key of the JSON payload. Namespaced so a paste of arbitrary text,
- * or of JSON belonging to some other application, is recognisable as not ours
- * by looking at one property.
- */
-declare const DRAWING_CLIPBOARD_KEY = "openalgo-charts/drawings";
-/**
- * Payload format version. Tracks the model version, since the body *is* a
- * drawings document: version 1 carried 1.9.x drawings, version 2 carries the
- * split text and levelled fibs.
- */
-declare const DRAWING_CLIPBOARD_VERSION: number;
-/** The async slice of `navigator.clipboard` this module uses. */
-interface ClipboardPort {
-    writeText(text: string): Promise<void>;
-    readText(): Promise<string>;
-}
-/** Test seam: drop whatever the in-memory clipboard is holding. */
-declare function clearMemoryClipboard(): void;
-/** `navigator.clipboard` when the browser exposes it, else null. */
-declare function systemClipboard(): ClipboardPort | null;
-/** Deep copy of the persisted fields, so a clone shares nothing with its source. */
-declare function cloneDrawing(d: Drawing): Drawing;
-/** Serialise drawings into the namespaced payload written to the clipboard. */
-declare function encodeClipboardPayload(drawings: readonly Drawing[]): string;
-/**
- * Validate one entry into a drawing with no id. Returns null for anything that
- * cannot be rendered: an unknown tool would throw inside the controller, and a
- * NaN anchor produces a drawing that can never be drawn or hit-tested again.
- * Accepts the 1.9.x shape too, lifting its text fields into `text`.
- */
-declare function sanitizeDrawing(value: unknown): Omit<Drawing, 'id'> | null;
-/**
- * Parse clipboard text into drawings, or null when the text is not ours or is
- * not usable. All-or-nothing on purpose: a payload with one corrupt entry is a
- * corrupt payload, and pasting the other nine silently would be worse than
- * pasting none.
- */
-declare function decodeClipboardPayload(text: unknown): Omit<Drawing, 'id'>[] | null;
-interface DrawingClipboardOptions {
-    /** Where to read and write. Defaults to `navigator.clipboard` when present. */
-    port?: ClipboardPort | null;
-    /**
-     * Keep a copy in the shared in-memory clipboard so copy and paste keep
-     * working when the OS clipboard is unavailable or the permission is refused.
-     * Default true. Set false to make a failed system write a failed copy, which
-     * a host that must not silently lose cross-tab transfer may prefer.
-     */
-    fallbackToMemory?: boolean;
-}
-/**
- * The clipboard as the controller sees it: drawings in, drawings out, no
- * exceptions escaping. Every failure mode (no clipboard API, refused
- * permission, foreign text, corrupt payload) reduces to `false` or `null`.
- */
-declare class DrawingClipboard {
-    private _port;
-    private _fallback;
-    /** Why the last operation did not reach the OS clipboard, if it did not. */
-    private _lastError;
-    constructor(options?: DrawingClipboardOptions);
-    /** Swap the port at runtime (a host granting permission later, or a test). */
-    setPort(port: ClipboardPort | null): void;
-    /**
-     * Turn the in-memory backstop off or on. With it off, a refused system write
-     * is a failed copy, which is what a host wants when a cut that cannot reach
-     * the OS clipboard must not delete the drawing.
-     */
-    setFallbackToMemory(enabled: boolean): void;
-    /**
-     * Why the OS clipboard was not used by the last call, or null when it was.
-     * Set on a successful copy too, when the payload reached memory but not the
-     * system clipboard: that copy works in this tab and will not appear in
-     * another, which is exactly what a host wants to be able to tell the user.
-     */
-    lastError(): string | null;
-    /**
-     * Write drawings out. Resolves true when the payload is retrievable by a
-     * later `read()` (through the system clipboard, or through memory when the
-     * fallback is on), false when it is not, so a caller doing a cut knows
-     * whether it is safe to delete the original.
-     */
-    write(drawings: readonly Drawing[]): Promise<boolean>;
-    /**
-     * Read drawings back, or null when there is nothing of ours to paste. The
-     * system clipboard wins when it holds our payload, so a copy made in another
-     * tab beats a stale in-tab one; memory is consulted when the read fails or
-     * returns something that is not ours. That last case can paste an older copy
-     * after the user has copied unrelated text elsewhere, which is the deliberate
-     * trade: losing the copy whenever a browser refuses the read half of the
-     * permission would be the worse surprise.
-     */
-    read(): Promise<Omit<Drawing, 'id'>[] | null>;
-}
-
-/**
- * Drawing controller: the interaction and persistence layer over
- * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
- * active tool (from its own button, a shortcut, a command palette) and the
- * controller runs placement, selection, dragging, undo, and serialisation.
- *
- * It listens on the chart's event bus (`click`, `crosshair:move`, `drag`,
- * `drag:end`) rather than the single-slot `subscribeClick`/`subscribeDrag`
- * callbacks, so a host keeps using those for its own order lines.
- *
- * Selection is a list. Every method that edits takes the whole list into one
- * undo entry, so a multi-drag, a batch delete or a paste of ten shapes is one
- * Ctrl+Z, which is what the hand that did it expects.
- */
-
-/**
- * The slice of the chart this controller needs.
- *
- * Declared structurally rather than as `Chart` on purpose. Each tier ships its
- * own bundled `.d.ts`, so naming the class here made the draw tier re-declare
- * `Chart`, and because `Chart` has private members, TypeScript treats the two
- * declarations as *different* types. A TS consumer passing the chart from
- * `createChart()` got "separate declarations of a private property", which made
- * the tier unusable from TypeScript at all. An interface with no private
- * members is structural, so the real `Chart` satisfies it with nothing to cast.
- */
-interface DrawingChartHost {
-    /**
-     * The event bus. The controller listens for `click`, `crosshair:move`,
-     * `drag`, `drag:end` and `dblclick`, and for `hover` (`{ id }`, the hit id
-     * under the pointer whenever it changes), which is what drives the hover
-     * state: the chart has already hit-tested the move, so the controller
-     * reads its answer rather than testing a second time. A host that never
-     * emits `hover` has drawings that select and drag but do not light up.
-     */
-    on(event: string, handler: (payload: unknown) => void): () => void;
-    emit(event: string, payload: unknown): void;
-    addPrimitive(primitive: IPrimitive, paneIndex?: number): void;
-    removePrimitive(primitive: IPrimitive): void;
-    readonly dataLayer: DataLayer;
-    getVisibleLogicalRange(): {
-        from: number;
-        to: number;
-    } | null;
-    drawingState(): unknown;
-    setDrawingState(state: unknown): void;
-    setPlacementMode?(active: boolean): void;
-    /**
-     * Optional, and used only to move a drawing by a fixed screen distance (a
-     * paste offset, an arrow-key nudge, a multi-drag across panes). Going
-     * through pixels rather than adding a price delta keeps the offset the same
-     * visible nudge on a log scale as on a linear one, and the same on an RSI
-     * pane as on the price pane. A host without them still gets the time half.
-     */
-    priceToCoordinate?(price: number, paneIndex?: number): number | null;
-    coordinateToPrice?(y: number, paneIndex?: number): number | null;
-    /**
-     * Optional, the time-axis half of the same conversion. coordinateToTime also
-     * keeps previews and freehand strokes active in empty space beyond the bars.
-     * Without these methods a horizontal nudge assumes the default bar spacing.
-     */
-    timeToCoordinate?(time: number): number;
-    coordinateToTime?(x: number): number;
-    /**
-     * Optional, and used only to keep a paste from a chart with more panes than
-     * this one landing on a pane the user cannot see. Adding a primitive creates
-     * the pane it names, so without this a drawing copied out of an indicator
-     * pane would conjure an empty pane in a single-pane chart.
-     */
-    panes?(): readonly unknown[];
-}
-interface DrawingControllerOptions {
-    /**
-     * Snap new anchors to the O/H/L/C of the bar under the cursor. `'strong'`
-     * always takes the nearest of the four; `'weak'` only when one sits within
-     * a few pixels of the pointer, so a click on open space stays where it was
-     * made. `true` means `'strong'` and `false` means `'off'`, which is what
-     * the boolean meant before the modes existed. Default `'off'`. While a
-     * tool is armed the layer paints a ring where the next click will land.
-     */
-    magnet?: boolean | MagnetMode;
-    /** Style merged under every tool's own defaults. */
-    defaultStyle?: DrawingStyle;
-    /** Stay in the active tool after finishing a drawing. Default false. */
-    stayInDrawingMode?: boolean;
-    /** Undo depth. Default 50. */
-    historyLimit?: number;
-    /**
-     * Where copy and paste move text. Defaults to `navigator.clipboard`; pass a
-     * port to route through a host's own transfer, or `null` to stay in the
-     * process-local clipboard entirely.
-     */
-    clipboard?: ClipboardPort | null;
-    /**
-     * Whether a refused or failing clipboard write still lands in the in-process
-     * clipboard. Defaults to true, which is what makes copy and paste work between
-     * two charts on a page where the browser has denied clipboard permission.
-     *
-     * Pass false for a host that would rather a failed copy be a failed copy: with
-     * it off, `cut` leaves the drawing alone when the write does not land, so a
-     * shape is never destroyed for a transfer that did not happen.
+     * Whether a refused or failing clipboard write still lands in the in-process
+     * clipboard. Defaults to true, which is what makes copy and paste work between
+     * two charts on a page where the browser has denied clipboard permission.
+     *
+     * Pass false for a host that would rather a failed copy be a failed copy: with
+     * it off, `cut` leaves the drawing alone when the write does not land, so a
+     * shape is never destroyed for a transfer that did not happen.
      */
     clipboardFallbackToMemory?: boolean;
     /**
@@ -1279,13 +734,17 @@ interface DrawingControllerOptions {
     pasteOffsetPixels?: number;
 }
 /** What `drawing:change` reports happened to the listed ids. */
-type DrawingChangeKind = 'add' | 'update' | 'remove' | 'reorder';
+type DrawingChangeKind = 'add' | 'update' | 'remove' | 'reorder' | 'undo' | 'redo';
 declare class DrawingController {
     private readonly _chart;
     private _opts;
     private readonly _clipboard;
     private readonly _layers;
     private _drawings;
+    private _groups;
+    private _nextGroup;
+    private readonly _linkedPreviews;
+    private _destroyed;
     private _tool;
     private _pending;
     private _pendingPane;
@@ -1307,6 +766,7 @@ declare class DrawingController {
     /** Snapshots for undo/redo; each is a full drawing list (they are small). */
     private _undo;
     private _redo;
+    private _pendingHistory;
     /**
      * One gesture's starting state. `items` are ids rather than objects because
      * an undo mid-drag replaces every drawing object, and a stale reference
@@ -1346,8 +806,25 @@ declare class DrawingController {
      * moves one; the list is the tie-break for equal `zIndex`, so it is also the
      * paint order within a band.
      */
+    /** Named drawing sets, returned as detached records. */
+    groups(): readonly DrawingGroup[];
+    /** Group live drawings, replacing any previous membership for those ids. */
+    createGroup(name: string, ids: readonly string[]): DrawingGroup | null;
+    renameGroup(id: string, name: string): boolean;
+    /** Remove a group, optionally deleting all its drawings as one edit. */
+    removeGroup(id: string, removeDrawings?: boolean): boolean;
+    /** Move one step through the rendered stack, preserving the side of the series. */
+    reorder(id: string, direction: -1 | 1): boolean;
+    private _remapPanes;
     drawings(): readonly Drawing[];
     get(id: string): Drawing | undefined;
+    get isDestroyed(): boolean;
+    /** Apply a linked commit without adding to this chart's local undo history. */
+    applyLinkedDrawing(id: string, drawing: Drawing | null): void;
+    /** A linked drag paints over its committed drawing without changing saved state. */
+    setLinkedPreview(id: string, drawing: Drawing | null): void;
+    /** Reorder related drawings inside their existing slots, preserving unrelated local order. */
+    reorderLinkedDrawings(ids: readonly string[]): void;
     /** Supported numeric levels, independent of whether the queried time lies on the shape. */
     alertInfo(id: string): AlertDrawingInfo;
     /** Numeric drawing value using the actual pane projection and collapsed time axis. */
@@ -1457,6 +934,7 @@ declare class DrawingController {
     private _offsetTime;
     undo(): boolean;
     redo(): boolean;
+    private _applyHistory;
     /** Drop selected ids the model no longer holds, after a history jump. */
     private _pruneSelection;
     canUndo(): boolean;
@@ -1546,78 +1024,753 @@ declare class DrawingController {
     private _onClick;
     private _placePoint;
     /**
-     * Where a click at `point` actually lands for the armed tool: on the 45
-     * degree lock while Shift holds the free end of a line, else on the magnet
-     * when it pulls, else where it was. The lock wins over the magnet because a
-     * snapped price would bend the exact angle the lock exists to give.
+     * Where a click at `point` actually lands for the armed tool: on the 45
+     * degree lock while Shift holds the free end of a line, else on the magnet
+     * when it pulls, else where it was. The lock wins over the magnet because a
+     * snapped price would bend the exact angle the lock exists to give.
+     */
+    private _aimPoint;
+    /**
+     * The free end of a two-anchor line under angle lock, or null when the lock
+     * does not apply: no Shift, a tool without the flag, no anchor yet to
+     * measure from, or a host that cannot map pixels (the lock is a screen
+     * angle, so there is nothing to lock to in data space).
+     */
+    private _lockedPoint;
+    /**
+     * The nearest O/H/L/C of the hovered bar, at that bar's time, when the
+     * magnet pulls; null when it does not. `strong` always pulls; `weak` only
+     * within a few pixels, measured on screen so the pull is the same reach at
+     * every zoom. Price panes only: an indicator pane's values are not prices.
+     */
+    private _snapPoint;
+    private _onDrag;
+    private _emitDragPreview;
+    /** Roll back an interrupted drag and leave the pre-gesture undo/redo stacks intact. */
+    cancelDrag(): boolean;
+    /** Apply one drag frame to the model, from the gesture's snapshot. */
+    private _moveDrag;
+    /** How far down the screen `to` is from `from` on one pane, in media px. */
+    private _pixelDelta;
+    /** An anchor in container media px, or null on a host without the mapping. */
+    private _toPixel;
+    /** The inverse of `_toPixel`. */
+    private _fromPixel;
+    /**
+     * `free` projected onto the nearest 45 degree ray from `anchor`, all in
+     * screen space: the angle the eye reads is the one on the canvas, and a log
+     * scale or a tall pane would make a data-space angle anything but. The
+     * projection rather than a rotation, so a level line still ends under the
+     * pointer's x and a vertical one under its y; only the stray axis is
+     * dropped. Null when the host cannot map pixels, or the two coincide.
+     */
+    private _lockAngle;
+    private _onDragEnd;
+    /**
+     * The pair of layers for a pane, made on first use. The bottom one is added
+     * first so a host that lists primitives sees them in paint order; the top one
+     * adopts it so handles and hit-tests come from one place.
+     */
+    private _layerFor;
+    /** Whether a drawing paints on the top layer: over the series, or lifted for a drag. */
+    private _onTop;
+    /** Push the current list into each pane's layers and into the chart state. */
+    private _sync;
+    /**
+     * The per-frame half of a drag: only the top layers of the panes the
+     * gesture touches are re-listed, so the repaint stays on the cursor tier.
+     * Everything moving is on a top layer by then (anything under the series
+     * was lifted when the gesture began), and the bottom layers have not
+     * changed since, so re-listing them would cost a series repaint for
+     * nothing.
+     */
+    private _syncDrag;
+    /**
+     * Mirror the in-progress anchors (plus the cursor) into the preview slot.
+     * The cursor point goes through the same aim as a click would, so the
+     * preview shows the locked angle or the snapped anchor before it lands.
+     */
+    private _syncPreview;
+    /**
+     * Show where the magnet will land the next click, or nothing. A ring only
+     * while a click would place an anchor: a tool armed, not a brush (which
+     * inks where the pointer is), and the pull actually applying at the cursor.
+     * Angle lock bypasses the magnet, so it hides the ring too.
+     */
+    private _syncSnapRing;
+    private _pushUndo;
+}
+
+/** Both fields must be known. A host may use its feed namespace as the exchange. */
+interface DrawingLinkContext {
+    symbol?: string;
+    exchange?: string;
+}
+/** Resolve a host-owned identity without modifying the chart's data context. */
+type DrawingLinkContextSource = DrawingLinkContext | (() => DrawingLinkContext | null | undefined);
+interface DrawingLinkOptions {
+    enabled?: boolean;
+}
+interface DrawingLinkChart extends Pick<DrawingChartHost, 'on'> {
+    readonly isDestroyed?: boolean;
+    getDataContext?(): Readonly<DrawingLinkContext> | undefined;
+}
+/**
+ * Existing local drawings stay local until `share` is called. Persisted shared
+ * lineage reconnects across restores. Only price-pane drawings participate; time anchors
+ * cross the boundary unchanged so each interval uses its own coordinate map.
+ */
+declare class DrawingLinkGroup {
+    private readonly _members;
+    private _enabled;
+    private _broadcasting;
+    private _destroyed;
+    constructor(options?: DrawingLinkOptions);
+    options(): Required<DrawingLinkOptions>;
+    add(chart: DrawingLinkChart, controller: DrawingController, context?: DrawingLinkContextSource): void;
+    setOptions(options: DrawingLinkOptions): void;
+    /** Report the current instrument. Unknown identity stops sharing immediately. */
+    setContext(chart: DrawingLinkChart, context: DrawingLinkContext | undefined): void;
+    /** Share selected ids, or every existing eligible drawing when ids are omitted. */
+    share(chart: DrawingLinkChart, ids?: readonly string[]): number;
+    has(chart: DrawingLinkChart): boolean;
+    /** Committed drawings remain on peers; transient previews are discarded. */
+    remove(chart: DrawingLinkChart): void;
+    destroy(): void;
+    private _eligible;
+    private _create;
+    private _reconnect;
+    private _change;
+    private _commit;
+    private _preview;
+    private _syncOrder;
+    private _orderFrom;
+    private _clearPreview;
+    private _clearMemberPreviews;
+    private _detachDrawings;
+}
+declare function createDrawingLinkGroup(options?: DrawingLinkOptions): DrawingLinkGroup;
+
+/**
+ * Built-in drawing tools + the tool registry. Same philosophy as the chart-type
+ * and indicator registries: a tool is a descriptor, the layer just runs it, and
+ * `registerDrawingTool` makes a custom one first-class.
+ *
+ * `draw` receives anchors already in device px; `distance` receives them in
+ * media px, the same space as the incoming cursor.
+ *
+ * Text lives in `drawing.text` (a `DrawingText`), never in the style bag: a
+ * shape's outline colour and its label colour are two decisions, and a tool
+ * that prints only a readout (a fib ladder, a measure chip) still reads its
+ * face from there. Ladders read `FibLevel[]` and stroke each level in its own
+ * colour, taken from the shared palette in levels.ts.
+ *
+ * Every tool declares `settings`: the fields a host may show for it. The
+ * schema is a contract, not a wish list. A field is declared only when this
+ * file reads it, because a control with nothing behind it is a defect.
+ */
+
+declare function registerDrawingTool(tool: DrawingTool): void;
+declare function getDrawingTool(id: string): DrawingTool;
+declare function hasDrawingTool(id: string): boolean;
+declare function registeredDrawingTools(): DrawingTool[];
+/** Keyboard event fields a shortcut is matched against. */
+interface ShortcutEvent {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+}
+/**
+ * The id of the tool whose `shortcut` matches this key event, or `null`.
+ *
+ * Pure, so a host can bind one `keydown` listener and decide for itself when
+ * shortcuts apply. The library installs no listener, because only the host
+ * knows whether the chart has focus, a dialog is open, or the user is typing.
+ *
+ * Modifiers must match exactly: `Alt+T` will not fire for `Ctrl+Alt+T`, so a
+ * tool shortcut cannot shadow a browser or host chord. `metaKey` (Cmd) is
+ * treated as Ctrl, which is what a Mac user expects.
+ */
+declare function matchDrawingShortcut(e: ShortcutEvent): string | null;
+/** Every registered tool that has a shortcut, as `id -> shortcut`. */
+declare function drawingShortcuts(): Record<string, string>;
+/**
+ * The settings a host may show for a tool: the tool's own declaration, else
+ * the line fields, which every stroked custom tool reads. This is a registry
+ * lookup, which is why it lives here and not in schema.ts: that module stays
+ * free of any import that could loop back into this one.
+ */
+declare function drawingSettingsSchema(toolId: string): SettingsSchema;
+declare const TREND_LINE: DrawingTool;
+declare const RAY: DrawingTool;
+declare const EXTENDED_LINE: DrawingTool;
+declare const ARROW: DrawingTool;
+declare const HORIZONTAL_LINE: DrawingTool;
+declare const HORIZONTAL_RAY: DrawingTool;
+declare const VERTICAL_LINE: DrawingTool;
+declare const CROSS_LINE: DrawingTool;
+declare const RECTANGLE: DrawingTool;
+declare const ELLIPSE: DrawingTool;
+declare const PARALLEL_CHANNEL: DrawingTool;
+declare const FIB_RETRACEMENT: DrawingTool;
+declare const FIB_EXTENSION: DrawingTool;
+declare const MEASURE: DrawingTool;
+declare const LONG_POSITION: DrawingTool;
+declare const SHORT_POSITION: DrawingTool;
+declare const TEXT: DrawingTool;
+/**
+ * Path: click each vertex, double-click to finish, arrowhead on the last leg.
+ * The arrow is what separates it from `polyline`: a path points somewhere.
+ */
+declare const PATH: DrawingTool;
+/**
+ * Brush: freehand ink. Press, drag, release. The anchors are the thinned
+ * samples of the gesture and the spline between them is what is stroked, so
+ * the ink stays a curve after the thinning that keeps a stroke small.
+ */
+declare const BRUSH: DrawingTool;
+/**
+ * Rotated rectangle: anchors 0 and 1 lay out one edge (and so the rotation),
+ * and anchor 2 sets the depth perpendicular to it. An axis-aligned `rectangle`
+ * cannot follow a trend channel; this can.
+ */
+declare const ROTATED_RECTANGLE: DrawingTool;
+/**
+ * Double curve: an S through three anchors. `curve` bends one way off a single
+ * control; this mirrors that control about the midpoint so the second half bends
+ * back, which is the shape a rounded top-then-bottom actually needs.
+ */
+declare const DOUBLE_CURVE: DrawingTool;
+/**
+ * Cyclic lines: vertical lines repeating at the interval the two anchors set,
+ * for reading a rhythm forward off a measured swing.
+ */
+declare const CYCLIC_LINES: DrawingTool;
+/**
+ * Time cycles: semicircles of the anchors' width repeating along the axis, the
+ * classic cycle-projection overlay.
+ */
+declare const TIME_CYCLES: DrawingTool;
+/**
+ * Sine line: a full wave between the anchors. The horizontal span is one
+ * period, the vertical offset its amplitude.
+ */
+declare const SINE_LINE: DrawingTool;
+/**
+ * Price label: a pill of the anchored price with a tail pointing at the bar.
+ * Reads its value off the anchor, so dragging it re-reads rather than going
+ * stale the way a typed-in text would. Text, when given, replaces the price.
+ */
+declare const PRICE_LABEL: DrawingTool;
+/**
+ * Callout: a text bubble on its own anchor with a tail back to the point it
+ * annotates, so the note can sit clear of the price action it refers to.
+ */
+declare const CALLOUT: DrawingTool;
+/** Flag mark: a pennant on a pole at one anchor, for tagging a bar. */
+declare const FLAG_MARK: DrawingTool;
+/**
+ * Note: a pin at the bar with its text to the upper right.
+ *
+ * The pin is the point being annotated and the plate is the annotation, which
+ * is why the two are drawn as separate marks joined by a stem rather than as
+ * one bubble: the reader needs to see exactly which bar is meant, and a bubble
+ * wide enough to hold a sentence covers several.
+ */
+declare const NOTE: DrawingTool;
+/**
+ * Balloon: a speech bubble sitting above its anchor, tail pointing down.
+ *
+ * One anchor rather than the callout's two: a balloon is for saying something
+ * *about this bar*, so letting the bubble be dragged away from what it labels
+ * would only invite it to drift.
+ */
+declare const BALLOON: DrawingTool;
+/**
+ * Comment: a small square-cornered box with a tail off its bottom left.
+ *
+ * Deliberately plainer than the balloon: a chart that says something at every
+ * other bar needs one of these marks to be quiet, and the shape is the only
+ * thing distinguishing them once both are the user's own colour.
+ */
+declare const COMMENT: DrawingTool;
+/**
+ * Signpost: a post standing on the bar with its plate at the top.
+ *
+ * The one annotation anchored to *time* rather than to a level: the post is
+ * vertical so the plate can clear the price action entirely while the foot
+ * still names an exact bar. Useful for events, which happen at a moment and
+ * not at a price.
+ */
+declare const SIGNPOST: DrawingTool;
+/**
+ * Price note: the anchored price, with the user's text under it.
+ *
+ * The price is read off the anchor rather than typed, so dragging the note
+ * re-reads it. A typed price is a number that was true once, which on a chart
+ * is worse than no number at all.
+ */
+declare const PRICE_NOTE: DrawingTool;
+/**
+ * Table: rows of text in a grid, anchored top-left.
+ *
+ * Cells come from the text: a newline starts a row and a pipe separates
+ * columns, so a whole table is one editable string and survives `getState`
+ * with no new shape in the drawing model. The first row is drawn as a header
+ * because a table on a chart is nearly always labelled.
+ */
+declare const TABLE: DrawingTool;
+/**
+ * Measurers. `measure` reports price *and* time together; these two constrain it
+ * to one axis, which is what you want when the other one is noise: sizing a
+ * retracement without caring how long it took, or counting bars to an event
+ * without caring where price went.
+ */
+declare const PRICE_RANGE: DrawingTool;
+declare const DATE_RANGE: DrawingTool;
+/**
+ * Position forecast: project a move from an anchor. Two anchors give the
+ * projected leg; the shape extends the same slope past the target as a dashed
+ * cone, so the drawing says "if this continues" rather than just marking a line.
+ */
+declare const FORECAST: DrawingTool;
+/**
+ * Circle from centre + a radius handle. The radius is measured in *pixels*, so
+ * it stays a circle on screen instead of the ellipse the two axes' differing
+ * scales would otherwise produce.
+ */
+declare const CIRCLE: DrawingTool;
+declare const TRIANGLE: DrawingTool;
+/** Free-form polyline: click each vertex, double-click to finish. */
+declare const POLYLINE: DrawingTool;
+/** Arc through three anchors: the middle one is on the curve, not a handle. */
+declare const ARC: DrawingTool;
+/** Quadratic curve: the middle anchor is a control handle, off the curve. */
+declare const CURVE: DrawingTool;
+declare const ARROW_UP: DrawingTool;
+declare const ARROW_DOWN: DrawingTool;
+declare const ARROW_LEFT: DrawingTool;
+declare const ARROW_RIGHT: DrawingTool;
+/** Highlighter: the brush with a fat, translucent stroke. */
+declare const HIGHLIGHTER: DrawingTool;
+/** Fib channel: fib levels spread across a trend leg, parallel to it. */
+declare const FIB_CHANNEL: DrawingTool;
+/**
+ * Fib time zone: vertical lines at Fibonacci multiples of the base leg's width.
+ * Its levels count bars rather than divide a leg, so they carry no convention
+ * colour and fall back to the drawing's own.
+ */
+declare const FIB_TIME_ZONE: DrawingTool;
+/** Rays from the anchor at fib fractions of the leg: the speed resistance fan. */
+declare const FIB_FAN: DrawingTool;
+/**
+ * Gann fan: rays from one anchor at the classic price/time angles. A level's
+ * ratio is price per unit of time, so the 1x1 is 1, the 1x2 is 0.5 and the
+ * 2x1 is 2; each angle keeps its own colour from the cycle palette.
+ */
+declare const GANN_FAN: DrawingTool;
+/**
+ * Gann box: the drawn rectangle divided at its levels on both axes, plus the
+ * 1x1 diagonal. Ratio 0 is the first anchor's price and time, ratio 1 the
+ * second's, so the box reads like a retracement laid over a date range.
+ */
+declare const GANN_BOX: DrawingTool;
+declare const BUILTIN_DRAWING_TOOLS: readonly DrawingTool[];
+/** Register every built-in tool. Idempotent; called on tier import. */
+declare function registerBuiltinDrawingTools(): void;
+
+/**
+ * The shared level palette for the Fibonacci and Gann family.
+ *
+ * Every ladder tool (retracement, extension, channel, fan, time zone, the Gann
+ * fan and box) strokes a list of ratios, and each ratio has a colour the eye
+ * expects: 0.618 reads as one thing across every tool, not a different hue per
+ * tool. Before this module each tool would have restated those colours, and
+ * restated colours drift. This is the one statement; tools take their defaults
+ * from it and hosts seed a newly added level from it.
+ *
+ * Pure: no DOM, no registry. Safe to import from a worker or a settings panel.
+ */
+
+/**
+ * The colour of a ratio that is an anchor rather than a level (0, 1, 2, 3 are
+ * where the measured leg starts and ends, or whole multiples of it) and of any
+ * ratio the convention does not name. Neutral on purpose: it is the reference
+ * the coloured levels are read against.
+ */
+declare const LEVEL_NEUTRAL = "#787b86";
+/**
+ * The conventional colour for a Fibonacci ratio. Anchors (0, 1, 2, 3) and any
+ * ratio without a convention come back {@link LEVEL_NEUTRAL}, so a host can call
+ * this for every new level and always get a usable colour.
+ */
+declare function levelColor(ratio: number): string;
+/**
+ * A short sequence of colours that stay distinguishable side by side, for
+ * tools whose levels are positions rather than ratios: the angles of a Gann
+ * fan, the repeats of a cycle. Index `i` wraps, so any count is safe.
+ */
+declare const CYCLE_PALETTE: readonly string[];
+/** The `i`th cycle colour. Wraps in both directions; a negative index is fine. */
+declare function cycleColor(i: number): string;
+/** `0.618` as `61.8%`: the text a level prints when it carries no label. */
+declare function formatRatio(ratio: number): string;
+/**
+ * The label for a Gann angle stored as a price-per-time ratio: `1` is the 1x1,
+ * `0.5` the 1x2, `2` the 2x1. Ratios that are not clean reciprocals fall back
+ * to the ratio itself, which is still true, just less idiomatic.
+ */
+declare function gannLabel(ratio: number): string;
+/** A mutable copy of a default ladder, for a fresh drawing's own `style.levels`. */
+declare function cloneLevels(levels: readonly FibLevel[]): FibLevel[];
+/** Retracement and extension: the classic ladder, coloured by convention. */
+declare const DEFAULT_FIB: readonly FibLevel[];
+/** Speed fan: rays at the fractions of the leg. No 0 ray, it would be flat. */
+declare const DEFAULT_FIB_FAN: readonly FibLevel[];
+/** Gann box: quarters plus the golden pair, applied to both axes of the box. */
+declare const DEFAULT_GANN_BOX: readonly FibLevel[];
+/**
+ * Gann fan: the classic angles as price-per-time ratios, 1x8 up to 8x1. These
+ * are positions in a sequence rather than Fibonacci ratios, so they take the
+ * cycle palette.
+ */
+declare const DEFAULT_GANN_FAN: readonly FibLevel[];
+/**
+ * Time zones count bars along the Fibonacci sequence, so `ratio` here is a
+ * multiple of the anchor leg, not a fraction of it. No colour is set: there is
+ * no convention for "the 13 line", so every zone takes the drawing's own colour
+ * until the user gives one its own.
+ */
+declare const DEFAULT_FIB_TIME_ZONE: readonly FibLevel[];
+
+/**
+ * Glyphs for the drawing tools and for host chrome, as path data.
+ *
+ * The engine ships no DOM, and this does not change that: an icon here is a
+ * string of SVG path commands, not an element. The host still builds its own
+ * toolbar, flyouts and rail; what it no longer has to do is draw every glyph
+ * before it can show them. `icon-svg.ts` turns these into markup strings for a
+ * host that wants the convenience; this file is the single source both of them
+ * and every other surface read from.
+ *
+ * That was the real cost of leaving them out. Every adopter drew their own set,
+ * each drifted on stroke weight, grid and visual density independently, and the
+ * result read as sixty icons rather than as one set, however carefully any
+ * single glyph was made. A shipped set is worth more than a better glyph.
+ *
+ * # Two tiers, one weight
+ *
+ * Tool glyphs live on a 24-unit grid and are shown at 24px in the rail. Host
+ * chrome (undo, close, the settings tab rail) is shown at 16px beside them, and
+ * a 24-grid glyph scaled to 16 lands its 2-unit stroke on 1.33 pixels, blurred
+ * across two rows on every edge. So chrome has its own registry drawn on a
+ * 16-unit grid with a 1.5 stroke. The two strokes are deliberately not in exact
+ * proportion: a small glyph needs a slightly heavier relative stroke than a
+ * large one to read as the same weight, and `tests/draw-icons.test.ts` holds
+ * the chrome tier inside that band rather than at parity.
+ *
+ * # The grid
+ *
+ * Every glyph is authored to the same constraints, and `tests/draw-icons.test.ts`
+ * enforces all of them mechanically, because a set of this size cannot be kept
+ * consistent by review:
+ *
+ *  - **One viewBox per tier.** 24 by 24 for tools, 16 by 16 for chrome, so a
+ *    host sets the size once per surface.
+ *  - **A margin all round.** Live area 2 to 22 on the tool grid, 1 to 15 on the
+ *    chrome grid. Without it, glyphs that happen to reach the edge look larger
+ *    than their neighbours and the rail reads as ragged.
+ *  - **Integer coordinates.** With `STROKE` of 2, an orthogonal edge centred on
+ *    an integer covers exactly two device pixels at 1:1, which is what makes it
+ *    crisp. Half-unit coordinates were the previous set's crispness bug: at a
+ *    1.5 stroke on integers, nothing landed on a pixel boundary at any size.
+ *  - **One stroke weight per tier.** Three different weights across identically
+ *    sized boxes is the single most visible tell of a set assembled rather than
+ *    drawn.
+ *
+ * # Rendering
+ *
+ * Tool glyphs are crispest at 24px, and at any integer multiple of it. At 18px
+ * the 0.75 scale puts a 2-unit stroke on 1.5 device pixels and every edge is
+ * anti-aliased across two rows: that is a host sizing choice, not something the
+ * path data can fix. Prefer 24, or 12 with a heavier weight. Chrome glyphs are
+ * drawn for 16px and its multiples.
+ */
+/** The viewBox every glyph is authored in. */
+declare const ICON_VIEWBOX = "0 0 24 24";
+/**
+ * Stroke width in viewBox units. Paths carry no presentation attributes, so a
+ * host that wants a lighter set overrides this once rather than editing glyphs.
+ */
+declare const ICON_STROKE = 2;
+/**
+ * The attribute bag a tier hands its host. Structural, so the markup builders
+ * in `icon-svg.ts` take either tier's bag through one signature.
+ */
+interface IconAttrs {
+    readonly viewBox: string;
+    readonly fill: 'none';
+    readonly stroke: 'currentColor';
+    readonly strokeWidth: number;
+    readonly strokeLinecap: 'round';
+    readonly strokeLinejoin: 'round';
+}
+/** Attributes a host should apply to the `<svg>`, so every set matches. */
+declare const ICON_ATTRS: {
+    readonly viewBox: "0 0 24 24";
+    readonly fill: "none";
+    readonly stroke: "currentColor";
+    readonly strokeWidth: 2;
+    readonly strokeLinecap: "round";
+    readonly strokeLinejoin: "round";
+};
+/**
+ * Path data by tool id, plus a few keys a host toolbar needs that are not
+ * themselves tools (`cursor`, the group headers).
+ *
+ * Values are the `d` attribute of one `<path>`. Multiple subpaths are joined
+ * into the same string rather than split across elements, so a host renders one
+ * node per glyph.
+ */
+declare const DRAWING_TOOL_ICONS: Readonly<Record<string, string>>;
+/**
+ * The glyph for a tool, or `undefined` when it has none.
+ *
+ * Undefined rather than a placeholder: a host that renders an empty box has a
+ * visible gap to fix, while one handed a question mark ships it.
+ */
+declare function drawingToolIcon(toolId: string): string | undefined;
+/** Every id this set covers, for a host building a palette from it. */
+declare function drawingToolIconIds(): string[];
+/** The viewBox every chrome glyph is authored in. */
+declare const CHROME_ICON_VIEWBOX = "0 0 16 16";
+/**
+ * Chrome stroke width in viewBox units. Not the tool stroke scaled (that would
+ * be 1.33): at 16px a glyph needs a touch more relative weight than at 24px to
+ * read as the same line, and 1.5 is where the two rails match by eye.
+ */
+declare const CHROME_ICON_STROKE = 1.5;
+/** Attributes a host should apply to the `<svg>` around a chrome glyph. */
+declare const CHROME_ICON_ATTRS: {
+    readonly viewBox: "0 0 16 16";
+    readonly fill: "none";
+    readonly stroke: "currentColor";
+    readonly strokeWidth: 1.5;
+    readonly strokeLinecap: "round";
+    readonly strokeLinejoin: "round";
+};
+/**
+ * Path data for host chrome: the buttons around the chart rather than the
+ * tools in it. Same rules as the tool tier (one path per glyph, no presentation
+ * attributes, integer coordinates) on the 16 grid with a 1..15 live area.
+ *
+ * The pair `cursor` / `magnet` / `text` also exist in the tool registry, at 24.
+ * They are drawn twice on purpose: a rail button and a toolbar button are
+ * different sizes, and the whole point of a second grid is not scaling one
+ * drawing to both.
+ */
+declare const CHROME_ICONS: Readonly<Record<string, string>>;
+/**
+ * Chrome glyphs meant to be painted solid. Paths carry no presentation
+ * attributes, so the fill is applied by the wrapper (`chromeIconSvg` does it,
+ * a host with its own wrapper reads this set) and the registry stays pure.
+ */
+declare const CHROME_ICON_FILLED: ReadonlySet<string>;
+/** The chrome glyph for an id, or `undefined` when there is none. */
+declare function chromeIcon(id: string): string | undefined;
+/** Every id the chrome tier covers. */
+declare function chromeIconIds(): string[];
+
+/** Prefix of every `<symbol id>` in the sprite, and of every `<use href>`. */
+declare const ICON_SYMBOL_PREFIX = "oac-icon-";
+/** Options shared by the inline builders. */
+interface IconSvgOptions {
+    /**
+     * Width and height. A number is CSS pixels; a string is written verbatim, so
+     * `'1em'` sizes the glyph with the surrounding text. Default: the grid's
+     * native size (24 for tools, 16 for chrome), where the stroke is crispest.
      */
-    private _aimPoint;
+    size?: number | string;
+    /** Stroke width in viewBox units. Default: the tier's `*_STROKE`. */
+    stroke?: number;
+    /** A class for the host's own styling. */
+    className?: string;
+}
+/** Options for `toolCursor`. */
+interface ToolCursorOptions {
+    /** Cursor image size in CSS pixels. Default 20. Browsers reject images over 128. */
+    size?: number;
+    /** The pointer's active pixel, from the image's top-left. Default: the centre. */
+    hotspot?: readonly [number, number];
+    /** Glyph colour. Default white. */
+    color?: string;
     /**
-     * The free end of a two-anchor line under angle lock, or null when the lock
-     * does not apply: no Shift, a tool without the flag, no anchor yet to
-     * measure from, or a host that cannot map pixels (the lock is a screen
-     * angle, so there is nothing to lock to in data space).
+     * Halo colour. Default: black under a light `color`, white under a dark one,
+     * judged from a hex colour. A non-hex `color` gets a black halo unless this
+     * is set.
      */
-    private _lockedPoint;
+    halo?: string;
+    /** The keyword after the image, for a browser that will not take it. Default `crosshair`. */
+    fallback?: string;
+}
+/**
+ * A complete inline `<svg>` for one tool glyph, stroked in `currentColor`.
+ *
+ * ```ts
+ * button.innerHTML = iconSvg('trend-line');
+ * button.innerHTML = iconSvg('trend-line', { size: '1em' });
+ * ```
+ */
+declare function iconSvg(id: string, opts?: IconSvgOptions): string;
+/**
+ * A complete inline `<svg>` for one chrome glyph, on the 16 grid. Glyphs in
+ * `CHROME_ICON_FILLED` are painted solid as well as stroked.
+ */
+declare function chromeIconSvg(id: string, opts?: IconSvgOptions): string;
+/**
+ * One hidden `<svg>` of `<symbol>`s, for a host that shows many glyphs and
+ * wants each path in the document once. Inject it once, then place glyphs with
+ * `iconUse`. Symbols carry the path and viewBox only; stroke and fill inherit
+ * from the `<svg>` around each `<use>`, so one sprite serves every weight.
+ *
+ * Default: every tool glyph. Repeated ids collapse to one symbol, since a
+ * duplicate element id is an invalid document.
+ */
+declare function iconSprite(ids?: readonly string[]): string;
+/** An `<svg>` that references a symbol from `iconSprite`. Same frame as `iconSvg`. */
+declare function iconUse(id: string, opts?: IconSvgOptions): string;
+/**
+ * A CSS `cursor` value carrying the tool's glyph, for the canvas while that
+ * tool is armed.
+ *
+ * The glyph is drawn twice: once in `halo`, one pixel wider on each side, and
+ * once in `color` on top, so it reads on a light chart and a dark one without
+ * the host choosing per theme. The value is `url("data:image/svg+xml,...") x y,
+ * fallback`, ready for `canvas.style.cursor`.
+ */
+declare function toolCursor(id: string, opts?: ToolCursorOptions): string;
+
+/**
+ * A `DrawingLayer` renders the drawings of one pane and answers the chart's
+ * hit-test. Anchors live in `{ time, price }`, so the layer maps them through
+ * the *fractional* index helpers: the gapless axis means an anchor can sit
+ * between bars (inside a collapsed weekend) or past the last one (a forward
+ * projection), and whole-index lookups have nothing to return there.
+ *
+ * Each pane carries **two** layers, one at z-order `bottom` for drawings with a
+ * negative `zIndex` (under the series) and one at `top` for the rest. The top
+ * one takes over handles and hit-testing for the pair through `setBelow`, so a
+ * shape parked under the candles still shows its grab handles above them and
+ * a click lands on whatever the eye sees on top.
+ *
+ * Hit ids are `draw:<id>` for the body and `draw:<id>#<n>` for anchor `n`, so
+ * the controller can tell "move the whole shape" from "move this handle".
+ *
+ * The hover ring, the magnet ring and the hover handles are all overlay
+ * state: they change on every pointer move, so they must only ever cost the
+ * top canvas. The layer that paints them is the one whose `requestUpdate`
+ * the chart maps to the cursor tier, which is why the bottom layer of a pair
+ * stores that state and asks for nothing.
+ */
+
+/** Which side of the series a layer paints on. */
+type DrawingLayerOrder = 'bottom' | 'top';
+/** The pointer kinds the layer sizes its targets for. */
+type DrawingPointerKind = 'mouse' | 'touch' | 'pen';
+/**
+ * Paint order: by `zIndex`, ties by array position. `Array.prototype.sort` is
+ * stable, which is what makes the tie rule hold without a second key.
+ */
+declare function sortByZIndex(drawings: readonly Drawing[]): Drawing[];
+declare class DrawingLayer implements IPrimitive {
+    private readonly _order;
+    /** In paint order. */
+    private _drawings;
+    private _host;
+    private _selected;
+    /** The drawing under the pointer, whether or not it is selected. */
+    private _hovered;
+    /** Where the next click will land while the magnet is pulling it. */
+    private _snap;
+    /** Anchors of the in-progress drawing, plus the live cursor point. */
+    private _preview;
+    /** The layer under this one, whose handles and hits this layer answers for. */
+    private _below;
+    /** The layer that has taken over this one's handles and hit-testing. */
+    private _above;
+    /** Sizes grab targets for the device last seen. */
+    private _touch;
+    constructor(order?: DrawingLayerOrder);
+    attached(host: PrimitiveHost): void;
+    detached(): void;
+    zOrder(): ZOrder;
+    /** Drawings overlay the price range; they never drive it. */
+    autoscaleInfo(): null;
+    setDrawings(drawings: readonly Drawing[]): void;
+    setSelected(ids: readonly string[]): void;
     /**
-     * The nearest O/H/L/C of the hovered bar, at that bar's time, when the
-     * magnet pulls; null when it does not. `strong` always pulls; `weak` only
-     * within a few pixels, measured on screen so the pull is the same reach at
-     * every zoom. Price panes only: an indicator pane's values are not prices.
+     * The drawing under the pointer. Its handles paint at a lighter weight than
+     * a selection's, as the hint that it can be grabbed. Repaints only from the
+     * layer that paints handles: the adopted bottom layer keeps the id for its
+     * own bookkeeping and asks for nothing, since its repaint costs the series.
      */
-    private _snapPoint;
-    private _onDrag;
-    /** Apply one drag frame to the model, from the gesture's snapshot. */
-    private _moveDrag;
-    /** How far down the screen `to` is from `from` on one pane, in media px. */
-    private _pixelDelta;
-    /** An anchor in container media px, or null on a host without the mapping. */
-    private _toPixel;
-    /** The inverse of `_toPixel`. */
-    private _fromPixel;
+    setHovered(id: string | null): void;
+    hovered(): string | null;
     /**
-     * `free` projected onto the nearest 45 degree ray from `anchor`, all in
-     * screen space: the angle the eye reads is the one on the canvas, and a log
-     * scale or a tall pane would make a data-space angle anything but. The
-     * projection rather than a rotation, so a level line still ends under the
-     * pointer's x and a vertical one under its y; only the stray axis is
-     * dropped. Null when the host cannot map pixels, or the two coincide.
+     * The point the magnet will snap the next click to, or null when it is not
+     * pulling. Painted as a hollow ring so the user sees the anchor land before
+     * committing to it.
      */
-    private _lockAngle;
-    private _onDragEnd;
+    setSnapPoint(point: DrawingPoint | null): void;
+    snapPoint(): DrawingPoint | null;
     /**
-     * The pair of layers for a pane, made on first use. The bottom one is added
-     * first so a host that lists primitives sees them in paint order; the top one
-     * adopts it so handles and hit-tests come from one place.
+     * Size the grab targets for the device in use. Touch doubles the radii; a
+     * mouse or a pen keeps the desktop sizes. The render context may carry the
+     * same fact (`pointerType`), and when it does that wins per call, so a
+     * first touch on a fresh chart is already sized right.
      */
-    private _layerFor;
-    /** Whether a drawing paints on the top layer: over the series, or lifted for a drag. */
-    private _onTop;
-    /** Push the current list into each pane's layers and into the chart state. */
-    private _sync;
+    setPointerType(kind: DrawingPointerKind | null | undefined): void;
+    setPreview(drawing: Drawing | null): void;
     /**
-     * The per-frame half of a drag: only the top layers of the panes the
-     * gesture touches are re-listed, so the repaint stays on the cursor tier.
-     * Everything moving is on a top layer by then (anything under the series
-     * was lifted when the gesture began), and the bottom layers have not
-     * changed since, so re-listing them would cost a series repaint for
-     * nothing.
+     * Adopt the layer under this one. From then on this layer paints the handles
+     * of both and answers `hitTest` for both, and the adopted layer paints bodies
+     * only. Handles have to live up here: a selected drawing under the series
+     * would otherwise have its handles buried under the candles, and a handle
+     * you cannot see is a handle you cannot grab. Pass null to release.
      */
-    private _syncDrag;
+    setBelow(layer: DrawingLayer | null): void;
+    /** Repaint for overlay-only state, from the layer that paints it. */
+    private _requestOverlay;
+    /** Whether targets are sized for a fingertip on this call. */
+    private _isTouch;
+    private _grabRadius;
+    private _handleRadius;
+    /** Map an anchor to media px on this pane. */
+    private _project;
+    private _points;
+    /** Selected, unlocked drawings of this layer, in paint order. */
+    private _handled;
     /**
-     * Mirror the in-progress anchors (plus the cursor) into the preview slot.
-     * The cursor point goes through the same aim as a click would, so the
-     * preview shows the locked angle or the snapped anchor before it lands.
+     * The hovered drawing of this layer, when it is one that could be grabbed
+     * and is not already showing selection handles.
      */
-    private _syncPreview;
+    private _hoverHandled;
+    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
+    private _drawingContext;
+    private _drawContent;
+    private _drawPlacementGuide;
     /**
-     * Show where the magnet will land the next click, or nothing. A ring only
-     * while a click would place an anchor: a tool armed, not a brush (which
-     * inks where the pointer is), and the pull actually applying at the cursor.
-     * Angle lock bypasses the magnet, so it hides the ring too.
+     * Anchor handles. A hover shows them light (thin, translucent) as a hint
+     * that the shape can be grabbed; a selection shows them at full weight.
      */
-    private _syncSnapRing;
-    private _pushUndo;
+    private _drawHandles;
+    /** The magnet ring: hollow, in the axis text colour, at the snap point. */
+    private _drawSnapRing;
+    hitTest(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
+    private _hitHandle;
+    private _hitBody;
 }
 
 /**
@@ -1825,4 +1978,4 @@ declare const PATTERN_DRAWING_TOOLS: readonly DrawingTool[];
 
 declare const DRAW_TIER: "draw";
 
-export { ADVANCED_GEOMETRY_TOOLS, ADVANCED_LINE_TOOLS, ALIGN_OPTIONS, ARC, ARROW, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, BALLOON, BRUSH, BUILTIN_DRAWING_TOOLS, CALLOUT, CHROME_ICONS, CHROME_ICON_ATTRS, CHROME_ICON_FILLED, CHROME_ICON_STROKE, CHROME_ICON_VIEWBOX, CIRCLE, COLOR_FIELD, COMMENT, CROSS_LINE, CURVE, CYCLE_PALETTE, CYCLIC_LINES, type ClipboardPort, DATE_RANGE, DEFAULT_FIB, DEFAULT_FIB_FAN, DEFAULT_FIB_TIME_ZONE, DEFAULT_GANN_BOX, DEFAULT_GANN_FAN, DOUBLE_CURVE, DRAWING_CLIPBOARD_KEY, DRAWING_CLIPBOARD_VERSION, DRAWING_STATE_VERSION, DRAWING_TOOL_ICONS, DRAW_TIER, type DrawContext, type Drawing, type DrawingChangeKind, type DrawingChartHost, DrawingClipboard, type DrawingClipboardOptions, DrawingController, type DrawingControllerOptions, type DrawingInput, type DrawingKeyAction, type DrawingKeyContext, type DrawingKeyEvent, DrawingLayer, type DrawingLayerOrder, type DrawingPatch, type DrawingPoint, type DrawingPointerKind, type DrawingStyle, type DrawingText, type DrawingTool, type DrawingValueContext, type DrawingsDocument, ELLIPSE, EXTENDED_LINE, EXTEND_FIELDS, type ExpandContext, FIB_CHANNEL, FIB_EXTENSION, FIB_FAN, FIB_RETRACEMENT, FIB_TIME_ZONE, FILL_FIELDS, FLAG_MARK, FONT_FIELDS, FONT_OPTIONS, FORECAST, type FibLevel, type FieldGroup, type FieldKind, GANN_BOX, GANN_FAN, HIGHLIGHTER, HORIZONTAL_LINE, HORIZONTAL_RAY, type HitContext, ICON_ATTRS, ICON_STROKE, ICON_SYMBOL_PREFIX, ICON_VIEWBOX, type IconAttrs, type IconSvgOptions, LEVEL_FIELDS, LEVEL_NEUTRAL, LINE_FIELDS, LINE_STYLE_FIELD, LINE_STYLE_OPTIONS, LINE_WIDTH_FIELD, LONG_POSITION, MEASURE, type MagnetMode, NOTE, NUDGE_STEP_PX, NUDGE_STEP_SHIFT_PX, PARALLEL_CHANNEL, PATH, PATTERN_DRAWING_TOOLS, PLATE_TEXT_FIELDS, POLYLINE, PRICE_LABEL, PRICE_NOTE, PRICE_RANGE, RAY, RECTANGLE, ROTATED_RECTANGLE, SHAPE_TEXT_FIELDS, SHORT_POSITION, SHOW_LABELS_FIELD, SIGNPOST, SINE_LINE, type ScreenPoint, type SettingsField, type SettingsSchema, type ShortcutEvent, TABLE, TEXT, TEXT_FIELDS, TEXT_POSITION_OPTIONS, TEXT_VALUE_FIELD, TIME_CYCLES, TREND_LINE, TRIANGLE, type ToolCursorOptions, VALIGN_OPTIONS, VERTICAL_LINE, applyDrawingSettings, boundsOf, catmullRom, chromeIcon, chromeIconIds, chromeIconSvg, clearMemoryClipboard, cloneDrawing, cloneLevels, coerceSettingValue, composeSettings, cycleColor, decodeClipboardPayload, distToEllipse, distToLine, distToPolyline, distToRect, distToSegment, drawingSettingsSchema, drawingShortcuts, drawingToolIcon, drawingToolIconIds, encodeClipboardPayload, extendSegment, formatRatio, gannLabel, getDrawingTool, hasDrawingTool, iconSprite, iconSvg, iconUse, keyToDrawingAction, levelColor, matchDrawingShortcut, migrateDrawings, pressureWidth, rdpSimplify, readDrawingSetting, readDrawingSettings, rectOf, registerBuiltinDrawingTools, registerDrawingTool, registeredDrawingTools, sanitizeDrawing, sortByZIndex, systemClipboard, toolCursor };
+export { ADVANCED_GEOMETRY_TOOLS, ADVANCED_LINE_TOOLS, ALIGN_OPTIONS, ANCHORED_VWAP, ARC, ARROW, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, type AnalysisProfileRow, type AnalysisStatus, type AnchoredVwapOptions, type AnchoredVwapPoint, type AnchoredVwapResult, type AnchoredVwapSource, BALLOON, BRUSH, BUILTIN_DRAWING_TOOLS, CALLOUT, CHROME_ICONS, CHROME_ICON_ATTRS, CHROME_ICON_FILLED, CHROME_ICON_STROKE, CHROME_ICON_VIEWBOX, CIRCLE, COLOR_FIELD, COMMENT, CROSS_LINE, CURVE, CYCLE_PALETTE, CYCLIC_LINES, type ClipboardPort, DATE_RANGE, DEFAULT_FIB, DEFAULT_FIB_FAN, DEFAULT_FIB_TIME_ZONE, DEFAULT_GANN_BOX, DEFAULT_GANN_FAN, DOUBLE_CURVE, DRAWING_CLIPBOARD_KEY, DRAWING_CLIPBOARD_VERSION, DRAWING_STATE_VERSION, DRAWING_TOOL_ICONS, DRAW_TIER, type DrawContext, type Drawing, type DrawingChangeKind, type DrawingChartHost, DrawingClipboard, type DrawingClipboardOptions, DrawingController, type DrawingControllerOptions, type DrawingGroup, type DrawingInput, type DrawingKeyAction, type DrawingKeyContext, type DrawingKeyEvent, DrawingLayer, type DrawingLayerOrder, type DrawingLinkChart, type DrawingLinkContext, type DrawingLinkContextSource, DrawingLinkGroup, type DrawingLinkOptions, type DrawingPatch, type DrawingPoint, type DrawingPointerKind, type DrawingStyle, type DrawingText, type DrawingTool, type DrawingValueContext, type DrawingsDocument, ELLIPSE, EXTENDED_LINE, EXTEND_FIELDS, type ExpandContext, FIB_CHANNEL, FIB_EXTENSION, FIB_FAN, FIB_RETRACEMENT, FIB_TIME_ZONE, FILL_FIELDS, FIXED_RANGE_VOLUME_PROFILE, FLAG_MARK, FONT_FIELDS, FONT_OPTIONS, FORECAST, type FibLevel, type FieldGroup, type FieldKind, type FixedRangeVolumeProfileOptions, type FixedRangeVolumeProfileResult, GANN_BOX, GANN_FAN, HIGHLIGHTER, HORIZONTAL_LINE, HORIZONTAL_RAY, type HitContext, ICON_ATTRS, ICON_STROKE, ICON_SYMBOL_PREFIX, ICON_VIEWBOX, type IconAttrs, type IconSvgOptions, LEVEL_FIELDS, LEVEL_NEUTRAL, LINE_FIELDS, LINE_STYLE_FIELD, LINE_STYLE_OPTIONS, LINE_WIDTH_FIELD, LONG_POSITION, MEASURE, type MagnetMode, NOTE, NUDGE_STEP_PX, NUDGE_STEP_SHIFT_PX, PARALLEL_CHANNEL, PATH, PATTERN_DRAWING_TOOLS, PLATE_TEXT_FIELDS, POLYLINE, PRICE_LABEL, PRICE_NOTE, PRICE_RANGE, RAY, RECTANGLE, ROTATED_RECTANGLE, SHAPE_TEXT_FIELDS, SHORT_POSITION, SHOW_LABELS_FIELD, SIGNPOST, SINE_LINE, type ScreenPoint, type SettingsField, type SettingsSchema, type ShortcutEvent, TABLE, TEXT, TEXT_FIELDS, TEXT_POSITION_OPTIONS, TEXT_VALUE_FIELD, TIME_CYCLES, TREND_LINE, TRIANGLE, type ToolCursorOptions, VALIGN_OPTIONS, VERTICAL_LINE, anchoredVwapAnalysis, applyDrawingSettings, boundsOf, catmullRom, chromeIcon, chromeIconIds, chromeIconSvg, clearMemoryClipboard, cloneDrawing, cloneLevels, coerceSettingValue, composeSettings, createDrawingLinkGroup, cycleColor, decodeClipboardPayload, distToEllipse, distToLine, distToPolyline, distToRect, distToSegment, drawingSettingsSchema, drawingShortcuts, drawingToolIcon, drawingToolIconIds, encodeClipboardPayload, extendSegment, fixedRangeVolumeProfileAnalysis, formatRatio, gannLabel, getDrawingTool, hasDrawingTool, iconSprite, iconSvg, iconUse, keyToDrawingAction, levelColor, matchDrawingShortcut, migrateDrawings, pressureWidth, rdpSimplify, readDrawingSetting, readDrawingSettings, rectOf, registerBuiltinDrawingTools, registerDrawingTool, registeredDrawingTools, sanitizeDrawing, sortByZIndex, systemClipboard, toolCursor };