openalgo-script 0.2.0 → 0.5.0

package/dist/core/backtest/compare.js

@@ -0,0 +1,191 @@
+import { canonicalise } from '../emit/index.js';
+/**
+ * A Summary field worth a delta, in the order a comparison reports them.
+ *
+ * Written out rather than walked off the object, for two reasons. A key walk
+ * would report a delta for `currency`, which is a string, and for `capital`,
+ * which is an input rather than a result. And the order a comparison prints its
+ * rows in would then be the order a literal happens to be written in, which is
+ * a thing somebody reformats without knowing they changed an output.
+ */
+const COMPARED = [
+    'netProfit',
+    'returnPercent',
+    'grossProfit',
+    'grossLoss',
+    'charges',
+    'tradeCount',
+    'openTradeCount',
+    'wins',
+    'losses',
+    'scratches',
+    'winRate',
+    'averageWin',
+    'averageLoss',
+    'expectancy',
+    'expectancyStandardError',
+    'profitFactor',
+    'maxDrawdown',
+    'maxDrawdownPercent',
+    'longestDrawdownBars',
+    'maxRunUp',
+    'maxRunUpPercent',
+    'averageBarsHeld',
+    'barsInMarket',
+    'barCount',
+];
+/**
+ * Two runs, side by side, and whether the gap between them is a result.
+ *
+ * **Comparable is about the inputs, not about the outputs.** Two runs over
+ * different bars, or on different contracts, are two studies: the money in one
+ * is not the money in the other, and subtracting them is arithmetic with no
+ * meaning behind it. A different program over the same bars is the opposite of
+ * that. It is the comparison somebody actually wants, so a differing program is
+ * reported as a difference and does not make the pair incomparable.
+ *
+ * **Every difference is named even when the pair is comparable**, because the
+ * reason a run improved is as often a setting somebody forgot they had changed
+ * as it is the change they meant to test. A comparison reporting only the money
+ * would let that through, and it would read as a result.
+ */
+export function compareRuns(before, after) {
+    const differences = differencesBetween(before, after);
+    const blocking = differences.some((one) => one.what === 'bars' || one.what === 'contract');
+    return {
+        comparable: !blocking,
+        differences,
+        deltas: deltasBetween(before.report.summary, after.report.summary),
+        // Withheld rather than computed on an incomparable pair. A separation
+        // between two runs over different bars is a number, and it means nothing.
+        separation: blocking ? null : separationBetween(before.report.summary, after.report.summary),
+        sharedTrades: sharedTradesBetween(before.report.trades, after.report.trades),
+    };
+}
+/**
+ * What differs between two runs' inputs, in a fixed order.
+ *
+ * Compared through the repository's one canonical writer rather than field by
+ * field, so a settings shape that grows a field is compared on that field
+ * without this function being edited. Field by field is how a comparison
+ * quietly stops covering whatever was added to the settings last.
+ */
+function differencesBetween(before, after) {
+    const found = [];
+    if (before.bars.hash !== after.bars.hash) {
+        found.push({
+            what: 'bars',
+            detail: `different bars: ${before.bars.count} rows hashing ${before.bars.hash}, against ${after.bars.count} hashing ${after.bars.hash}`,
+        });
+    }
+    if (canonicalise(before.settings.contract) !== canonicalise(after.settings.contract)) {
+        found.push({ what: 'contract', detail: 'the two runs are on different contracts' });
+    }
+    if (before.programHash !== after.programHash) {
+        found.push({
+            what: 'program',
+            detail: `different program: ${before.programHash}, against ${after.programHash}`,
+        });
+    }
+    if (canonicalise(before.settings.range) !== canonicalise(after.settings.range)) {
+        found.push({ what: 'range', detail: 'the two runs cover different date ranges' });
+    }
+    if (canonicalise(before.settings.costs) !== canonicalise(after.settings.costs)) {
+        found.push({ what: 'costs', detail: 'the two runs were charged under different cost models' });
+    }
+    if (canonicalise(before.settings.fill) !== canonicalise(after.settings.fill)) {
+        found.push({ what: 'fill', detail: 'the two runs were filled under different policies' });
+    }
+    if (canonicalise(before.settings.inputs) !== canonicalise(after.settings.inputs)) {
+        found.push({ what: 'inputs', detail: 'the two scripts ran with different input values' });
+    }
+    return found;
+}
+/**
+ * Every compared figure, before and after.
+ *
+ * A summary carries null where a figure has no meaning: no win rate until a
+ * trade closes, no profit factor without a loss. Null on one side and a number
+ * on the other is a real thing to report, and a delta between them is not, so
+ * the row appears with both values and a delta of zero. Subtracting from null
+ * would invent a movement out of a figure that was never there.
+ */
+function deltasBetween(before, after) {
+    // Widened once, here. COMPARED is a list of names and a summary is a closed
+    // shape, so the lookup is by string either way; doing it in one place keeps
+    // the rest of this file reading the real type.
+    const a0 = before;
+    const b0 = after;
+    const deltas = [];
+    for (const name of COMPARED) {
+        const a = numberOf(a0[name]);
+        const b = numberOf(b0[name]);
+        // Neither side holds a figure: a field of no summary, which is nothing to
+        // report rather than a row of three zeroes.
+        if (a === null && b === null)
+            continue;
+        deltas.push({
+            name,
+            before: a ?? 0,
+            after: b ?? 0,
+            delta: a === null || b === null ? 0 : (b ?? 0) - (a ?? 0),
+        });
+    }
+    return deltas;
+}
+/** A figure, or none where the summary carries null or a string for it. */
+function numberOf(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+/**
+ * How many standard errors apart the two expectancies are.
+ *
+ * Analytic, with no resampling and no random number generator, so two runs of
+ * this comparison over the same pair give the same figure for ever and a
+ * decision taken on it is one anybody can reproduce.
+ *
+ * **Null rather than a large number where there is no noise to measure.** A run
+ * with fewer than two closed trades has a standard error of zero, because one
+ * trade has no spread, and where both are zero the ratio divides by it.
+ * Returning infinity there would read as infinite confidence, which is the
+ * exact opposite of what one trade tells anybody. Null says the question cannot
+ * be answered from these two runs, which is the truth about them.
+ */
+function separationBetween(before, after) {
+    const noise = Math.sqrt(before.expectancyStandardError * before.expectancyStandardError +
+        after.expectancyStandardError * after.expectancyStandardError);
+    if (!Number.isFinite(noise) || noise === 0)
+        return null;
+    const gap = after.expectancy - before.expectancy;
+    return Number.isFinite(gap) ? gap / noise : null;
+}
+/**
+ * How many trades the two runs took alike.
+ *
+ * Alike means opened on the same bar on the same side, which is the coarsest
+ * thing two runs can agree about and the only one that survives a change to
+ * sizing or to costs. It is what says whether a change moved the money by
+ * trading differently or by trading the same and paying differently, and those
+ * are not the same result however alike the two totals look.
+ *
+ * Counted as a multiset, so two long trades opening on one bar in one run
+ * against one in the other share one trade rather than two.
+ */
+function sharedTradesBetween(before, after) {
+    const counts = new Map();
+    for (const trade of before) {
+        const key = `${trade.openedOnBar}:${trade.side}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    let shared = 0;
+    for (const trade of after) {
+        const key = `${trade.openedOnBar}:${trade.side}`;
+        const left = counts.get(key) ?? 0;
+        if (left > 0) {
+            counts.set(key, left - 1);
+            shared += 1;
+        }
+    }
+    return shared;
+}
+//# sourceMappingURL=compare.js.map

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

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

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

@@ -0,0 +1,52 @@
+/**
+ * The declaration's own half of a run, read once and read here.
+ *
+ * **What the program states is stored once, as the program**, so none of these
+ * figures is a setting a host chooses and none of them travels in the record
+ * beside the settings. They are read back out of the compiled program every
+ * time a run is driven or replayed, which is what makes a replay of a stored
+ * record the same run rather than a run under today's defaults.
+ *
+ * Every field of `meta.strategy` is written into the program with the value it
+ * resolved to, defaults included (`compiled-program.md` 2.3), so nothing here
+ * carries a table of defaults and a default that changes in a later language
+ * version cannot silently change an old program. A field a script wrote with an
+ * `input()` is resolved against the run's own settings, by the engine, at load,
+ * and `fieldValue` reads what that resolution produced: the rule lives in the
+ * engine and is applied here rather than repeated.
+ *
+ * A study has no strategy declaration at all. It places no order and has no
+ * money, and it reads here as the absence it is rather than as a zero capital
+ * somebody would divide by.
+ */
+import type { CompiledProgram } from '../emit/index.js';
+import type { ResolvedInput } from '../engine/index.js';
+/** The money and the fill the declaration fixed before bar 0. */
+export interface RunDeclaration {
+    /** False for a study, which declares none of this. */
+    readonly isStrategy: boolean;
+    readonly capital: number;
+    readonly currency: string;
+    /** Where a market order is priced, `language.md` 13.3. */
+    readonly fillOn: string;
+    readonly slippage: number;
+    readonly commission: number;
+    readonly commissionType: string;
+    /**
+     * The unit the declaration's quantity is stated in, `language.md` 13.3.
+     *
+     * Read here because the destination is the party that has to convert it, and
+     * a destination that cannot convert the unit a strategy sizes in has to
+     * refuse the run rather than fill a number in the wrong unit.
+     */
+    readonly qtyType: string;
+}
+/**
+ * What one program's declaration says about money, after its inputs.
+ *
+ * The inputs are the ones the engine resolved at load, handed back by `load`
+ * for this reader. A caller with none reads the literals, which is every
+ * program that did not write a declaration field with an `input()`.
+ */
+export declare function declarationOf(program: CompiledProgram, inputs?: readonly ResolvedInput[]): RunDeclaration;
+//# sourceMappingURL=declaration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/declaration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,aAAa,EAAS,MAAM,oBAAoB,CAAC;AAE/D,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,eAAe,EACxB,MAAM,GAAE,SAAS,aAAa,EAAO,GACpC,cAAc,CAwBhB"}

package/dist/core/backtest/declaration.js

@@ -0,0 +1,48 @@
+import { fieldValue } from '../engine/index.js';
+/**
+ * What one program's declaration says about money, after its inputs.
+ *
+ * The inputs are the ones the engine resolved at load, handed back by `load`
+ * for this reader. A caller with none reads the literals, which is every
+ * program that did not write a declaration field with an `input()`.
+ */
+export function declarationOf(program, inputs = []) {
+    const strategy = program.meta.strategy;
+    if (strategy === undefined) {
+        return {
+            isStrategy: false,
+            capital: 0,
+            currency: '',
+            fillOn: '',
+            slippage: 0,
+            commission: 0,
+            commissionType: '',
+            qtyType: '',
+        };
+    }
+    return {
+        isStrategy: true,
+        capital: numberOf(fieldValue(strategy.capital, inputs)),
+        currency: stringOf(fieldValue(strategy.currency, inputs)),
+        fillOn: stringOf(fieldValue(strategy.fillOn, inputs)),
+        slippage: numberOf(fieldValue(strategy.slippage, inputs)),
+        commission: numberOf(fieldValue(strategy.commission, inputs)),
+        commissionType: stringOf(fieldValue(strategy.commissionType, inputs)),
+        qtyType: stringOf(fieldValue(strategy.qtyType, inputs)),
+    };
+}
+/**
+ * A number the declaration states, or zero where it states something else.
+ *
+ * Zero rather than absence, and only here: every one of these fields is written
+ * into the program with a number, so anything else is a program this engine
+ * would already have refused at load. The fallback is what keeps this reader
+ * total rather than a second place a malformed program is diagnosed.
+ */
+function numberOf(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function stringOf(value) {
+    return typeof value === 'string' ? value : '';
+}
+//# sourceMappingURL=declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.js","sourceRoot":"","sources":["../../../src/core/backtest/declaration.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAwBhD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAwB,EACxB,SAAmC,EAAE;IAErC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;IACvC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO;YACL,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,CAAC;YACV,QAAQ,EAAE,EAAE;YACZ,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,CAAC;YACX,UAAU,EAAE,CAAC;YACb,cAAc,EAAE,EAAE;YAClB,OAAO,EAAE,EAAE;SACZ,CAAC;IACJ,CAAC;IACD,OAAO;QACL,UAAU,EAAE,IAAI;QAChB,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvD,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACzD,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrD,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACzD,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAC7D,cAAc,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QACrE,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;KACxD,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,QAAQ,CAAC,KAAY;IAC5B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,QAAQ,CAAC,KAAY;IAC5B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAChD,CAAC"}

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

@@ -0,0 +1,93 @@
+/**
+ * A case's rows and this engine's frames, and the destination between them.
+ *
+ * Both directions are here because they are one correspondence: a case names an
+ * order by an ordinal and an engine knows it by an id, so `Delivery` reads an
+ * ordinal into the id of the intent the run placed, and `framedAs` writes an id
+ * back out as the ordinal a case file prints. Split between two files, the two
+ * halves of it drift, and a suite whose rows say one thing and whose records
+ * say another is one nobody can read.
+ *
+ * `conformance.md` section 3: `frames.csv` supplies order frames the way
+ * `bars.csv` supplies bars, so a strategy case asserts the fold against input
+ * the engine did not choose. `simulate.ts` is the other destination this module
+ * has, the one that reads a bar and works out what a venue would have said.
+ * This one works nothing out. It holds the rows a case supplied, hands over the
+ * ones each boundary names, and the whole of its behaviour is the mapping
+ * between a row and a frame.
+ *
+ * **An ordinal is what a case can name, and an id is not.** A row names the nth
+ * intent the run placed, because no case can know the id an engine minted, so
+ * the intents are counted here in the order the run handed them over and the
+ * ordinal is read against that count. A row naming an ordinal the run never
+ * placed is delivered all the same, carrying an id no run mints: step 1 of
+ * `stdlib.md` 17.8 refuses a frame naming no row of the ledger, and that
+ * refusal is the ledger's to make. A destination that dropped the row instead
+ * would answer nothing at all where section 3 hands an engine a frame about an
+ * order its ledger does not hold, and the case would pass by the frame never
+ * having arrived.
+ *
+ * **What a row does not carry, this does not invent.** `host-interface.md` 7.2
+ * lets a frame say which instrument and product the destination booked the
+ * order under, and the file has no column for either, so neither is stated and
+ * the row keeps what its placement put there. The instant is the one the file
+ * does carry: a row states one or states `none`, and one that states none
+ * leaves `updatedAt` where the placement put it, which is what the fold does
+ * with a frame whose destination stated no instant.
+ */
+import type { OrderFrame, OrderIntent, RoutedEffect } from '../engine/index.js';
+import type { RecordedFrame } from './record.js';
+/** One frame, the boundary it was handed over at, and the row it came from. */
+export interface Delivered {
+    readonly frame: OrderFrame;
+    readonly afterBar: number;
+    /**
+     * The row a case supplied, or null where the run's own destination answered
+     * the frame and there is no row until the record is written.
+     */
+    readonly row: RecordedFrame | null;
+}
+/** Where a run's orders go, and what it is told between two of its bars. */
+export interface Destination {
+    /** Step 9: what the strategy decided, on the bar it decided it. */
+    route(effect: RoutedEffect, barIndex: number): void;
+    /** What this destination hands over at the boundary after `barIndex`. */
+    answers(barIndex: number): readonly Delivered[];
+    /** Every intent it was handed, in the order it was handed them. */
+    readonly intents: readonly OrderIntent[];
+}
+/**
+ * A destination holding one case's frames, ready at the boundaries they name.
+ *
+ * Built before the run rather than during it, because the rows are input: what
+ * a boundary hands over was decided by whoever wrote the case and not by
+ * anything this run does. The one thing it learns as the run goes is which
+ * intent an ordinal names, which only the run can say.
+ */
+export declare class Delivery implements Destination {
+    readonly intents: OrderIntent[];
+    /** The rows of each boundary, in file order, which section 3 fixes as the delivery order. */
+    private readonly rows;
+    constructor(frames: readonly RecordedFrame[]);
+    /** Nothing is decided by an order arriving here: it is counted, and that is all. */
+    route(effect: RoutedEffect): void;
+    answers(barIndex: number): readonly Delivered[];
+}
+/**
+ * The ordinal of every intent, which is how a case names one.
+ *
+ * One, two, three in the order the run placed them, because no engine can know
+ * the id another minted and a case that named one would only ever be readable
+ * by the engine that wrote it.
+ */
+export declare function ordinalsOf(intents: readonly OrderIntent[]): ReadonlyMap<number, number>;
+/**
+ * One delivered frame, in the columns a case file prints.
+ *
+ * The instant travels with it. `stdlib.md` 17.7 folds `updatedAt` from a
+ * frame's `time`, so a driver that dropped the field here wrote a record whose
+ * ledger no engine could fold from the record's own frames: it would have
+ * nothing to move that field to and would leave it at `placedAt`.
+ */
+export declare function framedAs(frame: OrderFrame, afterBar: number, ordinals: ReadonlyMap<number, number>): RecordedFrame;
+//# sourceMappingURL=deliver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/deliver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,+EAA+E;AAC/E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAAC;CACpC;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,mEAAmE;IACnE,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACpD,yEAAyE;IACzE,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAAC;IAChD,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C;AAcD;;;;;;;GAOG;AACH,qBAAa,QAAS,YAAW,WAAW;IAC1C,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAM;IACrC,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsC;gBAE/C,MAAM,EAAE,SAAS,aAAa,EAAE;IAQ5C,oFAAoF;IACpF,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIjC,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE;CAQhD;AAeD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAMvF;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,aAAa,CAWf"}

package/dist/core/backtest/deliver.js

@@ -0,0 +1,94 @@
+/**
+ * An id no run mints, which a row naming no intent of this run is delivered
+ * under.
+ *
+ * Ids are counted from one by the ledger that mints them, so nothing below one
+ * can name a row and the fold refuses the frame by the rule it refuses every
+ * other unknown one by. The alternative was an id of a real row chosen by some
+ * rule of this file's own, which would fold a case's frame into whichever order
+ * happened to be near it.
+ */
+const NO_INTENT = -1;
+/**
+ * A destination holding one case's frames, ready at the boundaries they name.
+ *
+ * Built before the run rather than during it, because the rows are input: what
+ * a boundary hands over was decided by whoever wrote the case and not by
+ * anything this run does. The one thing it learns as the run goes is which
+ * intent an ordinal names, which only the run can say.
+ */
+export class Delivery {
+    intents = [];
+    /** The rows of each boundary, in file order, which section 3 fixes as the delivery order. */
+    rows = new Map();
+    constructor(frames) {
+        for (const row of frames) {
+            const at = this.rows.get(row.afterBar);
+            if (at === undefined)
+                this.rows.set(row.afterBar, [row]);
+            else
+                at.push(row);
+        }
+    }
+    /** Nothing is decided by an order arriving here: it is counted, and that is all. */
+    route(effect) {
+        for (const intent of effect.intents)
+            this.intents.push(intent);
+    }
+    answers(barIndex) {
+        const due = this.rows.get(barIndex) ?? [];
+        return due.map((row) => ({
+            frame: frameOf(row, this.intents[row.intent - 1]),
+            afterBar: barIndex,
+            row,
+        }));
+    }
+}
+/** One row of a case, as the frame `host-interface.md` 7.2 describes. */
+function frameOf(row, intent) {
+    return {
+        intentId: intent?.intentId ?? NO_INTENT,
+        status: row.status,
+        filledQty: row.filledQty,
+        avgFillPrice: row.avgFillPrice,
+        orderRef: row.orderRef,
+        text: row.text,
+        time: row.time,
+    };
+}
+/**
+ * The ordinal of every intent, which is how a case names one.
+ *
+ * One, two, three in the order the run placed them, because no engine can know
+ * the id another minted and a case that named one would only ever be readable
+ * by the engine that wrote it.
+ */
+export function ordinalsOf(intents) {
+    const out = new Map();
+    for (const intent of intents) {
+        if (!out.has(intent.intentId))
+            out.set(intent.intentId, out.size + 1);
+    }
+    return out;
+}
+/**
+ * One delivered frame, in the columns a case file prints.
+ *
+ * The instant travels with it. `stdlib.md` 17.7 folds `updatedAt` from a
+ * frame's `time`, so a driver that dropped the field here wrote a record whose
+ * ledger no engine could fold from the record's own frames: it would have
+ * nothing to move that field to and would leave it at `placedAt`.
+ */
+export function framedAs(frame, afterBar, ordinals) {
+    return {
+        afterBar,
+        intent: ordinals.get(frame.intentId) ?? 0,
+        status: frame.status,
+        filledQty: frame.filledQty,
+        avgFillPrice: frame.avgFillPrice ?? null,
+        orderRef: frame.orderRef ?? null,
+        text: frame.text ?? null,
+        time: frame.time ?? null,
+    };
+}
+//# sourceMappingURL=deliver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.js","sourceRoot":"","sources":["../../../src/core/backtest/deliver.ts"],"names":[],"mappings":"AA6DA;;;;;;;;;GASG;AACH,MAAM,SAAS,GAAG,CAAC,CAAC,CAAC;AAErB;;;;;;;GAOG;AACH,MAAM,OAAO,QAAQ;IACV,OAAO,GAAkB,EAAE,CAAC;IACrC,6FAA6F;IAC5E,IAAI,GAAG,IAAI,GAAG,EAA2B,CAAC;IAE3D,YAAY,MAAgC;QAC1C,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,EAAE,KAAK,SAAS;gBAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;;gBACpD,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,KAAK,CAAC,MAAoB;QACxB,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,CAAC,QAAgB;QACtB,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC1C,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YACvB,KAAK,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACjD,QAAQ,EAAE,QAAQ;YAClB,GAAG;SACJ,CAAC,CAAC,CAAC;IACN,CAAC;CACF;AAED,yEAAyE;AACzE,SAAS,OAAO,CAAC,GAAkB,EAAE,MAA+B;IAClE,OAAO;QACL,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,SAAS;QACvC,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,IAAI,EAAE,GAAG,CAAC,IAAI;KACf,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,OAA+B;IACxD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAiB,EACjB,QAAgB,EAChB,QAAqC;IAErC,OAAO;QACL,QAAQ;QACR,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;QACzC,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,IAAI;QACxC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;QAChC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI;QACxB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI;KACzB,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,87 @@
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { CompiledProgram } from '../emit/index.js';
+import type { Instrument } from '../engine/index.js';
+import type { RecordedBar, RecordedFrame, RunRecord } from './record.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: false;
+    readonly diagnostic: Diagnostic;
+};
+/**
+ * The facts of `host-interface.md` 4.1 that the contract does not hold.
+ *
+ * The contract already states six of the twelve, the ones the money is priced
+ * under, and a fact stated in two places is a fact that can disagree with
+ * itself: a tick size the engine rounds to and a different one the venue
+ * worsens a fill by is a run under two instruments. So the other six are
+ * stated here and the six the contract holds cannot be, which the compiler
+ * enforces rather than a check at run time.
+ */
+export type InstrumentFacts = Omit<Instrument, 'symbol' | 'exchange' | 'tickSize' | 'lotSize' | 'pointValue' | 'currency'>;
+/** The few choices a driver has that are not settings of the run itself. */
+export interface DriveOptions {
+    /** Whether the bars travel in the record. Inline is the conformance form. */
+    readonly form?: 'inline' | 'referenced';
+    /**
+     * What the host states about the instrument beside the contract, so the
+     * record it produces is a conformance case.
+     *
+     * A case holds `instrument.json`, which `conformance.md` section 2 says is
+     * the record of `host-interface.md` 4.1, and that page requires one fact of
+     * every host: `hasVolume`, because no derivation recovers it (4.2). The
+     * engine reads the record and does not refuse a run without it, so a caller
+     * that leaves this out gets a record that replays and reruns like any other
+     * and cannot become a case, exactly as one without `sourceText` cannot.
+     *
+     * A session stated without a timezone is refused at load, OS6012, by the
+     * same rule that refuses it for any host.
+     */
+    readonly instrument?: InstrumentFacts;
+    /**
+     * The script's own text, so the record it produces is a conformance case.
+     *
+     * A compiled program identifies its source and cannot reproduce it, and a
+     * case has to hold `script.os`. A caller holding only a program leaves this
+     * out and gets a record that replays and reruns like any other; the one
+     * thing it cannot do is be handed to somebody else's engine as a case.
+     *
+     * It is checked against the program's own source hash, so text from a
+     * different revision than the one that was compiled is refused rather than
+     * written into a case that could never make its own expected output.
+     */
+    readonly sourceText?: string;
+}
+/**
+ * One run against a simulated destination, from a compiled program to a record.
+ *
+ * The frames are the destination's own: it is handed the orders, it reads the
+ * bars, and what it answers is what the engine folds. A run whose frames
+ * somebody else is supplying is `backtestSupplied` below.
+ */
+export declare function backtest(program: CompiledProgram, bars: readonly RecordedBar[], settings: BacktestSettings, options?: DriveOptions): BacktestResult;
+/**
+ * One run over the frames somebody else supplied, which this engine does not
+ * choose and does not add to.
+ *
+ * `conformance.md` section 3 gives a case a `frames.csv` that supplies order
+ * frames the way `bars.csv` supplies bars, so that a case asserts the fold
+ * against input the engine did not choose. Every other argument is `backtest`'s
+ * and means there what it means here. A row is delivered at the boundary it
+ * names and folded before the next bar, and the record carries the rows it was
+ * handed rather than a second spelling of them.
+ *
+ * **Nothing is invented.** No fill is priced off a bar, no order rests and no
+ * schedule is read, so an order the frames say nothing about stays where its
+ * placement left it, which is what a case saying nothing about it means.
+ *
+ * **A record made here is a record of this run and not of a simulated one.**
+ * `rerun` puts a record's program back on a simulated destination, because a
+ * record does not say which of the two answered it, so a rerun of one of these
+ * reproduces it only where that destination would answer these same frames.
+ */
+export declare function backtestSupplied(program: CompiledProgram, bars: readonly RecordedBar[], settings: BacktestSettings, frames: readonly RecordedFrame[], options?: DriveOptions): BacktestResult;
+//# sourceMappingURL=drive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/drive.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAIV,UAAU,EAIX,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EACV,WAAW,EAEX,aAAa,EAEb,SAAS,EACV,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,qEAAqE;AACrE,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,UAAU,EACV,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,CAC3E,CAAC;AAEF,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IACxC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;IACtC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAiB,GACzB,cAAc,CAahB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,GAAE,YAAiB,GACzB,cAAc,CAEhB"}