openalgo-script 0.4.0 → 0.6.0

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"] },
@@ -138,9 +141,11 @@ export const ENTRIES = {
   OS6018: { code: "OS6018", title: "The compiled program is malformed", severity: "error", stage: "host", since: 1, autofix: false, message: "The program failed verification at {location}: {reason}.", fix: "Recompile the script from its source; a program that fails verification came from a broken compiler or was edited after it was written, and neither is repairable by hand.", placeholders: ["location", "reason"] },
   OS6019: { code: "OS6019", title: "A host setting fails the input's validation", severity: "error", stage: "host", since: 1, autofix: false, message: "The host supplied {value} for {key}, and {validation}.", fix: "Correct the value in the settings dialog, or widen the input's own min, max or options so the value is allowed.", placeholders: ["value", "key", "validation"] },
   OS6020: { code: "OS6020", title: "The report window holds no bars", severity: "error", stage: "host", since: 1, autofix: false, message: "The window from {from} to {to} holds none of the {count} bars supplied.", fix: "Widen the window until it covers bars, or supply the bars it covers. Both bounds are inclusive and are compared against the times of the bars supplied rather than against a calendar, so a window that falls inside a gap in the data is empty however wide it looks.", placeholders: ["from", "to", "count"] },
-  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, or write down the reason a tolerance needs a bound. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.", placeholders: ["setting", "problem"] },
+  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);
+}

package/src/core/check/call-sites.ts

@@ -21,7 +21,7 @@ import { bindArguments } from './arguments.js';
 import { remember, resolveLibraryCall, unresolved } from './calls.js';
 import type { Checker, Placement } from './checker.js';
 import type { CheckedCall, InputKind, RequestMode } from './checked.js';
-import { calleeNameOf, isCompileTimeConstant, isSourceName } from './constant.js';
+import { calleeNameOf, isCompileTimeConstant, isSourceName, readsInputInPart } from './constant.js';
 import { checkExpression } from './expressions.js';
 import { ensureChecked } from './functions.js';
 import { allowHandle, refuseHandle } from './handles.js';
@@ -59,7 +59,10 @@ export function resolveCall(checker: Checker, call: Call, placement: Placement):
     checker.report('OS2010', call.span, {
       name: checker.textOf(call.callee.span),
       type: typeText(UNKNOWN),
-      suggestion: checker.suggestionFor(checker.textOf(call.callee.span)),
+      suggestion: checker.callSuggestionFor(
+        checker.textOf(call.callee.span),
+        call.args.map((one) => checker.textOf(one.span)),
+      ),
     });
     return record(checker, call, unresolved(call, 'call'));
   }
@@ -220,8 +223,12 @@ function checkInput(checker: Checker, call: Call, checked: CheckedCall): Checked
   const options = argumentOf(checked, 'options');
   const title = literalOf(checked, 'title');
 
-  if (value !== undefined && !isSourceName(value.value) && !isCompileTimeConstant(checker, value.value)) {
-    checker.report('OS3003', value.span, { option: 'value' });
+  if (value !== undefined && !isSourceName(value.value)) {
+    if (!isCompileTimeConstant(checker, value.value)) {
+      checker.report('OS3003', value.span, { option: 'value' });
+    } else if (readsInputInPart(checker, value.value, false)) {
+      checker.report('OS3025', value.span, { option: 'value' });
+    }
   }
   if (kind !== undefined && PLANNED_KINDS.has(kind)) {
     checker.report('OS2001', call.span, {

package/src/core/check/calls.ts

@@ -19,7 +19,7 @@ import type { ParameterShape } from './arguments.js';
 import type { Checker, Placement } from './checker.js';
 import { reportStrategyOnly } from './checker.js';
 import type { CheckedCall } from './checked.js';
-import { isCompileTimeConstant } from './constant.js';
+import { isCompileTimeConstant, readsInputInPart } from './constant.js';
 import { refuseHandle } from './handles.js';
 import type { LibraryEntry } from './library.js';
 import { literalNumber, literalString } from './literals.js';
@@ -244,8 +244,14 @@ export function validateArguments(
       });
     }
 
-    if (entry.constant.includes(parameter.name) && !isCompileTimeConstant(checker, argument.value)) {
-      checker.report('OS3003', span, { option: parameter.name });
+    if (entry.constant.includes(parameter.name)) {
+      if (!isCompileTimeConstant(checker, argument.value)) {
+        checker.report('OS3003', span, { option: parameter.name });
+      } else if (readsInputInPart(checker, argument.value, entry.name !== 'input')) {
+        checker.report('OS3025', span, { option: parameter.name });
+      } else if (entry.written.includes(parameter.name) && readsInputInPart(checker, argument.value, false)) {
+        checker.report('OS3026', span, { option: parameter.name });
+      }
     }
   }
 
@@ -331,7 +337,10 @@ export function resolveLibraryCall(
     checker.report('OS2010', call.span, {
       name,
       type: held === undefined ? typeText(UNKNOWN) : typeText(held.returns),
-      suggestion: checker.suggestionFor(name),
+      suggestion: checker.callSuggestionFor(
+        name,
+        call.args.map((one) => checker.textOf(one.span)),
+      ),
     });
     return unresolved(call, name);
   }

package/src/core/check/check.ts

@@ -21,11 +21,12 @@ import type { SourceFile } from '../source/index.js';
 import { Checker, TOP_LEVEL, finaliseStorage } from './checker.js';
 import type { CheckedScript } from './checked.js';
 import { checkDeclaration, checkLimits, readHeader } from './declaration.js';
+import { reportDeletedStillHeld } from './deleted.js';
 import { checkFunctionDeclarations, checkRemainingFunctions } from './functions.js';
 import { reportRepeatedAlertIds } from './outputs.js';
 import { checkStatement } from './statements.js';
 import { reportUnplaceableTags } from './tags.js';
-import { elementOf } from './types.js';
+import { elementOf, isHandle } from './types.js';
 
 export function check(file: SourceFile, script: Script, sink: DiagnosticSink): CheckedScript {
   const checker = new Checker(file, script, sink);
@@ -54,6 +55,7 @@ export function check(file: SourceFile, script: Script, sink: DiagnosticSink): C
   finaliseStorage(checker);
   reportUnknownElementTypes(checker);
   reportNamesNeverRead(checker);
+  reportDeletedStillHeld(checker);
   reportRepeatedTitles(checker);
   reportInputKeys(checker);
   reportRepeatedAlertIds(checker);
@@ -78,12 +80,22 @@ function reportUnknownElementTypes(checker: Checker): void {
   }
 }
 
-/** OS8010 and OS8018: a name, or an input, that nothing in the file reads. */
+/**
+ * OS8010 and OS8018: a name, or an input, that nothing in the file reads.
+ *
+ * A name bound to a declaration handle is exempt, as the entry's cause says: a
+ * handle is a compile-time binding, the declaration draws whether or not it is
+ * named, and so nothing is left in the bar loop for the warning to be about.
+ * `language.md` 5.4 gives `plot`, `plotCandles`, `fill` and `level` the one kind
+ * of value, so the exemption is the type rather than a list of the two calls
+ * `stdlib.md` 14.2 happens to name.
+ */
 function reportNamesNeverRead(checker: Checker): void {
   for (const binding of checker.bindings) {
     if (binding.isRead) continue;
     if (binding.kind === 'library' || binding.kind === 'function') continue;
     if (binding.kind === 'parameter' || binding.kind === 'loop') continue;
+    if (isHandle(binding.type)) continue;
 
     if (binding.input !== undefined) {
       const input = checker.inputs[binding.input];

package/src/core/check/checker.ts

@@ -35,13 +35,14 @@ import type {
   Mutable,
   Storage,
 } from './checked.js';
+import { namesGivenAValue } from './assigned.js';
 import { conditionalCalls } from './conditional.js';
-import { libraryNames } from './surface.js';
+import { libraryFunctionNames, libraryNames } from './surface.js';
 import { closestName } from './suggest.js';
 import type { Type } from './types.js';
 import { UNKNOWN } from './types.js';
 import type { Warmup } from './warmup.js';
-import { BAR_ZERO } from './warmup.js';
+import { BAR_ZERO, weaken } from './warmup.js';
 
 /**
  * One nesting of names, `language.md` 12.1.
@@ -143,6 +144,13 @@ export class Checker {
 
   /** Every call site a bar can pass without evaluating, `language.md` 11.4. */
   private readonly conditional: ReadonlySet<Call>;
+  /**
+   * The names some line gives a value, read before a `var` is called never.
+   *
+   * Built the first time it is asked for, because it is one walk of the whole
+   * tree and almost every file never reads a `var` that is still never.
+   */
+  private givenAValue: ReadonlySet<string> | undefined = undefined;
 
   constructor(file: SourceFile, script: Script, sink: DiagnosticSink) {
     this.file = file;
@@ -300,6 +308,21 @@ export class Checker {
     return this.types.get(expression) ?? UNKNOWN;
   }
 
+  /**
+   * The warmup a read of this name sees, here.
+   *
+   * A `var` that is still never at this line but that a later line gives a
+   * value is not never: the later line wrote it on the bar before, or on an
+   * earlier pass of the same loop. The honest answer is a floor of bar 0,
+   * which claims nothing and withdraws the claim OS8009 is built on, where an
+   * exact bar would need the later line's warmup before it has been read.
+   */
+  warmupOfRead(binding: Binding): Warmup {
+    if (binding.warmup.kind !== 'never' || binding.persistence === 'none') return binding.warmup;
+    this.givenAValue ??= namesGivenAValue(this.script);
+    return this.givenAValue.has(binding.name) ? weaken(BAR_ZERO) : binding.warmup;
+  }
+
   warmupOf(expression: Expression): Warmup {
     return this.warmups.get(expression) ?? BAR_ZERO;
   }
@@ -318,6 +341,20 @@ export class Checker {
     return closestName(written, this.namesInScope());
   }
 
+  /**
+   * OS2010's suggestion: the closest function, called with what was written.
+   *
+   * The catalogue documents the slot as the library function whose name is
+   * closest, with its first argument filled in, so `volume(20)` is offered a
+   * function over `volume` and the arguments the reader already wrote,
+   * rather than a name that cannot be called either.
+   */
+  callSuggestionFor(written: string, args: readonly string[]): string {
+    const inStrategy = this.declaration?.form === 'strategy';
+    const name = closestName(written, libraryFunctionNames(inStrategy));
+    return `${name}(${[written, ...args].join(', ')})`;
+  }
+
   /** A state region for one call site, `compiled-program.md` 2.11. */
   takeStateId(): number {
     const id = this.stateCount;

package/src/core/check/constant.ts

@@ -92,6 +92,63 @@ export function isCompileTimeConstant(checker: Checker, expression: Expression):
   }
 }
 
+/**
+ * Whether a constant reads a setting as part of something larger, OS3025.
+ *
+ * `compiled-program.md` 2.3 gives a field fixed before bar 0 two forms: the
+ * effective value, which the compiler folds, and `{ "input": "<key>" }`, one
+ * setting resolved at load. `precision = input(2, "Decimals") + 1` and
+ * `opacity = shade ? 1 : 0` are neither: the compiler cannot fold them, because
+ * the setting's value is not known until the host resolves it, and the program
+ * has no form for an expression evaluated at load. Nothing refused them, so the
+ * emitter met them with no way to write them and reported a defect in itself.
+ *
+ * `wholeOnly` is false for an input's own options: a default, a bound or a
+ * step is what the settings dialog shows before anybody has chosen, and a
+ * setting that took its default from another setting would have none to show.
+ */
+export function readsInputInPart(
+  checker: Checker,
+  expression: Expression,
+  wholeOnly: boolean,
+): boolean {
+  if (!readsInput(checker, expression)) return false;
+  return !wholeOnly || !isWholeInput(checker, expression);
+}
+
+/** Whether a setting is read anywhere inside the expression. */
+function readsInput(checker: Checker, expression: Expression): boolean {
+  if (isWholeInput(checker, expression)) return true;
+  const inner = withoutGrouping(expression);
+  switch (inner.kind) {
+    case 'arrayLiteral':
+      return inner.elements.some((element) => readsInput(checker, element));
+    case 'unary':
+      return readsInput(checker, inner.operand);
+    case 'binary':
+      return readsInput(checker, inner.left) || readsInput(checker, inner.right);
+    case 'ternary':
+      return (
+        readsInput(checker, inner.condition) ||
+        readsInput(checker, inner.whenTrue) ||
+        readsInput(checker, inner.whenFalse)
+      );
+    case 'call':
+      return inner.args.some((argument) => readsInput(checker, argument.value));
+    default:
+      return false;
+  }
+}
+
+/** One setting and nothing else: an `input()` call, or a name that holds one. */
+function isWholeInput(checker: Checker, expression: Expression): boolean {
+  const inner = withoutGrouping(expression);
+  if (inner.kind === 'call') return calleeName(inner.callee) === 'input';
+  if (inner.kind !== 'nameReference') return false;
+  const binding = checker.lookup(inner.name);
+  return binding !== undefined && inputHeldBy(binding) !== undefined;
+}
+
 /**
  * Whether the expression names one of the price series an `input` may default
  * to, `stdlib.md` 13.1.