openalgo-script 0.1.0-alpha.1 → 0.2.0

package/src/core/engine/requests.ts

@@ -0,0 +1,382 @@
+/**
+ * Higher timeframe and other instrument reads, folded onto the chart's bars.
+ *
+ * A read is an expression evaluated over a **different set of bars** than the
+ * chart's, whose value is then folded back onto the chart's. Two halves, and
+ * they are in two files: `request-body.ts` runs the expression once per
+ * requested bar, and this decides which requested bar each chart bar is allowed
+ * to see. The second half is where the off-by-one lives, so it is written as
+ * one comparison repeated three times rather than as three rules.
+ *
+ * **Bars in, buckets out.** Source bars are grouped by the bucket key of their
+ * open instant (`timeframe.ts`); a bucket becomes one requested bar. The source
+ * is the chart's own bars for a read of the chart's instrument, which is the
+ * read `host-interface.md` 5.1 says an engine can satisfy from what it already
+ * holds, and the host's answer for a read of another instrument, which it never
+ * can. One fold serves both, so the two kinds of read cannot drift apart.
+ *
+ * **The three modes differ in one thing: how far past the chart bar the fold is
+ * allowed to look.** Everything else about them is the same code.
+ *
+ * | Mode | Source bars it may consume | Value the chart bar takes |
+ * |---|---|---|
+ * | `"confirmed"` | Those opening at or before this chart bar | The last bucket that closed |
+ * | `"developing"` | Those opening at or before this chart bar | The bucket this bar is inside, so far |
+ * | `"lookahead"` | Those belonging to this bar's bucket or earlier | The bucket this bar is inside, in full |
+ *
+ * Read the middle column, because it is the repainting question written out.
+ * Confirmed and developing stop at the chart bar and can be computed live;
+ * lookahead reads past it, which is why it repaints on history permanently and
+ * by design, and why on the newest bucket, where there is nothing past the bar
+ * to read, it is the bucket so far and nothing better exists.
+ *
+ * **The boundary.** A bucket has begun on the first chart bar whose key is the
+ * new one, because a bar's open instant is what dates it. So a confirmed read
+ * steps to the closed bucket's value on the first chart bar of the next bucket,
+ * holds it across every bar inside that bucket including the last, and steps
+ * again on the first bar of the one after. The bar a bucket closes on still
+ * reads the bucket before it: at that bar's open, the bucket it is inside had
+ * not closed.
+ *
+ * **Warmup translates by arithmetic and not by a rule.** The expression runs on
+ * requested bars, so its own warmup is counted in requested bars and its absence
+ * folds onto the chart like any other value: a twenty period average of daily
+ * closes is absent until twenty daily bars exist, which on a five minute chart
+ * is about a month in. The `warmup` field of the compiled program is what a host
+ * extends the fetch range backwards by, a floor and not a promise, and an engine
+ * given less gets a read that is absent for longer rather than a wrong number.
+ */
+import type { Span } from '../span/index.js';
+import type { HostBar } from './bars.js';
+import type { Clock, EngineLimits } from './budget.js';
+import type { EngineHost } from './host.js';
+import type { ResolvedInput } from './inputs.js';
+import type { HostFacts, ManifestEntry, PositionFacts } from './library/index.js';
+import type { Registers } from './registers.js';
+import { RequestBody, bodyProgram } from './request-body.js';
+import { askHost, reasonFor, undatable, undatableReason } from './request-plan.js';
+import type { RequestPlan } from './request-plan.js';
+import { bucketKeyOf } from './timeframe.js';
+import type { CompiledProgram, Request } from './types.js';
+import { ABSENT } from './values/index.js';
+import type { Heap, Value } from './values/index.js';
+
+export interface RequestParts {
+  readonly program: CompiledProgram;
+  /** Every read in the program, nested ones included, keyed by its own id. */
+  readonly plans: ReadonlyMap<number, RequestPlan>;
+  readonly host: EngineHost;
+  readonly limits: EngineLimits;
+  readonly clock: Clock | undefined;
+  readonly library: readonly ManifestEntry[];
+  readonly inputs: readonly ResolvedInput[];
+  /** The facts a body inherits, with its own identity written over three of them. */
+  readonly facts: HostFacts;
+  /** The strategy's own position, which a body reads as the chart's bars do. */
+  readonly position: PositionFacts;
+  /**
+   * The heap of the machine these reads land in, read when a bar asks for it.
+   *
+   * A function rather than the heap, because a read written inside another lands
+   * in the enclosing body's heap and that body does not exist until its own
+   * reads have been built.
+   */
+  heapOf(): Heap;
+  spanAt(line: number, column: number): Span;
+}
+
+/** Where the fold of one read stands, and what a re-executed bar restores. */
+interface Mark {
+  readonly cursor: number;
+  readonly openKey: number | undefined;
+  readonly openFrom: number;
+}
+
+interface Read {
+  readonly plan: RequestPlan;
+  readonly register: number;
+  readonly body: RequestBody;
+  /** The host's bars for a `symbol` read, or nothing when the fold is the chart's. */
+  readonly source: readonly HostBar[] | undefined;
+  readonly ready: boolean;
+  readonly reason: string;
+  /** How far into the source the fold has read. */
+  cursor: number;
+  openKey: number | undefined;
+  /** Where in the source the bucket now forming began. */
+  openFrom: number;
+  open: HostBar | undefined;
+  /** The value of the most recently closed bucket, which a confirmed read takes. */
+  closedValue: Value;
+  /** The highest bucket key ever closed, so a re-executed bar closes none twice. */
+  highestClosed: number | undefined;
+  mark: Mark;
+}
+
+const START: Mark = { cursor: 0, openKey: undefined, openFrom: 0 };
+
+export class RequestSet {
+  private readonly reads: Read[] = [];
+  private readonly byId = new Map<number, Read>();
+  private readonly parts: RequestParts;
+
+  constructor(parts: RequestParts, requests: readonly Request[]) {
+    this.parts = parts;
+    for (const request of requests) {
+      const plan = parts.plans.get(request.id);
+      if (plan === undefined) continue;
+      const read = build(parts, request, plan);
+      this.reads.push(read);
+      this.byId.set(request.id, read);
+    }
+  }
+
+  get empty(): boolean {
+    return this.reads.length === 0;
+  }
+
+  /**
+   * Step 4: each read's value for this bar, written into its `"request"`
+   * register.
+   *
+   * `fresh` says whether this is the first execution of this bar. A bar that is
+   * executing again restores the fold to where it stood when the bar began and
+   * rebuilds the bucket now forming from the source as it now stands, which is
+   * what makes a moving bar idempotent one level down: the newest chart bar may
+   * have been revised since the last execution, and the bucket it is inside has
+   * to be rebuilt from the revision rather than from the reading it replaced.
+   */
+  fill(registers: Registers, bars: readonly HostBar[], index: number, fresh: boolean): void {
+    const heap = this.parts.heapOf();
+    for (const read of this.reads) {
+      if (fresh) {
+        read.mark = { cursor: read.cursor, openKey: read.openKey, openFrom: read.openFrom };
+      } else {
+        restore(read, bars);
+      }
+      // The body's value is the body's, in the body's heap. `carry` is what
+      // makes it a value of the machine that is about to read it.
+      registers.set(read.register, read.body.carry(valueOf(read, bars, index), heap));
+    }
+  }
+
+  /** `req.isReady(read)`: whether the host has answered this one yet. */
+  answered(id: Value): Value {
+    return typeof id === 'number' ? this.byId.get(id)?.ready === true : false;
+  }
+
+  /** `req.error(read)`: the reason it failed, or the empty string when none has. */
+  failure(id: Value): Value {
+    return typeof id === 'number' ? this.byId.get(id)?.reason ?? '' : '';
+  }
+}
+
+function build(parts: RequestParts, request: Request, plan: RequestPlan): Read {
+  const view = bodyProgram(parts.program, request);
+  const answer = askHost(plan, parts.host);
+  const refused = answer !== undefined && 'refused' in answer ? answer.refused : undefined;
+  let body: RequestBody | undefined;
+
+  // The facts a body reads are the chart's, except the three that identify an
+  // instrument: inside a read, those are the instrument and the interval the
+  // read asked for. The two request calls answer about the reads written inside
+  // this body, which is why the set below is built before the body is.
+  let nested: RequestSet | undefined;
+  const facts: HostFacts = {
+    ...parts.facts,
+    symbol: () => plan.query.instrument ?? parts.facts.symbol(),
+    exchange: () => plan.query.exchange ?? parts.facts.exchange(),
+    interval: () => plan.query.timeframe,
+    requestReady: (id: Value) => nested?.answered(id) ?? false,
+    requestError: (id: Value) => nested?.failure(id) ?? '',
+  };
+  nested = new RequestSet(
+    // A read inside this one lands in this body's heap, which is built below.
+    { ...parts, program: view, facts, heapOf: () => (body as RequestBody).objects },
+    request.body.requests,
+  );
+
+  body = new RequestBody({
+    program: view,
+    limits: parts.limits,
+    clock: parts.clock,
+    host: facts,
+    position: parts.position,
+    library: parts.library,
+    inputs: request.body.inputs.map((one) => ({
+      series: one.series,
+      value: parts.inputs.find((input) => input.key === one.input)?.value ?? null,
+    })),
+    nested,
+    spanAt: parts.spanAt,
+  });
+
+  // A reason is the read saying why it will never answer. A refusal is the
+  // host's; a calendar fold with no zone to date a bucket in is the engine's,
+  // and it is stated here rather than left as an absence the study cannot
+  // explain. The host's own words win where both hold: a source that refused is
+  // the fix the user can act on first.
+  const reason =
+    refused !== undefined
+      ? reasonFor(refused, plan.query)
+      : undatable(plan)
+        ? undatableReason(plan.query)
+        : '';
+
+  return {
+    plan,
+    register: request.series,
+    body,
+    source: answer !== undefined && 'bars' in answer ? answer.bars : undefined,
+    // A fold of the chart's own bars needs nothing from the host, so it is
+    // answered the moment it is planned. A read the host is still fetching is
+    // not: the read is absent, `req.isReady` is false, and the study keeps
+    // drawing everything that does not depend on it. A read with a reason is
+    // never ready: it is not waiting for anything.
+    ready:
+      reason === '' && (answer === undefined ? plan.query.read === 'timeframe' : 'bars' in answer),
+    reason,
+    cursor: 0,
+    openKey: undefined,
+    openFrom: 0,
+    open: undefined,
+    closedValue: ABSENT,
+    highestClosed: undefined,
+    mark: START,
+  };
+}
+
+/** The read's value for the chart bar at `index`, and the fold that gets there. */
+function valueOf(read: Read, bars: readonly HostBar[], index: number): Value {
+  if (!read.ready) return ABSENT;
+  const bar = bars[index];
+  const at = bar?.time ?? null;
+  if (at === null) return ABSENT;
+  const key = keyOf(read, at);
+  if (key === undefined) return ABSENT;
+
+  const source = read.source ?? bars;
+  const lookahead = read.plan.request.mode === 'lookahead';
+  for (;;) {
+    const next = source[read.cursor];
+    if (next === undefined) break;
+    const found = next.time === null ? undefined : keyOf(read, next.time);
+    if (found === undefined) {
+      // A source bar with no time, or none this calendar can date, belongs to
+      // no bucket. It is stepped over rather than folded into whichever bucket
+      // happens to be open.
+      read.cursor += 1;
+      continue;
+    }
+    // The one line the three modes differ in. A lookahead read may read to the
+    // end of the bucket the chart bar is inside; the other two stop at the bar.
+    if (lookahead ? found > key : (next.time ?? 0) > at) break;
+    read.cursor += 1;
+    feed(read, next, found);
+  }
+
+  if (read.plan.request.mode === 'confirmed') return read.closedValue;
+  if (read.openKey !== key || read.open === undefined) return ABSENT;
+  return read.body.peek(read.open);
+}
+
+function keyOf(read: Read, instant: number): number | undefined {
+  return bucketKeyOf(instant, read.plan.timeframe, read.plan.zone);
+}
+
+/**
+ * One source bar folded in.
+ *
+ * A bar whose key is the open bucket's extends it. A bar whose key is new
+ * closes the open bucket, which is the only place a requested bar ever settles:
+ * a bucket is closed by something later, never by the clock. The guard on
+ * `highestClosed` is what makes that idempotent, because a chart bar that
+ * closed a bucket on its first execution must not close it again on its second.
+ */
+function feed(read: Read, bar: HostBar, key: number): void {
+  if (read.openKey === key && read.open !== undefined) {
+    read.open = extend(read.open, bar);
+    return;
+  }
+  if (read.openKey !== undefined && read.open !== undefined) {
+    if (read.highestClosed === undefined || read.openKey > read.highestClosed) {
+      read.closedValue = read.body.settle(read.open);
+      read.highestClosed = read.openKey;
+    }
+  }
+  read.openKey = key;
+  read.openFrom = read.cursor - 1;
+  read.open = start(bar);
+}
+
+/** A re-executed bar: the fold as it stood when the bar began. */
+function restore(read: Read, bars: readonly HostBar[]): void {
+  read.cursor = read.mark.cursor;
+  read.openKey = read.mark.openKey;
+  read.openFrom = read.mark.openFrom;
+  read.open = undefined;
+  if (read.openKey === undefined) return;
+  const source = read.source ?? bars;
+  for (let at = read.openFrom; at < read.cursor; at += 1) {
+    const bar = source[at];
+    if (bar === undefined || bar.time === null) continue;
+    if (keyOf(read, bar.time) !== read.openKey) continue;
+    read.open = read.open === undefined ? start(bar) : extend(read.open, bar);
+  }
+}
+
+/**
+ * The first source bar of a bucket, as a bar of its own.
+ *
+ * The bucket's `time` is this bar's open instant rather than the instant the
+ * bucket's key names. The two differ whenever trading begins after the boundary,
+ * which is every session on a daily fold, and the first bar's instant is a
+ * reading from the data while the boundary is a number the engine chose.
+ */
+function start(bar: HostBar): HostBar {
+  return {
+    open: bar.open,
+    high: bar.high,
+    low: bar.low,
+    close: bar.close,
+    volume: bar.volume ?? null,
+    time: bar.time,
+    oi: bar.oi ?? null,
+  };
+}
+
+/**
+ * One more source bar in the same bucket.
+ *
+ * **Absence propagates through every field**, which is `host-interface.md` 3.1:
+ * an absent price is a hole and what it feeds turns absent. So a bucket whose
+ * high is missing from one of its bars has no high, rather than the highest of
+ * the bars that did report one, which would be a number with no name. Open is
+ * the first bar's, close is the last bar's, and open interest is a level rather
+ * than a flow so the coarser bar takes the last and never the sum.
+ */
+function extend(into: HostBar, bar: HostBar): HostBar {
+  return {
+    open: into.open,
+    high: higher(into.high, bar.high),
+    low: lower(into.low, bar.low),
+    close: bar.close ?? null,
+    volume: both(into.volume ?? null, bar.volume ?? null),
+    time: into.time,
+    oi: bar.oi ?? null,
+  };
+}
+
+function higher(a: number | null, b: number | null | undefined): number | null {
+  if (a === null || typeof b !== 'number') return null;
+  return b > a ? b : a;
+}
+
+function lower(a: number | null, b: number | null | undefined): number | null {
+  if (a === null || typeof b !== 'number') return null;
+  return b < a ? b : a;
+}
+
+function both(a: number | null, b: number | null): number | null {
+  return a === null || b === null ? null : a + b;
+}

package/src/core/engine/results.ts

@@ -0,0 +1,41 @@
+/**
+ * What a host reads back from a bar and from a run.
+ *
+ * Declared apart from the loop that fills it, because these are the shapes an
+ * adapter, a test and a second engine's harness all read, and a shape somebody
+ * outside this repository depends on is worth being able to read on its own.
+ *
+ * Four of the six fields are about one bar's execution and two are about what
+ * that execution sent and was told: the effects it applied, each carrying the
+ * intents it became, and what the frames that arrived before it did to the
+ * ledger. A run that places no orders carries both empty for every bar.
+ */
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { AlertFiring } from './alerts.js';
+import type { RoutedEffect } from './host.js';
+import type { FrameOutcome } from './ledger/index.js';
+import type { Value } from './values/index.js';
+
+/** What one execution of one bar produced. */
+export interface BarResult {
+  readonly index: number;
+  /** One value per channel, absent where nothing wrote, in channel order. */
+  readonly columns: readonly Value[];
+  /** Whether step 9 applied the deferred channels and the pending effects. */
+  readonly applied: boolean;
+  readonly effects: readonly RoutedEffect[];
+  /**
+   * What the frames delivered since the previous bar did to the ledger, a
+   * refused one included (`stdlib.md` 17.14).
+   */
+  readonly frames: readonly FrameOutcome[];
+  /** The watched conditions this bar raised, empty on a bar that raised none. */
+  readonly alerts: readonly AlertFiring[];
+  /** The failure that stopped the bar, when one did. */
+  readonly diagnostic: Diagnostic | undefined;
+}
+
+export interface RunResult {
+  readonly bars: readonly BarResult[];
+  readonly diagnostic: Diagnostic | undefined;
+}

package/src/core/engine/series.ts

@@ -0,0 +1,82 @@
+/**
+ * The two things the engine checks about the bars it is handed,
+ * `host-interface.md` 3.5 and conformance item 1.
+ *
+ * Everything else about a series the engine takes exactly as stated: it does
+ * not adjust, round, resample, deduplicate or reorder what it is given (3.2),
+ * because each of those is a decision with a market consequence and the party
+ * that knows the market makes it. These two are not decisions. They are the
+ * cases where the engine cannot compute anything at all and would otherwise
+ * compute something anyway.
+ *
+ * **No bars is not an empty chart, it is an unanswerable question.** The script
+ * is the body of the per-bar loop, so a loop over nothing draws nothing, and a
+ * pane with nothing in it looks exactly like a study that ran and had nothing
+ * to say. One of those is worth a sentence to the user and the other is not,
+ * and only the engine can tell them apart.
+ *
+ * **A repeated or a reversed timestamp is worse, because it computes.** The
+ * history operator, warmup and every session test are defined against a time
+ * that strictly increases (3.2). Hand over a swapped pair or the same bar twice
+ * and none of them means what it says, every number downstream is derived from
+ * a history that never happened, and nothing on the chart marks which ones. The
+ * wrongness enters at the boundary, which is the one place it cannot be
+ * attributed to anything later.
+ *
+ * **What it costs: one comparison per bar handed over, and no allocation.** The
+ * check is on the hand-over rather than on the execution, so a bar that moves
+ * and is executed a hundred times is compared once per hand-over rather than
+ * once per execution, and a series that is handed over once is walked once. On
+ * fifty thousand bars that is fifty thousand comparisons of two numbers against
+ * a full compute of the same fifty thousand bars, which is the relationship
+ * that makes an honest check of the whole series affordable: it is paid at the
+ * load and never again.
+ */
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { HostBar } from './bars.js';
+import { NO_POSITION, failure } from './errors.js';
+import type { Instrument } from './host.js';
+
+/** The spelling a reason uses for a fact the record does not hold. */
+const UNNAMED_INSTRUMENT = 'the chart\'s instrument';
+const UNNAMED_INTERVAL = 'the chart\'s interval';
+
+/**
+ * A run over nothing, OS6010.
+ *
+ * It names the instrument and the interval because the fix is to choose a pair
+ * that has history, and a sentence that does not say which pair was empty
+ * sends the reader back to the chart to work it out.
+ */
+export function noBars(instrument: Instrument | undefined): Diagnostic {
+  return failure('OS6010', NO_POSITION, {
+    symbol: instrument?.symbol ?? UNNAMED_INSTRUMENT,
+    timeframe: instrument?.interval ?? UNNAMED_INTERVAL,
+  });
+}
+
+/**
+ * A bar whose time does not follow the one before it, OS6011.
+ *
+ * The first such bar and not a count of them, because the fix is the same
+ * whether the feed sent one duplicate or a thousand, and the first one is the
+ * only one whose position tells the host where its own ordering went wrong.
+ *
+ * `previous` is the bar already handed over, or nothing for the first bar of a
+ * run, which follows nothing and is therefore always in order. A time the host
+ * did not state is not compared: the absent value is what `barField` gives a
+ * script for it (3.1), and the catalogue has no code for a bar dated nothing,
+ * so inventing this one for it would be a refusal the specification does not
+ * describe.
+ */
+export function outOfOrder(
+  bar: HostBar,
+  previous: HostBar | undefined,
+  index: number,
+): Diagnostic | undefined {
+  const time = bar.time;
+  const before = previous?.time;
+  if (typeof time !== 'number' || typeof before !== 'number') return undefined;
+  if (time > before) return undefined;
+  return failure('OS6011', NO_POSITION, { index, time, previous: index - 1 });
+}

package/src/core/engine/session/hours.ts

@@ -0,0 +1,86 @@
+/**
+ * A range of wall clock hours, and where one reading sits inside it.
+ *
+ * Two different things in this repository are a range of hours: the
+ * instrument's own trading session, which a host states in its instrument
+ * record (`host-interface.md` 4.3), and the range a script writes for
+ * `session.isIn` (`stdlib.md` 12.5). They are spelled differently and they mean
+ * different things, but the arithmetic is one arithmetic, and it is here so
+ * that it is one rule rather than two that can drift.
+ *
+ * **The open is inclusive and the close is exclusive**, so two ranges written
+ * back to back cover every minute once and no minute twice. A range whose start
+ * and end are the same minute holds nothing, which is what writing a zero length
+ * range says.
+ *
+ * **A range whose end is before its start crosses midnight and is read that
+ * way**, which is what an overnight session needs. The day list then names the
+ * day the range opened on rather than the day the reading falls on, because a
+ * session that opens on Friday evening and closes on Saturday morning is a
+ * Friday session: reading the list against the reading's own day would drop
+ * half of every overnight session and keep the wrong half.
+ *
+ * **A session is named by the day it opened on**, which is what tells two
+ * readings in one session from two readings in two. Naming it by an instant
+ * would be wrong across a seasonal clock change, where a wall clock hour inside
+ * a session is not an hour of elapsed time.
+ */
+import type { Civil } from '../../stdlib/index.js';
+import { dayNumber, weekdayOfDay } from '../../stdlib/index.js';
+
+/** Minutes in a day, so the wrap is named rather than written as a number. */
+const DAY = 1440;
+
+/** Hours as minutes from midnight, and the days they open on. */
+export interface Hours {
+  readonly from: number;
+  /** Minutes from midnight at the close, which may be at 24:00. */
+  readonly to: number;
+  /** The days it opens on, Monday as 1, or nothing for every day. */
+  readonly days: readonly number[] | null;
+}
+
+/** Where one reading sits in a range of hours. */
+export interface Standing {
+  readonly inside: boolean;
+  /** Minutes since the hours opened, zero on the minute they opened. */
+  readonly elapsed: number;
+  /** Minutes until they are scheduled to close. */
+  readonly remaining: number;
+  /** The day they opened on, which is the name of this one session. */
+  readonly openingDay: number;
+}
+
+const OUTSIDE: Standing = { inside: false, elapsed: 0, remaining: 0, openingDay: 0 };
+
+/** Where a wall clock reading sits in a range of hours, or outside every one. */
+export function standingIn(hours: Hours, at: Civil): Standing {
+  const minutes = at.hour * 60 + at.minute + at.second / 60;
+  const today = dayNumber(at.year, at.month, at.day);
+
+  if (hours.to > hours.from) {
+    if (minutes < hours.from || minutes >= hours.to) return OUTSIDE;
+    return held(hours, today, minutes - hours.from, hours.to - minutes);
+  }
+  if (hours.to === hours.from) return OUTSIDE;
+
+  // Crossing midnight: the evening part belongs to today's session and the
+  // morning part to yesterday's, which is the day the list is read against.
+  if (minutes >= hours.from) {
+    return held(hours, today, minutes - hours.from, DAY - minutes + hours.to);
+  }
+  if (minutes < hours.to) {
+    return held(hours, today - 1, DAY - hours.from + minutes, hours.to - minutes);
+  }
+  return OUTSIDE;
+}
+
+function held(
+  hours: Hours,
+  openingDay: number,
+  elapsed: number,
+  remaining: number,
+): Standing {
+  if (hours.days !== null && !hours.days.includes(weekdayOfDay(openingDay))) return OUTSIDE;
+  return { inside: true, elapsed, remaining, openingDay };
+}

package/src/core/engine/session/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Sessions: the instrument's own trading hours, and the ones a script writes.
+ *
+ * One module because they are one arithmetic. The instrument's hours come from
+ * the host's record (`host-interface.md` 4.3) and produce the per-bar facts of
+ * `stdlib.md` 12.4; the script's are the spec string of 12.5 and produce one
+ * test. Both read the same hours the same way, and keeping them behind one door
+ * is what stops a script's overnight range and an instrument's overnight
+ * session coming to disagree about which day a session belongs to.
+ *
+ * The hours themselves are behind the door rather than on it. Two spellings
+ * reach them, and a third caller reading them raw would be a third spelling.
+ */
+export type { SessionFacts, SessionHours, SessionReader } from './record.js';
+export { NO_SESSION, recordProblem, sessionReader } from './record.js';
+
+export { sessionHolds } from './spec.js';