openscript 0.4.0__py3-none-any.whl

openscript/civil.py

@@ -0,0 +1,196 @@
+"""Calendar arithmetic on civil dates: no zone, no instant, no clock.
+
+A civil date is a year, a month and a day as a person writes them. Turning one
+into an instant needs a zone and lives in ``zones.py``; everything here is
+counting days, and the two are separated for that reason: the day number of the
+fifteenth of March is the same fact in every zone on earth, and mixing the two
+questions is how a calendar ends up right in one half of the year.
+
+The day number is days since 1970-01-01, positive after it and negative before.
+The conversion both ways is the standard proleptic Gregorian one, shifted so the
+leap day falls at the end of an internal year that starts in March: that is what
+removes the special case for February and makes the inverse exact rather than
+iterative.
+
+**Nothing here is read out of a library that answers dates.** The interpreter
+ships one, and it holds a year to the range 1 to 9999 and raises outside it,
+while a timestamp a script may hand ``date.year`` is any binary64 number of
+milliseconds. An engine that raised there would stop a bar over a number the
+language says is a number, and an engine that clamped would answer a year nobody
+asked for, so the arithmetic is the formula and the range is the whole of it.
+The interpreter's own calendar is used in the tests instead, as the independent
+reference `conformance.md` section 4 asks the expected values of a numeric
+function to agree with.
+
+**Two instants are not a calendar field, and the boundary is stated here once.**
+A timestamp is truncated towards zero before it is read, because that is what the
+first engine's own date reader does with a fractional millisecond, and a
+magnitude past the largest instant that reader holds has no fields at all rather
+than fields read off an overflow.
+"""
+
+import math
+from typing import NamedTuple, Optional
+
+#: Milliseconds in the units a reading is split into.
+SECOND_MS = 1_000
+MINUTE_MS = 60_000
+HOUR_MS = 3_600_000
+DAY_MS = 86_400_000
+
+#: Minutes in a day, so that a wrap past midnight is named rather than written.
+DAY_MINUTES = 1_440
+
+#: The largest instant either engine reads.
+#:
+#: The first engine reads an instant through the runtime's own date object, whose
+#: range is fixed at a hundred million days either side of the epoch; past it
+#: there is no reading at all, and the calls of `stdlib.md` section 12.2 answer
+#: absence. The number is here so that this engine's absence begins on the same
+#: millisecond rather than a few days later, which is a difference no tolerance
+#: would forgive: section 6 compares a time exactly and compares absence for
+#: presence.
+MAX_INSTANT = 8.64e15
+
+
+class Civil(NamedTuple):
+    """A date and a time of day as a person writes them, with no zone attached."""
+
+    year: int
+    #: 1 to 12.
+    month: int
+    #: 1 to 31.
+    day: int
+    hour: int
+    minute: int
+    second: int
+
+
+def day_number(year: int, month: int, day: int) -> int:
+    """Days from 1970-01-01 to this civil date.
+
+    The era is the four hundred year block the date falls in, and it is a floor
+    division with nothing added to it. The published form of this algorithm is
+    written in a language whose division truncates towards zero, so it subtracts
+    399 from a negative year to make truncation behave like a floor; the
+    interpreter's own division already floors, and doing both is doing it twice.
+    The doubled adjustment is invisible for two thousand years either side of the
+    epoch and moves every date before the common era by one day, which is the
+    shape of mistake a test written over modern dates cannot see.
+    """
+    shifted = year - 1 if month <= 2 else year
+    era = shifted // 400
+    year_of_era = shifted - era * 400
+    day_of_year = (153 * (month + (-3 if month > 2 else 9)) + 2) // 5 + day - 1
+    day_of_era = (
+        year_of_era * 365 + year_of_era // 4 - year_of_era // 100 + day_of_year
+    )
+    return era * 146097 + day_of_era - 719468
+
+
+def date_of_day(days: int) -> tuple[int, int, int]:
+    """The civil date a day number names, the exact inverse of ``day_number``."""
+    shifted = days + 719468
+    era = shifted // 146097
+    day_of_era = shifted - era * 146097
+    year_of_era = (
+        day_of_era - day_of_era // 1460 + day_of_era // 36524 - day_of_era // 146096
+    ) // 365
+    year = year_of_era + era * 400
+    day_of_year = day_of_era - (365 * year_of_era + year_of_era // 4 - year_of_era // 100)
+    month_part = (5 * day_of_year + 2) // 153
+    day = day_of_year - (153 * month_part + 2) // 5 + 1
+    month = month_part + (3 if month_part < 10 else -9)
+    return (year + 1 if month <= 2 else year, month, day)
+
+
+def weekday_of_day(days: int) -> int:
+    """The day of the week, 1 for Monday through 7 for Sunday.
+
+    Monday is 1 so that a weekday test reads ``date.dayOfWeek(time) <= 5`` and a
+    trading week is a contiguous range, which `stdlib.md` section 12.2 states and
+    gives the reason for. 1970-01-01 was a Thursday, which is 4 on this
+    numbering, and the interpreter's own remainder is never negative, so a day
+    before the epoch needs no second rule.
+    """
+    return (days + 3) % 7 + 1
+
+
+def day_of_year_of(year: int, month: int, day: int) -> int:
+    """The day of the year, 1 to 366."""
+    return day_number(year, month, day) - day_number(year, 1, 1) + 1
+
+
+def week_of_year_of(year: int, month: int, day: int) -> int:
+    """The week number, weeks starting Monday.
+
+    Read as the ISO 8601 week: week 1 is the week holding the year's first
+    Thursday, so a week that straddles the new year belongs to the year holding
+    most of it and no year ever has a week 0. Section 12.2 fixes the Monday start
+    and settles the rest of it for the same reason it fixes the numbering: the
+    other common reading differs by a whole week at the turn of most years, and a
+    reader has no way to tell from a chart which of the two drew it.
+    """
+    days = day_number(year, month, day)
+    thursday = days + (4 - weekday_of_day(days))
+    owner = date_of_day(thursday)[0]
+    return (thursday - day_number(owner, 1, 1)) // 7 + 1
+
+
+def whole_instant(instant: float) -> Optional[int]:
+    """A timestamp as the whole millisecond a calendar reads, or nothing.
+
+    Truncated towards zero rather than floored, which is what the first engine's
+    date reader does with a fraction, and absent past ``MAX_INSTANT``, which is
+    where that reader stops having fields to give.
+    """
+    if not math.isfinite(instant) or abs(instant) > MAX_INSTANT:
+        return None
+    return int(instant)
+
+
+def fields_at(instant: int) -> Civil:
+    """The civil reading of a whole millisecond count, with no zone applied.
+
+    The floor division is the calendar's own: a day begins at midnight and an
+    instant before the epoch belongs to the day that holds it, not to the one
+    after it, which is what truncation towards zero would answer.
+    """
+    days, inside = divmod(instant, DAY_MS)
+    year, month, day = date_of_day(days)
+    hour, inside = divmod(inside, HOUR_MS)
+    minute, inside = divmod(inside, MINUTE_MS)
+    return Civil(year, month, day, hour, minute, inside // SECOND_MS)
+
+
+def instant_at(fields: Civil) -> int:
+    """The millisecond count a civil reading names, with no zone applied.
+
+    **Every field carries**, so a month of 13 is January of the next year, an
+    hour of 25 is one in the morning of the next day, and a day of 0 is the last
+    of the month before. That is not this engine's licence: ``date.from`` is
+    written on the first engine over a date object whose setters carry the same
+    way, and a second engine that refused an out of range field would answer
+    absence where the first answers an instant. The carrying is linear, so it is
+    one expression rather than a normalising step.
+    """
+    months = fields.year * 12 + (fields.month - 1)
+    year, month = divmod(months, 12)
+    days = day_number(year, month + 1, 1) + (fields.day - 1)
+    return (
+        days * DAY_MS
+        + fields.hour * HOUR_MS
+        + fields.minute * MINUTE_MS
+        + fields.second * SECOND_MS
+    )
+
+
+def minutes_of(fields: Civil) -> float:
+    """Minutes from midnight of a reading, which is what a wall clock range holds.
+
+    The seconds are in it and the milliseconds are not, because a reading is a
+    civil one: the first engine's ranges are tested against a reading with no
+    milliseconds in it, and a bound is a whole minute in both spellings of a
+    window, so the two readings fall on the same side of every bound either way.
+    """
+    return fields.hour * 60 + fields.minute + fields.second / 60

openscript/contracts.py

@@ -0,0 +1,165 @@
+"""The two edges of this engine: what a host hands it, and what a library is to it.
+
+``host-interface.md`` names six duties a host carries and
+``compiled-program.md`` section 5.2 lists what an engine reads from one. Neither
+is restated here. What is here is the shape those facts arrive in, so that the
+bar cycle has one thing to read and a test has one thing to build.
+
+**A bar and its state are two objects because they are two facts.** The prices
+are the dataset; ``isNew``, ``isConfirmed``, ``isRealtime`` and ``updates`` are
+facts about the delivery, which only the side that built the bar knows
+(``host-interface.md`` section 6.2). The other four bar facts are the engine's
+to derive from the dataset and the position in it, and it derives them rather
+than asking, because two sources for one number can disagree and no rule would
+say which of them wins.
+
+**The library is a seam and not an import.** The functions of ``stdlib.md`` are
+another stage's work and another package's; what the machine needs of them is
+below, and it is small on purpose: a manifest to disagree with at load, and a
+way to call one. An engine that reached into the library for anything else would
+be an engine the library could not be replaced under, and the whole point of the
+manifest check is that the two are separate enough to disagree.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Mapping, Optional, Protocol, Sequence
+
+from .values import ABSENT
+
+
+@dataclass(frozen=True)
+class Bar:
+    """One bar as a host states it, ``host-interface.md`` section 3.1.
+
+    A price may be absent: real feeds have holes, and an absent price propagates
+    rather than reading as a zero. An absent ``volume`` is not a zero volume,
+    which is that section's own three level distinction and the reason the two
+    are different values here rather than one with a default.
+    """
+
+    time: float
+    open: Any
+    high: Any
+    low: Any
+    close: Any
+    volume: Any = ABSENT
+    oi: Any = ABSENT
+
+
+@dataclass(frozen=True)
+class BarState:
+    """The four facts the host states about an execution, ``language.md`` 7.2."""
+
+    is_new: bool = True
+    is_confirmed: bool = True
+    is_realtime: bool = False
+    updates: float = 1.0
+
+
+@dataclass(frozen=True)
+class CallContext:
+    """What a library function may be told about the moment it is running in.
+
+    Deliberately thin. Everything a function computes from the bars is already
+    in its arguments, because the compiler put it there, and everything it
+    computes from its own past is in its state region. What is left is the two
+    facts that are neither: where in the run this bar is, and what the host says
+    about the instrument.
+    """
+
+    bar_index: int = 0
+    instrument: Mapping[str, Any] = field(default_factory=dict)
+    now: Any = ABSENT
+
+
+@dataclass(frozen=True)
+class LibraryEntry:
+    """What the manifest says about one function, section 2.5's four fields."""
+
+    name: str
+    arity: int
+    state: bool
+    effect: str
+
+
+class Library(Protocol):
+    """What the machine asks of the library, and the whole of what it asks.
+
+    ``entry`` and ``describe`` are load-time: section 2.5 has the program carry
+    facts the engine already knows so that the two can be disagreed with, and
+    ``describe`` is what the refusal says this engine's manifest holds instead.
+
+    ``call`` is the bar. ``state`` is the call site's own region, a plain mapping
+    the engine created and owns, because section 2.11 requires a region to be
+    snapshottable by a mechanical copy without the engine knowing which function
+    it belongs to. It is ``None`` for a pure function, which is what the ``-1``
+    on a ``CALL_LIB`` means, and a function whose manifest entry says it holds no
+    state is never handed one to write into by accident.
+
+    ``length_of`` is the string ceiling asked before the string exists. The
+    ceiling is the engine's to spend and the library raises nothing, so the two
+    meet here: the machine asks how long the string a call is about to build will
+    be, and refuses the call rather than the result where the answer is past the
+    ceiling. ``None`` is the honest answer for every call whose length is not
+    known until the work is done, which is all but two of them.
+
+    ``builds_a_string`` is the other half, asked after. Only a call that BUILDS
+    a string is held to the ceiling, because the ceiling is on what a script
+    grows. A call that passes one through, or answers a fact the host stated,
+    hands back a string it did not make, and refusing that would refuse the
+    host its own symbol for being long. Both questions are the library's,
+    because the library is what knows which of its functions build.
+    """
+
+    def entry(self, name: str, arity: int) -> Optional[LibraryEntry]:
+        ...
+
+    def describe(self, name: str) -> str:
+        ...
+
+    def length_of(self, name: str, arguments: Sequence[Any]) -> Optional[int]:
+        ...
+
+    def builds_a_string(self, name: str) -> bool:
+        ...
+
+    def call(
+        self,
+        name: str,
+        arguments: Sequence[Any],
+        state: Optional[Dict[str, Any]],
+        context: CallContext,
+    ) -> Any:
+        ...
+
+
+class NoLibrary:
+    """A library with nothing in it, which is what an engine has before one is wired.
+
+    It is not a stub standing in for the real thing: it answers every manifest
+    question with "this engine's manifest has no such function", so a program
+    that calls anything at all is refused at load with OS6004 naming the
+    function. A program that calls nothing runs exactly as it would with the
+    library present, which is what makes the machine testable on its own.
+    """
+
+    def entry(self, name: str, arity: int) -> Optional[LibraryEntry]:
+        return None
+
+    def describe(self, name: str) -> str:
+        return f"no function called {name}"
+
+    def length_of(self, name: str, arguments: Sequence[Any]) -> Optional[int]:
+        return None
+
+    def builds_a_string(self, name: str) -> bool:
+        return False
+
+    def call(
+        self,
+        name: str,
+        arguments: Sequence[Any],
+        state: Optional[Dict[str, Any]],
+        context: CallContext,
+    ) -> Any:
+        return ABSENT

openscript/dates.py

@@ -0,0 +1,302 @@
+"""The calendar of `stdlib.md` section 12.2, the pattern of 12.3, and the window of 12.5.
+
+The arithmetic is next door and raises nothing: ``civil.py`` counts days,
+``zones.py`` says which calendar this engine can read, and ``hours.py`` is the
+one wall clock range shared by a script's window and the instrument's own
+session. What is here is the call sites, which is where the library's rules about
+absence are applied, and the manifest rows a program's own library table is
+checked against at load.
+
+**Every call reads a timestamp in the chart's timezone unless a ``zone``
+argument names another**, which is 12.1, and the reason it gives is worth
+keeping in front of whoever changes this: a session study that disagreed with the
+labels on the chart's own axis would be wrong in the way that is hardest to see.
+The compiled program fills the default before the call arrives
+(`compiled-program.md` section 4.10), so the zone is an argument here; a script
+that passes ``none`` or a value that is absent on this bar falls back to the
+chart's zone, because the alternative reads the default two ways depending on
+whether the script wrote it out.
+
+**A zone this engine cannot read leaves the call absent, and that is not the
+whole of the rule.** The first engine stops the bar with OS6005 on a name its
+database does not hold, which is what 12.1 requires. This engine holds one zone
+(``zones.py`` says which and why), it raises nothing from a library call because
+no call site here carries a span to point at, and the two engines therefore part
+company on a script that names a zone: one answers a diagnostic and the other
+answers absence. That is not papered over with a guessed offset. The caller
+reports such a case ``unsupported`` naming the feature, which `conformance.md`
+section 8 counts separately from a pass, and the adapter is where a case meets
+that rule.
+
+**Two of these are not in the table above.** ``date.add`` is planned in 12.2 and
+``session.isHoliday`` in 12.4, so neither is in the manifest and a program
+calling one is refused at load naming it (OS6004) rather than answered from an
+arithmetic nobody has written down.
+"""
+
+import math
+from typing import Optional, Sequence
+
+from .civil import (
+    Civil,
+    date_of_day,
+    day_number,
+    day_of_year_of,
+    week_of_year_of,
+    weekday_of_day,
+)
+from .hours import standing_in, window_of
+from .library.stateless import Context, Entry
+from .library.values import ABSENT, Value, number, result
+from .zones import fields_in, instant_of
+
+#: The bar fact ``session.isIn`` reads, which is the bar's own open time. It is
+#: asked for by name like every other bar fact a stateless call reads, because
+#: the context a call is given carries where in the run the bar is and what the
+#: host said about the instrument, and the time of the bar being executed is
+#: neither of those.
+BAR_TIME = "time"
+
+#: 12.3: the month and weekday abbreviations, English and invariant, for the same
+#: determinism reason ``str.upper`` is: a name that followed the reader's locale
+#: would make one chart's label depend on who opened it.
+_MONTHS = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+_WEEKDAYS = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+
+#: 12.3's closed set, longest first, which is the order the scan tries them in:
+#: ``MMM`` is the month name and the ``MM`` inside it is never read a second time.
+_PLACEHOLDERS = ("yyyy", "MMM", "EEE", "MM", "dd", "HH", "mm", "ss")
+
+
+def _at(arguments: 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 the
+    library's own values module gives: nothing on this path stops a bar.
+    """
+    return arguments[index] if index < len(arguments) else ABSENT
+
+
+def _civil_at(instant: Value, zone: Value) -> Optional[Civil]:
+    """The civil reading of a timestamp in a zone, or nothing where there is none."""
+    return None if instant is ABSENT else fields_in(instant, zone)
+
+
+def field_of(instant: Value, zone: Value, which: str) -> Value:
+    """One calendar field of an instant, read in a zone. The nine reads of 12.2."""
+    at = _civil_at(instant, zone)
+    if at is None:
+        return ABSENT
+    if which == "dayOfWeek":
+        return result(weekday_of_day(day_number(at.year, at.month, at.day)))
+    if which == "dayOfYear":
+        return result(day_of_year_of(at.year, at.month, at.day))
+    if which == "weekOfYear":
+        return result(week_of_year_of(at.year, at.month, at.day))
+    return result(getattr(at, which))
+
+
+def start_of(instant: Value, zone: Value, boundary: str) -> Value:
+    """Midnight at the start of the day, the Monday or the month that holds an instant.
+
+    The answer is built as a wall clock reading and then turned back into an
+    instant, rather than by subtracting a count of milliseconds. Subtracting is
+    wrong across a clock change, where a local day is twenty three or twenty five
+    hours long, and it is wrong in a way that shows up twice a year on one chart
+    and never on another. In the one zone this engine reads the two agree, and
+    the form that stays right is the one written, because the zone it would be
+    wrong in is the zone a host supplies a reader for.
+    """
+    at = _civil_at(instant, zone)
+    if at is None:
+        return ABSENT
+    if boundary == "month":
+        midnight = Civil(at.year, at.month, 1, 0, 0, 0)
+    elif boundary == "day":
+        midnight = Civil(at.year, at.month, at.day, 0, 0, 0)
+    else:
+        days = day_number(at.year, at.month, at.day)
+        year, month, day = date_of_day(days - (weekday_of_day(days) - 1))
+        midnight = Civil(year, month, day, 0, 0, 0)
+    found = instant_of(midnight, zone)
+    return ABSENT if found is None else result(found)
+
+
+def instant_from(arguments: Sequence[Value], zone: Value) -> Value:
+    """``date.from``: an instant built from calendar fields in a zone.
+
+    A date is three fields and a time of day is three more, so an absent hour,
+    minute or second is midnight and an absent year, month or day is no date at
+    all. A field that is not a whole number is absent rather than rounded, for
+    the reason `stdlib.md` section 2.5 gives about a count: a day of 14.5 is a
+    bug in the script, and rounding it on the script's behalf hides the bug.
+    """
+    if zone is ABSENT:
+        return ABSENT
+    held = []
+    for at in range(6):
+        given = number(arguments[at]) if at < len(arguments) else None
+        if given is None:
+            if at < 3:
+                return ABSENT
+            given = 0.0
+        if not math.isfinite(given) or given != int(given):
+            return ABSENT
+        held.append(int(given))
+    found = instant_of(Civil(*held), zone)
+    return ABSENT if found is None else result(found)
+
+
+def same_day(first: Value, second: Value, zone: Value) -> Value:
+    """``date.isSameDay``: whether two timestamps fall on one calendar day."""
+    left = _civil_at(first, zone)
+    right = _civil_at(second, zone)
+    if left is None or right is None:
+        return ABSENT
+    return (left.year, left.month, left.day) == (right.year, right.month, right.day)
+
+
+def _padded(value: int, width: int) -> str:
+    """A field as its digits, zero filled, with the sign in front of the filling."""
+    digits = str(abs(int(value)))
+    filled = digits if len(digits) >= width else "0" * (width - len(digits)) + digits
+    return f"-{filled}" if value < 0 else filled
+
+
+def _substitution(token: str, at: Civil) -> str:
+    if token == "yyyy":
+        return _padded(at.year, 4)
+    if token == "MMM":
+        return _MONTHS[at.month - 1] if 1 <= at.month <= 12 else ""
+    if token == "EEE":
+        return _WEEKDAYS[weekday_of_day(day_number(at.year, at.month, at.day)) - 1]
+    if token == "MM":
+        return _padded(at.month, 2)
+    if token == "dd":
+        return _padded(at.day, 2)
+    if token == "HH":
+        return _padded(at.hour, 2)
+    if token == "mm":
+        return _padded(at.minute, 2)
+    return _padded(at.second, 2)
+
+
+def rendered(instant: Value, pattern: Value, zone: Value) -> Value:
+    """``date.format``: 12.3's closed placeholder set, and every other character copied.
+
+    The set is small and closed so that two engines cannot differ about what a
+    pattern means, and a character that looks like part of a placeholder is
+    copied through as itself: the scan takes the longest placeholder starting at
+    each position and moves past it.
+    """
+    at = _civil_at(instant, zone)
+    if at is None or not isinstance(pattern, str):
+        return ABSENT
+    out = []
+    position = 0
+    while position < len(pattern):
+        token = next(
+            (one for one in _PLACEHOLDERS if pattern.startswith(one, position)), None
+        )
+        if token is None:
+            out.append(pattern[position])
+            position += 1
+            continue
+        out.append(_substitution(token, at))
+        position += len(token)
+    return "".join(out)
+
+
+def holds(spec: Value, instant: Value, zone: Value) -> Value:
+    """``session.isIn``: whether this bar's reading falls in the window a script wrote.
+
+    The window is the script's own and the instrument's session is the host's, so
+    this reads 12.5's spelling and the record reads 4.3's, and both reach the one
+    range arithmetic in ``hours.py``.
+    """
+    hours = window_of(spec)
+    at = _civil_at(instant, zone)
+    if hours is None or at is None:
+        return ABSENT
+    return standing_in(hours, at).inside
+
+
+def _zone_at(ctx: Context, arguments: Sequence[Value], index: int) -> Value:
+    """The zone a call reads in: the one it was given, or the chart's.
+
+    A host that states no timezone leaves every call here absent rather than
+    answered in a zone nobody chose, which is 12.1 read the only way it can be:
+    the default is the chart's axis, and a chart with no axis to read has none.
+    """
+    given = _at(arguments, index)
+    if isinstance(given, str):
+        return given
+    return ctx.host("timezone")
+
+
+def _read(name: str, which: str) -> Entry:
+    """One of the nine field reads, which take a timestamp and a zone."""
+    return Entry(
+        f"date.{name}",
+        2,
+        lambda ctx, args: field_of(_at(args, 0), _zone_at(ctx, args, 1), which),
+    )
+
+
+def _boundary(name: str, which: str) -> Entry:
+    """One of the three boundaries a timestamp rounds back to."""
+    return Entry(
+        f"date.{name}",
+        2,
+        lambda ctx, args: start_of(_at(args, 0), _zone_at(ctx, args, 1), which),
+    )
+
+
+#: Section 12.2's table and 12.5's one call, as the manifest rows section 2.5 of
+#: `compiled-program.md` holds a program's own library table to. Every one of
+#: them holds no state and has no effect: the answer is the arguments, the
+#: chart's zone and, for the window, the bar the engine is executing.
+ENTRIES: tuple[Entry, ...] = (
+    _read("year", "year"),
+    _read("month", "month"),
+    _read("day", "day"),
+    _read("dayOfWeek", "dayOfWeek"),
+    _read("dayOfYear", "dayOfYear"),
+    _read("hour", "hour"),
+    _read("minute", "minute"),
+    _read("second", "second"),
+    _read("weekOfYear", "weekOfYear"),
+    _boundary("startOfDay", "day"),
+    _boundary("startOfWeek", "week"),
+    _boundary("startOfMonth", "month"),
+    Entry("date.from", 7, lambda ctx, args: instant_from(args, _zone_at(ctx, args, 6))),
+    Entry(
+        "date.isSameDay",
+        3,
+        lambda ctx, args: same_day(_at(args, 0), _at(args, 1), _zone_at(ctx, args, 2)),
+    ),
+    Entry(
+        "date.format",
+        3,
+        lambda ctx, args: rendered(_at(args, 0), _at(args, 1), _zone_at(ctx, args, 2)),
+    ),
+    Entry(
+        "session.isIn",
+        2,
+        lambda ctx, args: holds(_at(args, 0), ctx.bar(BAR_TIME), _zone_at(ctx, args, 1)),
+    ),
+)
+
+
+#: Every name this module answers, which is what a caller asks when the question
+#: is about the calendar rather than about one call: a case whose record names a
+#: zone this engine cannot read, and whose program reaches any of these, is a
+#: case answered under the wrong calendar unless the caller declines it.
+NAMES: frozenset = frozenset(entry.name for entry in ENTRIES)
+
+
+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}