openalgo-script 0.2.0 → 0.5.0

package/src/core/engine/arithmetic.ts

@@ -23,6 +23,7 @@
  * what a script wants when it wraps an index. Collapsing them would silently
  * change one of the two.
  */
+import { compareStrings } from './library/index.js';
 import type { Value } from './values/index.js';
 import { ABSENT, numberValue, valuesEqual } from './values/index.js';
 
@@ -99,12 +100,17 @@ function numeric(
  * absence is treated two ways, and it is deliberate: an operator that can
  * itself be absent gives a script no way to ask whether a value is absent at
  * all, so equality is the exception and every other comparison is not.
+ *
+ * **Two strings are ordered by code point** (`language.md` 9.3, `stdlib.md`
+ * section 10), through the one order `sort` uses, and not by the host's own
+ * operator, which orders by sixteen bit unit and puts a symbol outside the
+ * basic plane below the last thousands of the plane. Numbers take the host's
+ * operator, which is the binary64 order every engine shares.
  */
 export function compare(opcode: 'LT' | 'LE' | 'GT' | 'GE', a: Value, b: Value): Value {
   if (a === null || b === null) return ABSENT;
-  const bothNumbers = typeof a === 'number' && typeof b === 'number';
-  const bothStrings = typeof a === 'string' && typeof b === 'string';
-  if (!bothNumbers && !bothStrings) throw new OperandMismatch(opcode);
+  if (typeof a === 'string' && typeof b === 'string') return ordered(opcode, compareStrings(a, b));
+  if (typeof a !== 'number' || typeof b !== 'number') throw new OperandMismatch(opcode);
   switch (opcode) {
     case 'LT':
       return a < b;
@@ -117,6 +123,20 @@ export function compare(opcode: 'LT' | 'LE' | 'GT' | 'GE', a: Value, b: Value):
   }
 }
 
+/** An ordering comparison read off a three way order: negative, zero or positive. */
+function ordered(opcode: 'LT' | 'LE' | 'GT' | 'GE', order: number): boolean {
+  switch (opcode) {
+    case 'LT':
+      return order < 0;
+    case 'LE':
+      return order <= 0;
+    case 'GT':
+      return order > 0;
+    default:
+      return order >= 0;
+  }
+}
+
 /** `EQ` and `NE` are total: they always produce a boolean. */
 export function equals(a: Value, b: Value): boolean {
   return valuesEqual(a, b);

package/src/core/engine/index.ts

@@ -24,7 +24,7 @@
 export { Engine } from './engine.js';
 export type { BarResult, RunResult } from './results.js';
 
-export { load } from './load.js';
+export { load, loadText } from './load.js';
 export type { LoadOptions, LoadResult } from './load.js';
 
 export type { AlertFiring } from './alerts.js';
@@ -72,7 +72,7 @@ export type { Timeframe, TimeframeUnit } from './timeframe.js';
 export { bucketKeyOf, isIntraday, minutesOf, nominalMinutes, parseTimeframe } from './timeframe.js';
 
 export type { ResolvedInput, SettingCheck, TimeResolver } from './inputs.js';
-export { checkSetting, constantValue, utcTime } from './inputs.js';
+export { checkSetting, constantValue, fieldValue, utcTime } from './inputs.js';
 
 export { LANGUAGE_VERSIONS, capabilitiesFor, verify } from './verify.js';
 export type { VerifyOptions, VerifyResult } from './verify.js';

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

@@ -22,6 +22,7 @@ import type { Value } from '../values/index.js';
 import { isNumber, reference, valuesEqual } from '../values/index.js';
 import { entry, refAt, stringAt, valueAt, wholeAt } from './binding.js';
 import type { CallContext, ManifestEntry } from './binding.js';
+import { compareStrings } from './code-points.js';
 import { result } from '../../stdlib/index.js';
 
 /** The array a handle names, or nothing when the handle is absent or stale. */
@@ -68,12 +69,17 @@ function within(
   return index;
 }
 
-/** The order `sort` uses, written down so two engines cannot differ. */
+/**
+ * The order `sort` uses, written down so two engines cannot differ.
+ *
+ * Two strings order by code point (`language.md` 9.3), which is not the order
+ * the host's `<` gives once a string holds a symbol outside the basic plane.
+ */
 function rank(a: Value, b: Value): number {
   if (a === null) return b === null ? 0 : 1;
   if (b === null) return -1;
   if (typeof a === 'number' && typeof b === 'number') return a < b ? -1 : a > b ? 1 : 0;
-  if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === 'string' && typeof b === 'string') return compareStrings(a, b);
   if (typeof a === 'boolean' && typeof b === 'boolean') return a === b ? 0 : a ? 1 : -1;
   return 0;
 }

package/src/core/engine/library/code-points.ts

@@ -0,0 +1,73 @@
+/**
+ * The two string rules two engines have to share, written from the page.
+ *
+ * **A string is a sequence of code points** (`compiled-program.md` 3.1), and the
+ * host this engine is written in stores one as sixteen bit units. Every rule
+ * here counts code points and not units, because the two disagree the moment a
+ * string holds a symbol outside the basic plane, and a rule written on the
+ * host's units would be a rule a second engine could not follow.
+ *
+ * **Ordering.** Two strings are ordered by comparing code points from the
+ * front, the first difference deciding, and a string that runs out first
+ * ordering first (`language.md` 9.3, `stdlib.md` section 10). The host's own
+ * `<` orders by unit, which puts every symbol outside the basic plane, stored
+ * as a surrogate pair from U+D800, below the code points from U+E000 to U+FFFF
+ * that come after it, so it is not used.
+ *
+ * **Whitespace.** `str.trim` removes, and `toNumber` ignores, exactly the code
+ * points `stdlib.md` section 10 lists, which are the ones with the Unicode
+ * White_Space property. The host's own `trim` removes a set that is nearly this
+ * one: it takes the byte order mark U+FEFF as well, and a second engine's host
+ * takes the four separators U+001C to U+001F and leaves the byte order mark, so
+ * neither host's default is the set, and the set is implemented from the list.
+ * `tests/engine/strings.test.ts` walks every code point of the basic plane
+ * against the list read out of the page.
+ */
+
+/** The code points `str.trim` removes, as `stdlib.md` section 10 lists them. */
+const WHITESPACE: ReadonlySet<number> = new Set([
+  0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x0020, 0x0085, 0x00a0, 0x1680,
+  0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a,
+  0x2028, 0x2029, 0x202f, 0x205f, 0x3000,
+]);
+
+/** Code points, which is what every index over a string counts. */
+export function points(text: string): string[] {
+  return [...text];
+}
+
+/** Whether one code point is in the trimmed set. */
+export function isWhitespace(point: number): boolean {
+  return WHITESPACE.has(point);
+}
+
+/** `text` with the whitespace of the written set taken off both ends. */
+export function trimmed(text: string): string {
+  const all = points(text);
+  let from = 0;
+  let to = all.length;
+  while (from < to && isWhitespace(all[from]?.codePointAt(0) ?? -1)) from += 1;
+  while (to > from && isWhitespace(all[to - 1]?.codePointAt(0) ?? -1)) to -= 1;
+  return from === 0 && to === all.length ? text : all.slice(from, to).join('');
+}
+
+/**
+ * The order of two strings, negative when `a` comes first, by code point.
+ *
+ * Walked with the string iterator so a surrogate pair is one code point, and
+ * compared as numbers so U+10000 comes after U+FFFF, which is the order the
+ * page states and the one an engine with four byte strings gets for free.
+ */
+export function compareStrings(a: string, b: string): number {
+  const left = a[Symbol.iterator]();
+  const right = b[Symbol.iterator]();
+  for (;;) {
+    const one = left.next();
+    const other = right.next();
+    if (one.done) return other.done ? 0 : -1;
+    if (other.done) return 1;
+    const x = one.value.codePointAt(0) ?? 0;
+    const y = other.value.codePointAt(0) ?? 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+}

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

@@ -37,6 +37,12 @@ import { TREND_ENTRIES } from './trend.js';
 import { VOLUME_ENTRIES } from './volume.js';
 import type { ManifestEntry } from './binding.js';
 
+/**
+ * The two string rules, for the operators outside this module and the tests:
+ * `code-points.ts` says why neither is the host's own.
+ */
+export { compareStrings, isWhitespace, trimmed } from './code-points.js';
+
 const ENTRIES: readonly ManifestEntry[] = [
   ...COLOUR_ENTRIES,
   ...MATHS_ENTRIES,

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

@@ -8,34 +8,50 @@
  * one element, or two engines will disagree about the length of a string
  * holding a symbol outside the basic plane and about every substring taken
  * after one. That is what the spread into an array is doing everywhere below:
- * it costs a pass over the string and buys agreement.
+ * it costs a pass over the string and buys agreement. The trimmed set and the
+ * order of two strings are in `code-points.ts`, written from the page.
  *
  * **Number to string is specified, not the host's default.** `text(x)` is the
- * shortest decimal string that reads back as the same binary64 value, which is
- * what this language's own conversion already produces. `text(x, d)` rounds to
- * `d` decimals with halves away from zero and always emits exactly `d` digits
- * after the point, because this is a display conversion and half up is what a
- * reader of a price expects.
+ * rule of `language.md` 5.5 and goes through the one writer that implements
+ * it, `canonicalNumber`, as does every digit this file writes: a host's own
+ * conversion is never asked. `text(x, d)` rounds to `d` decimals with halves
+ * away from zero and always emits exactly `d` digits after the point, because
+ * this is a display conversion and half up is what a reader of a price expects.
  */
-import { roundHalfAway } from '../../stdlib/index.js';
+import { canonicalNumber } from '../../emit/index.js';
+import { roundHalfAway, scaleOf } from '../../stdlib/index.js';
 import type { Value } from '../values/index.js';
 import { isColour, reference } from '../values/index.js';
 import { entry, numberAt, refAt, stringAt, valueAt, wholeAt } from './binding.js';
 import type { CallContext, ManifestEntry } from './binding.js';
+import { points, trimmed } from './code-points.js';
 
 /** A value as `text(x)` spells it. */
 export function spell(ctx: CallContext, value: Value): string {
   if (value === null) return 'none';
-  if (typeof value === 'number') return String(value);
-  if (typeof value === 'boolean') return String(value);
+  if (typeof value === 'number') return canonicalNumber(value);
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (typeof value === 'string') return value;
   if (isColour(value)) {
-    const byte = (x: number): string => x.toString(16).padStart(2, '0');
-    return `#${byte(value.r)}${byte(value.g)}${byte(value.b)}${byte(roundHalfAway(value.a * 255))}`;
+    const alpha = roundHalfAway(value.a * 255);
+    return `#${hexByte(value.r)}${hexByte(value.g)}${hexByte(value.b)}${hexByte(alpha)}`;
   }
   return ctx.heap.get(value.id)?.kind ?? 'none';
 }
 
+/**
+ * A whole number from 0 to 255 as two hex digits, from a table.
+ *
+ * A colour's channels are whole numbers (`compiled-program.md` 3.1), so this
+ * is not the decimal rendering rule and asks no host conversion: each nibble
+ * indexes a string of sixteen characters.
+ */
+const HEX_DIGITS = '0123456789abcdef';
+
+function hexByte(channel: number): string {
+  return `${HEX_DIGITS[channel >> 4] ?? '0'}${HEX_DIGITS[channel & 15] ?? '0'}`;
+}
+
 /** A magnitude as decimal digits, and how many of them fall before the point. */
 interface Spread {
   readonly digits: string;
@@ -108,24 +124,31 @@ function written(of: Spread): string {
  * least one digit, and exactly `d` digits after the point. `spread` is what
  * makes that true of every magnitude rather than of the ones below a threshold.
  *
- * **Past the scaling range the digits are the shortest form's, zero filled.**
- * Scaling by `10 ** d` leaves binary64 altogether for a large enough magnitude
- * or a large enough `d`, and there is nothing to round out there: a binary64 at
- * or above 2 ** 53 is a whole number already, and a decimal place that far from
- * the leading digit is past every digit the value carries. Two engines write
- * the same digits, because the shortest decimal form is what each one's own
- * conversion produces. Inside the range the scaling is what it was, so no value
- * that had an answer has a different one.
+ * **The scale is `round(x, d)`'s**, `scaleOf` from the numeric library, so
+ * the display conversion and the rounding call multiply by one value
+ * (`stdlib.md` 20.7) and cannot part by an ulp at the one count where the
+ * host's power does.
+ *
+ * **The digits are the shortest form's, zero filled, at every magnitude.**
+ * Below 2 ** 53 a rounded whole number has no digits but its own, so nothing
+ * ordinary changes; at or above it the shortest form is what both engines
+ * write, and it is what this uses inside the scaling range as well as past it,
+ * where scaling by ten to the `d` leaves binary64 altogether and there is
+ * nothing to round: a binary64 that large is a whole number already, and a
+ * decimal place that far from the leading digit is past every digit the value
+ * carries. One rule for the digits at every magnitude, rather than the exact
+ * binary expansion below a threshold and the shortest form above it.
  */
 function fixed(x: number, decimals: number): string {
-  const scaled = roundHalfAway(x * Math.pow(10, decimals));
+  const scaled = roundHalfAway(x * scaleOf(decimals));
   const usable = Number.isFinite(scaled);
   const sign = (usable ? scaled < 0 : x < 0) ? '-' : '';
-  // Within the scaling range the whole number's own digits are asked for and
-  // not its shortest form, which drops the low digits of a large one.
+  // The digits are the shortest form's at every magnitude, through the one
+  // writer: a rounded whole below 2 ** 53 has no other digits, and above it
+  // the shortest form is the one rule both engines write (language.md 5.5).
   const magnitude = usable
-    ? spread(Math.abs(scaled).toFixed(0), 0)
-    : spread(Math.abs(x).toString(), decimals);
+    ? spread(canonicalNumber(Math.abs(scaled)), 0)
+    : spread(canonicalNumber(Math.abs(x)), decimals);
   const digits = written(magnitude).padStart(decimals + 1, '0');
   if (decimals === 0) return sign + digits;
   const whole = digits.slice(0, digits.length - decimals);
@@ -143,7 +166,7 @@ function fixed(x: number, decimals: number): string {
  * have. `str.repeat` measures first for the same reason.
  */
 function lengthOf(x: number, decimals: number): number {
-  const before = Math.max(1, spread(Math.abs(x).toString(), 0).point);
+  const before = Math.max(1, spread(canonicalNumber(Math.abs(x)), 0).point);
   return before + decimals + (decimals > 0 ? 1 : 0);
 }
 
@@ -154,22 +177,17 @@ function lengthOf(x: number, decimals: number): number {
  * which accepts hexadecimal, infinities and a bare leading point in some
  * languages and not others. Absence rather than zero for text that is not a
  * number, so a script can tell text that is not a number apart from the number
- * zero.
+ * zero. The whitespace ignored at either end is `str.trim`'s set and no other.
  */
 const NUMERIC = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 
 function parseNumber(text: string): Value {
-  const trimmed = text.trim();
-  if (!NUMERIC.test(trimmed)) return null;
-  const parsed = Number(trimmed);
+  const bare = trimmed(text);
+  if (!NUMERIC.test(bare)) return null;
+  const parsed = Number(bare);
   return Number.isFinite(parsed) ? (parsed === 0 ? 0 : parsed) : null;
 }
 
-/** Code points, which is what every index in this file counts. */
-function points(text: string): string[] {
-  return [...text];
-}
-
 function makeArray(ctx: CallContext, items: Value[]): Value {
   ctx.guard.array(ctx.span, 'the array', items.length);
   return reference(ctx.heap.allocate({ kind: 'array', items }));
@@ -198,7 +216,7 @@ export const TEXT_ENTRIES: readonly ManifestEntry[] = [
 
   entry('str.upper', 's', (ctx, args) => map(ctx, args, (s) => s.toUpperCase())),
   entry('str.lower', 's', (ctx, args) => map(ctx, args, (s) => s.toLowerCase())),
-  entry('str.trim', 's', (ctx, args) => map(ctx, args, (s) => s.trim())),
+  entry('str.trim', 's', (ctx, args) => map(ctx, args, trimmed)),
 
   entry('str.contains', 's part', (_ctx, args) => pair(args, (s, part) => s.includes(part))),
   entry('str.startsWith', 's part', (_ctx, args) => pair(args, (s, part) => s.startsWith(part))),

package/src/core/engine/load.ts

@@ -10,6 +10,7 @@
  * bar four thousand with half a study on the screen.
  */
 import type { Diagnostic } from '../diagnostics/index.js';
+import { canonicalise } from '../emit/index.js';
 import type { SourceFile } from '../source/index.js';
 import { BAR_FIELDS } from './bars.js';
 import { limitsWith } from './budget.js';
@@ -18,7 +19,7 @@ import { Engine } from './engine.js';
 import { NO_POSITION, failure, malformed } from './errors.js';
 import type { EngineHost } from './host.js';
 import { resolveInputs, utcTime } from './inputs.js';
-import type { TimeResolver } from './inputs.js';
+import type { ResolvedInput, TimeResolver } from './inputs.js';
 import { planRequests } from './request-plan.js';
 import { recordProblem } from './session/index.js';
 import { capabilitiesFor, verify } from './verify.js';
@@ -36,8 +37,21 @@ export interface LoadOptions {
   readonly time?: TimeResolver;
 }
 
+/**
+ * A loaded program, and the settings it was loaded under.
+ *
+ * The resolved inputs come back beside the engine because a declaration field
+ * may be written by an input (`compiled-program.md` 2.3), and a caller outside
+ * the engine reads some of those fields: what a run was carried out with is the
+ * declaration's capital, its commission and the bar a fill is priced at, and
+ * the backtest driver is what reports them. Resolving an input a second time
+ * out there would be the same rule written in two files, and the first host
+ * setting either of them read differently would be a report nobody could
+ * explain. So the resolution happens once, here, and what it produced is handed
+ * over rather than kept.
+ */
 export type LoadResult =
-  | { readonly ok: true; readonly engine: Engine }
+  | { readonly ok: true; readonly engine: Engine; readonly inputs: readonly ResolvedInput[] }
   | { readonly ok: false; readonly diagnostic: Diagnostic };
 
 /**
@@ -100,5 +114,73 @@ export function load(program: unknown, options: LoadOptions = {}): LoadResult {
   return {
     ok: true,
     engine: new Engine(checked.program, resolved.inputs, options, limits, planned.plans),
+    inputs: resolved.inputs,
   };
 }
+
+/**
+ * Loads a compiled program from text, which is where canonicity is required.
+ *
+ * `load` takes a parsed object because a host that compiled in this process
+ * never serialised, and there is nothing for such an object to be canonical
+ * about. Text is the other boundary, `compiled-program.md` 9.4 step 1 and
+ * section 13 (decision 57): a program an engine reads from outside its process
+ * arrives as the canonical encoding of 2.14, and text that parses to a program
+ * but is not that encoding is refused, because the hash a host recorded was
+ * taken over canonical bytes and text in any other spelling is text that hash
+ * does not name. So the text is parsed, written out again by the one canonical
+ * writer, and the two are compared character for character. Either failure is
+ * OS6018 naming where the text stops being readable or stops being canonical,
+ * counted in characters of the text, which is where an editor's cursor lands.
+ *
+ * What passes here is the object `load` verifies from step 2 on, so every
+ * refusal that applies to an object applies to text as well and in the same
+ * order.
+ */
+export function loadText(text: string, options: LoadOptions = {}): LoadResult {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (thrown) {
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    const at = /position (\d+)/.exec(message);
+    return {
+      ok: false,
+      diagnostic: malformed(
+        at === null ? 'the text' : `character ${at[1]}`,
+        'the text stops being the object notation of section 2.14 there, so it is not a program',
+      ),
+    };
+  }
+
+  let canonical: string;
+  try {
+    canonical = canonicalise(parsed);
+  } catch (thrown) {
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return {
+      ok: false,
+      diagnostic: malformed('the text', `it parses but cannot be written in the canonical form: ${message}`),
+    };
+  }
+  if (canonical !== text) {
+    return {
+      ok: false,
+      diagnostic: malformed(
+        `character ${firstDifference(text, canonical)}`,
+        'the text is not the canonical encoding of the program it parses to, and a program ' +
+          'read from outside the process has to be, because that is what its hash was taken over',
+      ),
+    };
+  }
+  return load(parsed, options);
+}
+
+/** Where two texts part, as an index into either, or the shorter one's length. */
+function firstDifference(a: string, b: string): number {
+  const shorter = Math.min(a.length, b.length);
+  for (let i = 0; i < shorter; i += 1) {
+    if (a[i] !== b[i]) return i;
+  }
+  return shorter;
+}

package/src/core/engine/verify-tables.ts

@@ -21,8 +21,51 @@ const META_KINDS = ['study', 'strategy'] as const;
 const CHANNEL_TYPES = ['number', 'string', 'color', 'bool'] as const;
 const EFFECTS = ['none', 'signal', 'order', 'draw', 'log'] as const;
 
+/**
+ * The tables a later minor of this format major added, with the minor that
+ * added each.
+ *
+ * 9.2's rule read from the other side, which 9.4 step 3 states and decision 56
+ * settled: a table a later minor added and an earlier program lacks reads as
+ * empty, never as a refusal, because 9.5's first line is a promise about that
+ * program. A program stamped at this minor or a later one has no such excuse.
+ * Section 2 says an empty table is written as an empty array and never
+ * omitted, so its absence there is the defect check 1 exists for, and the
+ * version is what tells the two apart.
+ *
+ * `spec/format-history.json` records the same additions, one entry per format
+ * version, and `tests/engine/format-minors.test.ts` holds this list to that
+ * file: a table the history says a later minor added has to be one a program
+ * at the earlier minor may lack.
+ */
+const ADDED_AT_MINOR: readonly { readonly table: string; readonly minor: number }[] = [
+  { table: 'requests', minor: 1 },
+];
+
+/** The minor of a `major.minor` the version step has already proved is one. */
+function minorOf(raw: Readonly<Record<string, unknown>>): number {
+  const version = raw['openscript'] as Readonly<Record<string, unknown>>;
+  return Number(String(version['format']).split('.')[1] ?? '0');
+}
+
+/**
+ * Writes the empty table an earlier minor is owed into the program itself.
+ *
+ * Into the object rather than into a local, because every later step reads
+ * the program as its own type and would find the table missing again: the
+ * verifier hands the same object on, and the engine holds it.
+ */
+function supplyAddedTables(raw: Readonly<Record<string, unknown>>): void {
+  const minor = minorOf(raw);
+  for (const added of ADDED_AT_MINOR) {
+    if (raw[added.table] !== undefined || minor >= added.minor) continue;
+    (raw as Record<string, unknown>)[added.table] = [];
+  }
+}
+
 /** Check 1 over every table the machine indexes, and every declaration field. */
 export function checkTables(shape: ShapeCheck, raw: Readonly<Record<string, unknown>>): boolean {
+  supplyAddedTables(raw);
   for (const name of ['requires', 'inputs', 'channels', 'consts', 'series', 'cells', 'states',
     'functions', 'callSites', 'loops', 'code', 'requests']) {
     if (!shape.array(raw[name], name)) return false;

package/src/core/index.ts

@@ -170,6 +170,7 @@ export type {
   InputKind,
   LibraryEntry,
   LibraryParameter,
+  LibraryProse,
   ObjectKind,
   RequestMode,
   Storage,
@@ -192,6 +193,7 @@ export {
   atLeastBar,
   check,
   delayed,
+  describedNames,
   earlier,
   elementOf,
   isLibraryName,
@@ -205,6 +207,7 @@ export {
   membersOf,
   sameType,
   seriesOf,
+  proseFor,
   typeText,
 } from './check/index.js';
 export { REQUEST_NAMES } from './check/index.js';
@@ -223,9 +226,21 @@ export { COMPILED_FORMAT_VERSION, VERSION } from './version/index.js';
  */
 export { emit } from './emit/index.js';
 export type { EmitOptions, EmitResult } from './emit/index.js';
-export type { CompiledProgram } from './emit/index.js';
+export type { Colour, CompiledProgram } from './emit/index.js';
 export { canonicalise, programHash, sourceHash } from './emit/index.js';
 
+/**
+ * Two answers the emitter holds that a tool built on the language needs.
+ *
+ * A declaration call's defaults and the channels a colour name denotes are both
+ * facts the compiler applies and neither is in the library manifest, so a tier
+ * above this one that read the manifest alone would show a writer nothing where
+ * the compiler has a value. They are here rather than reached for behind the
+ * emitter's door, and `scripts/check-defaults.mjs` holds the first of them to
+ * what `stdlib.md` prints.
+ */
+export { DECLARATION_CALLS, declarationDefaultText, namedColour } from './emit/index.js';
+
 /**
  * The engine: a program in, one bar at a time, values out.
  *
@@ -235,10 +250,15 @@ export { canonicalise, programHash, sourceHash } from './emit/index.js';
  * same check on its own, for a host that keeps compiled programs and wants to
  * refuse a bad one when it arrives rather than when it is first drawn.
  *
+ * `loadText` is `load` for a program that arrives as text, which is the one
+ * boundary where the canonical encoding is required (`compiled-program.md`
+ * section 13): text that parses to a program but is not that encoding is
+ * refused, because the hash a host recorded was taken over canonical bytes.
+ *
  * `capabilitiesFor` and `LANGUAGE_VERSIONS` are this engine's half of the
  * compatibility statement in 9.1, beside `COMPILED_FORMAT_VERSION` above.
  */
-export { load } from './engine/index.js';
+export { load, loadText } from './engine/index.js';
 export type { BarResult, Engine, LoadOptions, LoadResult, RunResult } from './engine/index.js';
 export type {
   BarState,
@@ -267,3 +287,81 @@ export { isAbsent } from './engine/index.js';
 export type { Value } from './engine/index.js';
 export { LANGUAGE_VERSIONS, capabilitiesFor, verify } from './engine/index.js';
 export type { VerifyOptions, VerifyResult } from './engine/index.js';
+
+/**
+ * The money, and the run it is folded from (`stdlib.md` 17.1, 17.7).
+ *
+ * Two modules rather than one, and the line between them is the design. The
+ * accounting shapes are arithmetic over portable data and know nothing about an
+ * engine, so a stored record can be reported again with no engine present and
+ * the engine can one day call the same arithmetic with no second implementation
+ * to disagree with. The backtest shapes are what one run was carried out under
+ * and what it produced, and a record of one is a conformance case a second
+ * engine can be handed whole.
+ *
+ * They are here rather than behind an entry point of their own because they are
+ * the same layer: a host that compiles and runs a program is the host that
+ * reports what it did.
+ */
+export type {
+  BarMark,
+  ChargeBase,
+  ChargeBreakdown,
+  ChargeLine,
+  ChargeSchedule,
+  ChargeSide,
+  Contract,
+  EquityPoint,
+  Money,
+  MonthlyReturn,
+  RecordedFill,
+  Report,
+  SideAnalysis,
+  Summary,
+  Trade,
+  TradeAnalysis,
+  TradeMarker,
+} from './accounting/index.js';
+export { chargeFor, scheduleFromDeclaration, scheduleProblem } from './accounting/index.js';
+export { markersOf, monthlyOver, reportOf } from './accounting/index.js';
+export { tradesOf } from './accounting/index.js';
+export { analysisOf, equityOver, summaryOf } from './accounting/index.js';
+export {
+  DEFAULT_FILL,
+  EXACT,
+  WHOLE_RANGE,
+  RECORD_VERSION,
+  backtest,
+  backtestSupplied,
+  barsHash,
+  caseFilesFrom,
+  checkSettings,
+  compareRuns,
+  recordFromJson,
+  recordToJson,
+  recordOf,
+  replay,
+  rerun,
+  runBytes,
+  settingsFor,
+  windowFor,
+} from './backtest/index.js';
+export type { BacktestResult, ReplayResult, ReportWindow } from './backtest/index.js';
+export type {
+  BacktestSettings,
+  BarsInRecord,
+  CaseFiles,
+  CaseIdentity,
+  CaseResult,
+  DateRange,
+  DriveOptions,
+  FillPolicy,
+  InstrumentFacts,
+  RecordedBar,
+  RecordedDiagnostic,
+  RecordedFrame,
+  RecordedOrder,
+  RunComparison,
+  RunRecord,
+  Tolerance,
+} from './backtest/index.js';

package/src/core/stdlib/index.ts

@@ -105,6 +105,7 @@ export {
   roundTo,
   roundToStep,
   roundToTick,
+  scaleOf,
   sign,
   sin,
   sqrt,

package/src/core/stdlib/maths/index.ts

@@ -18,6 +18,7 @@ export {
   roundTo,
   roundToStep,
   roundToTick,
+  scaleOf,
   trunc,
 } from './rounding.js';