openalgo-script 0.2.0 → 0.4.0

package/dist/core/backtest/record.d.ts

@@ -0,0 +1,238 @@
+/**
+ * The run record: a whole run as a plain JSON document.
+ *
+ * **The record is the conformance case.** That is the one decision this module
+ * exists to hold, and everything in it follows from it: no object reference, no
+ * function, no dependence on this implementation's internals, and nothing that
+ * only this engine can read. A record carries the script revision, the compiled
+ * program, the bars, the settings the host chose, the frames the destination
+ * answered in delivery order, the fills the engine folded in fold order, the
+ * ledger the run ended with, the diagnostics and the report.
+ *
+ * **The bars are inline or referenced, and both carry the same hash.** Inline is
+ * the conformance form, because a case has to hold every byte of its own input.
+ * Referenced is the operational form, because the smallest deployment has a one
+ * megabyte request body and nothing that grows with history may travel in one.
+ * A replay whose bars do not hash to the record's hash is OS6022 rather than a
+ * silently different study.
+ *
+ * **The frames name an intent by ordinal and never by an engine's own id**,
+ * because a case cannot know what id another engine minted. The same reason the
+ * ledger rows here are flat words rather than this engine's own types.
+ *
+ * The record is written through the existing canonical encoding, so there is one
+ * canonical writer in the repository and key order and number form are fixed for
+ * everybody.
+ */
+import type { RecordedFill, Report } from '../accounting/index.js';
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { CompiledProgram, SourceStamp } from '../emit/index.js';
+import type { LedgerRow } from '../engine/index.js';
+import type { BacktestSettings } from './settings.js';
+/** One bar as a record holds it. */
+export interface RecordedBar {
+    readonly time: number | null;
+    readonly open: number | null;
+    readonly high: number | null;
+    readonly low: number | null;
+    readonly close: number | null;
+    readonly volume: number | null;
+    readonly oi: number | null;
+}
+/**
+ * The bars, held or pointed at.
+ *
+ * Both forms carry the same hash, computed the same way over the canonical
+ * tuple of each bar, so a referenced record can be turned into an inline one by
+ * whoever holds the bars and the result is the same case.
+ */
+export type BarsInRecord = {
+    readonly form: 'inline';
+    readonly hash: string;
+    readonly count: number;
+    readonly rows: readonly RecordedBar[];
+} | {
+    readonly form: 'referenced';
+    readonly hash: string;
+    readonly count: number;
+    readonly firstTime: number | null;
+    readonly lastTime: number | null;
+};
+/** The columns of `conformance.md`'s frames.csv, in its order and with its names. */
+export interface RecordedFrame {
+    readonly afterBar: number;
+    /** An ordinal, 1-based, never an engine's own id. */
+    readonly intent: number;
+    readonly status: string;
+    readonly filledQty: number;
+    readonly avgFillPrice: number | null;
+    readonly orderRef: string | null;
+    readonly text: string | null;
+}
+/** A ledger row of `stdlib.md` 17.7, flattened: the `orders` channel of expected.json. */
+export interface RecordedOrder {
+    readonly intent: number;
+    readonly orderRef: string;
+    readonly tag: string;
+    readonly leg: string;
+    readonly positionRef: number;
+    readonly symbol: string | null;
+    readonly exchange: string | null;
+    readonly product: string;
+    readonly side: string;
+    readonly qty: number | null;
+    readonly qtyType: string;
+    readonly type: string | null;
+    readonly price: number | null;
+    readonly trigger: number | null;
+    readonly status: string;
+    readonly filledQty: number;
+    readonly avgFillPrice: number | null;
+    readonly rejection: string | null;
+    readonly placedAt: number | null;
+    readonly updatedAt: number | null;
+    readonly units: number | null;
+}
+/** A diagnostic as a record holds it: the code, the span and the bar. */
+export interface RecordedDiagnostic {
+    readonly code: string;
+    readonly line: number;
+    readonly column: number;
+    readonly severity: string;
+    readonly barIndex: number | null;
+}
+/** One run, whole, and readable by an engine that is not this one. */
+export interface RunRecord {
+    readonly recordVersion: number;
+    readonly engine: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly languageVersion: string;
+    /** Already plain data. */
+    readonly program: CompiledProgram;
+    readonly programHash: string;
+    /** Hash, lines, file: the script revision. */
+    readonly source: SourceStamp;
+    readonly settings: BacktestSettings;
+    readonly bars: BarsInRecord;
+    /** What the destination answered, in delivery order. */
+    readonly frames: readonly RecordedFrame[];
+    /** What the engine folded, in fold order. */
+    readonly fills: readonly RecordedFill[];
+    /** The ledger at the end, oldest first. */
+    readonly orders: readonly RecordedOrder[];
+    readonly diagnostics: readonly RecordedDiagnostic[];
+    readonly report: Report;
+}
+/**
+ * The revision of this document's own shape.
+ *
+ * A reader is handed a record and has to know what it is looking at before it
+ * reads a field, so the number is first in the document and is written by this
+ * file alone. It moves when a channel is added or a meaning changes, never when
+ * a figure in a report does.
+ */
+export declare const RECORD_VERSION = 1;
+/** The parts a run hands over, each already in the shape the record holds. */
+export interface RecordParts {
+    readonly program: CompiledProgram;
+    readonly settings: BacktestSettings;
+    readonly bars: readonly RecordedBar[];
+    /**
+     * Whether the bars travel in the record or are pointed at.
+     *
+     * Inline is the conformance form, because a case holds every byte of its own
+     * input. Referenced is the operational form, because nothing that grows with
+     * history may travel in a request body. Both carry the same hash over the
+     * same canonical tuples, so one becomes the other without becoming a
+     * different case.
+     */
+    readonly form: 'inline' | 'referenced';
+    readonly frames: readonly RecordedFrame[];
+    readonly fills: readonly RecordedFill[];
+    readonly orders: readonly RecordedOrder[];
+    readonly diagnostics: readonly RecordedDiagnostic[];
+    readonly report: Report;
+}
+/**
+ * One run, as the document another engine is handed.
+ *
+ * Nothing is computed here. Every channel arrives folded, because what a record
+ * says has to be what the run did rather than what a second fold of the same
+ * inputs came to: a record that recomputed its own report would agree with
+ * itself whatever the engine had actually done.
+ */
+export declare function recordOf(parts: RecordParts): RunRecord;
+/**
+ * The bars, held or pointed at, and the same hash either way.
+ *
+ * The referenced form keeps the first and last times so that a reader can say
+ * which bars are wanted without holding them, and the count so that a set of
+ * the wrong length is known to be wrong before it is hashed.
+ */
+export declare function barsIn(bars: readonly RecordedBar[], form: 'inline' | 'referenced'): BarsInRecord;
+/**
+ * The hash a record names its bars by.
+ *
+ * Over the canonical tuple of each bar, in the order they were supplied, and
+ * through the canonical encoding the compiled program is hashed with, so there
+ * is one canonical writer in the repository rather than two that agree until
+ * one of them is changed. A tuple rather than an object, because the field
+ * order is then the specification's and not a sort's.
+ */
+export declare function barsHash(bars: readonly RecordedBar[]): string;
+/**
+ * The record as the bytes another engine reads.
+ *
+ * Through the canonical encoding, so key order is fixed, every number is in the
+ * shortest decimal form that reads back as itself, and two runs of the same
+ * record produce the same bytes on every machine. That is what makes the
+ * reproducibility test a byte comparison rather than a tour of the fields.
+ */
+export declare function recordToJson(record: RunRecord): string;
+/**
+ * The run, without who produced it.
+ *
+ * **`engine` is provenance, and provenance is not part of the run.** The claim
+ * a rerun makes is that the run is a function of the record, and that claim has
+ * to survive the engine it runs on being upgraded: a record stored under
+ * `0.3.0` and rerun under `0.4.0` produces the same trades, the same fills and
+ * the same money, and a document carrying the version stamp inside the bytes
+ * being compared says it does not.
+ *
+ * It was compared as whole bytes until the first version bump would have broken
+ * it, which is a test that passes for exactly as long as nothing changes and
+ * then fails for the one reason that is not a defect. So the stamp stays in the
+ * record, because knowing which engine wrote a run is worth keeping, and the
+ * comparison is made over everything else.
+ */
+export declare function runBytes(record: RunRecord): string;
+/**
+ * A record read back from those bytes.
+ *
+ * A parse and not a validation: what comes back is the document as it was
+ * written, and a document this engine did not write is the caller's to trust or
+ * not. The one thing asserted is the revision, because reading a later
+ * revision's fields under this one's rules is how a record silently becomes a
+ * different run.
+ */
+export declare function recordFromJson(text: string): RunRecord | null;
+/**
+ * One ledger row, flattened into the words a case file prints.
+ *
+ * The engine's own types do not cross: a second engine has its own, and a
+ * channel written in this one's would be a case only this one could read. The
+ * intent is an ordinal for the same reason, because no engine can know what id
+ * another minted.
+ *
+ * `qtyType` comes from the intent rather than from the row, because the unit a
+ * quantity is counted in is per order and not per leg: an order the engine
+ * sized itself is in units whatever the declaration counts in, and a row that
+ * printed the declaration's unit for it would state a quantity in a unit it was
+ * never measured in.
+ */
+export declare function orderIn(row: LedgerRow, intent: number, qtyType: string): RecordedOrder;
+/** One diagnostic, as a record holds it: the code, the span and the bar. */
+export declare function diagnosticIn(diagnostic: Diagnostic, barIndex: number | null): RecordedDiagnostic;
+//# sourceMappingURL=record.d.ts.map

package/dist/core/backtest/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/record.ts"],"names":[],"mappings":"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"}

package/dist/core/backtest/record.js

@@ -0,0 +1,176 @@
+import { canonicalise, programHash, sha256 } from '../emit/index.js';
+import { VERSION } from '../version/index.js';
+/**
+ * The revision of this document's own shape.
+ *
+ * A reader is handed a record and has to know what it is looking at before it
+ * reads a field, so the number is first in the document and is written by this
+ * file alone. It moves when a channel is added or a meaning changes, never when
+ * a figure in a report does.
+ */
+export const RECORD_VERSION = 1;
+/** What this engine calls itself in a record it wrote. */
+const ENGINE_NAME = 'openscript';
+/**
+ * One run, as the document another engine is handed.
+ *
+ * Nothing is computed here. Every channel arrives folded, because what a record
+ * says has to be what the run did rather than what a second fold of the same
+ * inputs came to: a record that recomputed its own report would agree with
+ * itself whatever the engine had actually done.
+ */
+export function recordOf(parts) {
+    return {
+        recordVersion: RECORD_VERSION,
+        engine: { name: ENGINE_NAME, version: VERSION },
+        languageVersion: String(parts.program.openscript.language),
+        program: parts.program,
+        programHash: programHash(parts.program),
+        source: parts.program.source,
+        settings: parts.settings,
+        bars: barsIn(parts.bars, parts.form),
+        frames: parts.frames,
+        fills: parts.fills,
+        orders: parts.orders,
+        diagnostics: parts.diagnostics,
+        report: parts.report,
+    };
+}
+/**
+ * The bars, held or pointed at, and the same hash either way.
+ *
+ * The referenced form keeps the first and last times so that a reader can say
+ * which bars are wanted without holding them, and the count so that a set of
+ * the wrong length is known to be wrong before it is hashed.
+ */
+export function barsIn(bars, form) {
+    const hash = barsHash(bars);
+    if (form === 'inline') {
+        return { form: 'inline', hash, count: bars.length, rows: bars };
+    }
+    return {
+        form: 'referenced',
+        hash,
+        count: bars.length,
+        firstTime: bars[0]?.time ?? null,
+        lastTime: bars[bars.length - 1]?.time ?? null,
+    };
+}
+/**
+ * The hash a record names its bars by.
+ *
+ * Over the canonical tuple of each bar, in the order they were supplied, and
+ * through the canonical encoding the compiled program is hashed with, so there
+ * is one canonical writer in the repository rather than two that agree until
+ * one of them is changed. A tuple rather than an object, because the field
+ * order is then the specification's and not a sort's.
+ */
+export function barsHash(bars) {
+    const tuples = bars.map((bar) => [
+        bar.time,
+        bar.open,
+        bar.high,
+        bar.low,
+        bar.close,
+        bar.volume,
+        bar.oi,
+    ]);
+    return 'sha256:' + sha256(canonicalise(tuples));
+}
+/**
+ * The record as the bytes another engine reads.
+ *
+ * Through the canonical encoding, so key order is fixed, every number is in the
+ * shortest decimal form that reads back as itself, and two runs of the same
+ * record produce the same bytes on every machine. That is what makes the
+ * reproducibility test a byte comparison rather than a tour of the fields.
+ */
+export function recordToJson(record) {
+    return canonicalise(record);
+}
+/**
+ * The run, without who produced it.
+ *
+ * **`engine` is provenance, and provenance is not part of the run.** The claim
+ * a rerun makes is that the run is a function of the record, and that claim has
+ * to survive the engine it runs on being upgraded: a record stored under
+ * `0.3.0` and rerun under `0.4.0` produces the same trades, the same fills and
+ * the same money, and a document carrying the version stamp inside the bytes
+ * being compared says it does not.
+ *
+ * It was compared as whole bytes until the first version bump would have broken
+ * it, which is a test that passes for exactly as long as nothing changes and
+ * then fails for the one reason that is not a defect. So the stamp stays in the
+ * record, because knowing which engine wrote a run is worth keeping, and the
+ * comparison is made over everything else.
+ */
+export function runBytes(record) {
+    const { engine: _engine, ...run } = record;
+    return canonicalise(run);
+}
+/**
+ * A record read back from those bytes.
+ *
+ * A parse and not a validation: what comes back is the document as it was
+ * written, and a document this engine did not write is the caller's to trust or
+ * not. The one thing asserted is the revision, because reading a later
+ * revision's fields under this one's rules is how a record silently becomes a
+ * different run.
+ */
+export function recordFromJson(text) {
+    const parsed = JSON.parse(text);
+    if (parsed === null || typeof parsed !== 'object')
+        return null;
+    const record = parsed;
+    return record.recordVersion === RECORD_VERSION ? record : null;
+}
+/**
+ * One ledger row, flattened into the words a case file prints.
+ *
+ * The engine's own types do not cross: a second engine has its own, and a
+ * channel written in this one's would be a case only this one could read. The
+ * intent is an ordinal for the same reason, because no engine can know what id
+ * another minted.
+ *
+ * `qtyType` comes from the intent rather than from the row, because the unit a
+ * quantity is counted in is per order and not per leg: an order the engine
+ * sized itself is in units whatever the declaration counts in, and a row that
+ * printed the declaration's unit for it would state a quantity in a unit it was
+ * never measured in.
+ */
+export function orderIn(row, intent, qtyType) {
+    return {
+        intent,
+        orderRef: row.orderRef,
+        tag: row.tag,
+        leg: row.leg,
+        positionRef: row.positionRef,
+        symbol: row.instrument.symbol,
+        exchange: row.instrument.exchange,
+        product: row.product,
+        side: row.side,
+        qty: row.qty,
+        qtyType,
+        type: row.type,
+        price: row.price,
+        trigger: row.trigger,
+        status: row.status,
+        filledQty: row.filledQty,
+        avgFillPrice: row.avgFillPrice,
+        rejection: row.rejection === '' ? null : row.rejection,
+        placedAt: row.placedAt,
+        updatedAt: row.updatedAt,
+        units: row.units,
+    };
+}
+/** One diagnostic, as a record holds it: the code, the span and the bar. */
+export function diagnosticIn(diagnostic, barIndex) {
+    return {
+        code: diagnostic.code,
+        line: diagnostic.span.line,
+        column: diagnostic.span.column,
+        severity: diagnostic.severity,
+        barIndex,
+    };
+}
+//# sourceMappingURL=record.js.map

package/dist/core/backtest/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","sourceRoot":"","sources":["../../../src/core/backtest/record.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAwG9C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC;AAEhC,0DAA0D;AAC1D,MAAM,WAAW,GAAG,YAAY,CAAC;AAwBjC;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAkB;IACzC,OAAO;QACL,aAAa,EAAE,cAAc;QAC7B,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE;QAC/C,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC;QAC1D,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC;QACvC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;QAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;QACpC,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,MAAM,EAAE,KAAK,CAAC,MAAM;KACrB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,IAA4B,EAAE,IAA6B;IAChF,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAClE,CAAC;IACD,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,IAAI;QACJ,KAAK,EAAE,IAAI,CAAC,MAAM;QAClB,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,IAAI;QAChC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,IAAI,IAAI,IAAI;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,IAA4B;IACnD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC;QAC/B,GAAG,CAAC,IAAI;QACR,GAAG,CAAC,IAAI;QACR,GAAG,CAAC,IAAI;QACR,GAAG,CAAC,GAAG;QACP,GAAG,CAAC,KAAK;QACT,GAAG,CAAC,MAAM;QACV,GAAG,CAAC,EAAE;KACP,CAAC,CAAC;IACH,OAAO,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,MAAiB;IAC5C,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAiB;IACxC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,GAAG,MAAM,CAAC;IAC3C,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC/D,MAAM,MAAM,GAAG,MAAmB,CAAC;IACnC,OAAO,MAAM,CAAC,aAAa,KAAK,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CAAC,GAAc,EAAE,MAAc,EAAE,OAAe;IACrE,OAAO;QACL,MAAM;QACN,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,GAAG,EAAE,GAAG,CAAC,GAAG;QACZ,GAAG,EAAE,GAAG,CAAC,GAAG;QACZ,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,MAAM;QAC7B,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,QAAQ;QACjC,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,GAAG,EAAE,GAAG,CAAC,GAAG;QACZ,OAAO;QACP,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,SAAS,EAAE,GAAG,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS;QACtD,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,KAAK,EAAE,GAAG,CAAC,KAAK;KACjB,CAAC;AACJ,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,YAAY,CAC1B,UAAsB,EACtB,QAAuB;IAEvB,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI;QAC1B,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,MAAM;QAC9B,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/core/backtest/replay.d.ts

@@ -0,0 +1,48 @@
+import type { Report } from '../accounting/index.js';
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { BacktestResult } from './drive.js';
+import type { RecordedBar, RunRecord } from './record.js';
+/** The report a record folds to, or why it could not be folded. */
+export type ReplayResult = {
+    readonly ok: true;
+    readonly report: Report;
+} | {
+    readonly ok: false;
+    readonly diagnostic: Diagnostic;
+};
+/**
+ * The record's own report, computed again from its own fills.
+ *
+ * The bars are the record's where it carries them and the caller's where it
+ * points at them, and either way they are hashed against what the record names
+ * before a figure is computed from them.
+ */
+export declare function replay(record: RunRecord, bars?: readonly RecordedBar[] | null): ReplayResult;
+/**
+ * The same run, executed again.
+ *
+ * Everything the run depended on is in the record: the program, the bars, the
+ * settings and the inputs. So a rerun takes no argument the record does not
+ * already hold, except the bars a referenced record points at rather than
+ * carries, and the record it produces is comparable with the original field for
+ * field and byte for byte.
+ */
+export declare function rerun(record: RunRecord, bars?: readonly RecordedBar[] | null): BacktestResult;
+type BarsResult = {
+    readonly ok: true;
+    readonly bars: readonly RecordedBar[];
+} | {
+    readonly ok: false;
+    readonly diagnostic: Diagnostic;
+};
+/**
+ * The bars a record was made from, proved to be those bars.
+ *
+ * A record carrying its own bars is still checked against any that are supplied
+ * beside them, because supplying a different set is exactly the mistake worth
+ * catching: the caller believes they are replaying this run and they are
+ * studying another one.
+ */
+export declare function barsOf(record: RunRecord, supplied: readonly RecordedBar[] | null): BarsResult;
+export {};
+//# sourceMappingURL=replay.d.ts.map

package/dist/core/backtest/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/replay.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAkB,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAKjD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D,mEAAmE;AACnE,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,SAAS,WAAW,EAAE,GAAG,IAAW,GAAG,YAAY,CAoBlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,SAAS,WAAW,EAAE,GAAG,IAAW,GAAG,cAAc,CAInG;AAED,KAAK,UAAU,GACX;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,GAC5D;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,GAAG,UAAU,CAY7F"}

package/dist/core/backtest/replay.js

@@ -0,0 +1,127 @@
+/**
+ * A stored run, reported again and run again.
+ *
+ * Two questions, and they are different questions, which is why they are two
+ * calls:
+ *
+ * - **`replay` asks whether the report is a function of the fills.** It folds
+ *   the money again from the record's own fills and its own bar closes, with no
+ *   bar executed and no order placed, and what comes back has to equal the
+ *   report the record carries. If it does not, the report was reading something
+ *   the engine happened to be holding rather than what the run settled, and
+ *   nobody could reproduce it from the document.
+ * - **`rerun` asks whether the engine still does what it did.** It executes the
+ *   record's program over the record's bars under the record's settings, and
+ *   the two records are compared as bytes. A rerun of one record on this engine
+ *   is bit-identical or it is a defect: the tolerance on the record is for a
+ *   second implementation and is never this one's excuse.
+ *
+ * **The bars are proved before either is attempted.** A record names the bars it
+ * was made from by a hash, and bars are revised: a feed corrects a print, a
+ * session is extended, a split is applied to history. A replay over revised bars
+ * reporting the original figures is the most convincing wrong answer this system
+ * can produce, so a set that does not hash to the record's is OS6022.
+ *
+ * **One engine call is made, and nothing is executed by it.** A declaration
+ * field may be written by an `input()`, and what an input resolved to is the
+ * engine's rule; asking it here rather than resolving a second time is what
+ * keeps the replayed capital and commission the ones the run used. No bar is
+ * appended, so no value is computed and no order is placed: the load is a
+ * question about the program, not a run of it.
+ */
+import { reportOf, scheduleFromDeclaration } from '../accounting/index.js';
+import { diagnosticFor } from '../diagnostics/index.js';
+import { load } from '../engine/index.js';
+import { backtest } from './drive.js';
+import { declarationOf } from './declaration.js';
+import { marksFor, windowFor } from './range.js';
+import { barsHash } from './record.js';
+/**
+ * The record's own report, computed again from its own fills.
+ *
+ * The bars are the record's where it carries them and the caller's where it
+ * points at them, and either way they are hashed against what the record names
+ * before a figure is computed from them.
+ */
+export function replay(record, bars = null) {
+    const held = barsOf(record, bars);
+    if (!held.ok)
+        return { ok: false, diagnostic: held.diagnostic };
+    const framed = windowFor(held.bars, record.settings.range);
+    if (!framed.ok)
+        return { ok: false, diagnostic: framed.diagnostic };
+    const declared = declarationIn(record);
+    if (!declared.ok)
+        return { ok: false, diagnostic: declared.diagnostic };
+    return {
+        ok: true,
+        report: reportOf(record.fills, marksFor(held.bars, framed.covered), scheduleIn(record, declared.declaration), record.settings.contract, declared.declaration.capital),
+    };
+}
+/**
+ * The same run, executed again.
+ *
+ * Everything the run depended on is in the record: the program, the bars, the
+ * settings and the inputs. So a rerun takes no argument the record does not
+ * already hold, except the bars a referenced record points at rather than
+ * carries, and the record it produces is comparable with the original field for
+ * field and byte for byte.
+ */
+export function rerun(record, bars = null) {
+    const held = barsOf(record, bars);
+    if (!held.ok)
+        return { ok: false, diagnostic: held.diagnostic };
+    return backtest(record.program, held.bars, record.settings, { form: record.bars.form });
+}
+/**
+ * The bars a record was made from, proved to be those bars.
+ *
+ * A record carrying its own bars is still checked against any that are supplied
+ * beside them, because supplying a different set is exactly the mistake worth
+ * catching: the caller believes they are replaying this run and they are
+ * studying another one.
+ */
+export function barsOf(record, supplied) {
+    if (supplied !== null) {
+        const hash = barsHash(supplied);
+        if (hash !== record.bars.hash)
+            return { ok: false, diagnostic: mismatch(hash, record) };
+        return { ok: true, bars: supplied };
+    }
+    if (record.bars.form === 'inline')
+        return { ok: true, bars: record.bars.rows };
+    // A referenced record points at bars it does not hold, so there is nothing to
+    // replay until whoever holds them supplies them. It is the same refusal as a
+    // wrong set, because the question it answers is the same one: are these the
+    // bars the record was made from.
+    return { ok: false, diagnostic: mismatch('no bars supplied', record) };
+}
+function mismatch(found, record) {
+    return diagnosticFor('OS6022', NO_POSITION, { found, expected: record.bars.hash });
+}
+/**
+ * What the record's own program declares, after the record's own inputs.
+ *
+ * The destination handed to the load is one that answers nothing, because
+ * nothing is placed: a strategy declares the orders capability and a host that
+ * did not offer it would be refused at load for a reason that has nothing to do
+ * with the record.
+ */
+function declarationIn(record) {
+    const loaded = load(record.program, {
+        settings: record.settings.inputs,
+        host: { route: () => undefined },
+    });
+    if (!loaded.ok)
+        return { ok: false, diagnostic: loaded.diagnostic };
+    return { ok: true, declaration: declarationOf(loaded.engine.program, loaded.inputs) };
+}
+/** The cost model the record was carried out under, derived where it was derived. */
+function scheduleIn(record, declared) {
+    if (record.settings.costs !== null)
+        return record.settings.costs;
+    return scheduleFromDeclaration(declared.commission, declared.commissionType, declared.slippage, record.settings.contract.currency, record.settings.contract.digits);
+}
+/** Where a refusal about a record points: nowhere in anybody's script. */
+const NO_POSITION = { offset: 0, length: 0, line: 0, column: 0 };
+//# sourceMappingURL=replay.js.map

package/dist/core/backtest/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","sourceRoot":"","sources":["../../../src/core/backtest/replay.ts"],"names":[],"mappings":"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"}