openalgo-script 0.5.0 → 0.7.0

package/src/core/backtest/drive.ts

@@ -34,42 +34,51 @@
  * loop and the same record.
  */
 import { reportOf, scheduleFromDeclaration } from '../accounting/index.js';
-import type { ChargeSchedule, Contract, RecordedFill } from '../accounting/index.js';
+import type { ChargeSchedule, Contract } from '../accounting/index.js';
 import type { Diagnostic } from '../diagnostics/index.js';
 import type { CompiledProgram } from '../emit/index.js';
 import { load } from '../engine/index.js';
 import type {
-  BarResult,
-  Engine,
+  Drawing,
   EngineHost,
+  Grid,
   Instrument,
   LedgerRow,
   OrderIntent,
+  RequestProvider,
   RoutedEffect,
+  Value,
 } from '../engine/index.js';
 import { declarationOf } from './declaration.js';
 import type { RunDeclaration } from './declaration.js';
 import { Delivery, framedAs, ordinalsOf } from './deliver.js';
-import type { Delivered, Destination } from './deliver.js';
+import type { Destination } from './deliver.js';
 import { marksFor, windowFor } from './range.js';
-import type { ReportWindow } from './range.js';
-import { diagnosticIn, orderIn, recordOf } from './record.js';
-import type {
-  RecordedBar,
-  RecordedDiagnostic,
-  RecordedFrame,
-  RecordedOrder,
-  RunRecord,
-} from './record.js';
+import { orderIn, recordOf } from './record.js';
+import type { RecordedBar, RecordedFrame, RecordedOrder, RunRecord } from './record.js';
 import { Simulator } from './simulate.js';
 import { checkSettings } from './settings.js';
+import { walk } from './walk.js';
+import type { LogLine } from './walk.js';
 import type { BacktestSettings } from './settings.js';
 
 /** What a run came to, or why it could not be carried out at all. */
 export type BacktestResult =
-  | { readonly ok: true; readonly record: RunRecord }
+  | {
+      readonly ok: true;
+      readonly record: RunRecord;
+      readonly rows?: readonly (readonly Value[])[];
+      readonly log?: readonly LogLine[];
+      readonly surface?: Surface;
+    }
   | { readonly ok: false; readonly diagnostic: Diagnostic };
 
+/** The drawing objects and the grids the last bar left, `conformance.md` section 4. */
+export interface Surface {
+  readonly drawings: readonly Drawing[];
+  readonly tables: readonly Grid[];
+}
+
 /**
  * The facts of `host-interface.md` 4.1 that the contract does not hold.
  *
@@ -117,8 +126,35 @@ export interface DriveOptions {
    * written into a case that could never make its own expected output.
    */
   readonly sourceText?: string;
+  /**
+   * Whether to hand back every channel's value on every bar that ran, beside
+   * the record rather than inside it.
+   *
+   * A conformance case that asserts `values` compares one value per bar per
+   * plot, and the record holds none of them: it is the reproducible run, and a
+   * curve per plot is bytes it would carry for every run to serve the few cases
+   * that ask. So the rows are asked for, and a run that does not ask pays
+   * nothing. A bar that failed has no row, as in the second engine.
+   */
+  readonly rows?: boolean;
+  /** Whether to hand back every line `print` wrote, beside the record, for the same reason. */
+  readonly log?: boolean;
+  /** Whether to hand back the drawing objects and grids the last bar left, for the same reason. */
+  readonly surface?: boolean;
+  /**
+   * Bars for another instrument, `host-interface.md` 5, for a run whose host
+   * serves them.
+   *
+   * Left out, the run holds the chart's own bars and nothing else: a read of
+   * the chart's instrument at a coarser interval is folded from them, and a
+   * program that reads another instrument declares a capability this host does
+   * not have and is refused at load by name. Given, the host serves duty 3 and
+   * the engine asks it once per read, before bar 0.
+   */
+  readonly requestBars?: RequestProvider;
 }
 
+
 /**
  * One run against a simulated destination, from a compiled program to a record.
  *
@@ -206,7 +242,12 @@ function drive(
   const instrument = instrumentFor(settings.contract, options.instrument ?? {});
   const loaded = load(program, {
     settings: settings.inputs,
-    host: hostFor(instrument, settings.now, (effect, bar) => sending?.route(effect, bar)),
+    host: hostFor(
+      instrument,
+      settings.now,
+      (effect, bar) => sending?.route(effect, bar),
+      options.requestBars,
+    ),
   });
   if (!loaded.ok) return { ok: false, diagnostic: loaded.diagnostic };
 
@@ -219,12 +260,15 @@ function drive(
   const destination = choose(declared, schedule);
   sending = destination;
 
-  const run = walk(engine, destination, bars, framed.covered);
+  const run = walk(engine, destination, bars, framed.covered, options);
   const ordinals = ordinalsOf(destination.intents);
   const marks = marksFor(bars, framed.covered);
 
   return {
     ok: true,
+    ...(options.rows === true ? { rows: run.rows } : {}),
+    ...(options.log === true ? { log: run.log } : {}),
+    ...(options.surface === true ? { surface: { drawings: engine.drawings(), tables: engine.tables() } } : {}),
     record: recordOf({
       program: engine.program,
       ...(options.sourceText === undefined ? {} : { sourceText: options.sourceText }),
@@ -254,140 +298,6 @@ function simulated(venue: Simulator): Destination {
   };
 }
 
-/** What one walk of the bars produced. */
-interface Walked {
-  readonly fills: readonly RecordedFill[];
-  readonly frames: readonly Delivered[];
-  readonly diagnostics: readonly RecordedDiagnostic[];
-}
-
-/**
- * The bars, in order, with the venue answering between them.
- *
- * The one ordering rule: deliver, then append, then collect what the append
- * reported, then ask the venue what this bar did. A driver that asked the venue
- * before appending would price a fill against a bar the strategy had not seen.
- */
-function walk(
-  engine: Engine,
-  destination: Destination,
-  bars: readonly RecordedBar[],
-  covered: ReportWindow,
-): Walked {
-  const fills: RecordedFill[] = [];
-  const frames: Delivered[] = [];
-  const diagnostics: RecordedDiagnostic[] = [];
-  const intents = new Map<number, OrderIntent>();
-  const refs = new Map<number, string>();
-  const sizes = new Map<number, number>();
-
-  let pending: readonly Delivered[] = [];
-  let seq = 0;
-
-  for (let index = 0; index < covered.total; index += 1) {
-    const bar = bars[index];
-    if (bar === undefined) continue;
-
-    for (const one of pending) {
-      const ref = one.frame.orderRef;
-      if (typeof ref === 'string') refs.set(one.frame.intentId, ref);
-      engine.deliver(one.frame);
-      frames.push(one);
-    }
-    pending = [];
-
-    const result = engine.append(
-      { time: bar.time, open: bar.open, high: bar.high, low: bar.low, close: bar.close,
-        volume: bar.volume, oi: bar.oi },
-      { isConfirmed: true, isRealtime: false },
-      covered.total,
-    );
-
-    for (const intent of intentsIn(result)) intents.set(intent.intentId, intent);
-    seq = settle(result, index, bar, { intents, refs, sizes }, fills, seq);
-
-    if (result.diagnostic !== undefined) {
-      diagnostics.push(diagnosticIn(result.diagnostic, index));
-      break;
-    }
-
-    pending = destination.answers(index);
-  }
-
-  return { fills, frames, diagnostics };
-}
-
-/** What the run is holding while it folds one bar's frames into fills. */
-interface Books {
-  readonly intents: ReadonlyMap<number, OrderIntent>;
-  readonly refs: ReadonlyMap<number, string>;
-  readonly sizes: Map<number, number>;
-}
-
-/**
- * The fills one bar's fold settled.
- *
- * **The position sizes either side of step 6 are kept here and not read back
- * from the engine**, because the engine reports a leg's net and a fill settles
- * against one position reference: the two are different numbers whenever a leg
- * holds more than one position, which is every flip. They are folded in the
- * order the frames were folded in, from the same deltas, so they are the same
- * arithmetic the position book did rather than a second reading of its result.
- * When `FrameOutcome` carries them, these two lines come from the engine and
- * this fold keeps only the sequence number.
- *
- * A refused frame settles nothing and is not a fill. Today the fold reports the
- * refusal as a word rather than a code, so nothing here can write it into the
- * record as a diagnostic; that is OS7018 and OS7019, and both are deferred.
- */
-function settle(
-  result: BarResult,
-  index: number,
-  bar: RecordedBar,
-  books: Books,
-  fills: RecordedFill[],
-  from: number,
-): number {
-  let seq = from;
-  for (const outcome of result.frames) {
-    if (outcome.refused !== undefined) continue;
-    if (outcome.delta <= 0 || outcome.price === null) continue;
-    const intent = books.intents.get(outcome.intentId);
-    if (intent === undefined || intent.side === null) continue;
-
-    const before = books.sizes.get(intent.positionRef) ?? 0;
-    const after = before + (intent.side === 'sell' ? -outcome.delta : outcome.delta);
-    books.sizes.set(intent.positionRef, after);
-    seq += 1;
-
-    fills.push({
-      seq,
-      intentId: outcome.intentId,
-      orderRef: books.refs.get(outcome.intentId) ?? '',
-      tag: intent.tag,
-      positionRef: intent.positionRef,
-      side: intent.side,
-      units: outcome.delta,
-      price: outcome.price,
-      // The bar the fold happened at, which is the bar the position exists
-      // from. Where the fill itself traded is the bar before it or this bar's
-      // own open, and neither is a bar the strategy could have acted on it in.
-      barIndex: index,
-      barTime: bar.time,
-      refSizeBefore: before,
-      refSizeAfter: after,
-    });
-  }
-  return seq;
-}
-
-/** Every intent one bar handed over, in the order the bar applied them. */
-function intentsIn(result: BarResult): readonly OrderIntent[] {
-  const out: OrderIntent[] = [];
-  for (const effect of result.effects) for (const intent of effect.intents) out.push(intent);
-  return out;
-}
-
 /** The ledger at the end, copied out of the engine's own array. */
 function ordersOf(
   rows: readonly LedgerRow[],
@@ -450,19 +360,21 @@ function instrumentFor(contract: Contract, facts: InstrumentFacts): Instrument {
 /**
  * The host a backtest is: an instrument record, a clock and a destination.
  *
- * Duty 3 is not served. A backtest holds the chart's own bars and nothing else,
- * so a program that reads another instrument declares a capability this host
- * does not have and is refused at load, by name, rather than drawing a line
- * with nothing in it.
+ * Duty 3 is served only when the caller supplied bars for it. A backtest with
+ * none holds the chart's own bars and nothing else, so a program that reads
+ * another instrument declares a capability this host does not have and is
+ * refused at load, by name, rather than drawing a line with nothing in it.
  */
 function hostFor(
   instrument: Instrument,
   now: number | null,
   route: (effect: RoutedEffect, bar: number) => void,
+  requestBars: RequestProvider | undefined,
 ): EngineHost {
   return {
     instrument,
     ...(now === null ? {} : { now }),
     route,
+    ...(requestBars === undefined ? {} : { requestBars }),
   };
 }

package/src/core/backtest/index.ts

@@ -36,6 +36,8 @@
  */
 export { backtest, backtestSupplied } from './drive.js';
 export type { BacktestResult, DriveOptions, InstrumentFacts } from './drive.js';
+export type { LogLine } from './walk.js';
+export type { Surface } from './drive.js';
 export { declarationOf } from './declaration.js';
 export type { RunDeclaration } from './declaration.js';
 export { marksFor, windowFor } from './range.js';

package/src/core/backtest/walk.ts

@@ -0,0 +1,182 @@
+/**
+ * One walk of a backtest's bars, with the venue answering between them.
+ *
+ * Split from `drive.ts`, which sets a run up and writes its record, because the
+ * walk is the one part of a backtest that runs once per bar and it is read on its
+ * own: the order in which a frame is delivered, a bar appended and its fills
+ * folded is the whole of what makes a backtest reproducible.
+ */
+import type { RecordedFill } from '../accounting/index.js';
+import type { BarResult, Engine, HostBar, OrderIntent, Value } from '../engine/index.js';
+import type { Delivered, Destination } from './deliver.js';
+import type { ReportWindow } from './range.js';
+import { diagnosticIn } from './record.js';
+import type { RecordedBar, RecordedDiagnostic } from './record.js';
+
+/** One line of the script's log, `conformance.md` section 4. */
+export interface LogLine {
+  readonly barIndex: number;
+  readonly time: number | null;
+  readonly value: Value;
+}
+
+/** What one walk of the bars produced. */
+export interface Walked {
+  readonly fills: readonly RecordedFill[];
+  readonly frames: readonly Delivered[];
+  readonly diagnostics: readonly RecordedDiagnostic[];
+  readonly rows: readonly (readonly Value[])[];
+  readonly log: readonly LogLine[];
+}
+
+/**
+ * The bars, in order, with the venue answering between them.
+ *
+ * The one ordering rule: deliver, then append, then collect what the append
+ * reported, then ask the venue what this bar did. A driver that asked the venue
+ * before appending would price a fill against a bar the strategy had not seen.
+ */
+export function walk(
+  engine: Engine,
+  destination: Destination,
+  bars: readonly RecordedBar[],
+  covered: ReportWindow,
+  keep: { readonly rows?: boolean; readonly log?: boolean },
+): Walked {
+  const fills: RecordedFill[] = [];
+  const rows: (readonly Value[])[] = [];
+  const log: LogLine[] = [];
+  const frames: Delivered[] = [];
+  const diagnostics: RecordedDiagnostic[] = [];
+  const intents = new Map<number, OrderIntent>();
+  const refs = new Map<number, string>();
+  const sizes = new Map<number, number>();
+
+  let pending: readonly Delivered[] = [];
+  let seq = 0;
+
+  // The bars are a settled history, so the fold is handed all of them before
+  // bar 0 as `Engine.run` hands them. A `"lookahead"` read is the one reading
+  // that can tell (`compiled-program.md` 2.16.2): over history it reads the
+  // bucket a bar is inside in full, and a driver that fed the fold one bar at
+  // a time would answer the bucket so far, which is the live chart's reading.
+  const handed = bars.slice(0, covered.total).map(hostBarOf);
+  engine.history(handed);
+
+  for (let index = 0; index < covered.total; index += 1) {
+    const bar = bars[index];
+    const held = handed[index];
+    if (bar === undefined || held === undefined) continue;
+
+    for (const one of pending) {
+      const ref = one.frame.orderRef;
+      if (typeof ref === 'string') refs.set(one.frame.intentId, ref);
+      engine.deliver(one.frame);
+      frames.push(one);
+    }
+    pending = [];
+
+    const result = engine.append(
+      held,
+      { isConfirmed: true, isRealtime: false },
+      covered.total,
+    );
+
+    for (const intent of intentsIn(result)) intents.set(intent.intentId, intent);
+    seq = settle(result, index, bar, { intents, refs, sizes }, fills, seq);
+
+    if (result.diagnostic !== undefined) {
+      diagnostics.push(diagnosticIn(result.diagnostic, index));
+      break;
+    }
+    if (keep.rows === true) rows.push([...result.columns]);
+    if (keep.log === true) {
+      for (const one of result.effects) {
+        if (one.effect === 'log') log.push({ barIndex: index, time: bar.time, value: one.args[0] ?? null });
+      }
+    }
+
+    pending = destination.answers(index);
+  }
+
+  return { fills, frames, diagnostics, rows, log };
+}
+
+/** A recorded bar as the engine is handed one. */
+function hostBarOf(bar: RecordedBar): HostBar {
+  return {
+    time: bar.time, open: bar.open, high: bar.high, low: bar.low, close: bar.close,
+    volume: bar.volume, oi: bar.oi,
+  };
+}
+
+/** What the run is holding while it folds one bar's frames into fills. */
+interface Books {
+  readonly intents: ReadonlyMap<number, OrderIntent>;
+  readonly refs: ReadonlyMap<number, string>;
+  readonly sizes: Map<number, number>;
+}
+
+/**
+ * The fills one bar's fold settled.
+ *
+ * **The position sizes either side of step 6 are kept here and not read back
+ * from the engine**, because the engine reports a leg's net and a fill settles
+ * against one position reference: the two are different numbers whenever a leg
+ * holds more than one position, which is every flip. They are folded in the
+ * order the frames were folded in, from the same deltas, so they are the same
+ * arithmetic the position book did rather than a second reading of its result.
+ * When `FrameOutcome` carries them, these two lines come from the engine and
+ * this fold keeps only the sequence number.
+ *
+ * A refused frame settles nothing and is not a fill. Today the fold reports the
+ * refusal as a word rather than a code, so nothing here can write it into the
+ * record as a diagnostic; that is OS7018 and OS7019, and both are deferred.
+ */
+function settle(
+  result: BarResult,
+  index: number,
+  bar: RecordedBar,
+  books: Books,
+  fills: RecordedFill[],
+  from: number,
+): number {
+  let seq = from;
+  for (const outcome of result.frames) {
+    if (outcome.refused !== undefined) continue;
+    if (outcome.delta <= 0 || outcome.price === null) continue;
+    const intent = books.intents.get(outcome.intentId);
+    if (intent === undefined || intent.side === null) continue;
+
+    const before = books.sizes.get(intent.positionRef) ?? 0;
+    const after = before + (intent.side === 'sell' ? -outcome.delta : outcome.delta);
+    books.sizes.set(intent.positionRef, after);
+    seq += 1;
+
+    fills.push({
+      seq,
+      intentId: outcome.intentId,
+      orderRef: books.refs.get(outcome.intentId) ?? '',
+      tag: intent.tag,
+      positionRef: intent.positionRef,
+      side: intent.side,
+      units: outcome.delta,
+      price: outcome.price,
+      // The bar the fold happened at, which is the bar the position exists
+      // from. Where the fill itself traded is the bar before it or this bar's
+      // own open, and neither is a bar the strategy could have acted on it in.
+      barIndex: index,
+      barTime: bar.time,
+      refSizeBefore: before,
+      refSizeAfter: after,
+    });
+  }
+  return seq;
+}
+
+/** Every intent one bar handed over, in the order the bar applied them. */
+function intentsIn(result: BarResult): readonly OrderIntent[] {
+  const out: OrderIntent[] = [];
+  for (const effect of result.effects) for (const intent of effect.intents) out.push(intent);
+  return out;
+}

package/src/core/catalogue/catalogue.generated.ts

@@ -19,6 +19,7 @@ export const STAGE_LABELS = {
   check: "checker",
   runtime: "engine",
   host: "host",
+  import: "importer",
 } as const satisfies Readonly<Record<Stage, string>>;
 
 export const ENTRIES = {
@@ -95,6 +96,8 @@ export const ENTRIES = {
   OS3022: { code: "OS3022", title: "Two inputs share a settings key", severity: "error", stage: "check", since: 1, autofix: false, message: "This input is keyed by its title {name}, which is already the name of the input at line {line}.", fix: "Give this one a title of its own, or rename the input at line {line}.", placeholders: ["name", "line"] },
   OS3023: { code: "OS3023", title: "An order names a leg this file does not declare", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} was given a {argument}, and this file declares none.", fix: "Leave {argument} out. A file that declares no leg has exactly one, and every order acts on it.", placeholders: ["name", "argument"] },
   OS3024: { code: "OS3024", title: "An input written in place has an empty title", severity: "error", stage: "check", since: 1, autofix: false, message: "An input() assigned to no name is named by its title, and this one's title is empty.", fix: "Give the title something to say: input(2, \"Precision\").", placeholders: [] },
+  OS3025: { code: "OS3025", title: "A setting is part of a larger expression here", severity: "error", stage: "check", since: 1, autofix: false, message: "{option} is fixed before the first bar and holds an input() only as the whole of its value, so it cannot hold an expression over one.", fix: "Declare the setting as the value itself, with an input() written as the whole of {option}, or write the value out as a literal.", placeholders: ["option"] },
+  OS3026: { code: "OS3026", title: "This option cannot be a setting", severity: "error", stage: "check", since: 1, autofix: false, message: "{option} is written into the compiled program as a plain value, so a setting cannot choose it in this format version.", fix: "Write the option out as a string literal and drop the input(): style = \"step\", for instance, is one of the values OS3008 names.", placeholders: ["option"] },
   OS4001: { code: "OS4001", title: "History index is not usable", severity: "error", stage: "runtime", since: 1, autofix: false, message: "[{index}] is not a whole number of bars at or above zero.", fix: "Wrap the index in floor() or round(), and clamp a computed index with max(0, n).", placeholders: ["index"] },
   OS4002: { code: "OS4002", title: "History index is deeper than the retained depth", severity: "error", stage: "runtime", since: 1, autofix: false, message: "[{index}] reaches past the retained depth of {depth} bars.", fix: "Raise the depth in one place: limits(history = {suggested}).", placeholders: ["index", "depth", "suggested"] },
   OS4003: { code: "OS4003", title: "A whole number was required here", severity: "error", stage: "runtime", since: 1, autofix: false, message: "{name}'s {argument} was {found} on this bar; a whole number was required.", fix: "Round the value before passing it: floor() towards zero, round() to nearest.", placeholders: ["name", "argument", "found"] },
@@ -129,7 +132,7 @@ export const ENTRIES = {
   OS6009: { code: "OS6009", title: "The request failed", severity: "error", stage: "host", since: 1, autofix: false, message: "The host could not fetch {symbol} at {timeframe}: {reason}.", fix: "Act on {reason} in the host: it is a connection, permission or quota problem. Where the value can be derived from the chart's own bars, derive it and drop the request.", placeholders: ["symbol", "timeframe", "reason"] },
   OS6010: { code: "OS6010", title: "The engine was given no bars", severity: "error", stage: "host", since: 1, autofix: false, message: "There are no bars for {symbol} at {timeframe}, so the script cannot run.", fix: "Choose an instrument and interval that have history, or widen the chart's date range until bars exist.", placeholders: ["symbol", "timeframe"] },
   OS6011: { code: "OS6011", title: "The bars are not in order", severity: "error", stage: "host", since: 1, autofix: false, message: "Bar {index} is dated {time}, which is not after bar {previous}.", fix: "Reload the history; if the same bar repeats, the feed is sending duplicates and the host has to sort and deduplicate the bars before the engine runs.", placeholders: ["index", "time", "previous"] },
-  OS6012: { code: "OS6012", title: "An instrument fact is not known", severity: "error", stage: "host", since: 1, autofix: false, message: "The host did not supply {fact} for {symbol}.", fix: "Supply {fact} in the host's instrument record, or stop depending on it: round with a number the script chooses rather than chart.tickSize.", placeholders: ["fact", "symbol"] },
+  OS6012: { code: "OS6012", title: "An instrument fact is not known", severity: "error", stage: "host", since: 1, autofix: false, message: "The host did not supply {fact} for {symbol}.", fix: "Supply {fact} in the host's instrument record for {symbol}, or leave the session out of the record, which makes every session read absent rather than wrong.", placeholders: ["fact", "symbol"] },
   OS6013: { code: "OS6013", title: "The request changed after the first bar", severity: "error", stage: "runtime", since: 1, autofix: false, message: "This request asked for {first} on bar 0 and for {found} on bar {bar}.", fix: "Compute the symbol and the timeframe from literals or inputs, not from bar data.", placeholders: ["first", "found", "bar"] },
   OS6014: { code: "OS6014", title: "The feed does not offer this timeframe", severity: "error", stage: "host", since: 1, autofix: false, message: "The host has no {timeframe} data for {symbol}; it offers {available}.", fix: "Request one of {available}, or derive the interval you want from a lower one the host does serve.", placeholders: ["timeframe", "symbol", "available"] },
   OS6015: { code: "OS6015", title: "The requested timeframe does not fold into the chart's", severity: "error", stage: "host", since: 1, autofix: false, message: "{requested} is not a whole multiple of {chart}.", fix: "Request a multiple of {chart}, for example {suggestion}.", placeholders: ["requested", "chart", "suggestion"] },
@@ -141,6 +144,8 @@ export const ENTRIES = {
   OS6021: { code: "OS6021", title: "A run setting cannot be applied as stated", severity: "error", stage: "host", since: 1, autofix: false, message: "{setting} cannot be applied: {problem}.", fix: "State the setting so it can be carried out: declare a charge line after every line it is levied on, supply the tick size a slippage in ticks is measured in, write down the reason a tolerance needs a bound, or bring a bound past the cap back inside it. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.", placeholders: ["setting", "problem"] },
   OS6022: { code: "OS6022", title: "The bars are not the bars the record was made from", severity: "error", stage: "host", since: 1, autofix: false, message: "The bars supplied hash to {found}, and the record was made from {expected}.", fix: "Replay against the bars the record names. Where the revision is the point, make a second record over the revised bars and compare the two runs, rather than overwriting one run with the other under one name.", placeholders: ["found", "expected"] },
   OS6023: { code: "OS6023", title: "Two cost models are stated at once", severity: "error", stage: "host", since: 1, autofix: false, message: "A charge schedule was supplied, and the declaration states a commission of {commission} in {commissionType}.", fix: "Supply the schedule and leave the declaration's commission at its default of zero, or state the commission in the declaration and supply no schedule. A schedule is the one of the two that can carry a floor, a cap, a charge levied on a charge, and a cost that falls on one side of the trade only.", placeholders: ["commission", "commissionType"] },
+  OS6024: { code: "OS6024", title: "The host cannot draw something this study declares", severity: "error", stage: "host", since: 1, autofix: false, message: "This host cannot draw {what}: {limit}.", fix: "Declare what this host draws, or run the study on a host that draws {what}.", placeholders: ["what", "limit"] },
+  OS6025: { code: "OS6025", title: "A bar has no time", severity: "error", stage: "host", since: 1, autofix: false, message: "Bar {index} was handed over with no time.", fix: "State the bar's open instant in whole milliseconds since the Unix epoch, UTC, and leave out a bar the host cannot date rather than handing it over without a time.", placeholders: ["index"] },
   OS7001: { code: "OS7001", title: "Only a strategy can do that", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} is available only in a file declared with strategy().", fix: "Change study(...) on line {line} to strategy(...), or replace {name} with signal(\"...\") to mark the bar without trading.", placeholders: ["name", "line"] },
   OS7002: { code: "OS7002", title: "An order argument is absent", severity: "error", stage: "runtime", since: 1, autofix: false, message: "{name}'s {argument} is absent on this bar.", fix: "Guard the call with isNone({argument}), or supply a fallback with orElse() where one is genuinely correct.", placeholders: ["name", "argument"] },
   OS7003: { code: "OS7003", title: "An order function inside a request expression", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} inside a request expression would place an order from another instrument's bars.", fix: "Read the value with the request, and place the order at the top level from the result.", placeholders: ["name"] },
@@ -179,6 +184,18 @@ export const ENTRIES = {
   OS8017: { code: "OS8017", title: "The condition is constant", severity: "warning", stage: "check", since: 1, autofix: false, message: "This condition is {value} on every bar.", fix: "Restore the test that was meant, or delete the branch that never runs.", placeholders: ["value"] },
   OS8018: { code: "OS8018", title: "An input is never used", severity: "warning", stage: "check", since: 1, autofix: false, message: "The input {title} is declared at line {line} and never read.", fix: "Use the name the input assigns, or delete the input() and its dialog row.", placeholders: ["title", "line"] },
   OS8019: { code: "OS8019", title: "A deleted object is still held", severity: "warning", stage: "check", since: 1, autofix: false, message: "{name} still holds the {kind} deleted at line {line}.", fix: "Assign none to the name on the same path as the delete, and where the object came out of an array, remove the element as well as deleting the object.", placeholders: ["name", "kind", "line"] },
+  OS9001: { code: "OS9001", title: "Version not read by the importer", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer reads scripts written for version 5 or 6 of the source dialect, and this one {found}.", fix: "Bring the script up to version 5 or 6 in the source dialect, or translate it by hand, and import it again.", placeholders: ["found"] },
+  OS9002: { code: "OS9002", title: "Construct with no equivalent", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer cannot translate {construct}, so the statement holding it was kept as a comment.", fix: "Translate that statement by hand from the comment that holds it: the rest of the script was translated around it.", placeholders: ["construct"] },
+  OS9003: { code: "OS9003", title: "Built-in with no mapping", severity: "error", stage: "import", since: 1, autofix: false, message: "{name} is not one of the built-ins the importer maps, so the statement holding it was kept as a comment.", fix: "Find the OpenScript library call that does the same job, check how it treats its first bars and absent values, and write the statement by hand.", placeholders: ["name"] },
+  OS9004: { code: "OS9004", title: "Declaration the importer cannot place", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer writes the declaration from one indicator or strategy call at the top level, and this script {found}.", fix: "Give the source script exactly one indicator or strategy declaration at the top level, and import it again.", placeholders: ["found"] },
+  OS9005: { code: "OS9005", title: "Reads a statement that was not translated", severity: "error", stage: "import", since: 1, autofix: false, message: "{name} is declared by the statement at line {line}, which was not translated, so this statement that reads it was kept as a comment too.", fix: "Translate the statement at line {line} by hand first, then this one, which was kept as a comment only because it reads {name}.", placeholders: ["name", "line"] },
+  OS9006: { code: "OS9006", title: "Argument with no equivalent", severity: "error", stage: "import", since: 1, autofix: false, message: "{argument} changes what {call} computes or trades, and OpenScript has no equivalent the importer can write.", fix: "Translate the call by hand, deciding what OpenScript should do in place of {argument}, or remove {argument} from the source script if the script does not depend on it.", placeholders: ["argument", "call"] },
+  OS9007: { code: "OS9007", title: "Warmup and absent bars follow OpenScript", severity: "warning", stage: "import", since: 1, autofix: false, message: "{call} became {target} here and wherever else the script calls it, and {target} follows OpenScript's own warmup, arithmetic and handling of absent values, which the original is not guaranteed to share.", fix: "Compare the first bars of the translation with the original, and where the script depends on them, write the value as an explicit recurrence held in var, seeded the way the original seeds it.", placeholders: ["call", "target"] },
+  OS9008: { code: "OS9008", title: "Whole-number division in version 5", severity: "warning", stage: "import", since: 1, autofix: false, message: "Both sides of this division are whole-number constants, which version 5 of the source dialect divides without a fractional part, and OpenScript keeps the fraction.", fix: "If the script relied on the whole-number result, wrap the translated division in trunc(); otherwise leave it as it is.", placeholders: [] },
+  OS9009: { code: "OS9009", title: "Presentation argument left out", severity: "warning", stage: "import", since: 1, autofix: false, message: "{argument} changes how {call} is displayed or what it may allocate, not what it computes, and OpenScript has no equivalent, so the translation leaves it out.", fix: "Nothing needs to change unless the display mattered; where it did, restyle the translated call with the arguments OpenScript does have, such as its colour, width and style.", placeholders: ["argument", "call"] },
+  OS9010: { code: "OS9010", title: "Order placed under OpenScript's order model", severity: "warning", stage: "import", since: 1, autofix: false, message: "{call} was translated into OpenScript's order calls here and wherever else the script uses it, and OpenScript decides when an order fills, how a reversal and a repeated entry are handled and when an exit level starts to apply by its own order model.", fix: "Backtest the translation beside the original and compare the two trade lists before relying on it, and adjust the order calls by hand where they part.", placeholders: ["call"] },
+  OS9011: { code: "OS9011", title: "Equality over two absent values", severity: "warning", stage: "import", since: 1, autofix: false, message: "Both sides of {operator} can be absent on the same bar, and OpenScript counts two absent values as equal, which the original is not guaranteed to do.", fix: "If the original relied on two absent values never comparing equal, guard the translated comparison with isNone() on either side.", placeholders: ["operator"] },
+  OS9012: { code: "OS9012", title: "The translation does not compile", severity: "error", stage: "import", since: 1, autofix: false, message: "The OpenScript compiler refused the translation of this statement with {code}, so the statement was kept as a comment.", fix: "Look up {code} in this catalogue and translate the statement by hand in the form that code's fix describes.", placeholders: ["code"] },
 } as const satisfies Readonly<Record<string, CatalogueEntry>>;
 
 /** Every code the compiler and the engines may emit. Nothing else is one. */

package/src/core/catalogue/types.ts

@@ -6,8 +6,14 @@
 /** What a diagnostic does to the run. An error stops it; a warning never does. */
 export type Severity = 'error' | 'warning';
 
-/** Which part of the pipeline raised a diagnostic. */
-export type Stage = 'lex' | 'parse' | 'check' | 'runtime' | 'host';
+/**
+ * Which part of the pipeline raised a diagnostic.
+ *
+ * `import` is not a stage of compiling OpenScript: it is the importer, which
+ * reads a script written in another chart language and whose findings point
+ * into that script rather than into an OpenScript file.
+ */
+export type Stage = 'lex' | 'parse' | 'check' | 'runtime' | 'host' | 'import';
 
 /**
  * What a compiler puts into a message slot.

package/src/core/catalogue/values.generated.ts

@@ -87,6 +87,8 @@ export interface DiagnosticValues {
   readonly OS3022: { readonly name: PlaceholderValue; readonly line: PlaceholderValue };
   readonly OS3023: { readonly name: PlaceholderValue; readonly argument: PlaceholderValue };
   readonly OS3024: Record<string, never>;
+  readonly OS3025: { readonly option: PlaceholderValue };
+  readonly OS3026: { readonly option: PlaceholderValue };
   readonly OS4001: { readonly index: PlaceholderValue };
   readonly OS4002: { readonly index: PlaceholderValue; readonly depth: PlaceholderValue; readonly suggested: PlaceholderValue };
   readonly OS4003: { readonly name: PlaceholderValue; readonly argument: PlaceholderValue; readonly found: PlaceholderValue };
@@ -133,6 +135,8 @@ export interface DiagnosticValues {
   readonly OS6021: { readonly setting: PlaceholderValue; readonly problem: PlaceholderValue };
   readonly OS6022: { readonly found: PlaceholderValue; readonly expected: PlaceholderValue };
   readonly OS6023: { readonly commission: PlaceholderValue; readonly commissionType: PlaceholderValue };
+  readonly OS6024: { readonly what: PlaceholderValue; readonly limit: PlaceholderValue };
+  readonly OS6025: { readonly index: PlaceholderValue };
   readonly OS7001: { readonly name: PlaceholderValue; readonly line: PlaceholderValue };
   readonly OS7002: { readonly name: PlaceholderValue; readonly argument: PlaceholderValue };
   readonly OS7003: { readonly name: PlaceholderValue };
@@ -171,4 +175,16 @@ export interface DiagnosticValues {
   readonly OS8017: { readonly value: PlaceholderValue };
   readonly OS8018: { readonly title: PlaceholderValue; readonly line: PlaceholderValue };
   readonly OS8019: { readonly name: PlaceholderValue; readonly kind: PlaceholderValue; readonly line: PlaceholderValue };
+  readonly OS9001: { readonly found: PlaceholderValue };
+  readonly OS9002: { readonly construct: PlaceholderValue };
+  readonly OS9003: { readonly name: PlaceholderValue };
+  readonly OS9004: { readonly found: PlaceholderValue };
+  readonly OS9005: { readonly name: PlaceholderValue; readonly line: PlaceholderValue };
+  readonly OS9006: { readonly argument: PlaceholderValue; readonly call: PlaceholderValue };
+  readonly OS9007: { readonly call: PlaceholderValue; readonly target: PlaceholderValue };
+  readonly OS9008: Record<string, never>;
+  readonly OS9009: { readonly argument: PlaceholderValue; readonly call: PlaceholderValue };
+  readonly OS9010: { readonly call: PlaceholderValue };
+  readonly OS9011: { readonly operator: PlaceholderValue };
+  readonly OS9012: { readonly code: PlaceholderValue };
 }

package/src/core/check/assigned.ts

@@ -0,0 +1,31 @@
+/**
+ * The names some line of the file gives a value, wherever that line is.
+ *
+ * `warmup.ts` answers `never` for a value that is absent on every bar, and
+ * OS8009 is built on it. The checker reads a name's warmup at the point of use,
+ * in source order, which is right for a plain name: it is recomputed every bar
+ * and cannot be read before this bar's line writes it. It is not right for a
+ * `var`, which is one name over the whole run: a line near the top can read the
+ * value a line near the bottom wrote on the bar before, which is the shape of
+ * every rollover that carries a running figure into a held one and restarts it.
+ *
+ * So the checker asks this set before it calls a `var` never. An assignment of
+ * the literal `none` is not counted, because it gives the name nothing, and a
+ * placeholder `var x = none` that nothing else writes stays exactly what OS8009
+ * was written for.
+ */
+import type { AstNode, Script } from '../ast/index.js';
+import { childrenOf, withoutGrouping } from '../ast/index.js';
+
+export function namesGivenAValue(script: Script): ReadonlySet<string> {
+  const found = new Set<string>();
+  collect(script, found);
+  return found;
+}
+
+function collect(node: AstNode, found: Set<string>): void {
+  if (node.kind === 'assignment' && withoutGrouping(node.value).kind !== 'noneLiteral') {
+    found.add(node.target.text);
+  }
+  for (const child of childrenOf(node)) collect(child, found);
+}