openalgo-script 0.1.0-alpha.1 → 0.4.0

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

@@ -0,0 +1,62 @@
+/**
+ * One resting order against one bar: did it trade, and at what price.
+ *
+ * **A bar is four prices and no path.** Whether the high came before the low is
+ * not in the data, so every rule here is one that does not need to know, and
+ * the places where knowing would matter are decided against the strategy rather
+ * than guessed in its favour. That is the whole discipline of this file: a
+ * backtest that is generous about fills is a backtest that reports money the
+ * market never offered.
+ *
+ * Three rules, each with the case it exists for:
+ *
+ * - **Touched is not traded through.** A limit resting exactly at the low of a
+ *   bar may or may not have been filled: the print happened, somebody was
+ *   filled at that price, and whether it was this order depends on a queue no
+ *   bar records. The default is that it was not (`limitNeedsThrough`), and a
+ *   host that has decided otherwise for its own market says so in the policy.
+ * - **A gap fills at the open, not at the level.** A stop triggered by a bar
+ *   that opened beyond it was not filled at its trigger, and a backtest that
+ *   says it was is reporting the one price that was never available. The open
+ *   is the first price there was.
+ * - **A limit fills at its own price or better, and never worse.** Where the
+ *   bar opened already through a limit, the open is the better price and the
+ *   fill is there; a limit is never worsened by slippage, because a limit that
+ *   is worsened is not a limit.
+ *
+ * A stop limit is both, in one bar and in that order: the trigger has to be
+ * reached and the limit has to be traded through, and where only the trigger is
+ * reached the order becomes a resting limit and waits.
+ */
+import type { OrderSide, OrderType } from '../engine/index.js';
+import type { FillPolicy } from './settings.js';
+import type { RecordedBar } from './record.js';
+/** A resting order, as the venue holds one. */
+export interface RestingOrder {
+    readonly side: OrderSide;
+    readonly type: OrderType;
+    /** The price a limit may not be worse than, absent on a plain stop. */
+    readonly limit: number | null;
+    /** The price a stop is triggered at, absent on a plain limit. */
+    readonly trigger: number | null;
+}
+/** What one bar did to one resting order. */
+export type RestOutcome = {
+    readonly filled: false;
+    readonly triggered: boolean;
+} | {
+    readonly filled: true;
+    readonly price: number;
+    /** Whether the price is the bar's open, which is a gap through the level. */
+    readonly atOpen: boolean;
+    /** Whether slippage applies, which a limit never takes. */
+    readonly slips: boolean;
+};
+/**
+ * One order against one bar.
+ *
+ * A bar missing any of the four prices decides nothing: an incomplete bar is
+ * not evidence that a level was reached and it is not evidence that it was not.
+ */
+export declare function testResting(order: RestingOrder, bar: RecordedBar, policy: FillPolicy): RestOutcome;
+//# sourceMappingURL=resting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resting.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/resting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,+CAA+C;AAC/C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,6CAA6C;AAC7C,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GACvD;IACE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAIN;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,UAAU,GACjB,WAAW,CAwBb"}

package/dist/core/backtest/resting.js

@@ -0,0 +1,59 @@
+const NOTHING = { filled: false, triggered: false };
+/**
+ * One order against one bar.
+ *
+ * A bar missing any of the four prices decides nothing: an incomplete bar is
+ * not evidence that a level was reached and it is not evidence that it was not.
+ */
+export function testResting(order, bar, policy) {
+    const open = bar.open;
+    const high = bar.high;
+    const low = bar.low;
+    if (open === null || high === null || low === null || bar.close === null)
+        return NOTHING;
+    if (order.type === 'limit')
+        return limitAgainst(order, open, high, low, policy);
+    const trigger = order.trigger;
+    if (trigger === null)
+        return NOTHING;
+    const reached = order.side === 'buy' ? high >= trigger : low <= trigger;
+    if (!reached)
+        return NOTHING;
+    if (order.type === 'stop') {
+        const gapped = order.side === 'buy' ? open >= trigger : open <= trigger;
+        const price = gapped && policy.stopFillsAtOpenOnGap ? open : trigger;
+        return { filled: true, price, atOpen: gapped && policy.stopFillsAtOpenOnGap, slips: true };
+    }
+    // A stop limit that triggered is a limit for the rest of this bar. Where the
+    // limit is not traded through it keeps resting, and the caller is told the
+    // trigger was reached so that the order rests as a limit from here on.
+    const asLimit = limitAgainst(order, open, high, low, policy);
+    return asLimit.filled ? asLimit : { filled: false, triggered: true };
+}
+/**
+ * A limit against one bar.
+ *
+ * `limitNeedsThrough` is the difference between a strict comparison and a loose
+ * one, and it is the only knob in this file that changes a fill into no fill
+ * rather than one price into another.
+ */
+function limitAgainst(order, open, high, low, policy) {
+    const limit = order.limit;
+    if (limit === null)
+        return NOTHING;
+    if (order.side === 'buy') {
+        const traded = policy.limitNeedsThrough ? low < limit : low <= limit;
+        if (!traded)
+            return NOTHING;
+        // The open already below the limit is the better price, and it is the first
+        // price the bar had.
+        const gapped = open < limit;
+        return { filled: true, price: gapped ? open : limit, atOpen: gapped, slips: false };
+    }
+    const traded = policy.limitNeedsThrough ? high > limit : high >= limit;
+    if (!traded)
+        return NOTHING;
+    const gapped = open > limit;
+    return { filled: true, price: gapped ? open : limit, atOpen: gapped, slips: false };
+}
+//# sourceMappingURL=resting.js.map

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

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

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

@@ -0,0 +1,117 @@
+import type { ChargeSchedule, Contract } from '../accounting/index.js';
+import type { Diagnostic } from '../diagnostics/index.js';
+import type { Value } from '../engine/index.js';
+import type { RunDeclaration } from './declaration.js';
+/** The window of the supplied bars a report is about. */
+export interface DateRange {
+    /** Inclusive, UTC ms; null means the first bar supplied. */
+    readonly from: number | null;
+    /** Inclusive; null means the last. */
+    readonly to: number | null;
+}
+/** How a resting order is decided against a bar, and who holds a level. */
+export interface FillPolicy {
+    /** A limit fills only when the bar traded through it. */
+    readonly limitNeedsThrough: boolean;
+    readonly stopFillsAtOpenOnGap: boolean;
+    /** Who holds a bracket's levels; 'destination' until 17.9 exists. */
+    readonly levels: 'destination' | 'engine';
+    /** This policy's own revision, so an old record replays as it ran. */
+    readonly version: number;
+}
+/**
+ * How closely two numbers have to agree, and why they are allowed not to.
+ *
+ * Exact by default. A bound that is not zero without a reason beside it is
+ * refused, because a tolerance with no reason is a failed comparison somebody
+ * turned off. The reason a tolerance exists at all is a second implementation,
+ * never this one's own re-run: a rerun of the same record on this engine is
+ * bit-identical or it is a defect.
+ */
+export interface Tolerance {
+    readonly abs: number;
+    readonly rel: number;
+    /** Required whenever either bound is non-zero. */
+    readonly reason: string | null;
+}
+/** Everything the host decided about one run. */
+export interface BacktestSettings {
+    readonly range: DateRange;
+    readonly contract: Contract;
+    /** Null derives one from the declaration. */
+    readonly costs: ChargeSchedule | null;
+    readonly fill: FillPolicy;
+    readonly inputs: Readonly<Record<string, Value>>;
+    readonly now: number | null;
+    readonly tolerance: Tolerance;
+}
+/**
+ * How a resting order is decided when the host states nothing.
+ *
+ * Conservative on both counts, because a backtest that is wrong is wrong in the
+ * strategy's favour by default: a limit is only filled where the bar traded
+ * through it, so an order resting exactly at the extreme of a bar is not
+ * credited with a fill nobody can prove happened, and a stop that gapped is
+ * filled at the open rather than at its trigger, which is the price a trader
+ * would actually have been given.
+ *
+ * `levels` is `destination` because there is nowhere else for it to be: a
+ * bracket reaches a destination as a protective instruction attached to a tag
+ * and the engine holds no level of its own. The other spelling exists so that a
+ * record made today says which of the two it ran under.
+ *
+ * `version` is this policy's own revision. It travels in the record so that a
+ * run stored before the rules changed replays as it ran rather than being
+ * quietly re-decided under today's.
+ */
+export declare const DEFAULT_FILL: FillPolicy;
+/** Exact, which is what a comparison is until somebody writes down why it is not. */
+export declare const EXACT: Tolerance;
+/** The whole window of whatever bars were supplied. */
+export declare const WHOLE_RANGE: DateRange;
+/**
+ * The settings a run takes when the host states only the contract.
+ *
+ * Every default here is the absence of a choice rather than a choice made on
+ * the host's behalf: the whole of the bars supplied, no schedule, exact
+ * comparison, no inputs overridden and no clock. A host that wants any of it
+ * different says so, and what it said is what the record stores.
+ *
+ * **The contract is the first argument and cannot be in the second.** The
+ * second was `Partial<BacktestSettings>`, which names a `contract` field that
+ * this function then ignored in favour of the positional one: a caller passing
+ * a contract there silently got the other, and a test written that way passed
+ * while proving nothing. Excluding the field makes it a compiler error at the
+ * call rather than a wrong answer at the end of a run.
+ */
+export declare function settingsFor(contract: Contract, chosen?: Omit<Partial<BacktestSettings>, 'contract'>): BacktestSettings;
+/**
+ * What a run cannot be carried out under, before its first bar.
+ *
+ * Four questions, and every one of them is a figure nobody could explain
+ * afterwards rather than a tidiness rule:
+ *
+ * - **Two cost models at once**, OS6023. A supplied schedule and a declared
+ *   commission describe the same money. Applied together they charge it twice
+ *   and applied one at a time they charge whichever an engine preferred, which
+ *   is a rule nobody wrote down.
+ * - **A schedule that cannot be evaluated**, OS6021, which `scheduleProblem`
+ *   decides, because the schedule is the money layer's and the rule for it is
+ *   written once, there. **Whichever schedule the run will be charged under**,
+ *   which is the declaration's own when the host supplied none: asking only
+ *   about a supplied one left every refusal in the money layer unreachable on
+ *   the path almost every run takes.
+ * - **A quantity in a unit this destination cannot fill**, OS6021. A backtest
+ *   fills in units and works out no running equity, so a quantity in cash or in
+ *   a percentage of equity is one it cannot convert, and a lot needs a lot size
+ *   the instrument may not state.
+ * - **A tolerance with a bound and no reason**, OS6021. A comparison allowed to
+ *   pass by a margin nobody justified is a failed comparison somebody switched
+ *   off, and the reason a tolerance exists at all is a second implementation:
+ *   a rerun of one record on this engine is bit-identical or it is a defect.
+ *
+ * Nothing has been computed when this is asked, so a refusal costs one run
+ * rather than a report a reader has to be told to distrust.
+ */
+export declare function checkSettings(settings: BacktestSettings, declared: RunDeclaration): Diagnostic | null;
+//# sourceMappingURL=settings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/settings.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAYvD,yDAAyD;AACzD,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,yDAAyD;IACzD,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ,CAAC;IAC1C,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,EAAE,UAK1B,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,KAAK,EAAE,SAA4C,CAAC;AAEjE,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,SAAoC,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,UAAU,CAAM,GACvD,gBAAgB,CAUlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,cAAc,GACvB,UAAU,GAAG,IAAI,CAuBnB"}

package/dist/core/backtest/settings.js

@@ -0,0 +1,207 @@
+/**
+ * What the host chose, which is the half of a run that is not the program.
+ *
+ * **The dividing rule, and everything in this module follows from it: the
+ * record stores what the host chose, and what the program states is stored
+ * once, as the program.** So there is no capital here, no slippage and no
+ * commission: the declaration states those and the declaration is in the
+ * record. A charge schedule the host supplied is here because the host supplied
+ * it; a schedule derived from the declaration is derived again on replay.
+ *
+ * **The fill policy carries its own version** precisely so that a record made
+ * before the policy changed replays as it ran, rather than being quietly re-run
+ * under today's rules and reported as the same study. A policy that could not
+ * say which revision it was would make every stored run a claim about whichever
+ * engine happened to read it last.
+ *
+ * `fillOn` is deliberately not here: it is the declaration's, and the
+ * declaration is the program.
+ *
+ * Two refusals live in this module when the behaviour lands. A setting the run
+ * cannot be carried out under is OS6021, and a supplied schedule beside a
+ * declared commission that is not the default is OS6023, because two cost
+ * models stated at once is a number nobody can explain afterwards.
+ */
+import { scheduleFromDeclaration, scheduleProblem } from '../accounting/index.js';
+import { diagnosticFor } from '../diagnostics/index.js';
+/**
+ * Where a refusal about a setting points.
+ *
+ * Nowhere in the script. A run setting is what the host stated before the first
+ * bar, and a caret under a line of the strategy would blame the one party that
+ * did not choose it. The money layer states the same position for the same
+ * reason.
+ */
+const NO_POSITION = { offset: 0, length: 0, line: 0, column: 0 };
+/**
+ * How a resting order is decided when the host states nothing.
+ *
+ * Conservative on both counts, because a backtest that is wrong is wrong in the
+ * strategy's favour by default: a limit is only filled where the bar traded
+ * through it, so an order resting exactly at the extreme of a bar is not
+ * credited with a fill nobody can prove happened, and a stop that gapped is
+ * filled at the open rather than at its trigger, which is the price a trader
+ * would actually have been given.
+ *
+ * `levels` is `destination` because there is nowhere else for it to be: a
+ * bracket reaches a destination as a protective instruction attached to a tag
+ * and the engine holds no level of its own. The other spelling exists so that a
+ * record made today says which of the two it ran under.
+ *
+ * `version` is this policy's own revision. It travels in the record so that a
+ * run stored before the rules changed replays as it ran rather than being
+ * quietly re-decided under today's.
+ */
+export const DEFAULT_FILL = {
+    limitNeedsThrough: true,
+    stopFillsAtOpenOnGap: true,
+    levels: 'destination',
+    version: 1,
+};
+/** Exact, which is what a comparison is until somebody writes down why it is not. */
+export const EXACT = { abs: 0, rel: 0, reason: null };
+/** The whole window of whatever bars were supplied. */
+export const WHOLE_RANGE = { from: null, to: null };
+/**
+ * The settings a run takes when the host states only the contract.
+ *
+ * Every default here is the absence of a choice rather than a choice made on
+ * the host's behalf: the whole of the bars supplied, no schedule, exact
+ * comparison, no inputs overridden and no clock. A host that wants any of it
+ * different says so, and what it said is what the record stores.
+ *
+ * **The contract is the first argument and cannot be in the second.** The
+ * second was `Partial<BacktestSettings>`, which names a `contract` field that
+ * this function then ignored in favour of the positional one: a caller passing
+ * a contract there silently got the other, and a test written that way passed
+ * while proving nothing. Excluding the field makes it a compiler error at the
+ * call rather than a wrong answer at the end of a run.
+ */
+export function settingsFor(contract, chosen = {}) {
+    return {
+        range: chosen.range ?? WHOLE_RANGE,
+        contract,
+        costs: chosen.costs ?? null,
+        fill: chosen.fill ?? DEFAULT_FILL,
+        inputs: chosen.inputs ?? {},
+        now: chosen.now ?? null,
+        tolerance: chosen.tolerance ?? EXACT,
+    };
+}
+/**
+ * What a run cannot be carried out under, before its first bar.
+ *
+ * Four questions, and every one of them is a figure nobody could explain
+ * afterwards rather than a tidiness rule:
+ *
+ * - **Two cost models at once**, OS6023. A supplied schedule and a declared
+ *   commission describe the same money. Applied together they charge it twice
+ *   and applied one at a time they charge whichever an engine preferred, which
+ *   is a rule nobody wrote down.
+ * - **A schedule that cannot be evaluated**, OS6021, which `scheduleProblem`
+ *   decides, because the schedule is the money layer's and the rule for it is
+ *   written once, there. **Whichever schedule the run will be charged under**,
+ *   which is the declaration's own when the host supplied none: asking only
+ *   about a supplied one left every refusal in the money layer unreachable on
+ *   the path almost every run takes.
+ * - **A quantity in a unit this destination cannot fill**, OS6021. A backtest
+ *   fills in units and works out no running equity, so a quantity in cash or in
+ *   a percentage of equity is one it cannot convert, and a lot needs a lot size
+ *   the instrument may not state.
+ * - **A tolerance with a bound and no reason**, OS6021. A comparison allowed to
+ *   pass by a margin nobody justified is a failed comparison somebody switched
+ *   off, and the reason a tolerance exists at all is a second implementation:
+ *   a rerun of one record on this engine is bit-identical or it is a defect.
+ *
+ * Nothing has been computed when this is asked, so a refusal costs one run
+ * rather than a report a reader has to be told to distrust.
+ */
+export function checkSettings(settings, declared) {
+    if (settings.costs !== null && declared.isStrategy && declared.commission !== 0) {
+        return diagnosticFor('OS6023', NO_POSITION, {
+            commission: declared.commission,
+            commissionType: declared.commissionType,
+        });
+    }
+    // Whichever schedule the run will actually be charged under, which is the
+    // declaration's own when the host supplied none. Guarding this on
+    // `settings.costs !== null` left every refusal in the money layer unreachable
+    // on the default path: a declared commission of -5 was charged as a credit
+    // and turned a loss into a gain, with nothing raised anywhere.
+    const schedule = settings.costs ?? scheduleForDeclaration(declared, settings.contract);
+    if (schedule !== null) {
+        const problem = scheduleProblem(schedule, settings.contract);
+        if (problem !== null)
+            return problem;
+    }
+    const sizing = sizingProblem(declared, settings.contract);
+    if (sizing !== null)
+        return sizing;
+    return toleranceProblem(settings.tolerance);
+}
+/** The schedule a run with no host schedule is charged under, or none. */
+function scheduleForDeclaration(declared, contract) {
+    if (!declared.isStrategy)
+        return null;
+    return scheduleFromDeclaration(declared.commission, declared.commissionType, declared.slippage, contract.currency, contract.digits);
+}
+/**
+ * Whether this destination can fill the unit the strategy sizes in.
+ *
+ * **A quantity is stated in the declaration's own unit and the destination is
+ * the party that converts it** (`host-interface.md` 7.1). This one filled every
+ * order at the number the script wrote, whatever unit it was written in, so a
+ * strategy sizing in lots on a lot of sixty five traded one sixty fifth of what
+ * it asked for and every money figure in the record was out by that factor,
+ * with nothing refused and nothing said. A record like that is worse than a
+ * refused run twice over: somebody trades on the number, and a second engine is
+ * handed it as a conformance case and taught the wrong quantity.
+ *
+ * So: units and lots are converted, and the two that need a running equity this
+ * destination does not hold are refused by name. A refusal costs one run. The
+ * alternative cost a whole report that looked right.
+ */
+function sizingProblem(declared, contract) {
+    if (!declared.isStrategy)
+        return null;
+    if (declared.qtyType === 'units' || declared.qtyType === '')
+        return null;
+    if (declared.qtyType === 'lots') {
+        if (contract.lotSize !== null && contract.lotSize > 0)
+            return null;
+        return diagnosticFor('OS6021', NO_POSITION, {
+            setting: 'A quantity stated in lots',
+            problem: 'this instrument states no lot size, so there is nothing to convert a lot into',
+        });
+    }
+    return diagnosticFor('OS6021', NO_POSITION, {
+        setting: 'A quantity stated in ' + declared.qtyType,
+        problem: 'a backtest fills in units and works out no running equity to size against, so it ' +
+            'cannot convert one. State the quantity in units or in lots',
+    });
+}
+/**
+ * A bound, and the reason it is there.
+ *
+ * Both bounds are checked rather than the first one found, because a tolerance
+ * carrying two bounds and one reason is two allowances and one justification.
+ */
+function toleranceProblem(tolerance) {
+    const stated = tolerance.reason !== null && tolerance.reason.trim() !== '';
+    const bounded = tolerance.abs !== 0 || tolerance.rel !== 0;
+    if (bounded && !stated) {
+        return diagnosticFor('OS6021', NO_POSITION, {
+            setting: 'The comparison tolerance',
+            problem: 'a bound of ' + String(tolerance.abs) + ' absolute and ' + String(tolerance.rel) +
+                ' relative is stated with no reason beside it',
+        });
+    }
+    if (tolerance.abs < 0 || tolerance.rel < 0) {
+        return diagnosticFor('OS6021', NO_POSITION, {
+            setting: 'The comparison tolerance',
+            problem: 'a bound below zero admits nothing and refuses what is exact',
+        });
+    }
+    return null;
+}
+//# sourceMappingURL=settings.js.map

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

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

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

@@ -0,0 +1,146 @@
+/**
+ * The destination a backtest runs against: intents in, frames out.
+ *
+ * **This is a host, not part of the engine**, and the division is the one thing
+ * to keep straight while reading it. `stdlib.md` 17.1 puts slippage and
+ * commission on the destination: the engine folds the price it is told and
+ * never adjusts one, so the price worsening below is a venue giving a worse
+ * fill, which is what a venue does, and not an engine moving a number, which is
+ * what the invariant forbids. Everything here could be a broker.
+ *
+ * **A frame is cumulative and reaches the engine between bars.** Every frame
+ * restates the whole life of one order from its beginning, so a repeat costs
+ * nothing, and none of them is handed over during an execution: they are
+ * answered here and collected at the boundary, which is where
+ * `host-interface.md` 7.4 puts the intake.
+ *
+ * **When a fill is known is not when it happened.** A market order decided at
+ * the close of a bar and filled at the next bar's open is known at that open,
+ * so its frame is delivered before that bar executes and the strategy holds the
+ * position for the whole of it. An order that rested and traded somewhere
+ * inside a bar is only known to have traded once that bar is complete, so its
+ * frame is delivered before the bar after it. Both are the truthful reading of
+ * what a venue could have told anybody at the time, and the difference between
+ * them is why they are not folded together.
+ *
+ * **A bracket is answered with nothing at all**, exactly as a venue with no
+ * order to report would answer. A bracket reaches a destination as a protective
+ * instruction attached to a tag and the engine appends no row for it, so there
+ * is nothing for a frame to be about: a fill reported against one would name an
+ * intent no row holds and the fold would refuse it. The row a bracket wants is
+ * decision 55 and it is not in this release, so a stop cannot fill here and a
+ * page that says it can is ahead of the engine.
+ */
+import type { Contract } from '../accounting/index.js';
+import type { OrderFrame, OrderIntent, RoutedEffect } from '../engine/index.js';
+import type { RecordedBar } from './record.js';
+import type { FillPolicy } from './settings.js';
+/** What the venue prices against and how it decides a fill. */
+export interface SimulatorOptions {
+    readonly bars: readonly RecordedBar[];
+    readonly contract: Contract;
+    readonly fill: FillPolicy;
+    /** Adverse always, in ticks, applied to a market fill and to a stop. */
+    readonly slippageTicks: number;
+    /** The declaration's own fill rule: where a market order is priced. */
+    readonly fillOn: string;
+    /**
+     * The unit the declaration's quantity is stated in, `language.md` 13.3.
+     *
+     * Here because converting it is the destination's job and a fill is counted
+     * in units. Only the units this destination can arrive at reach it: the rest
+     * are refused before the first bar by `checkSettings`.
+     */
+    readonly qtyType: string;
+}
+/**
+ * A venue, for one run.
+ *
+ * It holds the orders it was handed and nothing else: no position, no money and
+ * no view of what the strategy is doing, because a destination has none of
+ * those about somebody else's strategy.
+ */
+export declare class Simulator {
+    private readonly options;
+    private readonly orders;
+    /** The intents handed over, in the order they were, whatever became of them. */
+    readonly intents: OrderIntent[];
+    /** Brackets, held so that a run can say how many it was handed and answered. */
+    readonly brackets: OrderIntent[];
+    private queued;
+    private answered;
+    private refs;
+    private seq;
+    constructor(options: SimulatorOptions);
+    /** Step 9: what the strategy decided reaches the venue. */
+    route(effect: RoutedEffect, barIndex: number): void;
+    /**
+     * The frames a boundary hands over: everything this venue can say now.
+     *
+     * The orders that were already resting are decided against this bar first and
+     * the orders this bar sent are answered after, which is the order the venue
+     * learned of them in.
+     */
+    framesFor(barIndex: number): readonly OrderFrame[];
+    /** How many orders this venue is still holding, which a run reports. */
+    get working(): number;
+    /** An order the strategy sent, which this venue now holds. */
+    private accept;
+    /**
+     * A cancellation, which is about the orders a tag names and not about itself.
+     *
+     * Every live order carrying the tag is withdrawn and answered, which is what
+     * releases the position they were claiming, and the cancellation is then
+     * answered as an order of its own, because the engine appended a row for it
+     * and a row nothing ever answers stays at `placed` for the life of the run.
+     */
+    private withdraw;
+    /**
+     * The first thing a venue says about an order it has taken.
+     *
+     * A working frame before any fill, because 7.4 asks for a frame on every
+     * change of status and a script waiting for a working order to clear waits
+     * blind without one. A market order is then filled in the same breath where
+     * the declaration prices it at this bar's close, and at the next bar's open
+     * where it does not.
+     */
+    private open;
+    /** One resting order against one bar. */
+    private decide;
+    /**
+     * The whole of an order, filled at one price.
+     *
+     * **The quantity is converted into units here, because that is what a fill
+     * is counted in and what every money figure is folded over.** A quantity
+     * travels in the declaration's own unit (`host-interface.md` 7.1) and the
+     * destination is the party that converts it. This filled the number verbatim,
+     * so a strategy sizing in lots on a lot of sixty five traded one sixty fifth
+     * of what it asked for and the whole report was out by that factor. The units
+     * this destination cannot arrive at are refused before the first bar rather
+     * than guessed at here, so by this point the unit is one of two.
+     */
+    private complete;
+    /**
+     * A price worsened by the slippage the run was carried out under.
+     *
+     * **Adverse always: a buy pays more and a sell receives less.** The sign is
+     * taken as written rather than as a magnitude, because a slippage below zero
+     * is refused before the first bar and taking its magnitude here would be this
+     * function quietly covering for a hole in that refusal. It went uncovered for
+     * a while: `scheduleProblem` has always refused a negative rate, and
+     * `checkSettings` asked it only about a schedule the host supplied, so a
+     * declaration stating a slippage of minus one improved both sides of every
+     * fill and the backtest paid the strategy to trade.
+     *
+     * A slippage in ticks with no tick size to measure a tick in charges nothing.
+     * The comment here once said that was refused before the first bar and it was
+     * not; it still is not, because an instrument with no tick is a fact a host
+     * may legitimately not hold, and a run that charges no slippage is a study
+     * before slippage rather than a wrong answer. What has changed is that this
+     * says so instead of claiming a refusal that never existed.
+     */
+    private worsen;
+    /** One frame, cumulative, in the order this venue spoke. */
+    private say;
+}
+//# sourceMappingURL=simulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/simulate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAa,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAkBD;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAM;IACrC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,WAAW,EAAE,CAAM;IACtC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,GAAG,CAAK;gBAEJ,OAAO,EAAE,gBAAgB;IAIrC,2DAA2D;IAC3D,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAenD;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE;IAkBlD,wEAAwE;IACxE,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,8DAA8D;IAC9D,OAAO,CAAC,MAAM;IAed;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;IAYhB;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI;IAcZ,yCAAyC;IACzC,OAAO,CAAC,MAAM;IAYd;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,QAAQ;IAUhB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,MAAM;IAOd,4DAA4D;IAC5D,OAAO,CAAC,GAAG;CAsBZ"}