openscript 0.7.0__tar.gz → 0.7.2__tar.gz

{openscript-0.7.0 → openscript-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscript
-Version: 0.7.0
+Version: 0.7.2
 Summary: An open trading language: the engine that runs a compiled program.
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/marketcalls/openscript#readme

{openscript-0.7.0 → openscript-0.7.2}/openscript/library/flows.py

@@ -52,13 +52,22 @@ def _anchored(state: Region, ctx, value: Value, anchor: Value) -> Value:
         return ABSENT
     if price is None or traded is None:
         return ABSENT
-    flow = held.get("flow", 0.0) + price * traded
+    # An overflowing product is an absent term under compiled-program.md 3.1:
+    # the bar is absent and neither total moves.
+    term = result(price * traded)
+    if term is None:
+        return ABSENT
+    flow = held.get("flow", 0.0) + term
     volume = held.get("traded", 0.0) + traded
     held["flow"] = flow
     held["traded"] = volume
-    if volume == 0:
+    # An overflowed total is kept and is absent, so the average divided by it is
+    # too, rather than the exact zero a finite flow over an infinity would give.
+    numerator = result(flow)
+    divisor = result(volume)
+    if numerator is None or divisor is None or divisor == 0:
         return ABSENT
-    return result(flow / volume)
+    return result(numerator / divisor)
 
 
 def balance(state: Region, ctx) -> Value:
@@ -93,6 +102,11 @@ def position_flow(ctx) -> Value:
     The two bracketed differences are formed first and subtracted, then divided by
     the span, then multiplied by the volume. **A bar whose span is not above zero
     contributes an exact 0** rather than ending the total.
+
+    A span that overflows is absent under `compiled-program.md` 3.1, and the term
+    with it: dividing a finite numerator by the raw infinity would give an exact
+    zero for a bar whose position was never computed. Any other step that
+    overflows stays non-finite to the end, where ``result`` catches it.
     """
     high = number(ctx.bar("high"))
     low = number(ctx.bar("low"))
@@ -100,7 +114,9 @@ def position_flow(ctx) -> Value:
     traded = number(ctx.bar("volume"))
     if high is None or low is None or close is None or traded is None:
         return ABSENT
-    span = high - low
+    span = result(high - low)
+    if span is None:
+        return ABSENT
     if span <= 0:
         return 0.0
     return result((((close - low) - (high - close)) / span) * traded)
@@ -149,7 +165,24 @@ def price_trend(state: Region, ctx) -> Value:
     before = back(contributed(state, "close", close, 2), 1)
     if close is None or traded is None or not isinstance(before, float) or before == 0:
         return ABSENT
-    return running_total(state, "run", ((close - before) / before) * traded)
+    return running_total(state, "run", _trend_term(close, before, traded))
+
+
+def _trend_term(close: float, before: float, traded: float) -> Value:
+    """The term ``pvt`` adds, checked after each operation as section 3.1 states.
+
+    A change that overflows is absent although the true proportion may be
+    finite, and an absent term leaves the running total where it was, so the
+    bar costs its own reading and nothing after it. Adding the unchecked
+    infinity instead would store it and end the reading for good.
+    """
+    change = result(close - before)
+    if change is None:
+        return ABSENT
+    proportion = result(change / before)
+    if proportion is None:
+        return ABSENT
+    return result(proportion * traded)
 
 
 def money_flow(state: Region, ctx, length: Optional[int]) -> Value:

{openscript-0.7.0 → openscript-0.7.2}/openscript/library/trend.py

@@ -179,8 +179,8 @@ def directional(state: Region, ctx, di_length: Optional[int], adx_length: Option
         if isinstance(before_high, float) and isinstance(before_low, float):
             up = high - before_high
             down = before_low - low
-            up_move = up if up > down and up > 0 else 0.0
-            down_move = down if down > up and down > 0 else 0.0
+            up_move = result(up) if up > down and up > 0 else 0.0
+            down_move = result(down) if down > up and down > 0 else 0.0
     smoothed_up = averages.smoothed(region(state, "up"), up_move, di_length)
     smoothed_down = averages.smoothed(region(state, "down"), down_move, di_length)
     smoothed_range = averages.smoothed(region(state, "range"), gap_range(ctx), di_length)

{openscript-0.7.0 → openscript-0.7.2}/openscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscript
-Version: 0.7.0
+Version: 0.7.2
 Summary: An open trading language: the engine that runs a compiled program.
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/marketcalls/openscript#readme

{openscript-0.7.0 → openscript-0.7.2}/openscript.egg-info/SOURCES.txt

@@ -118,6 +118,7 @@ tests/test_adapter_matching.py
 tests/test_adapter_page.py
 tests/test_adapter_spellings.py
 tests/test_analysis_and_runup.py
+tests/test_anchored_total_overflow.py
 tests/test_arrays.py
 tests/test_bar_cycle.py
 tests/test_bars.py
@@ -129,6 +130,7 @@ tests/test_charges.py
 tests/test_colour.py
 tests/test_cost_models.py
 tests/test_diagnostics.py
+tests/test_directional_recovery.py
 tests/test_engine_facts.py
 tests/test_frame_fold.py
 tests/test_frame_instant.py

{openscript-0.7.0 → openscript-0.7.2}/pyproject.toml

@@ -13,7 +13,7 @@
 
 [project]
 name = "openscript"
-version = "0.7.0"
+version = "0.7.2"
 description = "An open trading language: the engine that runs a compiled program."
 readme = "README.md"
 requires-python = ">=3.12"

openscript-0.7.2/tests/test_anchored_total_overflow.py

@@ -0,0 +1,294 @@
+"""An overflowing term is an absent observation, and the anchored total keeps its value.
+
+`compiled-program.md` section 3.1 makes every non-finite arithmetic result
+absent, checked after each individual operation. `stdlib.md` section 20.6 says
+an absent term produces an absent reading and leaves the running total where it
+was. Read together, a term whose change, proportion or product overflows costs
+the reading on its own bar and nothing after it. The wrong implementation these
+fixtures catch adds the unchecked term, stores the infinity it produced, and is
+absent on every later bar.
+
+A total that overflows although its term was finite is a different case: the
+total keeps what the arithmetic produced and every later reading is absent until
+the total is started again, which is what the sibling totals already do.
+
+The term ``ad`` and ``cmf`` share has one step whose overflow a later step could
+hide: a finite numerator divided by an overflowed span is an exact zero. That
+span is absent under section 3.1, so the term is absent rather than zero.
+"""
+
+import copy
+import json
+import math
+import struct
+import sys
+import unittest
+
+from openscript.library import stateful_table
+from tests.test_momentum_overflow import finite, operation
+
+
+def trend_expected(rows):
+    """Batch reading of ``pvt``, one rounded operation at a time from exact operands."""
+    output, total, before, started = [], 0.0, None, False
+    for row in rows:
+        close, volume = row['close'], row['volume']
+        previous, seen = before, started
+        before, started = close, True
+        reading = None
+        if seen and previous is not None and previous != 0 and close is not None and volume is not None:
+            change = finite(operation(close, previous, '-'))
+            proportion = None if change is None else finite(operation(change, previous, '/'))
+            term = None if proportion is None else finite(operation(proportion, volume, '*'))
+            if term is not None:
+                total = operation(total, term, '+')
+                reading = finite(total)
+        output.append(reading)
+    return output
+
+
+def anchored_expected(rows, anchors):
+    """Batch reading of ``vwapAnchor``: both totals reset first, then one term each."""
+    output, flow, traded, anchored = [], 0.0, 0.0, False
+    for row, anchor in zip(rows, anchors):
+        if anchor:
+            flow, traded, anchored = 0.0, 0.0, True
+        reading = None
+        price, volume = row['close'], row['volume']
+        if anchored and price is not None and volume is not None:
+            term = finite(operation(price, volume, '*'))
+            if term is not None:
+                flow = operation(flow, term, '+')
+                traded = operation(traded, volume, '+')
+                numerator, divisor = finite(flow), finite(traded)
+                if numerator is not None and divisor is not None and divisor != 0:
+                    reading = finite(operation(numerator, divisor, '/'))
+        output.append(reading)
+    return output
+
+
+def flow_term(row):
+    """The term ``ad`` and ``cmf`` share, every stated operation checked as it rounds."""
+    high, low, close, volume = (row[key] for key in ['high', 'low', 'close', 'volume'])
+    if high is None or low is None or close is None or volume is None:
+        return None
+    span = finite(operation(high, low, '-'))
+    if span is None:
+        return None
+    if span <= 0:
+        return 0.0
+    upper = finite(operation(close, low, '-'))
+    lower = finite(operation(high, close, '-'))
+    offset = None if upper is None or lower is None else finite(operation(upper, lower, '-'))
+    share = None if offset is None else finite(operation(offset, span, '/'))
+    return None if share is None else finite(operation(share, volume, '*'))
+
+
+def accumulation_expected(rows):
+    """Batch reading of ``ad``: an absent term is an absent bar and the total stays."""
+    output, total = [], 0.0
+    for row in rows:
+        term = flow_term(row)
+        if term is not None:
+            total = operation(total, term, '+')
+        output.append(None if term is None else finite(total))
+    return output
+
+
+def fraction_expected(rows, length):
+    """Batch reading of ``cmf``: fresh window sums, oldest first, then one division."""
+    terms = [flow_term(row) for row in rows]
+    output = []
+    for index in range(len(rows)):
+        start = index + 1 - length
+        flows = terms[start:index + 1] if start >= 0 else []
+        volumes = [row['volume'] for row in rows[start:index + 1]] if start >= 0 else []
+        reading = None
+        if flows and None not in flows and None not in volumes:
+            flow = traded = 0.0
+            for term, volume in zip(flows, volumes):
+                flow = operation(flow, term, '+')
+                traded = operation(traded, volume, '+')
+            flow, traded = finite(flow), finite(traded)
+            if flow is not None and traded is not None and traded > 0:
+                reading = finite(operation(flow, traded, '/'))
+        output.append(reading)
+    return output
+
+
+def flow_case(name, label, triples, volume=2.0):
+    rows = [dict(time=1700000000000 + index * 60000, open=close, high=high, low=low,
+                 close=close, volume=volume) for index, (high, low, close) in enumerate(triples)]
+    expected = accumulation_expected(rows) if name == 'ad' else fraction_expected(rows, 2)
+    return dict(id=f'{name}-{label}', name=name, bars=rows, anchors=[False] * len(rows), expected=expected)
+
+
+def bars(closes, volumes, anchors=None):
+    """Host bars; ``open`` marks an anchor so a compiled script can read it."""
+    anchors = anchors or [False] * len(closes)
+    return [dict(time=1700000000000 + index * 60000, open=1.0 if anchor else 0.0,
+                 high=close, low=close, close=close, volume=volume)
+            for index, (close, volume, anchor) in enumerate(zip(closes, volumes, anchors))]
+
+
+def trend_case(label, closes, volumes):
+    rows = bars(closes, volumes)
+    return dict(id=f'pvt-{label}', name='pvt', bars=rows, anchors=[False] * len(rows),
+                expected=trend_expected(rows))
+
+
+def anchored_case(label, closes, volumes, anchors):
+    rows = bars(closes, volumes, anchors)
+    return dict(id=f'vwapAnchor-{label}', name='vwapAnchor', bars=rows, anchors=list(anchors),
+                expected=anchored_expected(rows, anchors))
+
+
+def signed(values, sign):
+    return [None if value is None else sign * value for value in values]
+
+
+def cases():
+    rows = []
+    ordinary = [40.0 + index % 7 for index in range(40)]
+    for sign in [1.0, -1.0]:
+        tag = 'up' if sign > 0 else 'down'
+
+        def flip(values):
+            return signed(values, sign)
+
+        rows.append(trend_case(f'change-overflow-{tag}', flip([1.0, 1e308, -1e308, 2.0, 3.0]), [1.0] * 5))
+        rows.append(trend_case(f'proportion-overflow-{tag}',
+                               flip([1.0, 2.0, 1e-300, 1e10, 2e10, 3e10]), [1.0] * 6))
+        rows.append(trend_case(f'product-overflow-{tag}', flip([1.0, 2.0, 6.0, 7.0, 8.0]),
+                               [1.0, 1.0, 1e308, 1.0, 1.0]))
+        rows.append(trend_case(f'total-overflow-{tag}', flip([1.0, 2.0, 4.0, 8.0, 9.0]),
+                               [1.0, 1e308, 1e308, 1.0, 1.0]))
+        rows.append(trend_case(f'recovery-{tag}', flip(ordinary + [-1e308, 1e308] + ordinary),
+                               [1.0 + index % 3 for index in range(82)]))
+    rows.append(trend_case('holes', [10.0, 11.0, None, 12.0, 13.0, 14.0, 15.0],
+                           [5.0, 5.0, 5.0, 5.0, None, 5.0, 5.0]))
+    rows.append(trend_case('zero-previous', [0.0, 1e308, 1.0, 2.0], [1.0] * 4))
+    rows.append(trend_case('unchanged-negative', [-5.0, -5.0, -4.0], [3.0] * 3))
+    for sign in [1.0, -1.0]:
+        tag = 'up' if sign > 0 else 'down'
+        rows.append(anchored_case(f'product-overflow-{tag}', [10.0 * sign, 1e308 * sign, 20.0 * sign, 30.0 * sign],
+                                  [2.0, 1e10, 6.0, 2.0], [True, False, False, False]))
+        rows.append(anchored_case(f'flow-overflow-{tag}', [1e308 * sign, 1e308 * sign, 5.0 * sign, 4.0 * sign],
+                                  [1.0, 1.0, 1.0, 2.0], [True, False, False, True]))
+    rows.append(anchored_case('traded-overflow', [1e-10, 1e-10, 5.0, 4.0, 6.0], [1e308, 1e308, 1.0, 2.0, 2.0],
+                              [True, False, False, True, False]))
+    rows.append(anchored_case('overflow-before-anchor', [1e308, 10.0, 1e308, 20.0], [1e10, 2.0, 1e10, 2.0],
+                              [False, True, False, False]))
+    # The span overflows on the second bar although the true term there is 1.
+    span = [(2.0, 0.0, 1.5), (1e308, -1e308, 5e307), (4.0, 2.0, 4.0), (5.0, 1.0, 2.0), (6.0, 2.0, 5.0)]
+    for sign in [1.0, -1.0]:
+        tag = 'up' if sign > 0 else 'down'
+        triples = span if sign > 0 else [(-low, -high, -close) for high, low, close in span]
+        rows.append(flow_case('ad', f'span-overflow-{tag}', triples))
+        rows.append(flow_case('cmf', f'span-overflow-{tag}', triples))
+    rows.append(flow_case('ad', 'outside-range', [(2.0, 0.0, 1.0), (1e308, 0.0, -1e308), (4.0, 2.0, 3.0)]))
+    rows.append(flow_case('ad', 'zero-span', [(2.0, 0.0, 1.5), (3.0, 3.0, 3.0), (4.0, 2.0, 4.0)]))
+    return rows
+
+
+class Observation:
+    """What the stateful table reads from a bar, with the session flag for ``vwap``."""
+
+    def __init__(self, row, anchor):
+        self.values = {**row, 'isSessionFirst': anchor}
+
+    def bar(self, key):
+        return self.values.get(key)
+
+    def first_bar(self):
+        return False
+
+    def make_array(self, values):
+        return list(values)
+
+
+def call(name, row, anchor, state):
+    if name == 'pvt':
+        return stateful_table()[('pvt', 0)].call(Observation(row, anchor), [], state)
+    if name == 'ad':
+        return stateful_table()[('ad', 0)].call(Observation(row, anchor), [], state)
+    if name == 'cmf':
+        return stateful_table()[('cmf', 1)].call(Observation(row, anchor), [2.0], state)
+    if name == 'vwap':
+        return stateful_table()[('vwap', 1)].call(Observation(row, anchor), [row['close']], state)
+    return stateful_table()[('vwapAnchor', 2)].call(Observation(row, anchor), [row['close'], anchor], state)
+
+
+def encoded(values):
+    return [None if value is None else struct.pack('>d', value).hex() for value in values]
+
+
+def readings(row, name=None, forming=False):
+    name = name or row['name']
+    state, output = {}, []
+    for index, (bar, anchor) in enumerate(zip(row['bars'], row['anchors'])):
+        if forming:
+            saved = copy.deepcopy(state)
+            draft = {**bar, 'close': 1e308 if index % 2 else -1e308, 'volume': sys.float_info.max}
+            call(name, draft, anchor, state)
+            state = copy.deepcopy(saved)
+        output.append(call(name, bar, anchor, state))
+    return output
+
+
+def named(prefix):
+    return next(row for row in cases() if row['id'] == prefix)
+
+
+class AnchoredTotalOverflow(unittest.TestCase):
+    def test_the_specified_trend_values_are_hand_computed(self):
+        # Bar 2's change overflows, so its term is absent and the total stays at
+        # 1e308. Bar 3 adds ((2 + 1e308) / -1e308) * 1 = -1, and 1e308 - 1
+        # rounds back to 1e308, as does adding bar 4's 0.5.
+        self.assertEqual(named('pvt-change-overflow-up')['expected'], [None, 1e308, None, 1e308, 1e308])
+        self.assertEqual(named('pvt-change-overflow-down')['expected'], [None, 1e308, None, 1e308, 1e308])
+        self.assertEqual(named('pvt-proportion-overflow-up')['expected'], [None, 1.0, 0.0, None, 1.0, 1.5])
+        self.assertEqual(named('pvt-product-overflow-up')['expected'],
+                         [None, 1.0, None, 1.0 + 1.0 / 6.0, 1.0 + 1.0 / 6.0 + 1.0 / 7.0])
+        self.assertEqual(named('pvt-total-overflow-up')['expected'], [None, 1e308, None, None, None])
+        self.assertEqual(named('vwapAnchor-product-overflow-up')['expected'], [10.0, None, 17.5, 20.0])
+        self.assertEqual(named('vwapAnchor-traded-overflow')['expected'], [1e-10, None, None, 4.0, 5.0])
+        # A finite numerator over an overflowed span is not a zero term: the span
+        # is absent, so the bar is, and the total of 1 carries on to 3 and 2.
+        self.assertEqual(named('ad-span-overflow-up')['expected'], [1.0, None, 3.0, 2.0, 3.0])
+        self.assertEqual(named('cmf-span-overflow-up')['expected'], [None, None, None, 0.25, 0.0])
+        self.assertEqual(named('ad-zero-span')['expected'], [1.0, 1.0, 3.0])
+
+    def test_an_overflowing_term_leaves_the_total_where_it_was(self):
+        for row in cases():
+            with self.subTest(case=row['id']):
+                actual = readings(row)
+                self.assertEqual(encoded(actual), encoded(row['expected']))
+                self.assertTrue(all(value is None or math.isfinite(value) for value in actual))
+                if 'recovery' in row['id'] or 'product-overflow' in row['id']:
+                    self.assertIsNotNone(actual[-1])
+
+    def test_each_prefix_keeps_the_same_availability_and_bits(self):
+        for row in cases():
+            for end in range(len(row['bars']) + 1):
+                with self.subTest(case=row['id'], prefix=end):
+                    part = {**row, 'bars': row['bars'][:end], 'anchors': row['anchors'][:end]}
+                    self.assertEqual(encoded(readings(part)), encoded(row['expected'][:end]))
+
+    def test_forming_checkpoint_revisions_do_not_contaminate_history(self):
+        for row in cases():
+            with self.subTest(case=row['id']):
+                self.assertEqual(encoded(readings(row, forming=True)), encoded(row['expected']))
+
+    def test_the_session_average_is_the_same_calculation(self):
+        for row in cases():
+            if row['name'] == 'vwapAnchor':
+                with self.subTest(case=row['id']):
+                    self.assertEqual(encoded(readings(row, name='vwap')), encoded(row['expected']))
+
+
+if __name__ == '__main__':
+    if sys.argv[1:] == ['--cases']:
+        json.dump(cases(), sys.stdout)
+    else:
+        unittest.main()

openscript-0.7.2/tests/test_directional_recovery.py

@@ -0,0 +1,180 @@
+"""Selected directional overflow is an absent observation before smoothing."""
+
+import copy
+import json
+import math
+import struct
+import sys
+import unittest
+
+from openscript.library import stateful_table
+from tests.test_momentum_overflow import average, finite, operation
+
+
+def expected(rows, di_length, adx_length):
+    """Batch operation oracle, independent of directional state and dispatch."""
+    rises, falls, ranges = [], [], []
+    for index, bar in enumerate(rows):
+        before = rows[index - 1] if index else {}
+        high, low = bar['high'], bar['low']
+        old_high, old_low, old_close = (before.get(key) for key in ['high', 'low', 'close'])
+        up = down = width = None
+        if all(value is not None for value in [high, low, old_high, old_low]):
+            rise = operation(high, old_high, '-')
+            fall = operation(old_low, low, '-')
+            up = finite(rise) if rise > fall and rise > 0 else 0.0
+            down = finite(fall) if fall > rise and fall > 0 else 0.0
+        if all(value is not None for value in [high, low, old_close]):
+            width = finite(max(operation(high, low, '-'), abs(operation(high, old_close, '-')),
+                               abs(operation(low, old_close, '-'))))
+        rises.append(up)
+        falls.append(down)
+        ranges.append(width)
+    rises = average(rises, di_length, True)
+    falls = average(falls, di_length, True)
+    ranges = average(ranges, di_length, True)
+    plus, minus, spreads = [], [], []
+    for up, down, width in zip(rises, falls, ranges):
+        plus.append(None if up is None or width in [None, 0] else
+                    finite(operation(operation(up, width, '/'), 100.0, '*')))
+        minus.append(None if down is None or width in [None, 0] else
+                     finite(operation(operation(down, width, '/'), 100.0, '*')))
+        a, b = plus[-1], minus[-1]
+        if a is None or b is None:
+            spreads.append(None)
+        else:
+            total = operation(a, b, '+')
+            spreads.append(0.0 if total == 0 else finite(operation(
+                operation(abs(operation(a, b, '-')), total, '/'), 100.0, '*')))
+    return [list(row) for row in zip(average(spreads, adx_length, True), plus, minus)]
+
+
+def bars(rows):
+    return [dict(time=1700000000000 + index * 60000, open=close, high=high,
+                 low=low, close=close, volume=100.0)
+            for index, (high, low, close) in enumerate(rows)]
+
+
+def cases():
+    minimal = [(-1e308, -1e308, -1e308)] * 2 + [(1e308, 1e308, 1e308),
+                (1e308, 5e307, 1e308), (1e308, 5e307, 1e308)]
+    long = [minimal[0]] * 40 + minimal[2:4] + [(41.0 + i, 39.0 + i, 40.0 + i) for i in range(40)]
+    rows = []
+    for sign in [1, -1]:
+        for label, source, length in [('overflow', minimal, 1), ('seeded-overflow', long, 14)]:
+            source = source if sign == 1 else [(-low, -high, -close) for high, low, close in source]
+            rows.append(dict(id=f'{label}-{sign}', bars=bars(source), lengths=[length, length]))
+    competing = [(-1e308, -1.5e308, -1e308)] * 3 + [(1e308, -1.6e308, 0.),
+                 (1e308, 5e307, 1e308), (1e308, 5e307, 1e308)]
+    for sign in [1, -1]:
+        for label, source, length in [('leading-overflow', minimal[1:], 1), ('competing-overflow', competing, 2)]:
+            source = source if sign == 1 else [(-low, -high, -close) for high, low, close in source]
+            rows.append(dict(id=f'{label}-{sign}', bars=bars(source), lengths=[length, length]))
+    rows.append(dict(id='positive-movement-tie', bars=bars([(10., 8., 9.), (11., 7., 9.),
+                     (12., 6., 9.), (14., 7., 12.), (13., 5., 8.)]), lengths=[1, 2]))
+    ramp = [(41.0 + i, 39.0 + i, 40.0 + i) for i in range(9)]
+    for field in ['high', 'low', 'close', 'open']:
+        source = bars(ramp)
+        source[6][field] = None
+        rows.append(dict(id=f'missing-{field}', bars=source, lengths=[3, 3]))
+    rows.append(dict(id='zero-range', bars=bars([(10., 0., 5.), (11., 1., 6.), (10., 2., 6.),
+                     (6., 6., 6.), (12., 6., 9.), (11., 5., 8.)]), lengths=[1, 2]))
+    rows.append(dict(id='reversal', bars=bars([(10., 8., 9.), (12., 9., 11.), (11., 7., 8.),
+                     (13., 9., 12.), (12., 10., 11.)]), lengths=[2, 2]))
+    rows.append(dict(id='flat', bars=bars([(10., 10., 10.)] * 8), lengths=[2, 2]))
+    for row in rows:
+        row['expected'] = expected(row['bars'], *row['lengths'])
+    return rows
+
+
+class Observation:
+    def __init__(self, row, previous, index):
+        self.values = {**row, 'previousClose': previous}
+        self.index = index
+
+    def bar(self, key):
+        return self.values.get(key)
+
+    def first_bar(self):
+        return self.index == 0
+
+    def make_array(self, values):
+        return list(values)
+
+
+def encoded(rows):
+    return [[None if value is None else struct.pack('>d', value).hex() for value in row] for row in rows]
+
+
+def readings(row, forming=False):
+    entry = stateful_table()[('adx', 2)]
+    state, output = {}, []
+    for index, bar in enumerate(row['bars']):
+        previous = row['bars'][index - 1]['close'] if index else None
+        ctx = Observation(bar, previous, index)
+        if forming:
+            saved = copy.deepcopy(state)
+            draft = {**bar, 'high': 1e308, 'low': -1e308, 'close': 0.0}
+            entry.call(Observation(draft, previous, index), row['lengths'], state)
+            state = copy.deepcopy(saved)
+        output.append(entry.call(ctx, row['lengths'], state))
+    return output
+
+
+class DirectionalRecovery(unittest.TestCase):
+    def test_minimal_oracle_has_hand_computed_recovery(self):
+        upward = cases()[0]
+        self.assertEqual(upward['expected'], [[None] * 3] * 3 + [[100., 0., 100.], [0., 0., 0.]])
+        downward = cases()[2]
+        self.assertEqual(downward['expected'], [[None] * 3] * 3 + [[100., 100., 0.], [0., 0., 0.]])
+
+    def test_selected_overflow_never_poisoned_the_smoothed_state(self):
+        for row in cases():
+            with self.subTest(case=row['id']):
+                self.assertEqual(encoded(readings(row)), encoded(row['expected']))
+                if row['id'].startswith('seeded-overflow'):
+                    self.assertTrue(all(value is not None and math.isfinite(value) for value in row['expected'][-1]))
+
+    def test_each_prefix_keeps_the_same_availability_and_bits(self):
+        for row in cases():
+            for end in range(len(row['bars']) + 1):
+                with self.subTest(case=row['id'], prefix=end):
+                    self.assertEqual(encoded(readings({**row, 'bars': row['bars'][:end]})), encoded(row['expected'][:end]))
+
+    def test_forming_checkpoint_revisions_do_not_contaminate_history(self):
+        for row in cases():
+            with self.subTest(case=row['id']):
+                self.assertEqual(encoded(readings(row, forming=True)), encoded(row['expected']))
+
+
+def compiled():
+    from openscript.adapter.serving import Serving
+    from openscript.contracts import Bar, BarState
+    from openscript.run import load
+    from openscript.values import ABSENT
+    payload = json.load(sys.stdin)
+    library = Serving()
+    loaded = load(payload['program'], {}, library)
+    if not loaded.ok:
+        raise AssertionError(loaded.diagnostic)
+    accepted, output = {}, []
+    for delivery in payload['deliveries']:
+        index = delivery['index']
+        raw = {key: None if value is None else float(value) for key, value in delivery['bar'].items()}
+        library.at_bar({**raw, 'previousClose': accepted.get(index - 1, {}).get('close')}, index == 0)
+        actual = loaded.run.execute_bar(index, Bar(**raw), BarState())
+        if not actual.ok:
+            raise AssertionError(actual.diagnostic)
+        values = [actual.columns[plot['channel']] for plot in payload['program']['outputs']['plots']]
+        output.append([None if value is ABSENT else struct.pack('>d', value).hex() for value in values])
+        accepted[index] = raw
+    json.dump(output, sys.stdout)
+
+
+if __name__ == '__main__':
+    if sys.argv[1:] == ['--cases']:
+        json.dump(cases(), sys.stdout)
+    elif sys.argv[1:] == ['--compiled']:
+        compiled()
+    else:
+        unittest.main()