openalgo-charts 2.5.4 → 2.5.6

package/dist/draw/index.d.ts

@@ -1,9 +1,9 @@
-import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, IPrimitive, DataLayer, AlertDrawingInfo, PrimitiveHost, ZOrder, PrimitiveHit } from 'openalgo-charts';
+import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, PriceScaleId, IndicatorApi, IPrimitive, DataLayer, PlotRect, AlertDrawingInfo, PrimitiveHost, ZOrder, PrimitiveHit } from 'openalgo-charts';
 
 /**
  * The per-tool settings schema: what a host may show in a drawing's settings
  * dialog, expressed as dot paths into the drawing (`style.color`,
- * `text.fontSize`, `props.foo`, `zIndex`) with a control kind and a label.
+ * `text.fontSize`, `props.foo`, `zIndex`, `space`) with a control kind and a label.
  *
  * The rule the whole module exists for: a tool declares only fields its `draw`
  * actually reads. A schema is not a wish list. A host renders exactly what is
@@ -20,8 +20,8 @@ type FieldGroup = 'line' | 'fill' | 'text' | 'levels' | 'behavior';
 interface SettingsField {
     /**
      * Dot path into the drawing. Two segments under `style`, `text` or `props`
-     * (`style.lineWidth`), or one of the top-level flags `locked`, `visible`,
-     * `zIndex`.
+     * (`style.lineWidth`), or one of the top-level fields `locked`, `visible`,
+     * `zIndex`, `space`.
      */
     path: string;
     label: string;
@@ -63,6 +63,11 @@ declare const TEXT_POSITION_OPTIONS: ReadonlyArray<{
     value: string;
     label: string;
 }>;
+/** The two coordinate spaces, as a host offers them: follow the bars, or stay on screen. */
+declare const SPACE_OPTIONS: ReadonlyArray<{
+    value: DrawingSpace;
+    label: string;
+}>;
 /**
  * Font stacks a host can offer. Values are real CSS stacks, so a drawing's
  * `text.fontFamily` needs no translation before it reaches `ctx.font`; a host
@@ -79,6 +84,13 @@ declare const LINE_STYLE_FIELD: SettingsField;
 declare const LINE_FIELDS: readonly SettingsField[];
 declare const FILL_FIELDS: readonly SettingsField[];
 declare const EXTEND_FIELDS: readonly SettingsField[];
+/**
+ * Where the drawing is anchored: to time and price, or to the screen. Declared
+ * only by tools that set `viewport`, since the controller converts nothing
+ * else. Writing it converts the anchors at the view on screen, so the drawing
+ * keeps its place and only stops (or starts) following the bars.
+ */
+declare const SPACE_FIELD: SettingsField;
 declare const SHOW_LABELS_FIELD: SettingsField;
 declare const LEVEL_FIELDS: readonly SettingsField[];
 /**
@@ -153,6 +165,13 @@ declare function applyDrawingSettings(d: Drawing, patch: Record<string, unknown>
  * {@link DrawingText}, made `levels` a list of {@link FibLevel} rather than bare
  * ratios, and gave every drawing a `zIndex`. A 1.9.x document is upgraded by
  * `migrateDrawings` on the way in; nothing downstream sees the old shape.
+ *
+ * The one exception to data space is a drawing whose `space` is `'viewport'`:
+ * a note or a box that belongs to the screen rather than to a bar. Its anchors
+ * are {@link ViewportPoint} fractions of its pane's plot, kept in a field of
+ * their own so a time or a price never has to mean a pixel. The field is
+ * optional and additive, which is why the document stays version 2: a save
+ * with no viewport drawing is byte for byte what it was.
  */
 
 /** One anchor, in data space. */
@@ -167,6 +186,30 @@ interface DrawingPoint {
      */
     pressure?: number;
 }
+/**
+ * Which coordinates a drawing's anchors are in. `'data'`, the default, is time
+ * and price: the drawing moves with the bars when the chart pans or zooms.
+ * `'viewport'` pins it to the screen: its anchors are fractions of its pane's
+ * plot, so pan and zoom leave it where it is and a resize keeps it in
+ * proportion.
+ */
+type DrawingSpace = 'data' | 'viewport';
+/**
+ * One anchor of a viewport drawing, as a fraction of the plot area of the pane
+ * that holds the drawing. Pane-relative, not whole-chart-relative: the pane's
+ * layer paints, clips and hit-tests the drawing, so these are the coordinates
+ * that follow the pane when it moves, resizes or folds.
+ *
+ * `x` is 0 at the plot's left edge and 1 at its right edge; the price axes are
+ * outside that span. `y` is 0 at the top of the pane and 1 at the bottom of its
+ * plot, which on the lowest pane is the top of the time axis. Sizes that a tool
+ * sets in pixels (a font size, a wrap width) stay in pixels: a resize moves a
+ * note in proportion without scaling its type.
+ */
+interface ViewportPoint {
+    x: number;
+    y: number;
+}
 /**
  * How new anchors snap to the bar under the cursor. `weak` snaps only when an
  * O/H/L/C sits within a few pixels of the pointer, so a click on empty space
@@ -289,7 +332,15 @@ interface Drawing {
     id: string;
     /** Registered tool id. */
     tool: string;
+    /** Anchors in time and price. Empty on a viewport drawing, whose anchors are `viewportPoints`. */
     points: DrawingPoint[];
+    /**
+     * Which coordinates the anchors are in. Absent means `'data'`. Only a tool
+     * that declares {@link DrawingTool.viewport} can be anchored to the viewport.
+     */
+    space?: DrawingSpace;
+    /** The anchors of a viewport drawing, one per handle. Present only when `space` is `'viewport'`. */
+    viewportPoints?: ViewportPoint[];
     style: DrawingStyle;
     /** The label (or, for the text tool, the whole content). */
     text?: DrawingText;
@@ -313,9 +364,20 @@ interface Drawing {
     /**
      * Paint order. Below zero paints under the series, at or above zero paints
      * over it. Ties break by array order, so two drawings at 0 paint in the
-     * order they sit in the list.
+     * order they sit in the list. With `stackAbove` it orders the drawings
+     * placed above the same entry.
      */
     zIndex: number;
+    /**
+     * Placed inside the series band, directly above one entry of its pane's
+     * `chart.seriesStack()`: `'source:primary'` or `'indicator:<id>'`. It paints
+     * after that entry's series and before the next entry's. While the entry
+     * plots no series on this drawing's pane (a study removed or moved away) it
+     * paints by `zIndex` as if absent, and returns when the entry does. Absent
+     * means the drawing is not in the series band. See
+     * `DrawingController.placeInStack`.
+     */
+    stackAbove?: string;
     /** Epoch ms, set by the controller when the drawing is added. */
     createdAt?: number;
 }
@@ -332,8 +394,28 @@ type DrawingInput = Omit<Drawing, 'id' | 'zIndex' | 'createdAt'> & {
 /**
  * The fields `DrawingController.update` and `updateMany` can change. `policy`
  * merges flag by flag, the way `style` does.
+ *
+ * `space` on its own converts the anchors at the view on screen, so the
+ * drawing stays exactly where it is and only stops (or starts) following the
+ * bars. With the new space's anchors in the same patch (`viewportPoints` for
+ * the viewport, `points` for data) they are taken as given. A conversion the
+ * controller cannot make (a tool without viewport support, a pane with no
+ * place on screen) is left out of the patch and the rest of it applies, and
+ * `DrawingController.update` returns false.
+ */
+type DrawingPatch = Partial<Pick<Drawing, 'points' | 'style' | 'text' | 'props' | 'locked' | 'visible' | 'zIndex' | 'policy' | 'space' | 'viewportPoints'>> & {
+    /** A series-band entry to paint directly above, or null to leave the series band. */
+    stackAbove?: string | null;
+};
+/**
+ * What `DrawingController.placeInStack` puts a drawing next to: another
+ * drawing of its pane, or an entry of its pane's series band.
  */
-type DrawingPatch = Partial<Pick<Drawing, 'points' | 'style' | 'text' | 'props' | 'locked' | 'visible' | 'zIndex' | 'policy'>>;
+type DrawingStackTarget = {
+    drawing: string;
+} | {
+    entry: string;
+};
 /** The persisted shape's version; bumped when {@link Drawing} changes. */
 declare const DRAWING_STATE_VERSION = 2;
 /**
@@ -428,6 +510,33 @@ interface DrawingTool {
      * not what Shift means there.
      */
     angleLock?: boolean;
+    /**
+     * The tool can be anchored to the viewport (`Drawing.space`). Declare it
+     * only when `draw` and `distance` read the screen anchors (`pts`) and never
+     * `drawing.points`, which is empty in that space, and when nothing the tool
+     * prints is a price or a time: a label that reads the axis under a pinned
+     * shape would change every time the chart panned. `expand`, `constrain` and
+     * `alertValue` apply to data space only.
+     */
+    viewport?: boolean;
+    /**
+     * The box the drawing covers at `pts`, its anchors in media px (the space
+     * of {@link HitContext}). A drawing anchored to the viewport is always
+     * painted, hit-tested and moved with this box inside its pane's plot, so it
+     * can be seen and grabbed at every edge and after the chart resizes, and no
+     * drag, nudge or handle can take it out. Declare it on a `viewport` tool
+     * that paints beyond its anchors, as the text note and the table do from
+     * their one corner, and the rectangle and the ellipse do for a label above
+     * them or wider than they are; without it the box is the anchors' own
+     * bounds. A handle dragged toward an edge the box reaches first stops short
+     * of it, so the other anchors stay where they are.
+     */
+    bounds?(pts: readonly ScreenPoint[], drawing: Drawing): {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
     /**
      * Turn the anchors actually clicked into the full anchor set. Lets a tool drop
      * a complete, immediately editable default from fewer clicks: the position
@@ -567,6 +676,13 @@ declare function fixedRangeVolumeProfileAnalysis(bars: readonly Bar[], fromTime:
  * 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.
+ *
+ * A `paneIndex` in the payload counts the price pane as 0 and the study panes
+ * after it in their order, whatever slot the price pane holds on the chart it
+ * came from: `DrawingController` converts on copy and on paste, so a drawing
+ * copied beside the candles pastes beside the candles on a chart that keeps
+ * its price pane below its studies. On a chart with the price pane on top,
+ * the default, that is the chart's own slot, as it always was.
  */
 
 /**
@@ -664,6 +780,33 @@ declare class DrawingClipboard {
     read(): Promise<Omit<Drawing, 'id'>[] | null>;
 }
 
+/** Where a study's price input is picked and anchored: a pane, and a scale on it. */
+interface StudyInputTarget {
+    paneIndex: number;
+    priceScaleId: PriceScaleId;
+}
+/**
+ * One anchor move as an undo step, walked by the drawing history or by the
+ * host's timeline it was handed to (`DrawingController.delegateInputAnchorSteps`).
+ * Each call writes the other side's point, and is false, writing nothing, once
+ * the study no longer holds the point it starts from.
+ */
+interface InputAnchorStep {
+    undo(): boolean;
+    redo(): boolean;
+}
+/**
+ * The pane and scale a study's `price` input is picked on and anchored to,
+ * or null when that cannot be told. An explicit `pick` target with both
+ * halves is used as given. Otherwise the study's own plots decide: the price
+ * belongs where they are drawn, which must be one scale on one pane (and
+ * inside any half the descriptor did name), since a price read off the wrong
+ * scale is a different number.
+ */
+declare function studyInputTarget(chart: {
+    panes?(): readonly unknown[];
+}, study: IndicatorApi, key: string): StudyInputTarget | null;
+
 /**
  * Drawing controller: the interaction and persistence layer over
  * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
@@ -728,6 +871,23 @@ interface DrawingChartHost {
      */
     timeToCoordinate?(time: number): number;
     coordinateToTime?(x: number): number;
+    /**
+     * Optional, for drawings anchored to the viewport (`space: 'viewport'`):
+     * the time axis, which turns a data anchor's time into a place on the plot
+     * and back when a drawing is pinned or unpinned.
+     */
+    readonly timeScale?: {
+        indexToX(index: number): number;
+        xToIndex(x: number): number;
+    };
+    /**
+     * Optional, for drawings anchored to the viewport: a pane's plot in
+     * container px, as `Chart.plotRect` reports it, which is what a viewport
+     * anchor is a fraction of. A host without it still paints them, since the
+     * layer reads the plot size from its render context, but cannot place,
+     * move or convert them.
+     */
+    plotRect?(paneIndex: number): PlotRect | null;
     /**
      * Optional. It keeps 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
@@ -737,6 +897,20 @@ interface DrawingChartHost {
      * pane the chart maps no price for, one collapsed to its header strip.
      */
     panes?(): readonly unknown[];
+    /**
+     * Optional. Slot of the price pane, the one pane whose drawings the magnet
+     * snaps to candle prices and a drawing link shares. It moves when a host
+     * puts the price pane below its studies; without it the price pane is slot 0.
+     */
+    primaryPaneIndex?(): number;
+    /**
+     * Optional, both: a pane's series band, back to front, and the call that
+     * paints a layer directly above one of its entries. Without them no drawing
+     * can be placed in the series band, and one saved there paints by its
+     * `zIndex`.
+     */
+    seriesStack?(paneIndex: number): readonly string[];
+    setPrimitiveStackAbove?(primitive: IPrimitive, above: string | null): boolean;
 }
 interface DrawingControllerOptions {
     /**
@@ -778,9 +952,46 @@ interface DrawingControllerOptions {
      */
     pasteOffsetBars?: number;
     pasteOffsetPixels?: number;
+    /**
+     * Draw the anchor of every study input that declares one (a `price` input
+     * with a `timeKey` and `anchor: true`): a handle at the point the pair
+     * names that drags both as one settings change and one step of this undo
+     * history. Default true; false draws none, and the inputs are still edited
+     * in settings and picked with `Chart.beginPick('point')`.
+     */
+    inputAnchors?: boolean;
 }
-/** What `drawing:change` reports happened to the listed ids. */
+/** How `DrawingController.setTool` arms a tool. */
+interface DrawingPlacementOptions {
+    /**
+     * The space the placed drawing is anchored in. `'viewport'` pins it to the
+     * screen: the anchors are placed where they are clicked, as usual, and kept
+     * as fractions of the pane's plot from then on. Only a tool that declares
+     * `viewport` accepts it. Default `'data'`.
+     */
+    space?: DrawingSpace;
+}
+/**
+ * What `drawing:change` reports happened to the listed ids. The list is empty
+ * for a step of the undo history that changed no drawing, a study input
+ * anchor's drag and its undo or redo, so a control showing whether Undo is
+ * available still refreshes.
+ */
 type DrawingChangeKind = 'add' | 'update' | 'remove' | 'reorder' | 'undo' | 'redo';
+/** The `drawing:change` payload. */
+interface DrawingChangeEvent {
+    ids: string[];
+    kind: DrawingChangeKind;
+    /** Set on a change another chart's link applied; it records no step here. */
+    linked?: true;
+    /**
+     * The undo step this change was recorded as, on the change that closes it.
+     * Absent for everything the history does not hold: a host's forced edit, a
+     * linked commit, a restore, and a move along the branches (`undo`, `redo`).
+     * {@link DrawingController.historySteps} lists the step by this number.
+     */
+    step?: number;
+}
 /** Options for a call that changes, groups or deletes drawings. */
 interface DrawingEditOptions {
     /**
@@ -818,6 +1029,8 @@ declare class DrawingController {
     private readonly _linkedPreviews;
     private _destroyed;
     private _tool;
+    /** The space the armed tool places in; data whenever no tool is armed. */
+    private _toolSpace;
     private _pending;
     private _pendingPane;
     /** Selected ids, in the order they were picked. The first is the primary. */
@@ -831,6 +1044,8 @@ declare class DrawingController {
      * a drag that follows the hand and one that stutters through the candles.
      */
     private readonly _lifted;
+    /** The slots the series-band drawings were last listed in; see `_slotSignature`. */
+    private _slotKey;
     /** Shift as of the last pointer report: what angle lock reads mid-preview. */
     private _shift;
     /** The device behind the last pointer report, for target sizing. */
@@ -839,6 +1054,9 @@ declare class DrawingController {
     private _undo;
     private _redo;
     private _pendingHistory;
+    /** Depth of `untracked` runs, and the drawings as they were before the host's edit in progress. */
+    private _untracked;
+    private _hostEdit;
     /** The host's patches the recorded steps have yet to take, merged per drawing. */
     private readonly _hostPatches;
     /**
@@ -848,6 +1066,9 @@ declare class DrawingController {
      */
     private _dragStart;
     private readonly _off;
+    private _anchors;
+    /** The host's timeline an anchor step goes to instead of this history; see `delegateInputAnchorSteps`. */
+    private _anchorSteps;
     private _lastCursor;
     /**
      * Bar under the cursor, carried by the crosshair event, with the time the
@@ -856,8 +1077,16 @@ declare class DrawingController {
      */
     private _lastBar;
     constructor(chart: DrawingChartHost, options?: DrawingControllerOptions);
-    /** Arm a tool for placement, or pass null to return to the cursor. */
-    setTool(toolId: string | null): void;
+    /**
+     * Arm a tool for placement, or pass null to return to the cursor. With
+     * `options.space` set to `'viewport'` the drawing it places is pinned to the
+     * screen; a tool that cannot be (see `DrawingTool.viewport`) throws.
+     */
+    setTool(toolId: string | null, options?: DrawingPlacementOptions): void;
+    /** The space the armed tool places in: `'data'` unless it was armed for the viewport. */
+    activeToolSpace(): DrawingSpace;
+    /** `draw:tool`, carrying the space only when it is not the default, as the payload always has. */
+    private _emitTool;
     /**
      * Ask the chart to stop panning and report gestures as anchor placement.
      * Guarded so a base bundle predating `setPlacementMode` still loads the tier.
@@ -902,8 +1131,33 @@ declare class DrawingController {
     private _regroup;
     /** The live group `id`, unless it holds a read-only drawing and the call is not forced. */
     private _group;
-    /** Move one step through the rendered stack, preserving the side of the series. */
+    /**
+     * Move one step through the rendered stack, within the slot it paints in:
+     * its side of the series, or the entry it is placed above. `placeInStack`
+     * moves it between slots.
+     */
     reorder(id: string, direction: -1 | 1): boolean;
+    /**
+     * Move a drawing directly above or below `target` in its pane's paint
+     * order, as one undo step. Next to another drawing it joins the slot that
+     * drawing paints in; above a series-band entry (`chart.seriesStack`) it is
+     * placed on that entry, under the drawings already there; below one it goes
+     * on top of the slot under that entry, the drawings behind the series when
+     * the entry is the first. A slot's drawings are renumbered, below the series
+     * up to -1 and elsewhere from 0. False, with nothing recorded, for a target
+     * on another pane, one the host cannot report, or a move that changes nothing.
+     * Like `reorder`, it is outside a drawing's policy.
+     */
+    placeInStack(id: string, target: DrawingStackTarget, where: 'above' | 'below'): boolean;
+    /** A pane's series band as the chart reports it, or none on a host that cannot. */
+    private _entries;
+    /**
+     * The slot a drawing paints in: `entry:<id>` while the entry it is placed
+     * above is in its pane's series band, else its side of the series by `zIndex`.
+     */
+    private _slotOf;
+    /** The drawings of one slot of a pane, in paint order. */
+    private _slotMembers;
     private _remapPanes;
     drawings(): readonly Drawing[];
     get(id: string): Drawing | undefined;
@@ -934,6 +1188,12 @@ declare class DrawingController {
      * Patch one drawing. False when there is no such drawing, or when it is
      * read-only to the user and `options.force` is not set. A patch that
      * carries `policy` is the host's, and like a forced one records no step.
+     *
+     * Also false when the patch asks for a `space` the drawing could not be
+     * moved to (a tool without viewport support, or a pane with no place on
+     * screen, folded or hidden behind a maximized pane): the rest of the patch
+     * still applies, and the false tells a host that the drawing is not in the
+     * space it asked for, which a control showing that space has to say.
      */
     update(id: string, patch: DrawingPatch, options?: DrawingEditOptions): boolean;
     /**
@@ -947,6 +1207,14 @@ declare class DrawingController {
         id: string;
         patch: DrawingPatch;
     }>, options?: DrawingEditOptions): void;
+    /**
+     * A patch as it applies to `d`. A change of space comes out complete, with
+     * the anchors of the new space (converted at the view on screen unless the
+     * patch gives them), or is left out when it cannot be made; anchors of the
+     * space the drawing will not be in are left out too, so one drawing never
+     * carries two positions.
+     */
+    private _spacePatch;
     private _applyPatch;
     /** Delete one drawing. A read-only one goes only with `options.force`. */
     remove(id: string, options?: DrawingEditOptions): boolean;
@@ -977,15 +1245,22 @@ declare class DrawingController {
     private _setSelection;
     private _emitChange;
     setZIndex(id: string, z: number): void;
-    /** In front of every other drawing on its pane. Stays on its side of the series. */
+    /** In front of every other drawing in its slot: its side of the series, or the entry it is placed above. */
     bringToFront(id: string): void;
-    /** Behind every other drawing on its pane. Stays on its side of the series. */
+    /** Behind every other drawing in its slot: its side of the series, or the entry it is placed above. */
     sendToBack(id: string): void;
-    /** Under the series (`zIndex` -1). A no-op for a drawing already there. */
+    /**
+     * Under the series (`zIndex` -1), out of the series band when it was placed
+     * in it. A no-op for a drawing already there.
+     */
     sendBehindSeries(id: string): void;
-    /** Over the series (`zIndex` 0). A no-op for a drawing already there. */
+    /**
+     * Over the series (`zIndex` 0), out of the series band when it was placed
+     * in it. A no-op for a drawing already there.
+     */
     bringAboveSeries(id: string): void;
-    /** The other drawings sharing `d`'s pane and side of the series. */
+    private _crossSeries;
+    /** The other drawings sharing `d`'s pane and slot. */
     private _band;
     private _reorder;
     /**
@@ -1029,8 +1304,30 @@ declare class DrawingController {
     paste(): Promise<Drawing[]>;
     /** Resolve an id list to live drawings; defaults to the selection. */
     private _targets;
-    /** Fold a pane index from another chart onto a pane this one actually has. */
+    /** The slot this chart keeps its price pane in, read at each use because a host can move it. */
+    private _pricePane;
+    /**
+     * Drawings as the clipboard carries them: panes counted price pane first,
+     * the study panes after it in their order, the way a portable template
+     * counts them. A price pane at the top, where every build before the move
+     * kept it, is written exactly as before, and a drawing copied beside the
+     * candles pastes beside the candles on any chart in any arrangement.
+     */
+    private _portable;
+    /**
+     * Fold a clipboard pane onto a pane this chart actually has: clamped to the
+     * pane count in clipboard order, so a study drawing from a taller stack
+     * lands on the last study pane rather than on the price pane, then put in
+     * this chart's own slots around its price pane.
+     */
     private _clampPane;
+    /**
+     * A copy's anchors, offset from the original's in its own space. A viewport
+     * copy moves the paste offset in pixels on both axes, as a fraction of the
+     * pane it lands on, so it reads the same on a chart of any size, and stays
+     * on that pane's plot when the original sits at its edge.
+     */
+    private _offsetAnchors;
     /** Nudge every anchor so a pasted copy is not hidden under its original. */
     private _offsetPoints;
     /**
@@ -1041,6 +1338,40 @@ declare class DrawingController {
     private _offsetPrice;
     /** Move a time right along the screen by `px`. */
     private _offsetTime;
+    /**
+     * Move a study's input anchor (a price input declared with `timeKey` and
+     * `anchor: true`) to `point` as the user, the way dragging its handle does:
+     * the time snaps to the bar under it, both halves stay inside the bounds the
+     * inputs declare, a study the user may not configure refuses it, and the move
+     * is one undo step in this history. For a host control that sets the point
+     * another way, such as a point pick on the chart, so Undo takes it back like
+     * a drag. A point written through the study's settings instead (a settings
+     * dialog's Pick point) is one step of this history as well, unless it is
+     * written inside `untracked` or forced on a study the user may not
+     * configure, which are the host's own. False when the study has no anchor for `key` (or the controller was
+     * built without input anchors), the study refuses, or it already holds the point.
+     */
+    moveInputAnchor(studyId: string, key: string, point: {
+        time: number;
+        price: number;
+    }): boolean;
+    /**
+     * Hand the step each study input anchor move makes (a handle dragged, a
+     * `moveInputAnchor`) to a timeline of the host's instead of this history,
+     * until the returned function gives them back. For a host keeping one undo
+     * history for the whole chart that already records the settings patch the
+     * move writes, as the widget's `ChartHistory` does: held here as well, one
+     * move would be taken back twice, and a press here would reach a step the
+     * other timeline had already taken back. `record` is called once the patch
+     * is written, in the same turn, with the step's own `undo` and `redo`
+     * (each false once the settings have moved on from it); this history
+     * records nothing for it and emits no `drawing:change`. A move made inside
+     * `untracked` is the host's own and reaches neither. A later call takes
+     * the steps from an earlier one. A point written to the settings some other
+     * way, which this history otherwise holds as a step of its own, is not
+     * handed over: the host's timeline sees that write itself.
+     */
+    delegateInputAnchorSteps(record: (step: InputAnchorStep) => void): () => void;
     undo(): boolean;
     redo(): boolean;
     /**
@@ -1052,6 +1383,29 @@ declare class DrawingController {
     private _pruneSelection;
     canUndo(): boolean;
     canRedo(): boolean;
+    /**
+     * The steps each branch holds, oldest first, by the number `drawing:change`
+     * reported them under. For a host that keeps one timeline across drawings
+     * and its own edits: a step missing from both branches has been taken away
+     * (a reset, a trim, a host edit that left it nothing to do), and pressing
+     * undo for it would reach an older step instead. A step still being
+     * recorded, a drag in progress, is not listed until its change closes it.
+     */
+    historySteps(): {
+        undo: number[];
+        redo: number[];
+    };
+    /**
+     * Run `fn` as the host's own act. An edit it makes records no undo step and
+     * leaves both branches as they are, and every step already recorded takes
+     * it in, the way a forced call does, so no later undo or redo reverses it.
+     * Unlike `force` it reaches no read-only drawing, and `undo` or `redo`
+     * inside it still moves along the branches. For a host keeping one timeline
+     * across drawings and its own changes, whose own changes are never steps.
+     */
+    untracked<T>(fn: () => T): T;
+    /** Give every recorded step the host's edit, drawing by drawing and group by group. */
+    private _takeInHostEdit;
     /**
      * Serialisable document, the same shape `ChartState.drawings` carries.
      * Transient drawings (`policy.persistent` false) are left out, and so is
@@ -1069,6 +1423,8 @@ declare class DrawingController {
      */
     fromJSON(data: unknown): void;
     destroy(): void;
+    /** Every layer of every pane. */
+    private _allLayers;
     private _onCrosshair;
     /** The chart's hit-test answer for the pointer position, whenever it changes. */
     private _onHover;
@@ -1177,6 +1533,67 @@ declare class DrawingController {
     private _toPixel;
     /** The inverse of `_toPixel`. */
     private _fromPixel;
+    /**
+     * The drawing's anchors in container media px, the space `timeToCoordinate`
+     * and `priceToCoordinate` answer in, whichever space it is anchored in. What
+     * a host places an overlay by (an inline editor, a popover). Null for an
+     * unknown id, or when the drawing's pane has no place on screen (folded to
+     * a strip, or hidden behind a maximized pane).
+     */
+    screenPoints(id: string): ScreenPoint[] | null;
+    /** A pane's price projection, when the host exposes one. */
+    private _pane;
+    /**
+     * Where a pane's plot is and how big, or null when it has none on screen
+     * (folded to a strip, or hidden behind a maximized pane): a fraction of
+     * either would be a fraction of nothing. It needs a pane projection too,
+     * since every gesture reads its y back through one.
+     */
+    private _plotFrame;
+    /**
+     * A gesture's position on its pane's plot, in media px. y reads the price
+     * back through the pane's readout scale, the exact inverse of how the chart
+     * read it; x is the pointer's container x less the plot's left edge, or,
+     * for a payload without one, the time through the time axis.
+     */
+    private _gesturePlot;
+    /**
+     * Where a drag was pressed, on its pane's plot. Read from the press's time
+     * and price when the chart reports them, so the first move is measured from
+     * the press and not from itself; a chart with fewer than two bars has no
+     * time axis to read a position back from, so it measures from the first move.
+     */
+    private _dragOrigin;
+    /**
+     * Data anchors as fractions of their pane's plot at the view on screen, or
+     * null when it has none. What is on screen stays where it is; a drawing part
+     * way or wholly off the plot comes onto it, since once pinned no pan could
+     * bring it back. One that fits moves in whole. One wider or taller than the
+     * plot is cut to it on that axis instead, so every handle of a pinned box
+     * is on screen to be grabbed.
+     */
+    private _toViewport;
+    /**
+     * The inverse of `_toViewport`: fractions back to time and price at the view
+     * on screen, from where the drawing is painted, so it does not move.
+     */
+    private _fromViewport;
+    /**
+     * Anchors in plot px as the fractions a pinned drawing stores, moved first
+     * so its box lies inside the plot. Every gesture ends here, so what is
+     * stored is what is painted, and no drag can leave the box where the
+     * pointer cannot reach it.
+     */
+    private _pinPlot;
+    /**
+     * Pinned anchors moved by a screen distance in media px, from where the
+     * drawing is painted rather than from what it stores: a note the layer
+     * holds in from a stored place off the plot (a host's value, a larger
+     * chart) moves at once, with no dead travel before it starts.
+     */
+    private _shiftPinned;
+    /** Put a drawing's anchors back as a gesture found them. */
+    private _restoreAnchors;
     /**
      * `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
@@ -1193,10 +1610,24 @@ declare class DrawingController {
      * 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. */
+    /**
+     * Whether a drawing paints on the top layer: over the series and outside
+     * the series band, or lifted for a drag.
+     */
     private _onTop;
     /** Push the current list into each pane's layers and into the chart state. */
     private _sync;
+    /** Each drawing placed in the series band, with the slot it resolves to now. */
+    private _slotSignature;
+    /** List every drawing on the layer of the slot it paints in. */
+    private _syncLayers;
+    /**
+     * One series-band layer per entry a drawing on this pane is placed above,
+     * made on first use and dropped when its last drawing leaves, each painted
+     * by the chart right after its entry. The top layer answers for them,
+     * front to back, then for the layer under the series.
+     */
+    private _syncSeriesLayers;
     /**
      * 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.
@@ -1219,6 +1650,21 @@ declare class DrawingController {
      * Angle lock bypasses the magnet, so it hides the ring too.
      */
     private _syncSnapRing;
+    /**
+     * Record a step that is not a drawing edit, a study anchor's move, in the
+     * same history, so Undo walks it and the drawings in the order they were
+     * made. Like any new edit it clears the redo branch. An `outside` move was
+     * written to the settings by someone else (a settings dialog's Pick point):
+     * it ends no drawing drag, and a host timeline the steps are handed to saw
+     * that write itself, so only this history takes it.
+     */
+    private _recordStep;
+    /**
+     * Announce a move of the history that changed no drawing, with no ids, so
+     * a host's Undo and Redo controls, which refresh on `drawing:change`,
+     * follow it. Passes `applied` through.
+     */
+    private _external;
     private _pushUndo;
     /**
      * Open an edit: recorded, or, for a change the history does not hold (a
@@ -1250,7 +1696,7 @@ type DrawingLinkContextSource = DrawingLinkContext | (() => DrawingLinkContext |
 interface DrawingLinkOptions {
     enabled?: boolean;
 }
-interface DrawingLinkChart extends Pick<DrawingChartHost, 'on'> {
+interface DrawingLinkChart extends Pick<DrawingChartHost, 'on' | 'primaryPaneIndex'> {
     readonly isDestroyed?: boolean;
     getDataContext?(): Readonly<DrawingLinkContext> | undefined;
 }
@@ -1258,6 +1704,14 @@ interface DrawingLinkChart extends Pick<DrawingChartHost, 'on'> {
  * 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.
+ *
+ * The price pane is each chart's own, in whatever slot that chart keeps it: one
+ * chart can hold it at the top and another below its studies. A shared drawing
+ * is therefore kept on slot 0 and put on each member's price pane as it is
+ * applied there, never copied across by slot.
+ *
+ * A drawing pinned to the viewport never participates, and pinning a shared one
+ * takes it out of the link on that chart alone: the other charts keep their copy.
  */
 declare class DrawingLinkGroup {
     private readonly _members;
@@ -1276,10 +1730,32 @@ declare class DrawingLinkGroup {
     /** Committed drawings remain on peers; transient previews are discarded. */
     remove(chart: DrawingLinkChart): void;
     destroy(): void;
+    /** The slot this member keeps its price pane in, read at each use because it moves. */
+    private _pricePane;
+    /** A shared drawing as it lands on one member: on that member's own price pane. */
+    private _onPricePane;
     private _eligible;
     private _create;
     private _reconnect;
     private _change;
+    /**
+     * A shared drawing pinned to the screen leaves the link on this chart. Its
+     * lineage mark goes too, or a restore would find the peers' copy by it and
+     * pull the drawing back to where they keep it.
+     */
+    private _unlink;
+    /**
+     * An unbound drawing that carries this chart's lineage mark, while a peer
+     * still holds that lineage, is one that left the link by being pinned and
+     * came back by undo: the undo put the mark back but no binding. It joins
+     * again, as the newest edit, so its state goes to the peers the way any
+     * other undo on a linked drawing does. If the peers have since deleted
+     * their copies it stays on this chart alone and loses the mark, since an
+     * edit never brings back another chart's deletion, and a later restore
+     * must not apply that deletion here. A mark no peer holds is left for a
+     * peer that has yet to join, as after any restore.
+     */
+    private _rejoin;
     private _commit;
     private _preview;
     private _syncOrder;
@@ -1599,16 +2075,23 @@ declare const DEFAULT_FIB_TIME_ZONE: readonly FibLevel[];
  * 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
+ * # Two tiers, one line
  *
  * 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.
+ * 16-unit grid. Both tiers draw a 2-unit stroke, and since each is shown at its
+ * grid size, that is the same 2px line on screen in both rails: a lock under
+ * the tools reads as part of the same set, only smaller.
+ *
+ * The chrome stroke was 1.5 through 2.5.5, chosen to match the tool weight as a
+ * fraction of the box. On integer coordinates a 1.5 stroke covers 0.75 of two
+ * pixel rows, so no edge was ever solid (0.18 of its inked pixels, against 0.59
+ * for the tools). A 1px stroke on half-unit coordinates was tried as well: as
+ * crisp on straight edges, but faint on every curve and visibly lighter than
+ * the tool rail beside it, on both themes. Two it is, with the few glyphs that
+ * were too dense for it redrawn with more air.
  *
  * # The grid
  *
@@ -1618,16 +2101,21 @@ declare const DEFAULT_FIB_TIME_ZONE: readonly FibLevel[];
  *
  *  - **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
+ *  - **A margin all round.** Live area 2 to 22 on the tool grid, 2 to 14 on the
+ *    chrome grid, so the ink stops a pixel short of the box. Without it,
+ *    glyphs that happen to reach the edge look larger than their neighbours
+ *    and the rail reads as ragged.
+ *  - **Integer coordinates.** With a 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.
+ *    crisp.
+ *  - **One stroke weight.** Different weights across identically sized boxes
+ *    is the single most visible tell of a set assembled rather than drawn.
+ *  - **The whole glyph in its path.** The marks that tell siblings apart (a
+ *    segment ends in two dots, a ray starts at one, a path ends in a head)
+ *    are small closed shapes drawn in the path itself, so a host that renders
+ *    the path data and nothing else still gets every one of them. An accent
+ *    registry repeats those marks for a fill on top: a dot then paints solid
+ *    rather than as a ring, which adds weight, never identity.
  *
  * # Rendering
  *
@@ -1671,9 +2159,23 @@ declare const ICON_ATTRS: {
  *
  * 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.
+ * node per glyph, and that node is the whole glyph: its dots and heads are in
+ * the string as outlines. `DRAWING_TOOL_ACCENTS` repeats those marks for a
+ * host that also wants them filled.
  */
 declare const DRAWING_TOOL_ICONS: Readonly<Record<string, string>>;
+/**
+ * The fills of the tool glyphs' marks, by tool id: anchor dots, pole caps and
+ * arrowheads. Optional: most glyphs have none.
+ *
+ * Every mark here is also drawn, as an outline, in the glyph's own path, so a
+ * host that renders only `DRAWING_TOOL_ICONS` still shows each one. This adds
+ * the fill: a second `<path>` painted in `currentColor` with no stroke of its
+ * own, after the glyph's path. The markup builders in `icon-svg.ts` add it; a
+ * host wrapping the path data itself adds
+ * `<path d="..." fill="currentColor" stroke="none"/>` for the same result.
+ */
+declare const DRAWING_TOOL_ACCENTS: Readonly<Record<string, string>>;
 /**
  * The glyph for a tool, or `undefined` when it has none.
  *
@@ -1681,29 +2183,40 @@ declare const DRAWING_TOOL_ICONS: Readonly<Record<string, string>>;
  * visible gap to fix, while one handed a question mark ships it.
  */
 declare function drawingToolIcon(toolId: string): string | undefined;
+/** The filled accent for a tool glyph, or `undefined` when it has none. */
+declare function drawingToolAccent(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.
+ * Chrome stroke width in viewBox units. The same 2 as the tool tier, which at
+ * the two native sizes is the same 2px line on screen. It was 1.5 through 2.5.5:
+ * matched to the tool weight as a fraction of the box, and never crisp, since
+ * a 1.5 stroke on whole units puts every edge three quarters of the way
+ * across a pixel. See the file comment for the 1px alternative and why it
+ * lost.
  */
-declare const CHROME_ICON_STROKE = 1.5;
+declare const CHROME_ICON_STROKE = 2;
 /** 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 strokeWidth: 2;
     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.
+ * tools in it. Same rules as the tool tier (the whole glyph in one path, its
+ * marks included; no presentation attributes; integer coordinates) on the 16
+ * grid with a 2..14 live area.
+ *
+ * At a 2px line a 16px glyph has room for about four parallel strokes with a
+ * pixel between them, so the dense glyphs are drawn with that in mind: two
+ * sliders rather than three, a lens and a pupil as small solid dots rather
+ * than rings, and no plus squeezed inside a square.
  *
  * 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
@@ -1711,6 +2224,13 @@ declare const CHROME_ICON_ATTRS: {
  * drawing to both.
  */
 declare const CHROME_ICONS: Readonly<Record<string, string>>;
+/**
+ * The fills of the chrome glyphs' marks, as `DRAWING_TOOL_ACCENTS` is for the
+ * tools: each mark is outlined in the glyph's path, and this paints it solid.
+ * At 16px a ring of a 2px line is mostly line already, so the fill matters
+ * most for the slider knobs.
+ */
+declare const CHROME_ICON_ACCENTS: 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,
@@ -1719,6 +2239,8 @@ declare const CHROME_ICONS: Readonly<Record<string, string>>;
 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;
+/** The filled accent for a chrome glyph, or `undefined` when it has none. */
+declare function chromeIconAccent(id: string): string | undefined;
 /** Every id the chrome tier covers. */
 declare function chromeIconIds(): string[];
 
@@ -1771,8 +2293,10 @@ 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.
+ * `iconUse`. Symbols carry the paths and viewBox, and no stroke: the weight
+ * inherits from the `<svg>` around each `<use>`, so one sprite serves every
+ * weight. An accent carries its fill, the one attribute it cannot inherit,
+ * and no stroke, since the glyph's own path outlines it.
  *
  * Default: every tool glyph. Repeated ids collapse to one symbol, since a
  * duplicate element id is an invalid document.
@@ -1782,12 +2306,12 @@ declare function iconSprite(ids?: readonly string[]): string;
 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.
+ * tool is the active one.
  *
  * 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`.
+ * once in `color` on top with its marks filled, 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;
 
@@ -1798,15 +2322,25 @@ declare function toolCursor(id: string, opts?: ToolCursorOptions): string;
  * 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.
+ * Each pane carries a `bottom` layer for drawings with a negative `zIndex`
+ * (under the series), a `top` one for the rest, and a `series` layer for each
+ * series-band entry a drawing is placed above (`stackAbove`), which the chart
+ * paints right after that entry's series. The top one takes over handles and
+ * hit-testing for the others 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: the top layer's bodies first, then each layer
+ * under it in the order they paint, front to back.
  *
  * 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".
  *
+ * A viewport drawing (`space: 'viewport'`) skips the time and price mapping:
+ * its anchors are fractions of this pane's plot and scale by the plot size in
+ * the render context, which is all that pan and zoom never touch. The one step
+ * added is keeping its box inside the plot. Everything after the projection
+ * (paint, handles, hit-testing) is shared, so the two spaces cannot drift
+ * apart in how they are grabbed.
+ *
  * 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`
@@ -1814,8 +2348,11 @@ declare function toolCursor(id: string, opts?: ToolCursorOptions): string;
  * stores that state and asks for nothing.
  */
 
-/** Which side of the series a layer paints on. */
-type DrawingLayerOrder = 'bottom' | 'top';
+/**
+ * Where a layer paints: under the series, in the series band (placed above an
+ * entry by the controller, and over the series while it is not), or on top.
+ */
+type DrawingLayerOrder = 'bottom' | 'series' | 'top';
 /** The pointer kinds the layer sizes its targets for. */
 type DrawingPointerKind = 'mouse' | 'touch' | 'pen';
 /**
@@ -1835,7 +2372,7 @@ declare class DrawingLayer implements IPrimitive {
     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. */
+    /** The layers under this one, front to back, 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;
@@ -1873,13 +2410,14 @@ declare class DrawingLayer implements IPrimitive {
     setPointerType(kind: DrawingPointerKind | null | undefined): void;
     setPreview(drawing: Drawing | null): void;
     /**
-     * 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
+     * Adopt the layers under this one, front to back: the order they paint in,
+     * reversed. From then on this layer paints the handles of all of them and
+     * answers `hitTest` for all of them, and the adopted layers paint 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.
      */
-    setBelow(layer: DrawingLayer | null): void;
+    setBelow(layer: DrawingLayer | readonly 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. */
@@ -2008,6 +2546,11 @@ declare function keyToDrawingAction(e: DrawingKeyEvent, ctx: DrawingKeyContext):
  * - An unregistered tool is not a reason to drop anything: a plugin tool may
  *   register after the layout is restored. This module never consults the
  *   registry, which also keeps it pure.
+ * - A viewport drawing keeps its `viewportPoints` and carries no data
+ *   anchors; one without usable viewport anchors is dropped, since falling
+ *   back to its data anchors would put it somewhere it never was. Data is the
+ *   default space and is never written out, so a document with no viewport
+ *   drawing comes back exactly as it went in.
  * - Garbage yields an empty document. This runs on the load path, where an
  *   exception would take the whole chart down with it.
  *
@@ -2117,4 +2660,4 @@ declare const PATTERN_DRAWING_TOOLS: readonly DrawingTool[];
 
 declare const DRAW_TIER: "draw";
 
-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 DrawingEditOptions, 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 DrawingPolicy, 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 };
+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_ACCENTS, 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_ACCENTS, DRAWING_TOOL_ICONS, DRAW_TIER, type DrawContext, type Drawing, type DrawingChangeEvent, type DrawingChangeKind, type DrawingChartHost, DrawingClipboard, type DrawingClipboardOptions, DrawingController, type DrawingControllerOptions, type DrawingEditOptions, 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 DrawingPlacementOptions, type DrawingPoint, type DrawingPointerKind, type DrawingPolicy, type DrawingSpace, type DrawingStackTarget, 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, type InputAnchorStep, 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, SPACE_FIELD, SPACE_OPTIONS, type ScreenPoint, type SettingsField, type SettingsSchema, type ShortcutEvent, type StudyInputTarget, TABLE, TEXT, TEXT_FIELDS, TEXT_POSITION_OPTIONS, TEXT_VALUE_FIELD, TIME_CYCLES, TREND_LINE, TRIANGLE, type ToolCursorOptions, VALIGN_OPTIONS, VERTICAL_LINE, type ViewportPoint, anchoredVwapAnalysis, applyDrawingSettings, boundsOf, catmullRom, chromeIcon, chromeIconAccent, chromeIconIds, chromeIconSvg, clearMemoryClipboard, cloneDrawing, cloneLevels, coerceSettingValue, composeSettings, createDrawingLinkGroup, cycleColor, decodeClipboardPayload, distToEllipse, distToLine, distToPolyline, distToRect, distToSegment, drawingSettingsSchema, drawingShortcuts, drawingToolAccent, 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, studyInputTarget, systemClipboard, toolCursor };