openscript 0.4.0__py3-none-any.whl

openscript/library/stateful.py

@@ -0,0 +1,442 @@
+"""The stateful half of the library manifest: what a name and an arity resolve to.
+
+The other half of the table ``stateless.py`` holds, on the same terms.
+`compiled-program.md` section 2.5 has the engine check every entry of a program's
+library table against its manifest at load, by name and by arity, and ``state``
+and ``effect`` have to agree there as well, so a row is wrong if it says a
+function holds nothing when it holds a window.
+
+**Every entry here is ``state`` true and ``effect`` none.** A region is created
+per call site by the engine and handed back to the same call site on every bar,
+and section 6's rollback copies it without knowing whose it is. That is why a
+call here takes three things rather than two: the context, the arguments, and
+the region it is the only reader of.
+
+**A kernel takes the context only where the vector file says it read the bar.**
+``atr`` reads the high, the low and the previous close; ``sma`` reads nothing but
+its arguments. Passing the context to everything would make it impossible to
+tell, from this file, which functions an engine has to state bar facts for.
+"""
+
+from typing import Any, Callable, List, NamedTuple, Optional, Sequence
+
+from . import (
+    averages,
+    bookkeeping,
+    composites,
+    counting,
+    deviation,
+    extremes,
+    flows,
+    momentum,
+    ranges,
+    strength,
+    trend,
+)
+from .series import Region
+from .stateless import Context
+from .values import Value, whole
+
+#: One library call at a bar: the context, this bar's arguments, and the region.
+Call = Callable[[Context, Sequence[Value], Region], Value]
+
+
+class Entry(NamedTuple):
+    """One manifest row, the four fields of section 2.5 and the call itself."""
+
+    name: str
+    arity: int
+    call: Call
+    state: bool = True
+    effect: str = "none"
+
+
+def at(args: Sequence[Value], index: int) -> Value:
+    """An argument, or absence where the caller passed fewer than the arity.
+
+    A call arrives with its defaults already filled (`compiled-program.md`
+    section 4.10), so a short argument list is a program the load-time check
+    should have refused. Absence rather than a raise, for the reason
+    ``values.py`` gives: nothing in this package raises.
+    """
+    return args[index] if index < len(args) else None
+
+
+def length_of(value: Value) -> Optional[int]:
+    """A length argument as the whole number of bars it has to be.
+
+    `stdlib.md` section 2.5 refuses a fractional or negative length with a
+    diagnostic before the call arrives, so what is left here is the backstop:
+    anything that is not a whole count is absence, and a window of absence is
+    absent rather than guessed at.
+    """
+    return whole(value)
+
+
+def _measured(name: str, of: Callable[[Region, Value, Optional[int]], Value]) -> Entry:
+    """A row of the shape ``(src, len)``, which most of the library is."""
+    return Entry(name, 2, lambda ctx, args, state: of(state, at(args, 0), length_of(at(args, 1))))
+
+
+def _windowed(name: str, of: Callable[[Region, Any, Optional[int]], Value]) -> Entry:
+    """A row of the shape ``(len)`` whose kernel reads the bar."""
+    return Entry(name, 1, lambda ctx, args, state: of(state, ctx, length_of(at(args, 0))))
+
+
+def _pivot(name: str, of) -> Entry:
+    """A row of the shape ``(src, left, right)``."""
+    return Entry(
+        name,
+        3,
+        lambda ctx, args, state: of(
+            state, at(args, 0), length_of(at(args, 1)), length_of(at(args, 2))
+        ),
+    )
+
+
+def _paired(name: str, of) -> Entry:
+    """A row of the shape ``(a, b, len)``, two series over one window."""
+    return Entry(
+        name,
+        3,
+        lambda ctx, args, state: of(state, at(args, 0), at(args, 1), length_of(at(args, 2))),
+    )
+
+
+def _crossing(name: str, of) -> Entry:
+    """A row of the shape ``(a, b)``, which is every crossing test."""
+    return Entry(name, 2, lambda ctx, args, state: of(state, at(args, 0), at(args, 1)))
+
+
+def _array(items: List[Value], ctx: Context) -> Value:
+    """A multi-output call's answer: an array that is never absent, section 2.3."""
+    return ctx.make_array(items)
+
+
+# `stdlib.md` section 20.3, the means.
+_AVERAGES: tuple[Entry, ...] = (
+    _measured("sma", averages.simple),
+    _measured("ema", averages.exponential),
+    _measured("rma", averages.smoothed),
+    _measured("wma", averages.linear),
+    Entry("swma", 1, lambda ctx, args, state: averages.symmetric(state, at(args, 0))),
+    Entry(
+        "vwma",
+        2,
+        lambda ctx, args, state: averages.volume_weighted(
+            state, at(args, 0), ctx.bar("volume"), length_of(at(args, 1))
+        ),
+    ),
+    _measured("hma", composites.hull),
+    _measured("dema", composites.doubled),
+    _measured("tema", composites.tripled),
+    Entry(
+        "alma",
+        4,
+        lambda ctx, args, state: composites.gaussian(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2), at(args, 3)
+        ),
+    ),
+    Entry(
+        "linreg",
+        3,
+        lambda ctx, args, state: composites.fitted(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    Entry(
+        "ma",
+        3,
+        lambda ctx, args, state: composites.named(
+            state, ctx, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+)
+
+
+# `stdlib.md` section 20.8, the totals and the ranks, and section 20.10's scans.
+_HELPERS: tuple[Entry, ...] = (
+    _measured("highest", extremes.highest),
+    _measured("lowest", extremes.lowest),
+    _measured("highestBars", extremes.highest_bars),
+    _measured("lowestBars", extremes.lowest_bars),
+    _pivot("pivotHigh", extremes.pivot_high),
+    _pivot("pivotLow", extremes.pivot_low),
+    _measured("sum", counting.windowed_sum),
+    _measured("count", counting.counted),
+    _measured("sumSkip", counting.skipping_sum),
+    _measured("avgSkip", counting.skipping_mean),
+    _measured("countPresent", counting.present_count),
+    _measured("median", counting.middle),
+    _measured("percentRank", counting.rank_of),
+    Entry("cum", 1, lambda ctx, args, state: counting.accumulated(state, at(args, 0))),
+    Entry(
+        "history",
+        2,
+        lambda ctx, args, state: counting.history_at(state, at(args, 0), length_of(at(args, 1))),
+    ),
+    Entry(
+        "percentile",
+        3,
+        lambda ctx, args, state: counting.ranked(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    _paired("covariance", counting.covariance),
+    _paired("correlation", counting.correlation),
+)
+
+# `stdlib.md` section 9, the comparisons and the two that wait for a condition.
+_BOOKKEEPING: tuple[Entry, ...] = (
+    Entry("change", 1, lambda ctx, args, state: bookkeeping.change(state, at(args, 0), 1)),
+    _measured("change", bookkeeping.change),
+    _measured("rising", bookkeeping.rising),
+    _measured("falling", bookkeeping.falling),
+    _crossing("crossUp", bookkeeping.crossed_up),
+    _crossing("crossDown", bookkeeping.crossed_down),
+    _crossing("cross", bookkeeping.crossed),
+    Entry("barsSince", 1, lambda ctx, args, state: bookkeeping.bars_since(state, at(args, 0))),
+    Entry(
+        "valueWhen",
+        3,
+        lambda ctx, args, state: bookkeeping.value_when(
+            state, at(args, 0), at(args, 1), length_of(at(args, 2))
+        ),
+    ),
+)
+
+
+# `stdlib.md` section 20.5, the ranges and the bands.
+_RANGES: tuple[Entry, ...] = (
+    _windowed("atr", ranges.average_range),
+    _windowed("natr", ranges.normalised_range),
+    _windowed("chop", ranges.choppiness),
+    Entry(
+        "donchian",
+        1,
+        lambda ctx, args, state: _array(ranges.channel(state, ctx, length_of(at(args, 0))), ctx),
+    ),
+    Entry(
+        "variance",
+        3,
+        lambda ctx, args, state: deviation.variance(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    Entry(
+        "stdev",
+        3,
+        lambda ctx, args, state: deviation.deviation(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    Entry(
+        "bollinger",
+        3,
+        lambda ctx, args, state: _array(
+            deviation.bands(state, at(args, 0), length_of(at(args, 1)), at(args, 2)), ctx
+        ),
+    ),
+    Entry(
+        "bbWidth",
+        3,
+        lambda ctx, args, state: deviation.band_width(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    Entry(
+        "bbPercent",
+        3,
+        lambda ctx, args, state: deviation.band_position(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+    Entry(
+        "keltner",
+        4,
+        lambda ctx, args, state: _array(
+            deviation.range_bands(
+                state,
+                ctx,
+                length_of(at(args, 0)),
+                at(args, 1),
+                length_of(at(args, 2)),
+                at(args, 3),
+            ),
+            ctx,
+        ),
+    ),
+    Entry(
+        "hv",
+        3,
+        lambda ctx, args, state: deviation.historical(
+            state, at(args, 0), length_of(at(args, 1)), at(args, 2)
+        ),
+    ),
+)
+
+
+# `stdlib.md` section 20.3, the trend studies that carry a decision from bar to bar.
+_TREND: tuple[Entry, ...] = (
+    Entry(
+        "supertrend",
+        2,
+        lambda ctx, args, state: _array(
+            trend.trailing_band(state, ctx, at(args, 0), length_of(at(args, 1))), ctx
+        ),
+    ),
+    Entry(
+        "psar",
+        3,
+        lambda ctx, args, state: _array(
+            trend.accelerating_stop(state, ctx, at(args, 0), at(args, 1), at(args, 2)), ctx
+        ),
+    ),
+    Entry(
+        "adx",
+        2,
+        lambda ctx, args, state: _array(
+            trend.directional(state, ctx, length_of(at(args, 0)), length_of(at(args, 1))), ctx
+        ),
+    ),
+    Entry(
+        "aroon",
+        1,
+        lambda ctx, args, state: _array(trend.ages(state, ctx, length_of(at(args, 0))), ctx),
+    ),
+    Entry(
+        "ichimoku",
+        3,
+        lambda ctx, args, state: _array(
+            trend.cloud(
+                state, ctx, length_of(at(args, 0)), length_of(at(args, 1)), length_of(at(args, 2))
+            ),
+            ctx,
+        ),
+    ),
+)
+
+
+# `stdlib.md` section 20.4, the momentum and position readings.
+_OSCILLATORS: tuple[Entry, ...] = (
+    _measured("rsi", strength.strength),
+    _measured("cmo", strength.change_ratio),
+    _measured("mom", momentum.distance),
+    _measured("roc", momentum.rate),
+    _measured("trix", momentum.smoothed_rate),
+    _measured("dpo", momentum.detrended),
+    _windowed("cci", strength.deviation_reading),
+    _windowed("williamsR", strength.range_position),
+    Entry(
+        "stoch",
+        3,
+        lambda ctx, args, state: _array(
+            strength.position(
+                state, ctx, length_of(at(args, 0)), length_of(at(args, 1)), length_of(at(args, 2))
+            ),
+            ctx,
+        ),
+    ),
+    Entry(
+        "stochRsi",
+        5,
+        lambda ctx, args, state: _array(
+            strength.strength_position(
+                state,
+                at(args, 0),
+                length_of(at(args, 1)),
+                length_of(at(args, 2)),
+                length_of(at(args, 3)),
+                length_of(at(args, 4)),
+            ),
+            ctx,
+        ),
+    ),
+    Entry(
+        "macd",
+        4,
+        lambda ctx, args, state: _array(
+            momentum.gap(
+                state,
+                at(args, 0),
+                length_of(at(args, 1)),
+                length_of(at(args, 2)),
+                length_of(at(args, 3)),
+                False,
+            ),
+            ctx,
+        ),
+    ),
+    Entry(
+        "ppo",
+        4,
+        lambda ctx, args, state: _array(
+            momentum.gap(
+                state,
+                at(args, 0),
+                length_of(at(args, 1)),
+                length_of(at(args, 2)),
+                length_of(at(args, 3)),
+                True,
+            ),
+            ctx,
+        ),
+    ),
+    Entry(
+        "awesomeOsc",
+        2,
+        lambda ctx, args, state: momentum.midpoint_gap(
+            state, ctx, length_of(at(args, 0)), length_of(at(args, 1))
+        ),
+    ),
+    Entry(
+        "tsi",
+        3,
+        lambda ctx, args, state: momentum.double_smoothed(
+            state, at(args, 0), length_of(at(args, 1)), length_of(at(args, 2))
+        ),
+    ),
+    Entry(
+        "ultimateOsc",
+        3,
+        lambda ctx, args, state: momentum.blended(
+            state, ctx, length_of(at(args, 0)), length_of(at(args, 1)), length_of(at(args, 2))
+        ),
+    ),
+)
+
+
+# `stdlib.md` section 20.6, the volume readings.
+_VOLUME: tuple[Entry, ...] = (
+    Entry("obv", 0, lambda ctx, args, state: flows.balance(state, ctx)),
+    Entry("ad", 0, lambda ctx, args, state: flows.accumulation(state, ctx)),
+    Entry("pvt", 0, lambda ctx, args, state: flows.price_trend(state, ctx)),
+    Entry("vwap", 1, lambda ctx, args, state: flows.session_average(state, ctx, at(args, 0))),
+    Entry(
+        "vwapAnchor",
+        2,
+        lambda ctx, args, state: flows.anchored_average(state, ctx, at(args, 0), at(args, 1)),
+    ),
+    _windowed("cmf", flows.flow_fraction),
+    _windowed("mfi", flows.money_flow),
+    _windowed("eom", flows.movement),
+    _windowed("forceIndex", flows.force),
+    _windowed("relativeVolume", flows.relative_volume),
+    Entry(
+        "adOsc",
+        2,
+        lambda ctx, args, state: flows.accumulation_gap(
+            state, ctx, length_of(at(args, 0)), length_of(at(args, 1))
+        ),
+    ),
+)
+
+
+ENTRIES: tuple[Entry, ...] = (
+    _AVERAGES + _HELPERS + _BOOKKEEPING + _RANGES + _TREND + _OSCILLATORS + _VOLUME
+)
+
+
+def table() -> dict[tuple[str, int], Entry]:
+    """The entries by name and arity, which is how a manifest is looked up."""
+    return {(entry.name, entry.arity): entry for entry in ENTRIES}

openscript/library/stateless.py

@@ -0,0 +1,261 @@
+"""The stateless half of the library manifest: what a name and an arity resolve to.
+
+``CALL_LIB`` names a function by its index in a program's own table, and
+`compiled-program.md` section 2.5 has the engine check every entry of that table
+against its manifest at load: the name must exist, the arity must match, and
+``state`` and ``effect`` must agree. This module is the half of that manifest
+whose functions hold nothing across bars, keyed by name and arity, because the
+library keys a function that way: ``change(src)`` and ``change(src, len)`` are two
+functions and not one with a default.
+
+**Every entry here is ``state`` false and ``effect`` none.** A function that holds
+a state region across bars, and a function with an effect on the chart, the
+ledger or the log, is in the stateful half. That is not a division of taste: a
+stateless entry needs no state region, no checkpoint and no rollback
+(`compiled-program.md` section 6), so an engine can call one of these from
+anywhere without asking whose call site it is.
+
+**What a call is given.** Three of these read something that is not an argument:
+``roundToTick`` asks the host for the instrument's tick, ``trueRange`` reads the
+bar and whether it is the oldest one, and the calls that make or read an array
+reach the heap. None of those is this package's to own, so a call takes a context
+and asks it. The protocol below is the whole of what the stateless half needs
+from an interpreter, and it is written as six members rather than as an engine
+object so that the interpreter stage can satisfy it with whatever it already has.
+"""
+
+from typing import Callable, Dict, NamedTuple, Optional, Protocol, Sequence, Tuple
+
+from . import arithmetic, colour, elementary, rounding, strings
+from .bars import true_range
+from .number_text import spell, text_length, text_of, to_number
+from .values import Value
+
+
+class Context(Protocol):
+    """What a stateless call may ask its caller for, and nothing more."""
+
+    def bar(self, fact: str) -> Value:
+        """One fact of the bar being computed: ``high``, ``low``, ``previousClose``."""
+
+    def host(self, fact: str) -> Value:
+        """One fact the host states about the instrument, such as ``tickSize``."""
+
+    def first_bar(self) -> bool:
+        """Whether this is the oldest bar of the dataset.
+
+        ``trueRange`` turns on it, and no argument can answer it: `stdlib.md`
+        section 6 grants that bar the library's one exception to absence
+        propagation, and an absent previous close in the middle of a run is a
+        hole rather than the start of history.
+        """
+
+    def kind_of(self, reference: Value) -> str:
+        """The kind of a heap object, which is how ``text`` spells a reference."""
+
+    def items_of(self, reference: Value) -> list[Value] | None:
+        """The elements of an array, or absence when the value is not one."""
+
+    def make_array(self, items: list[Value]) -> Value:
+        """A new array on the heap, holding these elements in this order."""
+
+
+Call = Callable[[Context, Sequence[Value]], Value]
+
+
+class Entry(NamedTuple):
+    """One manifest row: what a program's table is checked against at load."""
+
+    name: str
+    arity: int
+    call: Call
+    state: bool = False
+    effect: str = "none"
+
+
+def _at(args: Sequence[Value], index: int) -> Value:
+    """An argument, or absence where the caller passed fewer than the arity.
+
+    A call arrives with its defaults already filled (`compiled-program.md`
+    section 4.10), so a short argument list is a program the load-time check
+    should have refused. Absence rather than a raise, for the reason
+    ``values.py`` gives.
+    """
+    return args[index] if index < len(args) else None
+
+
+def _one(name: str, of: Callable[[Value], Value]) -> Entry:
+    return Entry(name, 1, lambda _ctx, args: of(_at(args, 0)))
+
+
+def _two(name: str, of: Callable[[Value, Value], Value]) -> Entry:
+    return Entry(name, 2, lambda _ctx, args: of(_at(args, 0), _at(args, 1)))
+
+
+def _three(name: str, of: Callable[[Value, Value, Value], Value]) -> Entry:
+    return Entry(name, 3, lambda _ctx, args: of(_at(args, 0), _at(args, 1), _at(args, 2)))
+
+
+def _constant(name: str, value: float) -> Entry:
+    """A constant read bare, which the format still compiles to a call of none."""
+    return Entry(name, 0, lambda _ctx, _args: value)
+
+
+def _named_colour(name: str) -> Entry:
+    """One of the nineteen bare colour names, which is also a call of no arguments."""
+    return Entry(name, 0, lambda _ctx, _args: colour.named(name))
+
+
+def _text(ctx: Context, args: Sequence[Value]) -> Value:
+    return spell(_at(args, 0), ctx.kind_of)
+
+
+def _split(ctx: Context, args: Sequence[Value]) -> Value:
+    parts = strings.split(_at(args, 0), _at(args, 1))
+    return None if parts is None else ctx.make_array(list(parts))
+
+
+def _join(ctx: Context, args: Sequence[Value]) -> Value:
+    items = ctx.items_of(_at(args, 0))
+    return None if items is None else strings.join(items, _at(args, 1))
+
+
+def _round_to_tick(ctx: Context, args: Sequence[Value]) -> Value:
+    return rounding.round_to_tick(_at(args, 0), ctx.host("tickSize"))
+
+
+def _true_range(ctx: Context, _args: Sequence[Value]) -> Value:
+    return true_range(
+        ctx.bar("high"), ctx.bar("low"), ctx.bar("previousClose"), ctx.first_bar()
+    )
+
+
+# `stdlib.md` section 8.1, the bare arithmetic.
+_MATHS: tuple[Entry, ...] = (
+    _one("abs", arithmetic.abs_of),
+    _one("sign", arithmetic.sign),
+    _two("min", arithmetic.minimum),
+    _two("max", arithmetic.maximum),
+    _three("clamp", arithmetic.clamp),
+    _one("floor", rounding.floor),
+    _one("ceil", rounding.ceil),
+    _one("round", rounding.round_to_whole),
+    _two("round", rounding.round_to),
+    _one("trunc", rounding.trunc),
+    _two("roundToStep", rounding.round_to_step),
+    Entry("roundToTick", 1, _round_to_tick),
+    _one("sqrt", elementary.sqrt),
+    _two("pow", elementary.power),
+    _one("exp", elementary.exp),
+    _one("log", elementary.log),
+    _one("log10", elementary.log10),
+    _two("mod", arithmetic.mod),
+    _one("isNone", arithmetic.is_none),
+    _two("orElse", arithmetic.or_else),
+    _one("toBool", arithmetic.to_bool),
+)
+
+# `stdlib.md` section 8.2, the `math` namespace.
+_MATH_NAMESPACE: tuple[Entry, ...] = (
+    _constant("math.pi", elementary.PI),
+    _constant("math.e", elementary.E),
+    _one("math.log2", elementary.log2),
+    _two("math.hypot", elementary.hypot),
+    _one("math.toDegrees", elementary.to_degrees),
+    _one("math.toRadians", elementary.to_radians),
+    _one("math.sin", elementary.sin),
+    _one("math.cos", elementary.cos),
+    _one("math.tan", elementary.tan),
+    _one("math.asin", elementary.asin),
+    _one("math.acos", elementary.acos),
+    _one("math.atan", elementary.atan),
+    _two("math.atan2", elementary.atan2),
+)
+
+# `stdlib.md` section 10, strings and formatting.
+_TEXT: tuple[Entry, ...] = (
+    Entry("text", 1, _text),
+    _two("text", text_of),
+    _one("toNumber", to_number),
+    _one("str.length", strings.length),
+    _one("str.upper", strings.upper),
+    _one("str.lower", strings.lower),
+    _one("str.trim", strings.trim),
+    _two("str.contains", strings.contains),
+    _two("str.startsWith", strings.starts_with),
+    _two("str.endsWith", strings.ends_with),
+    _two("str.indexOf", strings.index_of),
+    _three("str.substring", strings.substring),
+    _three("str.replace", strings.replace),
+    _three("str.replaceAll", strings.replace_all),
+    Entry("str.split", 2, _split),
+    Entry("str.join", 2, _join),
+    _three("str.padLeft", strings.pad_left),
+    _three("str.padRight", strings.pad_right),
+    _two("str.repeat", strings.repeat),
+)
+
+#: The two calls whose string can be measured before it is built, and the
+#: function that measures each.
+#:
+#: The string ceiling is the interpreter's to spend and nothing in this package
+#: raises, so this is how the two meet: the interpreter asks how long the string
+#: will be and refuses the call rather than the result. Every other call that
+#: builds a string is measured after it is built, because its length is not known
+#: until the work is done, and that costs nothing: the length of a replaced or a
+#: padded string is within a constant factor of what it was handed. These two are
+#: not, and a count a script computed can ask either of them for a string no
+#: engine could hold.
+#: The calls that BUILD a string, and so are held to the code point ceiling.
+#:
+#: Named rather than inferred, because the answer's type cannot tell a string a
+#: call made from one it passed through. `orElse(chart.symbol, "x")` answers a
+#: string, and it is the host's symbol: refusing it for being long would refuse
+#: the host its own instrument name, which is a difference the first engine does
+#: not make. That engine guards these twelve call sites and no others
+#: (`src/core/engine/library/text.ts` and `dates.ts`), so this is that set.
+BUILDS_A_STRING: frozenset = frozenset(
+    {
+        "text",
+        "str.upper",
+        "str.lower",
+        "str.trim",
+        "str.substring",
+        "str.replace",
+        "str.replaceAll",
+        "str.join",
+        "str.padLeft",
+        "str.padRight",
+        "str.repeat",
+        "date.format",
+    }
+)
+
+MEASURED: Dict[Tuple[str, int], Callable[..., Optional[int]]] = {
+    ("text", 2): text_length,
+    ("str.repeat", 2): strings.repeat_length,
+}
+
+# `stdlib.md` section 11, the nineteen names and the calls that compute a colour.
+_COLOUR: tuple[Entry, ...] = tuple(_named_colour(name) for name in colour.NAMES) + (
+    _three("rgb", colour.rgb),
+    Entry(
+        "rgba",
+        4,
+        lambda _ctx, args: colour.rgba(_at(args, 0), _at(args, 1), _at(args, 2), _at(args, 3)),
+    ),
+    _two("fade", colour.fade),
+    _three("mix", colour.mix),
+    _one("alpha", colour.alpha),
+    _two("withAlpha", colour.with_alpha),
+)
+
+# `stdlib.md` section 6, the one reading of a range that holds nothing.
+_RANGES: tuple[Entry, ...] = (Entry("trueRange", 0, _true_range),)
+
+ENTRIES: tuple[Entry, ...] = _MATHS + _MATH_NAMESPACE + _TEXT + _COLOUR + _RANGES
+
+
+def table() -> dict[tuple[str, int], Entry]:
+    """The entries by name and arity, which is how a manifest is looked up."""
+    return {(entry.name, entry.arity): entry for entry in ENTRIES}