openalgo-script 0.1.0-alpha.1 → 0.4.0

package/src/core/engine/library/binding.ts

@@ -0,0 +1,325 @@
+/**
+ * What a `CALL_LIB` needs, and what the machine has to hand it.
+ *
+ * The interfaces the library asks its caller for are declared here rather than
+ * imported from the engine, so the dependency points one way: the engine knows
+ * about the library and the library knows only about the shape of the facts it
+ * is given. That is what lets the same table be driven by a chart engine, a
+ * backtest and a test that supplies four bars by hand.
+ *
+ * **An entry carries the same four facts the program carries.** `lib.functions`
+ * in a compiled program holds a name, an arity, whether the function holds
+ * state and what effect it has, and 2.5 says plainly why: they are there to be
+ * disagreed with. At load the engine compares each entry against this table and
+ * refuses a mismatch with OS6004, which catches a program compiled against a
+ * newer library before it computes a single wrong number.
+ */
+import type { Span } from '../../span/index.js';
+import type { ColourValue, Heap, Reference, Value } from '../values/index.js';
+import { isColour, isNumber, isRef, isString, reference } from '../values/index.js';
+import type { StateRecord } from '../../stdlib/index.js';
+
+/** What a call does to the world outside the machine, 5.4. */
+export type Effect = 'none' | 'signal' | 'order' | 'draw' | 'log';
+
+/** The bar being executed, as a library call sees it. */
+export interface BarView {
+  readonly index: number;
+  readonly open: number | null;
+  readonly high: number | null;
+  readonly low: number | null;
+  readonly close: number | null;
+  readonly volume: number | null;
+  readonly time: number | null;
+  /**
+   * The previous bar's close, or absent on bar 0.
+   *
+   * Here rather than in a state region because `trueRange()` needs it and the
+   * library surface declares that call stateless, and because the value is a
+   * fact about the dataset rather than about a call site: it is the same for
+   * every call on a bar and it does not move when a moving bar re-executes.
+   */
+  readonly previousClose: number | null;
+  readonly isConfirmed: boolean;
+  readonly isRealtime: boolean;
+  readonly isNew: boolean;
+  readonly isLast: boolean;
+  readonly updates: number;
+  /**
+   * Whether this bar opens the instrument's trading session, or closes it.
+   *
+   * Derived by the engine from the session hours in the instrument record,
+   * never asked of the host. Absent where the record cannot say, which is why
+   * the type carries absence: a session study on a host that states no session
+   * draws nothing rather than anchoring itself to a minute nobody chose.
+   */
+  readonly isSessionFirst: boolean | null;
+  readonly isSessionLast: boolean | null;
+}
+
+/** The facts an engine reads from the host and never from anywhere else, 5.2. */
+export interface HostFacts {
+  symbol(): Value;
+  exchange(): Value;
+  interval(): Value;
+  /**
+   * The instrument's own timezone, an IANA name.
+   *
+   * Read rather than derived, and never a fixed offset: an offset is silently
+   * wrong for half the year anywhere that observes a seasonal clock change
+   * (`host-interface.md` 4.1).
+   */
+  timezone(): Value;
+  tickSize(): Value;
+  lotSize(): Value;
+  pointValue(): Value;
+  currency(): Value;
+  instrumentType(): Value;
+  /**
+   * Whether the instrument has volume at all.
+   *
+   * The one instrument fact a host must state, because it is the one no
+   * derivation can recover: an instrument that never reports volume and one
+   * whose figures are late produce the same empty column.
+   */
+  hasVolume(): Value;
+  hasOpenInterest(): Value;
+  /** The chart clock, which the host supplies, 8.4. */
+  now(): Value;
+  /**
+   * Whether the host has answered the request with this id, `stdlib.md` 15.1.
+   *
+   * The compiler resolves `req.isReady(read)` to the request's id rather than
+   * to the read's value, because a value on a bar cannot say which request
+   * produced it. An engine that has been given no answers has answered none, so
+   * this is false rather than absent: "not yet" is a true statement about a
+   * read still in flight, and a script draws a loading state from it.
+   */
+  requestReady(id: Value): Value;
+  /** Why a request failed, or the empty string when none has, 15.1. */
+  requestError(id: Value): Value;
+}
+
+/**
+ * What the strategy holds, folded from its own settled fills, `stdlib.md` 17.1.
+ *
+ * Not a host fact, which is why it is not on `HostFacts` beside the instrument
+ * record. An account position is held per contract and is shared with every
+ * other strategy and every manual trade in it, so a strategy that read one
+ * would be sizing against somebody else's trade. What these two report is the
+ * run's own ledger (`stdlib.md` 17.7), and an engine with no ledger has no
+ * business answering them at all.
+ */
+export interface PositionFacts {
+  /** Net position in units, `0` while flat rather than absent. */
+  size(): Value;
+  /** Average price of the open position, absent while flat. */
+  avgPrice(): Value;
+}
+
+/** Everything one call can reach. */
+export interface CallContext {
+  readonly heap: Heap;
+  readonly span: Span;
+  readonly bar: BarView;
+  readonly host: HostFacts;
+  /** The strategy's own position, which is the ledger's and not the host's. */
+  readonly position: PositionFacts;
+  /** This call site's region, empty on the first bar that reaches the call. */
+  readonly state: StateRecord;
+  /** The ceilings, so a library call that grows something can be stopped. */
+  readonly guard: Guard;
+  /** The name this value goes by in the program, for a diagnostic. */
+  nameOf(value: Value): string;
+}
+
+/**
+ * The memory ceilings a library call has to respect.
+ *
+ * Three ceilings, because three are what the catalogue can state truthfully: an
+ * array holds at most so many elements (OS5002), a string at most so many code
+ * points (OS5008), and a script at most so many drawing objects at once
+ * (OS5010). There is still no code for a ceiling on the whole heap, and
+ * inventing one would mean a message that named an array for a limit the array
+ * did not reach, so the engine enforces the three it can name and reclaims what
+ * nothing can reach instead.
+ *
+ * The drawing ceiling is the one of the three that cannot be reclaimed around.
+ * An object lives until the script deletes it and an undeleted one is a root of
+ * its own, so a script that creates one per bar has a heap that grows for as
+ * long as the chart is open and a sweep that can free none of it.
+ */
+export interface Guard {
+  array(span: Span, name: string, size: number): void;
+  string(span: Span, text: string): string;
+  /** The same ceiling against a length, for a string not yet built. */
+  chars(span: Span, length: number): void;
+  /** The drawing object ceiling, charged with what the script holds now. */
+  drawing(span: Span, held: number): void;
+  /** Raise a run-time diagnostic that names an argument of this call. */
+  badArgument(span: Span, name: string, argument: string, found: string): never;
+  /** Raise a run-time diagnostic against an index outside an array. */
+  badIndex(span: Span, name: string, index: string, size: number): never;
+  /** Raise a run-time diagnostic against an object a script already deleted. */
+  deleted(span: Span, kind: string, bar: number): never;
+  /** Raise a run-time diagnostic against a zone name the host does not know. */
+  badZone(span: Span, value: string): never;
+}
+
+export type LibraryCall = (ctx: CallContext, args: readonly Value[]) => Value;
+
+export interface ManifestEntry {
+  readonly name: string;
+  readonly arity: number;
+  readonly state: boolean;
+  readonly effect: Effect;
+  /** Parameter names, in order, so a diagnostic can say which one was wrong. */
+  readonly params: readonly string[];
+  /** Positions that must hold a whole number of one or more. */
+  readonly whole: readonly number[];
+  readonly call: LibraryCall;
+}
+
+export interface EntryOptions {
+  readonly state?: true;
+  readonly effect?: Effect;
+  readonly whole?: readonly number[];
+}
+
+/**
+ * Declares one entry.
+ *
+ * The parameter names are written as one space separated string, because that
+ * is how `stdlib.md`'s tables show a signature and the two can then be compared
+ * by eye without translating one of them first.
+ */
+export function entry(
+  name: string,
+  params: string,
+  call: LibraryCall,
+  options: EntryOptions = {},
+): ManifestEntry {
+  const list = params === '' ? [] : params.split(' ');
+  return {
+    name,
+    arity: list.length,
+    state: options.state === true,
+    effect: options.effect ?? 'none',
+    params: list,
+    whole: options.whole ?? [],
+    call,
+  };
+}
+
+/**
+ * An entry whose work happens at step 9, so the call itself produces absence.
+ *
+ * **An order call takes one argument more than the language surface shows**,
+ * and it is appended here rather than written into each of the nine signatures,
+ * so that the count the program records and the count this table expects cannot
+ * be given different answers. It is the names of the arguments the script wrote,
+ * in parameter order, and `compiled-program.md` 4.10 says why an order call
+ * needs it: two of its defaults are absence itself, so an argument left out and
+ * an argument written that came out absent arrive as the same value, and
+ * `language.md` 6.8 gives those opposite meanings.
+ */
+export function deferred(name: string, params: string, effect: Effect): ManifestEntry {
+  const all = effect === 'order' ? `${params} written`.trim() : params;
+  return entry(name, all, () => null, { effect });
+}
+
+/**
+ * The several numbers a multi-value call returns, as the array `stdlib.md`
+ * sections 2.3, 5 and 6 say it hands back.
+ *
+ * A fresh reference on every bar, because the language's own way of returning a
+ * trio is an array and an array is a heap object. The array never changes
+ * length and is never absent: each element carries its own warmup and is absent
+ * until it is reached, so an index is never out of range at the left edge of a
+ * chart and in range everywhere else.
+ */
+export function multi(ctx: CallContext, items: readonly (number | null)[]): Value {
+  return reference(ctx.heap.allocate({ kind: 'array', items: [...items] }));
+}
+
+export function numberAt(args: readonly Value[], index: number): number | null {
+  const value = args[index];
+  return value !== undefined && isNumber(value) ? value : null;
+}
+
+export function stringAt(args: readonly Value[], index: number): string | null {
+  const value = args[index];
+  return value !== undefined && isString(value) ? value : null;
+}
+
+export function boolAt(args: readonly Value[], index: number): boolean | null {
+  const value = args[index];
+  return typeof value === 'boolean' ? value : null;
+}
+
+export function colourAt(args: readonly Value[], index: number): ColourValue | null {
+  const value = args[index];
+  return value !== undefined && isColour(value) ? value : null;
+}
+
+export function refAt(args: readonly Value[], index: number): Reference | null {
+  const value = args[index];
+  return value !== undefined && isRef(value) ? value : null;
+}
+
+export function valueAt(args: readonly Value[], index: number): Value {
+  return args[index] ?? null;
+}
+
+/**
+ * A length argument, checked against its contract.
+ *
+ * A length that is present and is not a whole number of one or more is a bug in
+ * the script and is OS4003, named against the parameter that took it. A length
+ * that is absent is left to the function, which returns absence: the argument
+ * arrived during another value's warmup, and stopping the study would turn a
+ * gap into an error.
+ */
+export function lengthAt(
+  ctx: CallContext,
+  name: string,
+  param: string,
+  args: readonly Value[],
+  index: number,
+): number | null {
+  return checkedWhole(ctx, name, param, args[index], 1);
+}
+
+/** A whole number of zero or more, for a digit count or an index. */
+export function wholeAt(
+  ctx: CallContext,
+  name: string,
+  param: string,
+  args: readonly Value[],
+  index: number,
+): number | null {
+  return checkedWhole(ctx, name, param, args[index], 0);
+}
+
+function checkedWhole(
+  ctx: CallContext,
+  name: string,
+  param: string,
+  value: Value | undefined,
+  least: number,
+): number | null {
+  if (value === undefined || value === null) return null;
+  if (!isNumber(value) || !Number.isInteger(value) || value < least) {
+    ctx.guard.badArgument(ctx.span, name, param, describe(value));
+  }
+  return value;
+}
+
+/** A value as a diagnostic has to print it. */
+export function describe(value: Value): string {
+  if (value === null) return 'none';
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (value.tag === 'color') return `a colour`;
+  return 'an object';
+}

package/src/core/engine/library/chart.ts

@@ -0,0 +1,115 @@
+/**
+ * The calls that read something other than the bars: the instrument, the
+ * session, the position, and the order functions.
+ *
+ * `compiled-program.md` 5.2 lists what an engine reads from the host and from
+ * nowhere else, and every `chart` entry here is one row of that list. Two of
+ * them are deliberately not: `chart.intervalMinutes` and `chart.isIntraday` are
+ * derived from the interval string rather than read, which keeps them from
+ * disagreeing with the interval they describe.
+ *
+ * **The five `pos` entries are not host facts at all.** They read the run's own
+ * ledger (`stdlib.md` 17.7), folded from the orders this strategy sent and the
+ * fills the destination reported for them. An account position is held per
+ * contract and shared with every other strategy trading it, so a script that
+ * read one would be deciding against somebody else's trade (`stdlib.md` 17.1).
+ *
+ * **An order call performs nothing.** It appends a record to the pending effect
+ * list and pushes absent, and the list is applied at step 9 only when the bar is
+ * confirmed. The consequence is the one `language.md` 7.5 promises: a condition
+ * that was true halfway through a bar and false when it closed never places an
+ * order at all, because the execution that produced the pending record was
+ * thrown away. That is why every entry below with an effect is `deferred` and
+ * has no body: the machine never calls it.
+ */
+import type { Value } from '../values/index.js';
+import { deferred, entry } from './binding.js';
+import type { ManifestEntry } from './binding.js';
+
+/**
+ * Minutes in an interval code, or absent for a code that is not intraday.
+ *
+ * The grammar is the smallest thing that covers the codes a host serves: a
+ * count of minutes written bare, or a count with a unit letter. It is derived
+ * rather than read so that a study cannot see a `chart.interval` of one value
+ * and a `chart.intervalMinutes` of another.
+ */
+const INTERVAL = /^(\d+)([smhDWM]?)$/;
+
+const MINUTES: Readonly<Record<string, number>> = {
+  s: 1 / 60,
+  '': 1,
+  m: 1,
+  h: 60,
+  D: 60 * 24,
+  W: 60 * 24 * 7,
+};
+
+function intervalMinutes(code: string | null): number | null {
+  if (code === null) return null;
+  const parsed = INTERVAL.exec(code);
+  if (parsed === null) return null;
+  const count = Number(parsed[1]);
+  const unit = parsed[2] ?? '';
+  // A month is not a fixed number of minutes, so it has no answer here rather
+  // than an average that would be wrong in every month.
+  if (unit === 'M') return null;
+  const scale = MINUTES[unit];
+  return scale === undefined ? null : count * scale;
+}
+
+export const CHART_ENTRIES: readonly ManifestEntry[] = [
+  entry('chart.symbol', '', (ctx) => ctx.host.symbol()),
+  entry('chart.exchange', '', (ctx) => ctx.host.exchange()),
+  entry('chart.interval', '', (ctx) => ctx.host.interval()),
+  entry('chart.timezone', '', (ctx) => ctx.host.timezone()),
+  entry('chart.tickSize', '', (ctx) => ctx.host.tickSize()),
+  entry('chart.lotSize', '', (ctx) => ctx.host.lotSize()),
+  entry('chart.pointValue', '', (ctx) => ctx.host.pointValue()),
+  entry('chart.currency', '', (ctx) => ctx.host.currency()),
+  entry('chart.instrumentType', '', (ctx) => ctx.host.instrumentType()),
+  entry('chart.hasVolume', '', (ctx) => ctx.host.hasVolume()),
+  entry('chart.hasOpenInterest', '', (ctx) => ctx.host.hasOpenInterest()),
+  entry('chart.now', '', (ctx) => ctx.host.now()),
+
+  entry('chart.intervalMinutes', '', (ctx) => {
+    const code = ctx.host.interval();
+    return intervalMinutes(typeof code === 'string' ? code : null);
+  }),
+
+  entry('chart.isIntraday', '', (ctx) => {
+    const code = ctx.host.interval();
+    const minutes = intervalMinutes(typeof code === 'string' ? code : null);
+    return minutes === null ? null : minutes < 60 * 24;
+  }),
+
+  entry('req.isReady', 'read', (ctx, args) => ctx.host.requestReady(args[0] ?? null)),
+  entry('req.error', 'read', (ctx, args) => ctx.host.requestError(args[0] ?? null)),
+
+  entry('session.isFirstBar', '', (ctx) => ctx.bar.isSessionFirst),
+  entry('session.isLastBar', '', (ctx) => ctx.bar.isSessionLast),
+
+  entry('pos.size', '', (ctx) => ctx.position.size()),
+  entry('pos.avgPrice', '', (ctx) => ctx.position.avgPrice()),
+  entry('pos.isLong', '', (ctx) => sideOf(ctx.position.size(), 1)),
+  entry('pos.isShort', '', (ctx) => sideOf(ctx.position.size(), -1)),
+  entry('pos.isFlat', '', (ctx) => sideOf(ctx.position.size(), 0)),
+
+  deferred('print', 'value', 'log'),
+  deferred('buy', 'qty limit stop tag leg', 'order'),
+  deferred('sell', 'qty limit stop tag leg', 'order'),
+  deferred('close', 'tag qty leg', 'order'),
+  deferred('exit', 'tag qty limit stop profit loss leg', 'order'),
+  deferred('cancel', 'tag', 'order'),
+  deferred('cancelAll', '', 'order'),
+  deferred('order.place', 'side qty type price trigger tag leg', 'order'),
+  deferred('order.reverse', 'qty tag leg', 'order'),
+  deferred('order.bracket', 'tag profit loss leg', 'order'),
+];
+
+/** Which side a position is on, absent where the size is not a number. */
+function sideOf(size: Value, want: number): boolean | null {
+  if (typeof size !== 'number') return null;
+  const side = size > 0 ? 1 : size < 0 ? -1 : 0;
+  return side === want;
+}

package/src/core/engine/library/colours.ts

@@ -0,0 +1,111 @@
+/**
+ * Colour: the nineteen names and the calls that compute one.
+ *
+ * **The channel table is standing in for something that does not exist yet.**
+ * `stdlib.md` 11.1 fixes the exact channel values of the named colours in the
+ * library manifest and makes them part of the conformance suite; there is no
+ * manifest in this repository, so the compiler carries a copy for the colours
+ * it has to write into a declaration field before bar 0, and the engine carries
+ * one for the colours a script computes on a bar. Two copies of one fact is
+ * exactly what should not happen, and `tests/engine/colours.test.ts` asserts
+ * they agree, so the day the manifest exists both are deleted rather than
+ * reconciled.
+ *
+ * Every call that computes a colour rounds red, green and blue to a whole
+ * number before it returns, halves away from zero, which `colour()` in the
+ * value module does. Alpha is not rounded: it stays a binary64 number from 0 to
+ * 1 and becomes a byte only at the contract boundary, where the conversion is
+ * one way and is not a round trip (3.1).
+ */
+import type { Value } from '../values/index.js';
+import { colour } from '../values/index.js';
+import { colourAt, entry, numberAt } from './binding.js';
+import type { ManifestEntry } from './binding.js';
+
+const CHANNELS: Readonly<Record<string, readonly [number, number, number]>> = {
+  aqua: [0, 255, 255],
+  black: [0, 0, 0],
+  blue: [0, 0, 255],
+  brown: [165, 42, 42],
+  fuchsia: [255, 0, 255],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  lime: [0, 255, 0],
+  maroon: [128, 0, 0],
+  navy: [0, 0, 128],
+  olive: [128, 128, 0],
+  orange: [255, 165, 0],
+  pink: [255, 192, 203],
+  purple: [128, 0, 128],
+  red: [255, 0, 0],
+  silver: [192, 192, 192],
+  teal: [0, 128, 128],
+  white: [255, 255, 255],
+  yellow: [255, 255, 0],
+};
+
+/** The nineteen names, for a test that has to compare two tables. */
+export const COLOUR_NAMES: readonly string[] = Object.keys(CHANNELS);
+
+export function namedColour(name: string): Value {
+  const channels = CHANNELS[name];
+  return channels === undefined ? null : colour(channels[0], channels[1], channels[2], 1);
+}
+
+export const COLOUR_ENTRIES: readonly ManifestEntry[] = [
+  ...COLOUR_NAMES.map((name) => entry(name, '', () => namedColour(name))),
+
+  entry('rgb', 'r g b', (_ctx, args) => {
+    const r = numberAt(args, 0);
+    const g = numberAt(args, 1);
+    const b = numberAt(args, 2);
+    if (r === null || g === null || b === null) return null;
+    return colour(r, g, b, 1);
+  }),
+
+  entry('rgba', 'r g b a', (_ctx, args) => {
+    const r = numberAt(args, 0);
+    const g = numberAt(args, 1);
+    const b = numberAt(args, 2);
+    const a = numberAt(args, 3);
+    if (r === null || g === null || b === null || a === null) return null;
+    return colour(r, g, b, a);
+  }),
+
+  // `fade` takes transparency, not opacity, and the argument is a percentage:
+  // 100 is invisible. Both spellings follow the way a chart's own style controls
+  // are labelled, and the two conventions are opposites, so the arithmetic is
+  // written out rather than left to a reader to infer from the name.
+  entry('fade', 'color percent', (_ctx, args) => {
+    const base = colourAt(args, 0);
+    const percent = numberAt(args, 1);
+    if (base === null || percent === null) return null;
+    return colour(base.r, base.g, base.b, base.a * (1 - percent / 100));
+  }),
+
+  entry('mix', 'a b weight', (_ctx, args) => {
+    const a = colourAt(args, 0);
+    const b = colourAt(args, 1);
+    const weight = numberAt(args, 2);
+    if (a === null || b === null || weight === null) return null;
+    const blend = (from: number, to: number): number => from + (to - from) * weight;
+    return colour(
+      blend(a.r, b.r),
+      blend(a.g, b.g),
+      blend(a.b, b.b),
+      blend(a.a, b.a),
+    );
+  }),
+
+  entry('alpha', 'color', (_ctx, args) => {
+    const base = colourAt(args, 0);
+    return base === null ? null : base.a;
+  }),
+
+  entry('withAlpha', 'color a', (_ctx, args) => {
+    const base = colourAt(args, 0);
+    const a = numberAt(args, 1);
+    if (base === null || a === null) return null;
+    return colour(base.r, base.g, base.b, a);
+  }),
+];

package/src/core/engine/library/dates.ts

@@ -0,0 +1,109 @@
+/**
+ * The calendar, `stdlib.md` section 12.2, and the session range test of 12.5.
+ *
+ * **Every number here is the numeric library's**, for the reason `series.ts`
+ * sets out beside the same wiring. The zone arithmetic is under
+ * `src/core/stdlib/calendar`, which raises nothing; this file is the call sites
+ * and the one refusal the calendar cannot make for itself.
+ *
+ * **The zone defaults to the chart's, not to UTC.** Section 12.1 gives the
+ * reason: 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. So an absent `zone`
+ * argument falls back to `chart.timezone`, which is a host fact, and a host
+ * that states no timezone leaves every call here absent rather than answered in
+ * a zone nobody chose.
+ *
+ * **A zone the runtime does not know is OS6005 and never a guess.** An
+ * abbreviation is not a zone name: several of them mean two different offsets
+ * in different parts of the world, and a session test cannot carry that.
+ */
+import {
+  civilAt,
+  dateField,
+  instantFrom,
+  isKnownZone,
+  renderPattern,
+  sameDay,
+  startOf,
+} from '../../stdlib/index.js';
+import type { Boundary, DateField } from '../../stdlib/index.js';
+import { entry, numberAt, stringAt } from './binding.js';
+import type { CallContext, ManifestEntry } from './binding.js';
+import type { Value } from '../values/index.js';
+import { sessionHolds } from '../session/index.js';
+
+/**
+ * The zone a call reads in: the one it was given, or the chart's.
+ *
+ * A name the runtime's zone table does not hold stops the bar with OS6005,
+ * because the alternatives are both worse: an invented offset is silently wrong
+ * for half the year, and an absent answer would look exactly like a host that
+ * stated no timezone at all.
+ */
+function zoneAt(ctx: CallContext, args: readonly Value[], index: number): string | null {
+  const given = stringAt(args, index);
+  if (given !== null) {
+    if (!isKnownZone(given)) ctx.guard.badZone(ctx.span, given);
+    return given;
+  }
+  const chart = ctx.host.timezone();
+  if (typeof chart !== 'string') return null;
+  if (!isKnownZone(chart)) ctx.guard.badZone(ctx.span, chart);
+  return chart;
+}
+
+/** One calendar field read at `t`, which is every entry of the table in 12.2. */
+function field(name: string, which: DateField): ManifestEntry {
+  return entry(`date.${name}`, 't zone', (ctx, args) =>
+    dateField(numberAt(args, 0), zoneAt(ctx, args, 1), which),
+  );
+}
+
+/** One of the three boundaries a timestamp rounds back to. */
+function boundary(name: string, which: Boundary): ManifestEntry {
+  return entry(`date.${name}`, 't zone', (ctx, args) =>
+    startOf(numberAt(args, 0), zoneAt(ctx, args, 1), which),
+  );
+}
+
+export const DATE_ENTRIES: readonly ManifestEntry[] = [
+  field('year', 'year'),
+  field('month', 'month'),
+  field('day', 'day'),
+  field('dayOfWeek', 'dayOfWeek'),
+  field('dayOfYear', 'dayOfYear'),
+  field('hour', 'hour'),
+  field('minute', 'minute'),
+  field('second', 'second'),
+  field('weekOfYear', 'weekOfYear'),
+
+  boundary('startOfDay', 'day'),
+  boundary('startOfWeek', 'week'),
+  boundary('startOfMonth', 'month'),
+
+  entry('date.from', 'year month day hour minute second zone', (ctx, args) =>
+    instantFrom(
+      numberAt(args, 0),
+      numberAt(args, 1),
+      numberAt(args, 2),
+      numberAt(args, 3),
+      numberAt(args, 4),
+      numberAt(args, 5),
+      zoneAt(ctx, args, 6),
+    ),
+  ),
+
+  entry('date.isSameDay', 'a b zone', (ctx, args) =>
+    sameDay(numberAt(args, 0), numberAt(args, 1), zoneAt(ctx, args, 2)),
+  ),
+
+  entry('date.format', 't pattern zone', (ctx, args) => {
+    const zone = zoneAt(ctx, args, 2);
+    const rendered = renderPattern(stringAt(args, 1), civilAt(numberAt(args, 0), zone));
+    return rendered === null ? null : ctx.guard.string(ctx.span, rendered);
+  }),
+
+  entry('session.isIn', 'spec zone', (ctx, args) =>
+    sessionHolds(stringAt(args, 0), civilAt(ctx.bar.time, zoneAt(ctx, args, 1))),
+  ),
+];