openscript 0.4.0__tar.gz → 0.6.0__tar.gz

{openscript-0.4.0 → openscript-0.6.0}/PKG-INFO

@@ -1,82 +1,82 @@
-Metadata-Version: 2.4
-Name: openscript
-Version: 0.4.0
-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
-Project-URL: Source, https://github.com/marketcalls/openscript
-Keywords: trading,language,interpreter,indicators,backtesting
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Office/Business :: Financial :: Investment
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# openscript
-
-The engine that runs a compiled OpenScript program, in Python.
-
-OpenScript is an open trading language. A script is compiled to a **compiled
-program**: plain data, an instruction list, never generated code. This package
-runs one.
-
-It exists so that a platform can run a strategy where a JavaScript runtime is
-not available, which for a production trading server is the ordinary case. The
-compiler and the first engine are the `openalgo-script` package on npm; this is
-the second engine, and the two are held to each other by a conformance suite
-where any disagreement is a release blocker.
-
-## What it is
-
-- **No compiler.** This package is handed a compiled program and never a script.
-  The program arrives as canonical text, which is what a run's hash is taken
-  over, so an engine cannot quietly run something other than what was recorded.
-- **Nothing builds code out of text.** No string evaluator, no statement
-  executor, no import driven by hand, no object graph loaded out of bytes. That
-  is what lets a platform run many people's scripts in one process, and it is
-  enforced by a check rather than intended.
-- **Zero dependencies.** The standard library only, and not the parts of it that
-  stop a run being reproducible. Measured on every build against the module
-  names the running interpreter says are its own.
-
-## Installing
-
-```
-pip install openscript
-```
-
-Python 3.12 or newer. Nothing else.
-
-## Using it
-
-```python
-from openscript.run import load_text
-
-loaded = load_text(program_text, settings, library)
-if loaded.ok:
-    result = loaded.run.execute_bar(0, bar)
-```
-
-A host loads a program once and pushes bars at it one at a time, keeping a
-checkpoint so a bar that is still moving can be executed again and rolled back.
-The conformance adapter is the other way in:
-
-```
-python -m openscript --describe
-python -m openscript <case-directory>
-```
-
-## Where the documentation is
-
-The specification and the guides live in the repository:
-
-- `docs/integrating/the-python-engine.md` for what is in this package and what a
-  host needs.
-- `docs/integrating/running-a-strategy.md` for driving it bar by bar: the load,
-  the bar cycle, the rollback a moving bar rests on, and the order boundary.
-- `spec/` for the language, the compiled program format, the standard library
-  and the conformance suite.
-
-## Licence
-
-Apache-2.0.
+Metadata-Version: 2.4
+Name: openscript
+Version: 0.6.0
+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
+Project-URL: Source, https://github.com/marketcalls/openscript
+Keywords: trading,language,interpreter,indicators,backtesting
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# openscript
+
+The engine that runs a compiled OpenScript program, in Python.
+
+OpenScript is an open trading language. A script is compiled to a **compiled
+program**: plain data, an instruction list, never generated code. This package
+runs one.
+
+It exists so that a platform can run a strategy where a JavaScript runtime is
+not available, which for a production trading server is the ordinary case. The
+compiler and the first engine are the `openalgo-script` package on npm; this is
+the second engine, and the two are held to each other by a conformance suite
+where any disagreement is a release blocker.
+
+## What it is
+
+- **No compiler.** This package is handed a compiled program and never a script.
+  The program arrives as canonical text, which is what a run's hash is taken
+  over, so an engine cannot quietly run something other than what was recorded.
+- **Nothing builds code out of text.** No string evaluator, no statement
+  executor, no import driven by hand, no object graph loaded out of bytes. That
+  is what lets a platform run many people's scripts in one process, and it is
+  enforced by a check rather than intended.
+- **Zero dependencies.** The standard library only, and not the parts of it that
+  stop a run being reproducible. Measured on every build against the module
+  names the running interpreter says are its own.
+
+## Installing
+
+```
+pip install openscript
+```
+
+Python 3.12 or newer. Nothing else.
+
+## Using it
+
+```python
+from openscript.run import load_text
+
+loaded = load_text(program_text, settings, library)
+if loaded.ok:
+    result = loaded.run.execute_bar(0, bar)
+```
+
+A host loads a program once and pushes bars at it one at a time, keeping a
+checkpoint so a bar that is still moving can be executed again and rolled back.
+The conformance adapter is the other way in:
+
+```
+python -m openscript --describe
+python -m openscript <case-directory>
+```
+
+## Where the documentation is
+
+The specification and the guides live in the repository:
+
+- `docs/integrating/the-python-engine.md` for what is in this package and what a
+  host needs.
+- `docs/integrating/running-a-strategy.md` for driving it bar by bar: the load,
+  the bar cycle, the rollback a moving bar rests on, and the order boundary.
+- `spec/` for the language, the compiled program format, the standard library
+  and the conformance suite.
+
+## Licence
+
+Apache-2.0.

{openscript-0.4.0 → openscript-0.6.0}/openscript/__init__.py

@@ -16,7 +16,9 @@ What is where, for somebody reading this engine rather than running it:
                       memory regions and their lifetimes, the values, the bars,
                       the inputs, the verification done before the first bar,
                       the execution budget, the canonical encoding, the
-                      diagnostics and the two version numbers.
+                      diagnostics and the two version numbers, and the reads
+                      of section 2.16: a timeframe's buckets, a read's plan
+                      and body, and the fold that puts its value on the chart.
 - ``library/``        the functions of ``spec/stdlib.md``, each accumulating in
                       the order that page fixes, in the two halves that page
                       divides them into: the calls that remember nothing and

{openscript-0.4.0 → openscript-0.6.0}/openscript/adapter/answers.py

@@ -30,11 +30,12 @@ have it say. The stage's report records that as a defect of the page rather than
 leaving it to be discovered.
 """
 
+import email.parser
 import json
 import sys
 import tomllib
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Mapping, Optional
 
 from ..version import FORMAT, LANGUAGE_VERSIONS
 from .expectations import expected_channels
@@ -47,6 +48,11 @@ from .spellings import Malformed
 #: The distribution file beside the package, which states the version once.
 _PROJECT = "pyproject.toml"
 
+#: The distribution this engine is, as the build and the installer name it. It is
+#: named for its top package, so the name is read from where this module sits
+#: rather than written out a second time beside the one in pyproject.toml.
+_NAME = __name__.split(".", 1)[0]
+
 #: Section 8: what this implementation claims. The profile that covers the cases
 #: it runs, which is the one a case it would report ``unsupported`` is not in.
 #:
@@ -65,24 +71,89 @@ PROFILE = PROFILES[2]
 
 
 def _distribution() -> Dict[str, Any]:
-    """``pyproject.toml``, read from beside the package, or a refusal saying so.
-
-    The version is a fact of the release and is written in the distribution
-    file; ``scripts/check-python.mjs`` already holds that file and the package
-    manifest equal, so reading it here adds no third copy. An installed package
-    that does not carry the file cannot prove its version, and an identity with
-    an invented version in it is worse than an adapter that says which file it
-    could not find.
+    """The engine's name and version, from wherever this copy of it was built.
+
+    The version is a fact of the release, stated once in the distribution file,
+    and ``scripts/check-python.mjs`` holds that file and the package manifest
+    equal, so nothing read here is a third copy.
+    """
+    return _identity(Path(__file__).resolve().parent.parent.parent / _PROJECT, _installed)
+
+
+def _installed(name: str, site: Optional[Path] = None) -> Optional[Mapping[str, str]]:
+    """The metadata an installer wrote beside this package, or ``None`` if none did.
+
+    Every installer records a distribution in ``<name>-<version>.dist-info``
+    beside the package it installed, and ``METADATA`` there holds the name and
+    version the build wrote. It is read directly, with the standard library's
+    own header parser, rather than through the import system's metadata finder:
+    this project refuses anything that loads modules by a name computed at run
+    time, and reading two headers out of one file does not need it.
+
+    Two records beside one package is a broken upgrade, and there is no telling
+    which of them describes the files actually installed, so that is refused
+    by name rather than resolved by picking one.
+    """
+    if site is None:
+        site = Path(__file__).resolve().parent.parent.parent
+    records = sorted(site.glob(f"{name}-*.dist-info/METADATA"))
+    if not records:
+        return None
+    if len(records) > 1:
+        raise Malformed(
+            f"{len(records)} installed records for {name!r} sit beside this package "
+            f"({', '.join(record.parent.name for record in records)}), so its version cannot "
+            "be told. Reinstall it so that one remains."
+        )
+    with records[0].open(encoding="utf-8") as file:
+        return email.parser.Parser().parse(file, headersonly=True)
+
+
+def _identity(
+    project_file: Path, installed: Callable[[str], Optional[Mapping[str, str]]]
+) -> Dict[str, Any]:
+    """Read the identity from ``project_file``, else from the installed distribution.
+
+    **Two places, because a copy of this engine lives in one of two.** A checkout
+    has ``pyproject.toml`` beside the package, which is what the conformance suite
+    runs. An installed copy does not: the build reads that file and records what
+    it says in the distribution's own metadata, and the file itself is never
+    installed. This used to read only the first, so ``python -m openscript
+    --describe`` failed on every installed copy, 0.5.0 from the index included,
+    and no host could run the suite against the engine it had actually installed.
+
+    The installed metadata is not an invented version. It is the one the wheel
+    was built with, written by the same build from the same file, and it is what
+    the installer, the index and ``pip show`` all report for this copy.
+
+    **A file that names some other project is not this one's.** Beside an
+    installed package, the directory above is ``site-packages``, where a stray
+    ``pyproject.toml`` from anything else would otherwise be read as this
+    engine's identity. The name is checked, and a mismatch falls through.
+
+    Neither available is still a refusal that names both, because an identity
+    with a guessed version in it is worse than an adapter saying what it could
+    not find.
     """
-    path = Path(__file__).resolve().parent.parent.parent / _PROJECT
+    reasons = []
     try:
-        with path.open("rb") as file:
-            return tomllib.load(file)["project"]
+        with project_file.open("rb") as file:
+            project = tomllib.load(file)["project"]
+        if project.get("name") == _NAME:
+            return project
+        reasons.append(f"{project_file} names {project.get('name')!r}, not {_NAME!r}")
     except (OSError, KeyError, ValueError) as reason:
-        raise Malformed(
-            f"{path} could not be read, and section 9 has an adapter answer with the engine's own "
-            f"name and version: {reason}"
-        ) from None
+        reasons.append(f"{project_file} could not be read: {reason}")
+
+    recorded = installed(_NAME)
+    if recorded is not None and recorded.get("Name") and recorded.get("Version"):
+        return {"name": recorded["Name"], "version": recorded["Version"]}
+    reasons.append(f"no installed distribution named {_NAME!r} was found")
+
+    raise Malformed(
+        "section 9 has an adapter answer with the engine's own name and version, and "
+        + "; ".join(reasons)
+    )
 
 
 def describe() -> Dict[str, Any]:

{openscript-0.4.0 → openscript-0.6.0}/openscript/adapter/facts.py

@@ -14,18 +14,20 @@ for every entry but one: ``chart.symbol`` is the empty string, because 3.4 says
 so. A default anywhere else would make "the smallest increment is five paise"
 and "nobody said" the same reading.
 
-**The two derived facts are not here.** ``chart.intervalMinutes`` and
-``chart.isIntraday`` are computed from the interval string by section 15.2's
-canonical form, which this engine does not read yet, so a program calling one is
-refused at load by name (OS6004) rather than answered from a guess at what the
-string meant. The planned entries of both tables are absent for the same reason:
-a name the language does not serve yet is a refusal naming it.
+**The two derived facts are computed from the interval, never read.**
+``chart.intervalMinutes`` and ``chart.isIntraday`` are derived from the one
+interval string the host stated, so neither can disagree with it, by the rule the
+first engine applies: a count, then an optional unit of seconds, minutes, hours,
+days or weeks, where a count alone is minutes, and a month has no answer because
+it is no fixed number of minutes. The planned entries of both tables are absent:
+a name the language does not serve yet is a refusal naming it (OS6004).
 """
 
-from typing import Any, Dict, Optional, Protocol, Tuple
+import re
+from typing import Any, Dict, Mapping, Optional, Protocol, Tuple
 
 from ..values import ABSENT
-from .sessions import SESSION_FACTS
+from .sessions import SESSION_FACT_OF, SESSION_FACTS
 
 #: Section 3.4 against ``host-interface.md`` 4.1: the call, and the fact of the
 #: instrument record it reads. Every one is arity 0, holds no state and has no
@@ -115,13 +117,47 @@ def position_value(name: str, book: Book) -> Any:
 #: 0, hold no state and have no effect, which is what section 2.5's check holds a
 #: program's own library table to. The session's own entry is beside them because
 #: it is read the same way and answered from the bar rather than from a record.
-FACT_NAMES: Tuple[str, ...] = (*CHART_FACTS, CHART_CLOCK, *POSITION_FACTS, *SESSION_FACTS)
+DERIVED_FACTS: Tuple[str, ...] = ("chart.intervalMinutes", "chart.isIntraday")
+
+FACT_NAMES: Tuple[str, ...] = (
+    *CHART_FACTS,
+    CHART_CLOCK,
+    *DERIVED_FACTS,
+    *POSITION_FACTS,
+    *SESSION_FACTS,
+)
+
+#: A count, then an optional unit. A count alone is minutes.
+_INTERVAL = re.compile(r"^(\d+)([smhDWM]?)$")
+
+#: Minutes in one of each unit. A month is absent from it on purpose.
+_MINUTES = {"s": 1 / 60, "": 1, "m": 1, "h": 60, "D": 60 * 24, "W": 60 * 24 * 7}
+
+
+def interval_minutes(interval: Any) -> Any:
+    """Minutes in an interval code, or absent for one that has no fixed length."""
+    if not isinstance(interval, str):
+        return ABSENT
+    found = _INTERVAL.match(interval)
+    if found is None or found.group(2) not in _MINUTES:
+        return ABSENT
+    return float(int(found.group(1)) * _MINUTES[found.group(2)])
+
+
+def derived_value(name: str, instrument: Any) -> Any:
+    """``chart.intervalMinutes`` or ``chart.isIntraday``, from the stated interval."""
+    minutes = interval_minutes(instrument.get("interval", ABSENT))
+    if name == "chart.intervalMinutes" or minutes is ABSENT:
+        return minutes
+    return minutes < 60 * 24
 
 
-def fact_value(name: str, instrument: Any, now: Any, book: Book, bar: Any) -> Any:
+def fact_value(name: str, instrument: Any, now: Any, book: Book, bar: Mapping[str, Any]) -> Any:
     """Whichever of the three namespaces this name belongs to, read once."""
     if name in POSITION_FACTS:
         return position_value(name, book)
     if name in SESSION_FACTS:
-        return bar
+        return bar.get(SESSION_FACT_OF[name], ABSENT)
+    if name in DERIVED_FACTS:
+        return derived_value(name, instrument)
     return chart_value(name, instrument, now)

{openscript-0.4.0 → openscript-0.6.0}/openscript/adapter/running.py

@@ -25,7 +25,10 @@ case can assert them.
 **The bars are confirmed and are not live.** A case is a run over a dataset, so
 every execution is a new, confirmed, non-realtime bar with one update, and the
 count supplied is the whole file: that is what makes ``bar.isLast`` true on the
-last row and false everywhere else. An engine that only backtests is handed
+last row and false everywhere else. The whole file is also handed to the fold
+before bar 0, as a history is, which a ``"lookahead"`` read is the one reading
+to notice; a read of another instrument is answered from the case's own file
+(``secondary.py``). An engine that only backtests is handed
 ``isRealtime`` false throughout, which is why no alert is raised here, and
 ``run.py`` reaches the same answer from the other side.
 
@@ -42,25 +45,32 @@ is here is the order the three are asked in.
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 from ..accounting import report_of
-from ..contracts import Bar as EngineBar, BarState
+from ..buckets import is_intraday
+from ..contracts import BarState
+from ..dates import BAR_TIME, NAMES as DATE_NAMES
 from ..inputs import utc_time
+from ..logbook import Logbook
 from ..run import load_text
 from ..strategy import IntentBar
 from ..values import ABSENT
 from ..verify import capabilities
 from .channels import orders_channel, performance_channel, trade_row
 from .ordering import ORDER_ENTRIES, Desk, options_for, unfoldable
-from .reading import Bar, Case
+from .reading import Case
 from .reporting import contract_for, marks_for, schedule_for, settings_problem
+from .secondary import engine_bar, provider_for
 from .serving import Serving, is_reference
 from .sessions import (
     READABLE_ZONE,
     SESSION_FACTS,
     SESSION_FIRST,
+    SESSION_LAST,
     first_bars,
+    last_bars,
     session_from,
 )
 from .spellings import Malformed, as_reported
+from .surface import DRAWINGS, SURFACE_TAGS, TABLE, drawings_channel, table_channel
 
 #: The codes a load raises when the program needs something this engine does not
 #: have, each with the field naming what it was.
@@ -75,7 +85,7 @@ _UNSUPPORTED_CODES = {
 #: assert is named ``unsupported`` on the case rather than answered emptily,
 #: because an empty channel compares equal to an empty expectation and would be a
 #: pass nobody earned.
-ANSWERED = ("diagnostics", "values", "orders", "trades", "performance")
+ANSWERED = ("diagnostics", "values", "orders", "trades", "performance", "log", DRAWINGS, TABLE)
 
 #: ``compiled-program.md`` 2.2's tag for a program that places orders, and the
 #: word the meta uses for a program that is one. This engine serves the tag
@@ -143,19 +153,6 @@ def _unsupported_from(diagnostic: Any) -> Optional[str]:
     return sentence.format(value=value)
 
 
-def _engine_bar(bar: Bar) -> EngineBar:
-    """One row of the file as the engine's own bar. An absent field stays absent."""
-    return EngineBar(
-        time=float(bar.time),
-        open=bar.open,
-        high=bar.high,
-        low=bar.low,
-        close=bar.close,
-        volume=bar.volume,
-        oi=ABSENT,
-    )
-
-
 def _plot_channels(program: Dict[str, Any]) -> Dict[str, int]:
     """Every plot's legend title and its stable key, against its channel.
 
@@ -203,21 +200,30 @@ def _values_channel(
     return out
 
 
-def _unreadable_zone(program: Dict[str, Any], instrument: Dict[str, Any]) -> Optional[str]:
+def _unreadable_zone(run: Any, instrument: Dict[str, Any]) -> Optional[str]:
     """What this program reads in a calendar this engine cannot read, or nothing.
 
     ``stdlib.md`` section 12.1 reads a calendar field in the chart's timezone,
     which the host states; this engine carries a reader for one zone and a host
     with any other supplies its own. A case in another zone whose script takes a
-    written time, or asks where a session begins, is therefore a case this engine
-    would answer under the wrong calendar, and it says so instead.
+    written time, asks where a session begins or folds a read by the calendar
+    (``buckets.py``) is therefore a case this engine would answer under the wrong
+    calendar, and it says so instead.
     """
     if instrument.get("timezone") == READABLE_ZONE:
         return None
+    program = run.program.raw
+    # A day, week or month read is dated in the zone as well. With no zone at
+    # all it is the read neither engine can date, which both answer alike.
+    zoned = instrument.get("timezone") is not None
+    if zoned and any(not is_intraday(one.timeframe) for one in run.plans):
+        return "a day, week or month read"
     if any(one["kind"] == "time" for one in program["inputs"]):
         return "a time input"
     if any(one["name"] in SESSION_FACTS for one in program["lib"]["functions"]):
         return "a session boundary"
+    if any(one["name"] in DATE_NAMES for one in program["lib"]["functions"]):
+        return "a calendar call"
     return None
 
 
@@ -238,8 +244,6 @@ def run_case(case: Case, program_text: str) -> Answer:
             "how a tick row becomes the newest bar's four prices is not written down anywhere, so "
             "a replay here would be this adapter's invention"
         )
-    for name in case.secondary:
-        answer.cannot(f"{name} (section 3): this engine is handed one series and reads no other")
     if case.frames is not None and case.bars is not None:
         beyond = unfoldable(case.frames, len(case.bars))
         if beyond:
@@ -264,8 +268,10 @@ def run_case(case: Case, program_text: str) -> Answer:
         program_text,
         dict(case.settings),
         serving,
-        capabilities=capabilities(ORDERS),
+        capabilities=capabilities(ORDERS, *SURFACE_TAGS),
         read_time=utc_time,
+        instrument=case.instrument,
+        provider=provider_for(case),
     )
     if loaded.diagnostic is not None:
         feature = _unsupported_from(loaded.diagnostic)
@@ -280,7 +286,7 @@ def run_case(case: Case, program_text: str) -> Answer:
 
     run = loaded.run
     raw = run.program.raw
-    unreadable = _unreadable_zone(raw, case.instrument)
+    unreadable = _unreadable_zone(run, case.instrument)
     if unreadable is not None:
         answer.cannot(
             f"{unreadable} under the timezone {case.instrument.get('timezone')}: this engine reads "
@@ -324,7 +330,8 @@ def run_case(case: Case, program_text: str) -> Answer:
             answer.channels = _with_empty(case, {"diagnostics": [_refusal_row(refused)]})
             return answer
 
-    rows, diagnostics = _every_bar(run, serving, desk, case)
+    logbook = Logbook()
+    rows, diagnostics = _every_bar(run, serving, desk, case, logbook)
     answered: Dict[str, Any] = {"diagnostics": diagnostics}
     if "values" in case.asserts:
         if not case.expected_columns:
@@ -335,6 +342,14 @@ def run_case(case: Case, program_text: str) -> Answer:
         answered["values"] = _values_channel(case.expected_columns, raw, rows, answer)
     if "orders" in case.asserts:
         answered["orders"] = orders_channel(desk.rows(), desk.intents)
+    if "log" in case.asserts:
+        # conformance.md section 4: the bar, its time, and the value spelled as a
+        # cell of the values channel is, absence included.
+        answered["log"] = [dict(one, value=as_reported(one["value"])) for one in logbook.rows()]
+    if DRAWINGS in case.asserts:
+        answered[DRAWINGS] = drawings_channel(run.objects)
+    if TABLE in case.asserts:
+        answered[TABLE] = table_channel(run.objects)
     if "trades" in case.asserts or "performance" in case.asserts:
         report = report_of(
             desk.fills.settled(),
@@ -394,7 +409,7 @@ def _declaration(run: Any) -> Dict[str, Any]:
 
 
 def _every_bar(
-    run: Any, serving: Serving, desk: Desk, case: Case
+    run: Any, serving: Serving, desk: Desk, case: Case, logbook: Logbook
 ) -> Tuple[List[List[Any]], List[Dict[str, Any]]]:
     """Every bar of the file, in order, stopping at the first that fails.
 
@@ -414,8 +429,12 @@ def _every_bar(
     bars = case.bars or []
     supplied = len(bars)
     when = case.declared.get("now", ABSENT)
-    opens = first_bars([bar.time for bar in bars], session_from(case.instrument))
+    times = [bar.time for bar in bars]
+    session = session_from(case.instrument)
+    opens = first_bars(times, session)
+    closes = last_bars(times, session, case.instrument.get("interval"))
     rows: List[List[Any]] = []
+    run.history([engine_bar(one) for one in bars])
     for index, bar in enumerate(bars):
         desk.fold(index, float(bar.time))
         previous = bars[index - 1].close if index > 0 else ABSENT
@@ -427,12 +446,14 @@ def _every_bar(
                 "previousClose": previous,
                 "volume": bar.volume,
                 SESSION_FIRST: opens[index],
+                SESSION_LAST: closes[index],
+                BAR_TIME: bar.time,
             },
             index == 0,
         )
         result = run.execute_bar(
             index,
-            _engine_bar(bar),
+            engine_bar(bar),
             BarState(is_new=True, is_confirmed=True, is_realtime=False, updates=1.0),
             supplied=supplied,
             instrument=case.instrument,
@@ -441,7 +462,11 @@ def _every_bar(
         if result.diagnostic is not None:
             found = result.diagnostic
             return rows, [_diagnostic_row(found.code, found.line, found.column, index)]
-        sent = desk.apply(result.applied, IntentBar(index=index, time=float(bar.time)))
+        # Step 9's records, each to the side of the run that owns it: an order
+        # to the desk, a log line to the book. Nothing else carries an effect.
+        logbook.write(result.applied, index, bar.time)
+        orders = [one for one in result.applied if one.effect == "order"]
+        sent = desk.apply(orders, IntentBar(index=index, time=float(bar.time)))
         if sent is not None:
             return rows, [_diagnostic_row(sent.code, sent.line, sent.column, index)]
         rows.append(list(result.columns))