openalgo-script 0.7.1 → 0.8.0

package/src/adapters/charts/fills.ts

@@ -2,23 +2,40 @@
  * Declared bands into the chart's shaded bands.
  *
  * A band is two plot keys and two colours, which is the chart's own spec, so the
- * pair of keys crosses unchanged. Two details do not.
+ * pair of keys crosses unchanged. Three details do not.
  *
  * **Opacity is a dimmer, not a second alpha.** A colour carries its own alpha
  * everywhere in the language, and the band's `opacity` multiplies whatever the
- * colours already are. That is exactly what the chart does with the field, so a
- * script that never touches it gets the colour it wrote.
+ * colours already are. That is exactly what the chart does with the field, to a
+ * colour computed per bar as much as to a constant one, so a script that never
+ * touches it gets the colour it wrote.
  *
  * **A band with no colour of its own follows the first plot.** `stdlib.md` 14.2
  * says such a band is that plot's colour faded to twelve percent, and the plot's
  * colour may be one the host picked from its palette rather than one the script
  * wrote, so the band is pointed at the plot's settings key rather than at a value
  * read now. The twelve percent is then the dimmer, multiplied by whatever the
- * script asked for.
+ * script asked for. A band whose colour is computed per bar has a colour of its
+ * own, so neither applies to it.
+ *
+ * **A colour computed per bar travels as columns and is read back per bar.**
+ * It arrives on a channel, rides the values table as the two columns
+ * `columns.ts` describes, and the band's colour callback reads them on each bar
+ * for the side the band is on there. The side is decided the way the chart
+ * decides it, the first plot at or above the second, so the colour answered is
+ * the colour of the run the chart is drawing that bar in. An absent colour is a
+ * transparent one rather than no answer, because no answer hands the bar to
+ * the band's colour for that side, and `docs/visuals/fills.md` teaches an absent
+ * colour as how a band switches itself off. The callback exists only on a chart
+ * that reads it (`capabilities.ts`); on any other, `undrawable.ts` has refused
+ * the program before this is drawn.
  */
 import type { Band, CompiledProgram } from '../../core/emit/index.js';
+import type { ChartCapabilities } from './capabilities.js';
 import { cssColour } from './colours.js';
-import type { ChartFill } from './contract.js';
+import { bandColourKey, colourAt, colourColumns } from './columns.js';
+import type { ColumnSpec } from './columns.js';
+import type { ChartFill, ChartFillContext } from './contract.js';
 import { boolField, colourField, isReference, numberField } from './fields.js';
 import type { InputLookup } from './fields.js';
 
@@ -30,17 +47,67 @@ import type { InputLookup } from './fields.js';
  */
 const UNCOLOURED_FADE = 0.12;
 
-export function buildFills(program: CompiledProgram, lookup: InputLookup): readonly ChartFill[] {
-  const out: ChartFill[] = [];
-  for (const band of program.outputs.fills) out.push(oneBand(program, band, lookup));
-  return out;
+/** What a bar whose computed colour is absent is painted in: nothing. */
+const UNPAINTED = 'rgba(0, 0, 0, 0)';
+
+export interface FillsBuild {
+  readonly fills: readonly ChartFill[];
+  /** The colour columns the bands' callbacks read, for the values table. */
+  readonly columns: readonly ColumnSpec[];
 }
 
-function oneBand(program: CompiledProgram, band: Band, lookup: InputLookup): ChartFill {
+export function buildFills(
+  program: CompiledProgram,
+  lookup: InputLookup,
+  chart: ChartCapabilities,
+): FillsBuild {
+  const fills: ChartFill[] = [];
+  const columns: ColumnSpec[] = [];
+  program.outputs.fills.forEach((band, index) => {
+    const perBar = chart.bandColours ? perBarColours(band, index) : undefined;
+    if (perBar !== undefined) columns.push(...perBar.columns);
+    fills.push(oneBand(program, band, lookup, perBar));
+  });
+  return { fills, columns };
+}
+
+/** The keys a band's two computed colours travel under, and their columns. */
+interface PerBar {
+  readonly up: string | undefined;
+  readonly down: string | undefined;
+  readonly columns: readonly ColumnSpec[];
+}
+
+/**
+ * The columns a band's computed colours need, or nothing for a band with none.
+ *
+ * `color = ...` computed per bar writes one channel into both sides, and that
+ * channel travels once rather than twice.
+ */
+function perBarColours(band: Band, index: number): PerBar | undefined {
+  const upChannel = band.colorUpChannel;
+  const downChannel = band.colorDownChannel;
+  if (upChannel === null && downChannel === null) return undefined;
+  const up = upChannel === null ? undefined : bandColourKey(index, 'up');
+  const shared = downChannel !== null && downChannel === upChannel;
+  const down = downChannel === null ? undefined : shared ? up : bandColourKey(index, 'down');
+  const columns: ColumnSpec[] = [];
+  if (up !== undefined && upChannel !== null) columns.push(...colourColumns(up, upChannel));
+  if (down !== undefined && downChannel !== null && !shared) columns.push(...colourColumns(down, downChannel));
+  return { up, down, columns };
+}
+
+function oneBand(
+  program: CompiledProgram,
+  band: Band,
+  lookup: InputLookup,
+  perBar: PerBar | undefined,
+): ChartFill {
   const up = colourField(band.colorUp, lookup);
   const down = colourField(band.colorDown, lookup);
   const overlay = boolField(band.overlay, lookup);
-  const declared = up !== undefined || down !== undefined;
+  const computed = band.colorUpChannel !== null || band.colorDownChannel !== null;
+  const declared = up !== undefined || down !== undefined || computed;
   const opacity = numberField(band.opacity, lookup, 1) * (declared ? 1 : UNCOLOURED_FADE);
   const follow = declared ? undefined : plotColourKey(program, band.between[0]);
 
@@ -53,6 +120,23 @@ function oneBand(program: CompiledProgram, band: Band, lookup: InputLookup): Cha
     ...(follow === undefined ? {} : { colorUpKey: follow, colorDownKey: follow }),
     opacity,
     ...(overlay === undefined ? {} : { overlay }),
+    ...(perBar === undefined ? {} : { colorBy: colourBy(perBar) }),
+  };
+}
+
+/**
+ * The band's colour on one bar: the computed colour for the side it is on.
+ *
+ * Nothing where either column is absent, which is a bar the chart does not
+ * draw, and nothing where that side's colour is not computed, which leaves the
+ * chart the band's own colour for the side.
+ */
+function colourBy(perBar: PerBar): (ctx: ChartFillContext) => string | undefined {
+  return (ctx: ChartFillContext): string | undefined => {
+    if (typeof ctx.a !== 'number' || typeof ctx.b !== 'number') return undefined;
+    const key = ctx.a >= ctx.b ? perBar.up : perBar.down;
+    if (key === undefined) return undefined;
+    return colourAt(ctx.values, ctx.index, key) ?? UNPAINTED;
   };
 }
 

package/src/adapters/charts/index.ts

@@ -16,10 +16,16 @@
  * What is mapped is the whole output surface: the declared inputs and the
  * settings dialog a chart generates from them, the plots with their styles and
  * scales, the bands between them, the horizontal levels, the pane's fixed range,
- * the markers, the candle and pane painting, the summary grid, the drawing
+ * the markers, the candle and pane painting, the summary grids, the drawing
  * objects a script mutates over time, the watched conditions, and the lifecycle
  * a read of another instrument fetches through.
  *
+ * **Two of those depend on the chart the host states.** A band coloured per bar
+ * and a study with more than one grid need hooks only a newer chart has, so a
+ * host passes the chart library's own `VERSION` as
+ * `ChartAdapterOptions.chartVersion`, and without it such a study is refused
+ * with OS6024 rather than drawn in part. `capabilities.ts` has the versions.
+ *
  * What a study can express and this descriptor has no field for is recorded,
  * with its reason, in `spec/chart-narrowings.json`, and each one is also named
  * in the file that would have written it. `scripts/check-chart-surface.mjs`
@@ -41,6 +47,7 @@ export type {
   ChartCalcContext,
   ChartDescriptor,
   ChartFill,
+  ChartFillContext,
   ChartInput,
   ChartLevel,
   ChartLevelContext,
@@ -75,4 +82,5 @@ export type {
   ChartSurfaceContext,
   ChartTableOptions,
   ChartTablePosition,
+  ChartTableSpec,
 } from './surfaces.js';

package/src/adapters/charts/produced.ts

@@ -32,7 +32,7 @@
  */
 import type { Value } from '../../core/engine/index.js';
 import type { ChartSettings } from './contract.js';
-import type { ChartDrawing, ChartGrid, ChartMarker } from './surfaces.js';
+import type { ChartDrawing, ChartMarker, ChartTableSpec } from './surfaces.js';
 
 /**
  * One declared alert's message channel, whole, as the run left it.
@@ -47,13 +47,14 @@ export type MessageColumn = readonly Value[];
 /** One run's non-numeric output, as the hooks that follow it read it. */
 export interface Produced {
   readonly markers: readonly ChartMarker[];
-  readonly table: ChartGrid | null;
+  /** Every declared grid, in declaration order; the single hook reads the first. */
+  readonly tables: readonly ChartTableSpec[];
   readonly drawings: readonly ChartDrawing[];
   /** One entry per declared alert, in the order `outputs.alerts` declares them. */
   readonly messages: readonly MessageColumn[];
 }
 
-const NOTHING: Produced = { markers: [], table: null, drawings: [], messages: [] };
+const NOTHING: Produced = { markers: [], tables: [], drawings: [], messages: [] };
 
 const runs = new WeakMap<ChartSettings, Produced>();
 

package/src/adapters/charts/run.ts

@@ -38,6 +38,7 @@ import type { CompiledProgram } from '../../core/emit/index.js';
 import type { SourceFile } from '../../core/index.js';
 import { hostBar, hostNow, stateFor } from './bars.js';
 import type { ChartBar, ChartCalcContext, ChartSettings, ChartStore } from './contract.js';
+import { capabilitiesOf } from './capabilities.js';
 import { refused, stopped } from './errors.js';
 import { undrawable } from './undrawable.js';
 import { stationIn, stationOf } from './requests.js';
@@ -60,6 +61,29 @@ export interface ChartAdapterOptions {
   readonly id?: string;
   /** The category a picker groups the study under, when `meta.group` is empty. */
   readonly category?: string;
+  /**
+   * The chart library's own version: the `VERSION` string it exports, which a
+   * host that imports the chart already holds, passed on as
+   * `descriptorFor(program, { chartVersion: VERSION })`.
+   *
+   * It says which of the descriptor's hooks the chart this descriptor is
+   * registered with will read. Two arrived after the oldest chart the peer
+   * range accepts: a band's per-bar colour and the list of grids. From 2.5.4
+   * on, a band whose colour the script computes is drawn bar by bar and every
+   * declared grid is drawn. Before it, or when nothing is stated, the adapter
+   * cannot tell whether the chart will read either hook, and a chart that
+   * ignores one draws a band in its own default colours or the first grid
+   * alone, with nothing said. So such a program is refused before any bar runs
+   * with OS6024, which is what a host that states nothing got before this
+   * option existed.
+   *
+   * The version rather than a switch per hook, because it is one fact the
+   * host already holds, it moves with the chart the host actually installed,
+   * and a hook the adapter learns to read later needs nothing new from any
+   * host. `capabilities.ts` has the rule, prereleases and unreadable strings
+   * included.
+   */
+  readonly chartVersion?: string;
   /**
    * What the host has stored for this study's inputs, for the declared shape.
    *
@@ -338,7 +362,7 @@ function start(
 
   // What this chart has no room for is refused before the engine is asked,
   // because a study drawn without it is a study that looks broken.
-  const narrower = undrawable(program);
+  const narrower = undrawable(program, capabilitiesOf(options.chartVersion));
   if (narrower !== undefined) throw refused(narrower);
 
   const loaded = load(program, {

package/src/adapters/charts/surfaces.ts

@@ -125,6 +125,18 @@ export interface ChartGrid {
   readonly options?: ChartTableOptions;
 }
 
+/**
+ * One grid of several, under an identity the chart keeps it by.
+ *
+ * The chart reuses the grid a recompute names again and removes one it no
+ * longer names, so the id is the declaration's key: stable across recomputes,
+ * never empty, and unique within a program because the compiler writes one per
+ * declaration.
+ */
+export interface ChartTableSpec extends ChartGrid {
+  readonly id: string;
+}
+
 /** One end of a drawing: a time on the shared axis, a price on the pane's scale. */
 export interface ChartAnchor {
   readonly time: number;

package/src/adapters/charts/tables.ts

@@ -27,13 +27,17 @@
  * placed into it, which is what `language.md` 6.7 asks for from the other
  * direction: a cell nothing was written into is blank, never a zero.
  *
- * **A chart pane holds one grid and the language declares as many as it likes.**
- * The descriptor has one `table` hook, and merging two grids into it would put
- * cells somewhere the script never asked for. So a program declaring a second
- * grid never reaches this file: `undrawable.ts` refuses it before any bar runs,
- * with OS6024, and this reads the one grid a program that runs can have.
- * `spec/chart-narrowings.json` records the refusal and
- * `scripts/check-chart-surface.mjs` proves it with a study that declares two.
+ * **The language declares as many grids as it likes, and a chart with the list
+ * of grids draws them all** (`capabilities.ts` says which chart has it). The
+ * list holds each grid under an id the chart keeps it by, and every declared
+ * grid is built for it here under its declaration's key. The single `table`
+ * hook stays beside the list with the first grid in it, because a chart
+ * without the list reads that one. Merging two grids into the single hook
+ * would put cells somewhere the script never asked for, so on a chart without
+ * the list a program declaring a second grid never reaches this file:
+ * `undrawable.ts` refuses it before any bar runs, with OS6024.
+ * `spec/chart-narrowings.json` records both halves and
+ * `scripts/check-chart-surface.mjs` proves both with a study that declares two.
  */
 import type { CompiledProgram, Grid as DeclaredGrid } from '../../core/emit/index.js';
 import type { Grid, GridCell } from '../../core/engine/index.js';
@@ -45,6 +49,7 @@ import type {
   ChartCellAlign,
   ChartGrid,
   ChartTablePosition,
+  ChartTableSpec,
 } from './surfaces.js';
 
 /** The language's four corners, in the chart's own words. */
@@ -58,22 +63,34 @@ const CORNERS: Readonly<Record<string, ChartTablePosition>> = {
 const ALIGNMENTS: readonly string[] = ['left', 'center', 'right'];
 
 /**
- * The grid a chart draws, from the declaration and the engine's buffer.
+ * Every grid a chart draws, from the declarations and the engine's buffers.
  *
- * The buffer is paired with the declaration by the key both of them carry
+ * Each buffer is paired with its declaration by the key both of them carry
  * rather than by position. The engine reads its grids in declaration order, so
  * the two agree today, and a pairing by position is one reordering away from
  * drawing one grid's cells into another grid's shape, which would be a wrong
  * table that looks like a right one.
+ *
+ * The key is the id as well. The compiler writes one per declaration and never
+ * an empty one, and it does not move between recomputes, which is what lets the
+ * chart keep a grid rather than build it again on every tick.
  */
-export function buildTable(
+export function buildTables(
   program: CompiledProgram,
   lookup: InputLookup,
   written: readonly Grid[],
-): ChartGrid | null {
-  const declared = program.outputs.tables[0];
-  if (declared === undefined) return null;
-  return oneTable(declared, lookup, written.find((one) => one.key === declared.key));
+): readonly ChartTableSpec[] {
+  return program.outputs.tables.map((declared) => ({
+    id: declared.key,
+    ...oneTable(declared, lookup, written.find((one) => one.key === declared.key)),
+  }));
+}
+
+/** The first grid alone, for the single hook a chart without the list reads. */
+export function firstGrid(tables: readonly ChartTableSpec[]): ChartGrid | null {
+  const first = tables[0];
+  if (first === undefined) return null;
+  return { rows: first.rows, ...(first.options === undefined ? {} : { options: first.options }) };
 }
 
 function oneTable(

package/src/adapters/charts/undrawable.ts

@@ -3,17 +3,24 @@
  *
  * `compiled-program.md` section 11: a host draws what its surface has room for,
  * and refuses what it does not with OS6024 rather than drawing part of a study
- * and saying nothing. Two things a version 1 program can declare have no place
- * on this chart's surface, and both used to be dropped in silence.
+ * and saying nothing. Two things a version 1 program can declare have a place
+ * on a newer chart and none on an older one (`capabilities.ts` says which is
+ * which), and on an older one both used to be dropped in silence.
  *
- * - **A second grid.** The descriptor has one `table` hook, so one grid reaches
- *   a pane. Merging two into it would put cells somewhere the script never
- *   asked for, and drawing the first alone is a study whose second panel never
- *   appears and whose cells look broken.
- * - **A band colour computed per bar.** The chart's band takes one colour for
- *   the whole run and has no channel to point at, so a band whose colour the
- *   script computes was drawn in the first plot's colour faded, which is a
- *   colour the script did not choose.
+ * - **A second grid.** An older descriptor has one `table` hook, so one grid
+ *   reaches a pane. Merging two into it would put cells somewhere the script
+ *   never asked for, and drawing the first alone is a study whose second panel
+ *   never appears and whose cells look broken. A newer chart's list of grids
+ *   carries every one (`tables.ts`).
+ * - **A band colour computed per bar.** An older chart's band takes one colour
+ *   for each side for the whole run, and a band whose colour the script
+ *   computes would be drawn in a colour the script did not choose. A newer
+ *   chart's band has a per-bar colour callback (`fills.ts`).
+ *
+ * Which chart the descriptor is registered with is what the host states, and
+ * `capabilities.ts` reads it. A host that states nothing is refused both, as
+ * before, because a chart that ignores a hook it does not know draws the
+ * silent version of each.
  *
  * The compiled program carries no source position for a declaration, so the
  * refusal names the declaration by its title, which is what a reader sees in
@@ -22,23 +29,26 @@
 import { diagnosticFor, makeSpan } from '../../core/index.js';
 import type { Diagnostic } from '../../core/index.js';
 import type { CompiledProgram, Field } from '../../core/emit/index.js';
+import { lacking } from './capabilities.js';
+import type { ChartCapabilities } from './capabilities.js';
 
 /** A load refusal has no line of its own: the program is what was refused. */
 const AT_LOAD = makeSpan(0, 0, 0, 0);
 
-export function undrawable(program: CompiledProgram): Diagnostic | undefined {
+export function undrawable(program: CompiledProgram, chart: ChartCapabilities): Diagnostic | undefined {
   const second = program.outputs.tables[1];
-  if (second !== undefined) {
+  if (second !== undefined && !chart.grids) {
     return diagnosticFor('OS6024', AT_LOAD, {
       what: `the table ${titled(second.title, 'after the first')}, the second grid this study declares`,
-      limit: 'a chart pane draws one grid',
+      limit: lacking(chart, 'grids', 'a chart pane draws one grid'),
     });
   }
+  if (chart.bandColours) return undefined;
   for (const band of program.outputs.fills) {
     if (band.colorUpChannel !== null || band.colorDownChannel !== null) {
       return diagnosticFor('OS6024', AT_LOAD, {
         what: "a band's colour that is computed per bar",
-        limit: "a chart's band takes one colour for the whole run",
+        limit: lacking(chart, 'bandColours', "a chart's band takes one colour for the whole run"),
       });
     }
   }

package/src/core/stdlib/volume/accumulation.ts

@@ -10,6 +10,14 @@
  * A running total is the one thing a lookback cannot stand in for, so each of
  * these carries its total in the state region rather than in a closure: that is
  * what lets an engine roll one back with the rest of a moving bar's state.
+ *
+ * A bar's term is checked after every operation that forms it
+ * (`compiled-program.md` section 3.1), and a term that is not finite is an absent
+ * term: the bar is absent and the total is left where it was, so one overflowing
+ * bar costs its own reading and nothing after it. A total that overflows although
+ * its term was finite is kept as the arithmetic produced it, and every later
+ * reading is absent, which is what `stdlib.md` section 20.6 says of every running
+ * total there.
  */
 import type { Bar, StateRecord, Tail, Value } from '../values/index.js';
 import { NONE, fold, held, isPresent, result, slot, tailOf } from '../values/index.js';
@@ -22,11 +30,18 @@ import { emaStep } from '../averages/index.js';
  * A bar whose high and low are equal has no position inside it to report, and
  * the settled treatment is that such a bar contributes nothing rather than
  * ending the running total.
+ *
+ * A span that overflows is not that bar. It is absent (`compiled-program.md`
+ * section 3.1), and so is the term, because the one later step that could hide
+ * it is this division: a finite numerator over an infinite span is an exact
+ * zero, a term for a bar whose position was never computed. Every other step
+ * that overflows stays non-finite to the end and the last check catches it.
  */
 export function moneyFlow(bar: Bar): Value {
   if (!isPresent(bar.high) || !isPresent(bar.low)) return NONE;
   if (!isPresent(bar.close) || !isPresent(bar.volume)) return NONE;
-  const span = bar.high - bar.low;
+  const span = result(bar.high - bar.low);
+  if (!isPresent(span)) return NONE;
   if (!(span > 0)) return 0;
   return result((((bar.close - bar.low) - (bar.high - bar.close)) / span) * bar.volume);
 }
@@ -115,6 +130,24 @@ export function adOsc(bars: readonly Bar[], fast = 3, slow = 10): Value[] {
   return fold(adOscTail(fast, slow), bars);
 }
 
+/**
+ * The per-bar term `pvt` adds: the change, then the proportion, then the
+ * product with the volume, each checked as it is formed.
+ *
+ * A change can overflow although the true proportion is finite: a close of
+ * -1e308 after one of 1e308 is a proportion of -2. Section 3.1 makes that change
+ * absent, and so the term. Each step is checked where it rounds because that is
+ * how the rule is stated, not because a later step could turn an infinity back
+ * into a number here: none of these three can.
+ */
+function trendTerm(close: number, before: number, volume: number): Value {
+  const change = result(close - before);
+  if (!isPresent(change)) return NONE;
+  const proportion = result(change / before);
+  if (!isPresent(proportion)) return NONE;
+  return result(proportion * volume);
+}
+
 /**
  * `pvt()`: the running total of volume weighted by percentage change, from bar
  * 1, seeded 0.
@@ -136,7 +169,9 @@ export function pvtStep(state: StateRecord, key: string, bar: Bar): Value {
   if (!started) return NONE;
   if (!isPresent(before) || before === 0) return NONE;
   if (!isPresent(bar.close) || !isPresent(bar.volume)) return NONE;
-  const total = slot(state, totalKey, 0) + ((bar.close - before) / before) * bar.volume;
+  const term = trendTerm(bar.close, before, bar.volume);
+  if (!isPresent(term)) return NONE;
+  const total = slot(state, totalKey, 0) + term;
   state[totalKey] = total;
   return result(total);
 }

package/src/core/stdlib/volume/flow.ts

@@ -21,7 +21,9 @@ export function cmfStep(
 ): Value {
   const flow = sumStep(state, `${key}f`, moneyFlow(bar), len);
   const traded = sumStep(state, `${key}v`, bar.volume, len);
-  if (!isPresent(flow) || !isPresent(traded) || !(traded > 0)) return NONE;
+  // A ratio is absent where its divisor is zero, and only there: a window whose
+  // volume sums below zero divides like any other.
+  if (!isPresent(flow) || !isPresent(traded) || traded === 0) return NONE;
   return result(flow / traded);
 }
 

package/src/core/stdlib/volume/weighted.ts

@@ -30,6 +30,13 @@ export interface Anchored {
  * The bar the condition holds on is the first bar of the new average, not the
  * last bar of the old one. Absent before the condition has ever been true,
  * because there is no anchor to measure from and zero would read as a price.
+ *
+ * A price times volume that overflows is an absent term (`compiled-program.md`
+ * section 3.1): the bar is absent and neither total moves, so the bar costs its
+ * own reading and nothing after it. A total that overflows is kept as the
+ * arithmetic produced it and is absent, so the average divided by it is absent
+ * until the next anchor rather than the exact zero a finite flow over an
+ * infinite volume would give.
  */
 export function vwapAnchorStep(state: StateRecord, key: string, input: Anchored): Value {
   const flowKey = `${key}f`;
@@ -42,12 +49,16 @@ export function vwapAnchorStep(state: StateRecord, key: string, input: Anchored)
   }
   if (!flag(state, anchoredKey)) return NONE;
   if (!isPresent(input.src) || !isPresent(input.volume)) return NONE;
-  const flow = slot(state, flowKey, 0) + input.src * input.volume;
+  const term = result(input.src * input.volume);
+  if (!isPresent(term)) return NONE;
+  const flow = slot(state, flowKey, 0) + term;
   const traded = slot(state, tradedKey, 0) + input.volume;
   state[flowKey] = flow;
   state[tradedKey] = traded;
-  if (traded === 0) return NONE;
-  return result(flow / traded);
+  const numerator = result(flow);
+  const divisor = result(traded);
+  if (!isPresent(numerator) || !isPresent(divisor) || divisor === 0) return NONE;
+  return result(numerator / divisor);
 }
 
 /** `vwapAnchor(src, resetWhen)` as a tail. */

package/src/core/version/version.generated.ts

@@ -4,7 +4,7 @@
 // spec/compiled-program.md, so neither can drift from the thing it names.
 
 /** This build's package version. The release refuses to publish unless the tag, the manifest and this agree. */
-export const VERSION = "0.7.1";
+export const VERSION = "0.8.0";
 
 /**
  * The compiled program format this compiler emits.