@invinite-org/chartlang-adapter-kit 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,147 @@
 # @invinite-org/chartlang-adapter-kit
 
+## 1.6.0
+
+### Minor Changes
+
+- 189493a: Add `bezierCurveTo` to the canvas sink's `RenderCtx` (and the shared
+  `MockCanvasContext` / `RecordedCall` / `canonicalise`). A self-scaled canvas
+  adapter uses it to stroke a smooth curve through a plot series' points instead
+  of straight segments. Production `CanvasRenderingContext2D` /
+  `OffscreenCanvasRenderingContext2D` already satisfy the new member, so this is
+  additive — every existing canvas-family caller keeps compiling, and an adapter
+  that never calls it paints byte-for-byte as before (the method is absent from
+  all existing `hashCallLog` pins).
+
+  This backs default plot-line smoothing in the reference adapters: plain `line`
+  plots now render as a smooth curve (monotone-cubic in the canvas2d reference;
+  each library adapter uses its native smoothing — konva `tension`, echarts
+  `smooth`, uPlot spline paths, lightweight-charts `lineType: Curved`) so a
+  moving-average line reads as a curve rather than a faceted polyline at dense bar
+  spacing. Step-lines and area edges stay straight.
+
+- 8bc628e: Promote the canvas glyph geometry into the shared `./canvas` sink so the
+  canvas-family adapters (uplot draw-hook, lightweight-charts overlay) consume one
+  source instead of hand-porting it (the bug class the `shift.ts` /
+  `renderOrder.ts` promotions exist to kill). New `./canvas` exports:
+  `drawShape` / `drawCharacter` / `drawArrow` / `drawMarker` / `drawLabel`
+  (`shape` / `character` / `arrow` / `marker` / `label` geometry on a
+  `RenderCtx`) plus their arg + enum types (`ShapeArgs` / `ShapeGlyph` /
+  `CharacterArgs` / `ArrowArgs` / `MarkerArgs` / `MarkerShape` / `LabelArgs` /
+  `LabelPosition` / `GlyphLocation`). Each helper is model-free — it draws onto a
+  `RenderCtx` and takes a plain `fallbackColor: string` (the null-color default),
+  so it carries no palette / library / model types. The five filled-marker `shape`
+  glyphs delegate to `drawMarker`; `cross` / `xcross` / `flag` stroke directly.
+  Promoted out of the canvas2d reference adapter (which keeps its own
+  `Palette`-taking local renderers — re-consume deferred). Pure, fully covered.
+- ab8b218: Add `rect` + `clip` to the canvas sink's `RenderCtx` (and the shared
+  `MockCanvasContext` / `RecordedCall` / `hashCallLog`). Together they compose the
+  standard `beginPath()` → `rect()` → `clip()` idiom an adapter uses to confine a
+  hand-rolled `ctx` draw pass to its plotting-area box. Production
+  `CanvasRenderingContext2D` / `OffscreenCanvasRenderingContext2D` already satisfy
+  the two new members, so this is additive — every existing canvas-family caller
+  keeps compiling, and an adapter that never calls them paints byte-for-byte as
+  before (the methods are absent from all existing `hashCallLog` pins). The uPlot
+  reference adapter is the first consumer: it clips its candle/band/hline/drawing
+  overlay so off-window marks stop spilling into the axis gutters.
+- 8bc628e: Add the shared z-order render comparator (`geometry/renderOrder.ts`) so every
+  adapter sorts its paint pass identically instead of hand-porting the math. New
+  public exports on the root barrel: `sortByRenderOrder<T extends RenderOrderKey>`
+  (the model-agnostic `a.z - b.z || a.band - b.band || a.seq - b.seq` total order,
+  sorted in place and the same array returned), `RENDER_BAND` (`{ series, glyph,
+hline, drawing }`, the pre-`z` phase order), and the `RenderOrderKey` structural
+  key (`{ z, band, seq }`). Promoted out of the canvas2d reference adapter
+  (which now re-exports the comparator and aliases `BAND = RENDER_BAND`),
+  mirroring the earlier `shift.ts` promotion — the z-comparator is identical
+  across rendering models, so one generic helper replaces what would otherwise be
+  five divergent ports as Tasks 4/6/10/12 add `z` to the other adapters. The
+  comparator is generic over the mark payload, so each adapter keeps its own
+  mark union local. Pure, fully covered, behaviour-preserving (the canvas2d
+  integration hash has no drawings, so the comparator path is unchanged).
+- ab8b218: Add the shared bar-shift projection contract (`geometry/shift.ts`) so every
+  adapter honours the universal plot `offset` (`PlotEmission.xShift`) identically.
+  New public exports: `medianBarSpacing`, `shiftedBarTime`, `projectShiftedX`
+  (promoted out of the canvas2d reference adapter), plus `maxShiftedTime` (widen a
+  self-scaled adapter's `xMax` for a `+k` future-projected point) and
+  `shiftedBarIndex` (the category/index analogue for declarative adapters). The
+  three rendering models — self-scaled time (canvas2d, konva), category/index
+  (echarts), and aligned/native-time (uplot, lightweight-charts) — now share one
+  pure, fully-covered implementation instead of four divergent ports, which is
+  what let four of the five reference adapters silently drop the offset and
+  collapse multi-plot/offset scripts onto a single x-position. An omitted / `0`
+  `xShift` reproduces the unshifted projection byte-for-byte, so no rendering
+  goldens change from this addition.
+- 189493a: Two rendering fixes for the self-scaled adapters.
+
+  **Viewport no longer snaps to fit-all on the first interaction.** The shared
+  `createViewController` now seeds the held window from the window last returned by
+  `resolveXWindow` (what the user is currently looking at — the framed
+  `initialVisibleBars` view) on the first `zoomAt`/`panBy`, instead of from the full
+  data range. Previously the first wheel/drag discarded the framed window and
+  snapped the chart back to all bars; now leaving auto-follow zooms smoothly from
+  the current view. It falls back to the data bounds only when nothing has rendered
+  yet, so the interact-before-first-render path is unchanged.
+
+  **Add `setTransform` to the canvas sink's `RenderCtx`** (and the shared
+  `MockCanvasContext` / `RecordedCall` / `canonicalise`). This lets a self-scaled
+  canvas adapter apply an ambient `setTransform(dpr, 0, 0, dpr, 0, 0)` and draw in
+  CSS-pixel space, so absolute sizes (line widths, fonts) render at their intended
+  thickness on a HiDPI backing store instead of a half-thick, edgy hairline.
+  Production `CanvasRenderingContext2D` / `OffscreenCanvasRenderingContext2D`
+  already satisfy the new member, so this is additive — every existing
+  canvas-family caller keeps compiling, and an adapter that never calls it (e.g.
+  at `dpr === 1`) paints byte-for-byte as before (the method is absent from all
+  existing `hashCallLog` pins). The canvas2d reference adapter is the first
+  consumer.
+
+- e620ba8: Add `bgcolor(color, opts?)` and `barcolor(color, opts?)` — Pine-ergonomic
+  top-level aliases for the `bg-color` / `bar-color` plot styles. One call
+  (`bgcolor(close > open ? "#16a34a" : "#dc2626", { transp: 80 })`) replaces
+  the verbose `plot(NaN, { style: { kind: "bg-color", … } })`. Surfaced in the
+  generated primitive reference and taught in the chartlang-coding skill.
+
+  Deliverable 2 (per-bar dynamic color): `PlotEmission` gains an optional
+  `colorValue: Color | null` channel; the runtime resolves the `bgcolor` /
+  `barcolor` per-bar color into it (omitted on the static `plot` path → wire
+  byte-identical, every pinned `plot-hash` untouched), validates it
+  (non-empty color string or `null`), and dedups it last-write-wins per
+  `(slotId, bar)` like `value`. Adapters prefer `colorValue` over the static
+  `style.color` at render time — this precedence is now the normative
+  adapter-kit contract (`PlotEmission.colorValue` JSDoc) and is implemented in
+  the canvas2d reference renderer (`null` ⇒ paint-nothing gap; omitted ⇒ static
+  fallback). The Pine converter emits the real per-bar dynamic color
+  (`bgcolor(close > open ? "#16a34a" : "#dc2626")`) instead of a static
+  `plot(NaN, …)`, so `bgcolor`/`barcolor` round-trip with per-bar semantics
+  intact.
+
+- 08cba38: Add `time.*` calendar accessors (`time.year/month/dayofmonth/dayofweek/hour/
+minute/second/timestamp`), a `time.timeClose(t, tz?)` bar-close accessor
+  (Pine's `time_close()` = bar start + interval), a `session.isOpen(t, spec, tz?)`
+  helper, and an `input.session` kind. Calendar fields are derived from a `Time`
+  epoch via the host (authors stay sandboxed — `Date`/`Intl` remain banned). v1
+  is UTC + fixed-offset only; exchange-tz/DST is a scoped follow-up. The Pine
+  converter lowers `dayofweek` / `time()` / `time_close()` / `input.session`.
+- 1efb49c: Add multi-symbol support to `request.security`. `request.security({ symbol,
+interval })` now reads a **different instrument** (not just a higher
+  timeframe), e.g. `request.security({ symbol: "AMEX:SPY", interval: "1D" })`.
+  `symbol` is optional (defaults to the chart symbol) and must be a compile-time
+  literal (`input.symbol` / `input.enum` resolved). A new `multiSymbol` adapter
+  capability gates non-chart-symbol requests: a different-symbol request against
+  an adapter declaring `multiSymbol: false` degrades to an all-NaN
+  bar/series with a single deduped `multi-symbol-not-supported` diagnostic,
+  mirroring `multi-timeframe-not-supported` (the symbol gate precedes the
+  timeframe gate, so a both-different request emits only the symbol diagnostic).
+  The Pine converter now lowers `request.security("OTHER", tf, expr)`, and the
+  `chartlang scaffold-adapter` template advertises `multiSymbol`.
+
+### Patch Changes
+
+- Updated dependencies [e620ba8]
+- Updated dependencies [08cba38]
+- Updated dependencies [1efb49c]
+- Updated dependencies [1efb49c]
+  - @invinite-org/chartlang-core@1.3.0
+
 ## 1.5.0
 
 ### Minor Changes

package/dist/base/bufferingAdapter.d.ts

@@ -25,6 +25,7 @@ import type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from "../typ
  *             inputs: new Set(),
  *             intervals: [],
  *             multiTimeframe: false,
+ *             multiSymbol: false,
  *             subPanes: 0,
  *             symInfoFields: new Set(),
  *             maxDrawingsPerScript: {

package/dist/base/bufferingAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bufferingAdapter.d.ts","sourceRoot":"","sources":["../../src/base/bufferingAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,gBAAiB,YAAW,OAAO;aAIxB,EAAE,EAAE,MAAM;aACV,IAAI,EAAE,MAAM;aACZ,YAAY,EAAE,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAN3B,OAAO,CAAC,QAAQ,CAAyB;gBAGrB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EACzB,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC;IAGvD,OAAO,IAAI,aAAa,CAAC,WAAW,CAAC;IAIrC,WAAW,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAI7C,KAAK,IAAI,aAAa,CAAC,eAAe,CAAC;IAMvC,OAAO,IAAI,IAAI;CAGlB"}
+{"version":3,"file":"bufferingAdapter.d.ts","sourceRoot":"","sources":["../../src/base/bufferingAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,gBAAiB,YAAW,OAAO;aAIxB,EAAE,EAAE,MAAM;aACV,IAAI,EAAE,MAAM;aACZ,YAAY,EAAE,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAN3B,OAAO,CAAC,QAAQ,CAAyB;gBAGrB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EACzB,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC;IAGvD,OAAO,IAAI,aAAa,CAAC,WAAW,CAAC;IAIrC,WAAW,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAI7C,KAAK,IAAI,aAAa,CAAC,eAAe,CAAC;IAMvC,OAAO,IAAI,IAAI;CAGlB"}

package/dist/base/bufferingAdapter.js

@@ -26,6 +26,7 @@
  *             inputs: new Set(),
  *             intervals: [],
  *             multiTimeframe: false,
+ *             multiSymbol: false,
  *             subPanes: 0,
  *             symInfoFields: new Set(),
  *             maxDrawingsPerScript: {

package/dist/base/bufferingAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"bufferingAdapter.js","sourceRoot":"","sources":["../../src/base/bufferingAdapter.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,OAAO,gBAAgB;IAIL;IACA;IACA;IACC;IANb,QAAQ,GAAsB,EAAE,CAAC;IAEzC,YACoB,EAAU,EACV,IAAY,EACZ,YAA0B,EACzB,MAAkC;QAHnC,OAAE,GAAF,EAAE,CAAQ;QACV,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAc;QACzB,WAAM,GAAN,MAAM,CAA4B;IACpD,CAAC;IAEJ,OAAO;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,SAA0B;QAClC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED,KAAK;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,OAAO,GAAG,CAAC;IACf,CAAC;IAED,OAAO;QACH,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACvB,CAAC;CACJ","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from \"../types.js\";\n\n/**\n * `Adapter` that records every `onEmissions` batch and exposes a\n * `drain()` method to retrieve them all at once. Used by the\n * conformance suite (Task 11) to collect emissions across a full\n * fixture playback before asserting against golden bars.\n *\n * @since 0.1\n * @stable\n * @example\n *     import {\n *         BufferingAdapter,\n *         capabilities,\n *         mockCandleSource,\n *     } from \"@invinite-org/chartlang-adapter-kit\";\n *\n *     const a = new BufferingAdapter(\n *         \"b\", \"Buffering\",\n *         {\n *             plots: capabilities.allLines(),\n *             drawings: new Set(),\n *             alerts: new Set(),\n *             alertConditions: false,\n *             logs: false,\n *             inputs: new Set(),\n *             intervals: [],\n *             multiTimeframe: false,\n *             subPanes: 0,\n *             symInfoFields: new Set(),\n *             maxDrawingsPerScript: {\n *                 lines: 0, labels: 0, boxes: 0, polylines: 0, other: 0,\n *             },\n *             maxLookback: 5000,\n *             maxTickHz: 10,\n *         },\n *         mockCandleSource([]),\n *     );\n *     a.drain();\n */\nexport class BufferingAdapter implements Adapter {\n    private buffered: RunnerEmissions[] = [];\n\n    constructor(\n        public readonly id: string,\n        public readonly name: string,\n        public readonly capabilities: Capabilities,\n        private readonly source: AsyncIterable<CandleEvent>,\n    ) {}\n\n    candles(): AsyncIterable<CandleEvent> {\n        return this.source;\n    }\n\n    onEmissions(emissions: RunnerEmissions): void {\n        this.buffered.push(emissions);\n    }\n\n    drain(): ReadonlyArray<RunnerEmissions> {\n        const out = this.buffered.slice();\n        this.buffered = [];\n        return out;\n    }\n\n    dispose(): void {\n        this.buffered = [];\n    }\n}\n"]}
+{"version":3,"file":"bufferingAdapter.js","sourceRoot":"","sources":["../../src/base/bufferingAdapter.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,OAAO,gBAAgB;IAIL;IACA;IACA;IACC;IANb,QAAQ,GAAsB,EAAE,CAAC;IAEzC,YACoB,EAAU,EACV,IAAY,EACZ,YAA0B,EACzB,MAAkC;QAHnC,OAAE,GAAF,EAAE,CAAQ;QACV,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAc;QACzB,WAAM,GAAN,MAAM,CAA4B;IACpD,CAAC;IAEJ,OAAO;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,SAA0B;QAClC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED,KAAK;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,OAAO,GAAG,CAAC;IACf,CAAC;IAED,OAAO;QACH,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACvB,CAAC;CACJ","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from \"../types.js\";\n\n/**\n * `Adapter` that records every `onEmissions` batch and exposes a\n * `drain()` method to retrieve them all at once. Used by the\n * conformance suite (Task 11) to collect emissions across a full\n * fixture playback before asserting against golden bars.\n *\n * @since 0.1\n * @stable\n * @example\n *     import {\n *         BufferingAdapter,\n *         capabilities,\n *         mockCandleSource,\n *     } from \"@invinite-org/chartlang-adapter-kit\";\n *\n *     const a = new BufferingAdapter(\n *         \"b\", \"Buffering\",\n *         {\n *             plots: capabilities.allLines(),\n *             drawings: new Set(),\n *             alerts: new Set(),\n *             alertConditions: false,\n *             logs: false,\n *             inputs: new Set(),\n *             intervals: [],\n *             multiTimeframe: false,\n *             multiSymbol: false,\n *             subPanes: 0,\n *             symInfoFields: new Set(),\n *             maxDrawingsPerScript: {\n *                 lines: 0, labels: 0, boxes: 0, polylines: 0, other: 0,\n *             },\n *             maxLookback: 5000,\n *             maxTickHz: 10,\n *         },\n *         mockCandleSource([]),\n *     );\n *     a.drain();\n */\nexport class BufferingAdapter implements Adapter {\n    private buffered: RunnerEmissions[] = [];\n\n    constructor(\n        public readonly id: string,\n        public readonly name: string,\n        public readonly capabilities: Capabilities,\n        private readonly source: AsyncIterable<CandleEvent>,\n    ) {}\n\n    candles(): AsyncIterable<CandleEvent> {\n        return this.source;\n    }\n\n    onEmissions(emissions: RunnerEmissions): void {\n        this.buffered.push(emissions);\n    }\n\n    drain(): ReadonlyArray<RunnerEmissions> {\n        const out = this.buffered.slice();\n        this.buffered = [];\n        return out;\n    }\n\n    dispose(): void {\n        this.buffered = [];\n    }\n}\n"]}

package/dist/base/passThroughAdapter.d.ts

@@ -24,6 +24,7 @@ import type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from "../typ
  *             inputs: new Set(),
  *             intervals: [],
  *             multiTimeframe: false,
+ *             multiSymbol: false,
  *             subPanes: 0,
  *             symInfoFields: new Set(),
  *             maxDrawingsPerScript: {

package/dist/base/passThroughAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"passThroughAdapter.d.ts","sourceRoot":"","sources":["../../src/base/passThroughAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,kBAAmB,YAAW,OAAO;aAE1B,EAAE,EAAE,MAAM;aACV,IAAI,EAAE,MAAM;aACZ,YAAY,EAAE,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAHP,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EACzB,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC;IAGvD,OAAO,IAAI,aAAa,CAAC,WAAW,CAAC;IAIrC,WAAW,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAI9C,OAAO,IAAI,IAAI;CAGlB"}
+{"version":3,"file":"passThroughAdapter.d.ts","sourceRoot":"","sources":["../../src/base/passThroughAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,kBAAmB,YAAW,OAAO;aAE1B,EAAE,EAAE,MAAM;aACV,IAAI,EAAE,MAAM;aACZ,YAAY,EAAE,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAHP,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EACzB,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC;IAGvD,OAAO,IAAI,aAAa,CAAC,WAAW,CAAC;IAIrC,WAAW,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAI9C,OAAO,IAAI,IAAI;CAGlB"}

package/dist/base/passThroughAdapter.js

@@ -25,6 +25,7 @@
  *             inputs: new Set(),
  *             intervals: [],
  *             multiTimeframe: false,
+ *             multiSymbol: false,
  *             subPanes: 0,
  *             symInfoFields: new Set(),
  *             maxDrawingsPerScript: {

package/dist/base/passThroughAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"passThroughAdapter.js","sourceRoot":"","sources":["../../src/base/passThroughAdapter.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,OAAO,kBAAkB;IAEP;IACA;IACA;IACC;IAJrB,YACoB,EAAU,EACV,IAAY,EACZ,YAA0B,EACzB,MAAkC;QAHnC,OAAE,GAAF,EAAE,CAAQ;QACV,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAc;QACzB,WAAM,GAAN,MAAM,CAA4B;IACpD,CAAC;IAEJ,OAAO;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,UAA2B;QACnC,oBAAoB;IACxB,CAAC;IAED,OAAO;QACH,oBAAoB;IACxB,CAAC;CACJ","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from \"../types.js\";\n\n/**\n * Minimal `Adapter` that forwards a supplied `AsyncIterable<CandleEvent>`\n * and drops every emission. Useful as a runtime test fixture when the\n * caller doesn't need to observe outputs.\n *\n * @since 0.1\n * @stable\n * @example\n *     import {\n *         PassThroughAdapter,\n *         capabilities,\n *         mockCandleSource,\n *     } from \"@invinite-org/chartlang-adapter-kit\";\n *\n *     const a = new PassThroughAdapter(\n *         \"p\", \"Passthrough\",\n *         {\n *             plots: capabilities.allLines(),\n *             drawings: new Set(),\n *             alerts: new Set(),\n *             alertConditions: false,\n *             logs: false,\n *             inputs: new Set(),\n *             intervals: [],\n *             multiTimeframe: false,\n *             subPanes: 0,\n *             symInfoFields: new Set(),\n *             maxDrawingsPerScript: {\n *                 lines: 0, labels: 0, boxes: 0, polylines: 0, other: 0,\n *             },\n *             maxLookback: 5000,\n *             maxTickHz: 10,\n *         },\n *         mockCandleSource([]),\n *     );\n *     void a;\n */\nexport class PassThroughAdapter implements Adapter {\n    constructor(\n        public readonly id: string,\n        public readonly name: string,\n        public readonly capabilities: Capabilities,\n        private readonly source: AsyncIterable<CandleEvent>,\n    ) {}\n\n    candles(): AsyncIterable<CandleEvent> {\n        return this.source;\n    }\n\n    onEmissions(_emissions: RunnerEmissions): void {\n        // intentional no-op\n    }\n\n    dispose(): void {\n        // intentional no-op\n    }\n}\n"]}
+{"version":3,"file":"passThroughAdapter.js","sourceRoot":"","sources":["../../src/base/passThroughAdapter.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,OAAO,kBAAkB;IAEP;IACA;IACA;IACC;IAJrB,YACoB,EAAU,EACV,IAAY,EACZ,YAA0B,EACzB,MAAkC;QAHnC,OAAE,GAAF,EAAE,CAAQ;QACV,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAc;QACzB,WAAM,GAAN,MAAM,CAA4B;IACpD,CAAC;IAEJ,OAAO;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,WAAW,CAAC,UAA2B;QACnC,oBAAoB;IACxB,CAAC;IAED,OAAO;QACH,oBAAoB;IACxB,CAAC;CACJ","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { Adapter, CandleEvent, Capabilities, RunnerEmissions } from \"../types.js\";\n\n/**\n * Minimal `Adapter` that forwards a supplied `AsyncIterable<CandleEvent>`\n * and drops every emission. Useful as a runtime test fixture when the\n * caller doesn't need to observe outputs.\n *\n * @since 0.1\n * @stable\n * @example\n *     import {\n *         PassThroughAdapter,\n *         capabilities,\n *         mockCandleSource,\n *     } from \"@invinite-org/chartlang-adapter-kit\";\n *\n *     const a = new PassThroughAdapter(\n *         \"p\", \"Passthrough\",\n *         {\n *             plots: capabilities.allLines(),\n *             drawings: new Set(),\n *             alerts: new Set(),\n *             alertConditions: false,\n *             logs: false,\n *             inputs: new Set(),\n *             intervals: [],\n *             multiTimeframe: false,\n *             multiSymbol: false,\n *             subPanes: 0,\n *             symInfoFields: new Set(),\n *             maxDrawingsPerScript: {\n *                 lines: 0, labels: 0, boxes: 0, polylines: 0, other: 0,\n *             },\n *             maxLookback: 5000,\n *             maxTickHz: 10,\n *         },\n *         mockCandleSource([]),\n *     );\n *     void a;\n */\nexport class PassThroughAdapter implements Adapter {\n    constructor(\n        public readonly id: string,\n        public readonly name: string,\n        public readonly capabilities: Capabilities,\n        private readonly source: AsyncIterable<CandleEvent>,\n    ) {}\n\n    candles(): AsyncIterable<CandleEvent> {\n        return this.source;\n    }\n\n    onEmissions(_emissions: RunnerEmissions): void {\n        // intentional no-op\n    }\n\n    dispose(): void {\n        // intentional no-op\n    }\n}\n"]}

package/dist/canvas/glyphs.d.ts

@@ -0,0 +1,209 @@
+import type { RenderCtx } from "./renderCtx.js";
+/**
+ * Vertical anchoring mode shared by the `shape` / `character` glyphs.
+ * `above` / `below` offset the glyph relative to the plot value; `absolute`
+ * pins it at the value.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const location: GlyphLocation = "below";
+ *     void location;
+ */
+export type GlyphLocation = "above" | "below" | "absolute";
+/**
+ * Inventory of `shape` glyphs (Pine `plotshape`). The first five reuse the
+ * filled {@link drawMarker} geometry; `cross` / `xcross` / `flag` are
+ * stroke-only.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const glyph: ShapeGlyph = "cross";
+ *     void glyph;
+ */
+export type ShapeGlyph = "circle" | "triangle-up" | "triangle-down" | "square" | "diamond" | "cross" | "xcross" | "flag";
+/**
+ * Inputs for {@link drawShape}. World-space `x` / `y` are pixels the caller
+ * derives via `timeToX` / `priceToY`; `size` is the glyph bounding-box edge
+ * length in pixels.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const args: ShapeArgs = { x: 10, y: 20, shape: "cross", size: 8, color: null };
+ *     void args;
+ */
+export type ShapeArgs = {
+    readonly x: number;
+    readonly y: number;
+    readonly shape: ShapeGlyph;
+    readonly size: number;
+    readonly location?: GlyphLocation;
+    readonly color: string | null;
+};
+/**
+ * Discrete marker glyph. Matches the `marker` variant of `PlotStyle.shape`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const s: MarkerShape = "triangle-up";
+ *     void s;
+ */
+export type MarkerShape = "circle" | "triangle-up" | "triangle-down" | "square" | "diamond";
+/**
+ * Inputs for {@link drawMarker}. World-space `x` / `y` are pixels the caller
+ * derives via `timeToX` / `priceToY`; `size` is the glyph's bounding-box edge
+ * length in pixels (the circle uses `size` as its diameter).
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const args: MarkerArgs = { x: 100, y: 50, shape: "triangle-up", size: 8, color: "#26a69a" };
+ *     void args;
+ */
+export type MarkerArgs = {
+    readonly x: number;
+    readonly y: number;
+    readonly shape: MarkerShape;
+    readonly size: number;
+    readonly color: string | null;
+};
+/**
+ * Inputs for {@link drawCharacter}. World-space `x` / `y` are pixels the
+ * caller derives via `timeToX` / `priceToY`; `size` is the font px size.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const args: CharacterArgs = { x: 10, y: 20, char: "A", size: 12, color: null };
+ *     void args;
+ */
+export type CharacterArgs = {
+    readonly x: number;
+    readonly y: number;
+    readonly char: string;
+    readonly size: number;
+    readonly location?: GlyphLocation;
+    readonly color: string | null;
+};
+/**
+ * Inputs for {@link drawArrow}. World-space `x` / `y` are pixels the caller
+ * derives via `timeToX` / `priceToY`; `size` is the triangle bounding-box edge
+ * length in pixels.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const args: ArrowArgs = { x: 10, y: 20, direction: "up", size: 10, color: null };
+ *     void args;
+ */
+export type ArrowArgs = {
+    readonly x: number;
+    readonly y: number;
+    readonly direction: "up" | "down";
+    readonly size: number;
+    readonly color: string | null;
+};
+/**
+ * Position the label sits in relative to the (`x`, `y`) anchor.
+ *
+ * - `above` → text sits above the anchor (`textBaseline = "bottom"`).
+ * - `below` → text sits below the anchor (`textBaseline = "top"`).
+ * - `anchor` → text is vertically centred on the anchor (`textBaseline =
+ *   "middle"`).
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const p: LabelPosition = "above";
+ *     void p;
+ */
+export type LabelPosition = "above" | "below" | "anchor";
+/**
+ * Inputs for {@link drawLabel}. World-space `x` / `y` are pixels the caller
+ * derives via `timeToX` / `priceToY`. `font` defaults to `"10px sans-serif"`
+ * when omitted.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const args: LabelArgs = { x: 100, y: 50, text: "PEAK", position: "above", color: "#26a69a" };
+ *     void args;
+ */
+export type LabelArgs = {
+    readonly x: number;
+    readonly y: number;
+    readonly text: string;
+    readonly position: LabelPosition;
+    readonly color: string | null;
+    readonly font?: string;
+};
+/**
+ * Render a `shape` glyph at a plot anchor. The five filled-marker shapes
+ * (`circle` / `triangle-up` / `triangle-down` / `square` / `diamond`)
+ * delegate to {@link drawMarker}; `cross` / `xcross` / `flag` stroke their
+ * geometry directly. A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawShape(ctx, { x: 10, y: 20, shape: "cross", size: 8, color: null }, "#90caf9");
+ */
+export declare function drawShape(ctx: RenderCtx, args: ShapeArgs, fallbackColor: string): void;
+/**
+ * Render a discrete marker glyph at (`x`, `y`). The renderer sets `fillStyle`
+ * once, then dispatches on `shape`:
+ *
+ * - `circle` → `arc` → `closePath` → `fill`.
+ * - `square` → single `fillRect` (`size x size`, centred on the anchor).
+ * - `triangle-up` / `triangle-down` / `diamond` → polygon via `beginPath` +
+ *   `moveTo` + `lineTo`s + `closePath` + `fill`.
+ *
+ * A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawMarker(ctx, { x: 100, y: 50, shape: "circle", size: 6, color: "#26a69a" }, "#90caf9");
+ */
+export declare function drawMarker(ctx: RenderCtx, args: MarkerArgs, fallbackColor: string): void;
+/**
+ * Render a `character` glyph (Pine `plotchar`) as centred canvas text. A null
+ * `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawCharacter(ctx, { x: 10, y: 20, char: "A", size: 12, color: null }, "#90caf9");
+ */
+export declare function drawCharacter(ctx: RenderCtx, args: CharacterArgs, fallbackColor: string): void;
+/**
+ * Render an `arrow` glyph (Pine `plotarrow`) as a filled directional triangle.
+ * A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawArrow(ctx, { x: 10, y: 20, direction: "up", size: 10, color: null }, "#90caf9");
+ */
+export declare function drawArrow(ctx: RenderCtx, args: ArrowArgs, fallbackColor: string): void;
+/**
+ * Render a single text annotation at (`x`, `y`). The renderer sets `fillStyle`,
+ * `font`, `textAlign = "center"`, and a `position`-dependent `textBaseline`,
+ * then calls `fillText`. A null `color` falls back to `fallbackColor`; an
+ * omitted `font` falls back to `"10px sans-serif"`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawLabel(ctx, { x: 100, y: 50, text: "PEAK", position: "above", color: "#26a69a" }, "#90caf9");
+ */
+export declare function drawLabel(ctx: RenderCtx, args: LabelArgs, fallbackColor: string): void;
+//# sourceMappingURL=glyphs.d.ts.map

package/dist/canvas/glyphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyphs.d.ts","sourceRoot":"","sources":["../../src/canvas/glyphs.ts"],"names":[],"mappings":"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"}

package/dist/canvas/glyphs.js

@@ -0,0 +1,219 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+// Shared, model-free glyph geometry for the canvas-family adapters (uplot
+// draw-hook, lightweight-charts overlay). Promoted out of the canvas2d
+// reference adapter's `render/{shape,character,arrow,marker,label}.ts` so the
+// `shape` / `character` / `arrow` / `marker` / `label` geometry is written ONCE
+// instead of hand-ported per consumer (the bug class the `shift.ts` /
+// `renderOrder.ts` promotions exist to kill). Each helper draws onto a
+// `RenderCtx` and takes a plain `fallbackColor: string` (the null-color
+// default), so it carries no palette / library / model types — the move is a
+// pure RenderCtx-based promotion. canvas2d keeps its own `Palette`-taking
+// local renderers (re-consume deferred).
+const OFFSET_RATIO = 1.25;
+const TWO_PI = Math.PI * 2;
+const DEFAULT_LABEL_FONT = "10px sans-serif";
+function anchoredShapeY(args) {
+    switch (args.location ?? "absolute") {
+        case "above":
+            return args.y - args.size * OFFSET_RATIO;
+        case "below":
+            return args.y + args.size * OFFSET_RATIO;
+        case "absolute":
+            return args.y;
+    }
+}
+/**
+ * Render a `shape` glyph at a plot anchor. The five filled-marker shapes
+ * (`circle` / `triangle-up` / `triangle-down` / `square` / `diamond`)
+ * delegate to {@link drawMarker}; `cross` / `xcross` / `flag` stroke their
+ * geometry directly. A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawShape(ctx, { x: 10, y: 20, shape: "cross", size: 8, color: null }, "#90caf9");
+ */
+export function drawShape(ctx, args, fallbackColor) {
+    const y = anchoredShapeY(args);
+    if (args.shape === "circle" ||
+        args.shape === "triangle-up" ||
+        args.shape === "triangle-down" ||
+        args.shape === "square" ||
+        args.shape === "diamond") {
+        drawMarker(ctx, { ...args, y, shape: args.shape }, fallbackColor);
+        return;
+    }
+    ctx.strokeStyle = args.color ?? fallbackColor;
+    ctx.lineWidth = 1;
+    const half = args.size / 2;
+    switch (args.shape) {
+        case "cross":
+            ctx.beginPath();
+            ctx.moveTo(args.x - half, y);
+            ctx.lineTo(args.x + half, y);
+            ctx.moveTo(args.x, y - half);
+            ctx.lineTo(args.x, y + half);
+            ctx.stroke();
+            return;
+        case "xcross":
+            ctx.beginPath();
+            ctx.moveTo(args.x - half, y - half);
+            ctx.lineTo(args.x + half, y + half);
+            ctx.moveTo(args.x + half, y - half);
+            ctx.lineTo(args.x - half, y + half);
+            ctx.stroke();
+            return;
+        case "flag":
+            ctx.beginPath();
+            ctx.moveTo(args.x - half, y + half);
+            ctx.lineTo(args.x - half, y - half);
+            ctx.lineTo(args.x + half, y - half / 2);
+            ctx.lineTo(args.x - half, y);
+            ctx.stroke();
+            return;
+    }
+}
+/**
+ * Render a discrete marker glyph at (`x`, `y`). The renderer sets `fillStyle`
+ * once, then dispatches on `shape`:
+ *
+ * - `circle` → `arc` → `closePath` → `fill`.
+ * - `square` → single `fillRect` (`size x size`, centred on the anchor).
+ * - `triangle-up` / `triangle-down` / `diamond` → polygon via `beginPath` +
+ *   `moveTo` + `lineTo`s + `closePath` + `fill`.
+ *
+ * A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawMarker(ctx, { x: 100, y: 50, shape: "circle", size: 6, color: "#26a69a" }, "#90caf9");
+ */
+export function drawMarker(ctx, args, fallbackColor) {
+    ctx.fillStyle = args.color ?? fallbackColor;
+    const half = args.size / 2;
+    switch (args.shape) {
+        case "circle":
+            ctx.beginPath();
+            ctx.arc(args.x, args.y, half, 0, TWO_PI);
+            ctx.closePath();
+            ctx.fill();
+            return;
+        case "square":
+            ctx.fillRect(args.x - half, args.y - half, args.size, args.size);
+            return;
+        case "triangle-up":
+            ctx.beginPath();
+            ctx.moveTo(args.x, args.y - half);
+            ctx.lineTo(args.x + half, args.y + half);
+            ctx.lineTo(args.x - half, args.y + half);
+            ctx.closePath();
+            ctx.fill();
+            return;
+        case "triangle-down":
+            ctx.beginPath();
+            ctx.moveTo(args.x, args.y + half);
+            ctx.lineTo(args.x + half, args.y - half);
+            ctx.lineTo(args.x - half, args.y - half);
+            ctx.closePath();
+            ctx.fill();
+            return;
+        case "diamond":
+            ctx.beginPath();
+            ctx.moveTo(args.x, args.y - half);
+            ctx.lineTo(args.x + half, args.y);
+            ctx.lineTo(args.x, args.y + half);
+            ctx.lineTo(args.x - half, args.y);
+            ctx.closePath();
+            ctx.fill();
+            return;
+    }
+}
+function characterAnchor(args) {
+    switch (args.location ?? "absolute") {
+        case "above":
+            return { y: args.y - args.size, baseline: "bottom" };
+        case "below":
+            return { y: args.y + args.size, baseline: "top" };
+        case "absolute":
+            return { y: args.y, baseline: "middle" };
+    }
+}
+/**
+ * Render a `character` glyph (Pine `plotchar`) as centred canvas text. A null
+ * `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawCharacter(ctx, { x: 10, y: 20, char: "A", size: 12, color: null }, "#90caf9");
+ */
+export function drawCharacter(ctx, args, fallbackColor) {
+    const resolved = characterAnchor(args);
+    ctx.fillStyle = args.color ?? fallbackColor;
+    ctx.font = `${args.size}px sans-serif`;
+    ctx.textAlign = "center";
+    ctx.textBaseline = resolved.baseline;
+    ctx.fillText(args.char, args.x, resolved.y);
+}
+/**
+ * Render an `arrow` glyph (Pine `plotarrow`) as a filled directional triangle.
+ * A null `color` falls back to `fallbackColor`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawArrow(ctx, { x: 10, y: 20, direction: "up", size: 10, color: null }, "#90caf9");
+ */
+export function drawArrow(ctx, args, fallbackColor) {
+    const half = args.size / 2;
+    ctx.fillStyle = args.color ?? fallbackColor;
+    ctx.beginPath();
+    if (args.direction === "up") {
+        ctx.moveTo(args.x, args.y - half);
+        ctx.lineTo(args.x + half, args.y + half);
+        ctx.lineTo(args.x - half, args.y + half);
+    }
+    else {
+        ctx.moveTo(args.x, args.y + half);
+        ctx.lineTo(args.x + half, args.y - half);
+        ctx.lineTo(args.x - half, args.y - half);
+    }
+    ctx.closePath();
+    ctx.fill();
+}
+function labelBaseline(position) {
+    switch (position) {
+        case "above":
+            return "bottom";
+        case "below":
+            return "top";
+        case "anchor":
+            return "middle";
+    }
+}
+/**
+ * Render a single text annotation at (`x`, `y`). The renderer sets `fillStyle`,
+ * `font`, `textAlign = "center"`, and a `position`-dependent `textBaseline`,
+ * then calls `fillText`. A null `color` falls back to `fallbackColor`; an
+ * omitted `font` falls back to `"10px sans-serif"`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     declare const ctx: RenderCtx;
+ *     drawLabel(ctx, { x: 100, y: 50, text: "PEAK", position: "above", color: "#26a69a" }, "#90caf9");
+ */
+export function drawLabel(ctx, args, fallbackColor) {
+    ctx.fillStyle = args.color ?? fallbackColor;
+    ctx.font = args.font ?? DEFAULT_LABEL_FONT;
+    ctx.textAlign = "center";
+    ctx.textBaseline = labelBaseline(args.position);
+    ctx.fillText(args.text, args.x, args.y);
+}
+//# sourceMappingURL=glyphs.js.map