openalgo-script 0.2.0 → 0.4.0

package/dist/core/accounting/equity.js

@@ -0,0 +1,155 @@
+/**
+ * Whether this trade was still held at the close of this bar.
+ *
+ * The boundaries are the whole of the rule and both are decisions. A trade is
+ * held from the close of the bar it opened on, because an entry that settled
+ * during a bar is a position that bar ended holding. It is not held at the
+ * close of the bar it closed on, because that bar ended flat. So a trade
+ * opened and closed inside one bar is held at no close at all, which is what a
+ * run that was flat at every mark should report.
+ *
+ * Every figure in this module that asks which trades are open asks it here, so
+ * the curve, the exposure and the count of bars in the market cannot come to
+ * three different answers about one bar.
+ */
+export function openOnBar(trade, barIndex) {
+    if (barIndex < trade.openedOnBar)
+        return false;
+    return trade.closedOnBar === null || barIndex < trade.closedOnBar;
+}
+/**
+ * A ratio against a basis that may not be there to divide by.
+ *
+ * Capital of zero and a peak of zero are both reachable, and both turn an
+ * honest division into a value JSON cannot carry: a report whose worst figure
+ * comes back `null` from a round trip is worse than one that says zero. A basis
+ * that is not positive has no ratio to state, so the figure beside it, which is
+ * money and is always true, is the one a reader is left with.
+ */
+export function ratioOf(value, basis) {
+    return basis > 0 ? value / basis : 0;
+}
+/**
+ * The curve, one point per report bar, in the order the bars arrived.
+ *
+ * Warmup bars are swept and not reported: their orders were real, so a trade
+ * opened during the warmup is already in the fold at the first point, with its
+ * charges already paid and its position already marked. A curve that began its
+ * fold at the first report bar would lose both, and would lose them silently.
+ *
+ * The running peak starts at the capital rather than at the first point, so a
+ * run that is down from its first bar is in drawdown at its first bar. Starting
+ * it at the first point would report every run as having begun at its high.
+ */
+export function equityOver(trades, marks, contract, capital) {
+    const points = [];
+    let held = [];
+    let next = 0;
+    let realised = 0;
+    let charges = 0;
+    let peak = capital;
+    let mark = null;
+    for (const bar of marks) {
+        // Opened by this bar, charges and all. The pointer is why the trades have
+        // to arrive in the order they opened.
+        while (next < trades.length) {
+            const opening = trades[next];
+            if (opening === undefined || opening.openedOnBar > bar.barIndex)
+                break;
+            charges += opening.charges;
+            held.push(opening);
+            next += 1;
+        }
+        // Closed by this bar, gross and all. A trade that opened and closed inside
+        // one bar is taken on and given up here in that order, so its cost and its
+        // gross are both in this point and its position is in none.
+        let closedHere = false;
+        for (const trade of held) {
+            if (closedBy(trade, bar.barIndex)) {
+                realised += trade.grossProfit;
+                closedHere = true;
+            }
+        }
+        if (closedHere)
+            held = held.filter((trade) => !closedBy(trade, bar.barIndex));
+        // A close the host did not have leaves the previous mark standing. It is
+        // carried across the warmup boundary too, so the first report bar of a run
+        // whose close is absent is marked at the last price there was.
+        if (bar.close !== null)
+            mark = bar.close;
+        if (!bar.inReport)
+            continue;
+        let openProfit = 0;
+        let exposure = 0;
+        for (const trade of held) {
+            // Before the first close there has ever been, a trade is marked at its
+            // own entry: no profit, and the position still visible in the exposure.
+            const at = mark ?? trade.entryPrice;
+            const direction = trade.side === 'long' ? 1 : -1;
+            openProfit += direction * (at - trade.entryPrice) * trade.units * contract.pointValue;
+            exposure += Math.abs(trade.units * at * contract.pointValue);
+        }
+        const cash = capital + realised - charges;
+        const equity = cash + openProfit;
+        if (equity > peak)
+            peak = equity;
+        const drawdown = equity - peak;
+        points.push({
+            barIndex: bar.barIndex,
+            time: bar.time,
+            realised,
+            charges,
+            openProfit,
+            cash,
+            equity,
+            exposure,
+            drawdown,
+            drawdownPercent: ratioOf(drawdown, peak),
+        });
+    }
+    return points;
+}
+/**
+ * How many of these bars ended with something held.
+ *
+ * Swept rather than searched: a sorted list of the bars trades opened on, a
+ * sorted list of the bars they closed on, and the running difference between
+ * how many of each have gone by. That is the boundary rule `openOnBar` states,
+ * arrived at from the other side, and the two are asserted to agree over a
+ * generated corpus rather than trusted to. A count that disagrees with the
+ * curve beside it about which bars were in the market is exactly the kind of
+ * defect a reader finds by adding two of the printed figures up.
+ */
+export function barsInMarketOver(trades, equity) {
+    const opens = trades.map((trade) => trade.openedOnBar).sort(ascending);
+    const closes = trades
+        .filter((trade) => trade.closedOnBar !== null)
+        .map((trade) => trade.closedOnBar ?? 0)
+        .sort(ascending);
+    let opened = 0;
+    let closed = 0;
+    let live = 0;
+    let bars = 0;
+    for (const point of equity) {
+        while (opened < opens.length && (opens[opened] ?? 0) <= point.barIndex) {
+            live += 1;
+            opened += 1;
+        }
+        while (closed < closes.length && (closes[closed] ?? 0) <= point.barIndex) {
+            live -= 1;
+            closed += 1;
+        }
+        if (live > 0)
+            bars += 1;
+    }
+    return bars;
+}
+/** Whether this bar is the bar the trade closed on, or one after it. */
+function closedBy(trade, barIndex) {
+    return trade.closedOnBar !== null && trade.closedOnBar <= barIndex;
+}
+/** Smallest first, said once, because a sort without a comparison sorts text. */
+function ascending(left, right) {
+    return left - right;
+}
+//# sourceMappingURL=equity.js.map

package/dist/core/accounting/equity.js.map

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

package/dist/core/accounting/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The money: what a run made, what it cost, and what that is worth knowing.
+ *
+ * **This module imports no engine and no emitter, and it never will.** It is
+ * arithmetic over portable data: a list of settled fills, a list of bar closes,
+ * a charge schedule and the contract the run was carried out under. Two things
+ * follow from that and both of them are the reason for it.
+ *
+ * A stored record can be reported again with no engine present, which is what
+ * makes a run record a conformance case rather than a souvenir. And the engine
+ * can call this, when the day comes that a script may read its own equity,
+ * without a cycle and without a second implementation of any of these formulas
+ * sitting inside the execution path disagreeing with this one.
+ *
+ * The door names what a caller may use. The fold itself, the cost basis, the
+ * round trip state machine and the statistics stay behind it: they are one
+ * algorithm with one caller.
+ *
+ * Behaviour lands beside these shapes, each call in the file its type is in.
+ * The cost model is here: `chargeFor` is what one fill came to,
+ * `scheduleFromDeclaration` is the declaration's own commission as the one kind
+ * of schedule this module evaluates, and `scheduleProblem` is what a schedule
+ * is refused for before the first bar. The round trips, the equity curve, the
+ * statistics and the report land beside their own shapes the same way.
+ *
+ * The shapes were agreed before any of it computed, because they are what the
+ * engine, the backtest driver and a second engine all have to agree about.
+ */
+export { chargeFor, scheduleFromDeclaration, scheduleProblem } from './charges.js';
+export type { BarMark, Contract, Money, RecordedFill } from './shapes.js';
+export type { ChargeBase, ChargeBreakdown, ChargeLine, ChargeSchedule, ChargeSide, } from './charges.js';
+export { tradesOf } from './trades.js';
+export type { Trade } from './trades.js';
+export { equityOver } from './equity.js';
+export type { EquityPoint } from './equity.js';
+export { monthlyOver } from './monthly.js';
+export type { MonthlyReturn } from './monthly.js';
+export { markersOf } from './markers.js';
+export type { TradeMarker } from './markers.js';
+export { summaryOf } from './statistics.js';
+export type { Summary } from './statistics.js';
+export { reportOf } from './report.js';
+export type { Report } from './report.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/accounting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACnF,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,cAAc,EACd,UAAU,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/core/accounting/index.js

@@ -0,0 +1,36 @@
+/**
+ * The money: what a run made, what it cost, and what that is worth knowing.
+ *
+ * **This module imports no engine and no emitter, and it never will.** It is
+ * arithmetic over portable data: a list of settled fills, a list of bar closes,
+ * a charge schedule and the contract the run was carried out under. Two things
+ * follow from that and both of them are the reason for it.
+ *
+ * A stored record can be reported again with no engine present, which is what
+ * makes a run record a conformance case rather than a souvenir. And the engine
+ * can call this, when the day comes that a script may read its own equity,
+ * without a cycle and without a second implementation of any of these formulas
+ * sitting inside the execution path disagreeing with this one.
+ *
+ * The door names what a caller may use. The fold itself, the cost basis, the
+ * round trip state machine and the statistics stay behind it: they are one
+ * algorithm with one caller.
+ *
+ * Behaviour lands beside these shapes, each call in the file its type is in.
+ * The cost model is here: `chargeFor` is what one fill came to,
+ * `scheduleFromDeclaration` is the declaration's own commission as the one kind
+ * of schedule this module evaluates, and `scheduleProblem` is what a schedule
+ * is refused for before the first bar. The round trips, the equity curve, the
+ * statistics and the report land beside their own shapes the same way.
+ *
+ * The shapes were agreed before any of it computed, because they are what the
+ * engine, the backtest driver and a second engine all have to agree about.
+ */
+export { chargeFor, scheduleFromDeclaration, scheduleProblem } from './charges.js';
+export { tradesOf } from './trades.js';
+export { equityOver } from './equity.js';
+export { monthlyOver } from './monthly.js';
+export { markersOf } from './markers.js';
+export { summaryOf } from './statistics.js';
+export { reportOf } from './report.js';
+//# sourceMappingURL=index.js.map

package/dist/core/accounting/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/accounting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AASnF,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC"}

package/dist/core/accounting/markers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * One marker per entry and exit fill, which is the chart's whole input.
+ *
+ * A chart draws a trade as two marks and a line between them, and everything it
+ * needs to do that is in the fills: the bar, the trade the fill belongs to, the
+ * side, the units, the price and the tag the order carried. So the markers are
+ * produced here, by the module that already knows which fill belongs to which
+ * trade, and no chart is needed to produce them and none is imported to.
+ */
+import type { RecordedFill } from './shapes.js';
+import type { Trade } from './trades.js';
+/** One entry or exit fill, addressed as a chart addresses it. */
+export interface TradeMarker {
+    readonly barIndex: number;
+    readonly time: number | null;
+    readonly tradeIndex: number;
+    readonly kind: 'entry' | 'exit';
+    readonly side: 'buy' | 'sell';
+    readonly units: number;
+    readonly price: number;
+    readonly tag: string;
+}
+/**
+ * One marker per entry and exit fill, against the trades those fills made up.
+ *
+ * **The fill is read with the same rule the trade list read it with.**
+ * `closedBy` and `openedBy` are imported from `trades.ts` rather than restated,
+ * because a marker that called an exit an entry would draw the chart the report
+ * contradicts. A fill that carried a reference through zero is both: it closes
+ * the trade the reference held and opens the next one, so it produces two
+ * markers, in that order, which is the order the trade list folded it in.
+ *
+ * **A trade is found by its reference and by the order it opened**, never by
+ * the bar it opened on: a reference that went to zero and was entered again on
+ * the same bar is two trades, and addressing them by bar would put both
+ * markers on the first. The trades are walked once per reference, oldest first,
+ * which is the order `tradesOf` built them in.
+ *
+ * The count is an identity rather than a claim: the markers of one trade are
+ * its `entries` plus its `exits`, and a test asserts it over the same fills.
+ */
+export declare function markersOf(fills: readonly RecordedFill[], trades: readonly Trade[]): readonly TradeMarker[];
+//# sourceMappingURL=markers.d.ts.map

package/dist/core/accounting/markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markers.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/markers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,iEAAiE;AACjE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,SAAS,WAAW,EAAE,CA6BxB"}

package/dist/core/accounting/markers.js

@@ -0,0 +1,64 @@
+import { closedBy, openedBy } from './trades.js';
+/**
+ * One marker per entry and exit fill, against the trades those fills made up.
+ *
+ * **The fill is read with the same rule the trade list read it with.**
+ * `closedBy` and `openedBy` are imported from `trades.ts` rather than restated,
+ * because a marker that called an exit an entry would draw the chart the report
+ * contradicts. A fill that carried a reference through zero is both: it closes
+ * the trade the reference held and opens the next one, so it produces two
+ * markers, in that order, which is the order the trade list folded it in.
+ *
+ * **A trade is found by its reference and by the order it opened**, never by
+ * the bar it opened on: a reference that went to zero and was entered again on
+ * the same bar is two trades, and addressing them by bar would put both
+ * markers on the first. The trades are walked once per reference, oldest first,
+ * which is the order `tradesOf` built them in.
+ *
+ * The count is an identity rather than a claim: the markers of one trade are
+ * its `entries` plus its `exits`, and a test asserts it over the same fills.
+ */
+export function markersOf(fills, trades) {
+    const ordered = fills.slice().sort((a, b) => a.seq - b.seq);
+    const queues = new Map();
+    for (const trade of trades) {
+        const held = queues.get(trade.positionRef) ?? [];
+        held.push(trade);
+        queues.set(trade.positionRef, held);
+    }
+    const out = [];
+    for (const fill of ordered) {
+        const queue = queues.get(fill.positionRef) ?? [];
+        const closing = closedBy(fill.refSizeBefore, fill.refSizeAfter);
+        const opening = openedBy(fill.refSizeBefore, fill.refSizeAfter);
+        if (closing > 0) {
+            const held = queue[0];
+            if (held !== undefined)
+                out.push(markerFor(fill, held.index, 'exit', closing));
+            // The trade the reference held is finished by a fill that closed the
+            // whole of it, and the next trade on that reference is the one the fills
+            // after this belong to.
+            if (held !== undefined && (opening > 0 || fill.refSizeAfter === 0))
+                queue.shift();
+        }
+        if (opening > 0) {
+            const held = queue[0];
+            if (held !== undefined)
+                out.push(markerFor(fill, held.index, 'entry', opening));
+        }
+    }
+    return out;
+}
+function markerFor(fill, tradeIndex, kind, units) {
+    return {
+        barIndex: fill.barIndex,
+        time: fill.barTime,
+        tradeIndex,
+        kind,
+        side: fill.side,
+        units,
+        price: fill.price,
+        tag: fill.tag,
+    };
+}
+//# sourceMappingURL=markers.js.map

package/dist/core/accounting/markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markers.js","sourceRoot":"","sources":["../../../src/core/accounting/markers.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAejD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,SAAS,CACvB,KAA8B,EAC9B,MAAwB;IAExB,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC5D,MAAM,MAAM,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC1C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjB,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,MAAM,GAAG,GAAkB,EAAE,CAAC;IAC9B,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QACjD,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAChE,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAEhE,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,IAAI,KAAK,SAAS;gBAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;YAC/E,qEAAqE;YACrE,yEAAyE;YACzE,wBAAwB;YACxB,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,OAAO,GAAG,CAAC,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,CAAC;gBAAE,KAAK,CAAC,KAAK,EAAE,CAAC;QACpF,CAAC;QACD,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,IAAI,KAAK,SAAS;gBAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,SAAS,CAChB,IAAkB,EAClB,UAAkB,EAClB,IAAsB,EACtB,KAAa;IAEb,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,IAAI,EAAE,IAAI,CAAC,OAAO;QAClB,UAAU;QACV,IAAI;QACJ,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,KAAK;QACL,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,GAAG,EAAE,IAAI,CAAC,GAAG;KACd,CAAC;AACJ,CAAC"}

package/dist/core/accounting/monthly.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The month by month table, bucketed in UTC from bar times.
+ *
+ * **UTC, and it says so on the type.** A calendar month in the instrument's own
+ * timezone would need the session machinery and the instrument's calendar, and
+ * a table that silently buckets a trade into the wrong month is worse than one
+ * that states the basis it used. No timezone library, and no pretence of the
+ * instrument's calendar.
+ */
+import type { EquityPoint } from './equity.js';
+import type { Money } from './shapes.js';
+import type { Trade } from './trades.js';
+/** One calendar month of the run, in UTC. */
+export interface MonthlyReturn {
+    readonly year: number;
+    /** 1 to 12, UTC. */
+    readonly month: number;
+    readonly netProfit: Money;
+    /** Against the equity at the month's first bar. */
+    readonly returnPercent: number;
+    readonly trades: number;
+}
+/**
+ * The months a run passed through, in the order it passed through them.
+ *
+ * **A month holds the change in equity across the closes inside it.** The first
+ * point of the curve has nothing before it to be compared with, so it opens the
+ * table rather than contributing to it, and every later point contributes what
+ * it moved from the point before. The consequence is an identity rather than a
+ * claim: the months add up to the equity at the last point less the equity at
+ * the first, and nothing that happened during the warmup is attributed to a
+ * month it did not happen in.
+ *
+ * `returnPercent` is that change over the equity at the month's first bar,
+ * which is the basis this table states and the reason the figure is a fraction
+ * rather than a fraction times a hundred: `drawdownPercent` beside it is
+ * `drawdown / peak`, and one report with two conventions is a report a reader
+ * has to check every figure of.
+ *
+ * `trades` counts the trades that closed inside the month, by the time they
+ * closed. An open trade is in no month, because the month it will be counted in
+ * is not decided yet.
+ *
+ * **A point with no time is in no month.** A bucket is a calendar fact and a
+ * bar with no time states no calendar, so such a point carries its change into
+ * the month in force rather than opening one, and where none is in force it is
+ * outside the table altogether. That is the honest reading: bucketing it by the
+ * month that happened to come before would put money in a month on the strength
+ * of nothing.
+ */
+export declare function monthlyOver(equity: readonly EquityPoint[], trades: readonly Trade[]): readonly MonthlyReturn[];
+//# sourceMappingURL=monthly.d.ts.map

package/dist/core/accounting/monthly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monthly.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/monthly.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,SAAS,aAAa,EAAE,CA2C1B"}

package/dist/core/accounting/monthly.js

@@ -0,0 +1,99 @@
+/**
+ * The months a run passed through, in the order it passed through them.
+ *
+ * **A month holds the change in equity across the closes inside it.** The first
+ * point of the curve has nothing before it to be compared with, so it opens the
+ * table rather than contributing to it, and every later point contributes what
+ * it moved from the point before. The consequence is an identity rather than a
+ * claim: the months add up to the equity at the last point less the equity at
+ * the first, and nothing that happened during the warmup is attributed to a
+ * month it did not happen in.
+ *
+ * `returnPercent` is that change over the equity at the month's first bar,
+ * which is the basis this table states and the reason the figure is a fraction
+ * rather than a fraction times a hundred: `drawdownPercent` beside it is
+ * `drawdown / peak`, and one report with two conventions is a report a reader
+ * has to check every figure of.
+ *
+ * `trades` counts the trades that closed inside the month, by the time they
+ * closed. An open trade is in no month, because the month it will be counted in
+ * is not decided yet.
+ *
+ * **A point with no time is in no month.** A bucket is a calendar fact and a
+ * bar with no time states no calendar, so such a point carries its change into
+ * the month in force rather than opening one, and where none is in force it is
+ * outside the table altogether. That is the honest reading: bucketing it by the
+ * month that happened to come before would put money in a month on the strength
+ * of nothing.
+ */
+export function monthlyOver(equity, trades) {
+    const buckets = [];
+    let previous;
+    let current;
+    for (const point of equity) {
+        const at = monthOf(point.time);
+        if (at !== null && (current === undefined || current.year !== at.year || current.month !== at.month)) {
+            // The equity this month started from, which is where the previous month
+            // left the account and not where this one's first bar closed. Taking the
+            // opening point's own equity put the month's first move into the
+            // numerator and into the denominator at once: a February that doubled a
+            // thousand pounds reported fifty percent, because the gain was divided by
+            // the two thousand it had already produced.
+            current = {
+                year: at.year,
+                month: at.month,
+                netProfit: 0,
+                basis: previous === undefined ? point.equity : previous.equity,
+                trades: 0,
+            };
+            buckets.push(current);
+        }
+        if (previous !== undefined && current !== undefined) {
+            current.netProfit += point.equity - previous.equity;
+        }
+        previous = point;
+    }
+    for (const trade of trades) {
+        const at = monthOf(trade.closedAt);
+        if (at === null)
+            continue;
+        const bucket = buckets.find((one) => one.year === at.year && one.month === at.month);
+        if (bucket !== undefined)
+            bucket.trades += 1;
+    }
+    return buckets.map((one) => ({
+        year: one.year,
+        month: one.month,
+        netProfit: one.netProfit,
+        returnPercent: one.basis > 0 ? one.netProfit / one.basis : 0,
+        trades: one.trades,
+    }));
+}
+/**
+ * The calendar month an instant falls in, in UTC and in no other zone.
+ *
+ * Decomposed rather than formatted, so no locale, no zone table and no library
+ * is involved: the same instant produces the same month on every machine this
+ * ever runs on.
+ */
+function monthOf(time) {
+    if (time === null || !Number.isFinite(time) || Math.abs(time) > LATEST_INSTANT)
+        return null;
+    const at = new Date(time);
+    return { year: at.getUTCFullYear(), month: at.getUTCMonth() + 1 };
+}
+/**
+ * The furthest either way an instant can be and still name a month.
+ *
+ * A finite number outside it decomposes to NaN rather than throwing, and a NaN
+ * year never equals the next one, so every point opened a bucket of its own and
+ * a fifty thousand bar run produced fifty thousand rows of NaN. The canonical
+ * writer then threw a bare error with no code on them, out of core, on a path a
+ * host could not tell from an internal fault. The mistake that gets here is
+ * ordinary: bar times supplied in nanoseconds rather than milliseconds.
+ *
+ * A point whose time names no month contributes to no month, which is what an
+ * absent time already did.
+ */
+const LATEST_INSTANT = 8.64e15;
+//# sourceMappingURL=monthly.js.map

package/dist/core/accounting/monthly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monthly.js","sourceRoot":"","sources":["../../../src/core/accounting/monthly.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,WAAW,CACzB,MAA8B,EAC9B,MAAwB;IAExB,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,QAAiC,CAAC;IACtC,IAAI,OAA2B,CAAC;IAEhC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,EAAE,KAAK,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,OAAO,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;YACrG,wEAAwE;YACxE,yEAAyE;YACzE,iEAAiE;YACjE,wEAAwE;YACxE,0EAA0E;YAC1E,4CAA4C;YAC5C,OAAO,GAAG;gBACR,IAAI,EAAE,EAAE,CAAC,IAAI;gBACb,KAAK,EAAE,EAAE,CAAC,KAAK;gBACf,SAAS,EAAE,CAAC;gBACZ,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM;gBAC9D,MAAM,EAAE,CAAC;aACV,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,QAAQ,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACpD,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QACtD,CAAC;QACD,QAAQ,GAAG,KAAK,CAAC;IACnB,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnC,IAAI,EAAE,KAAK,IAAI;YAAE,SAAS;QAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;QACrF,IAAI,MAAM,KAAK,SAAS;YAAE,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC3B,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,aAAa,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5D,MAAM,EAAE,GAAG,CAAC,MAAM;KACnB,CAAC,CAAC,CAAC;AACN,CAAC;AAYD;;;;;;GAMG;AACH,SAAS,OAAO,CAAC,IAAmB;IAClC,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,cAAc;QAAE,OAAO,IAAI,CAAC;IAC5F,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,cAAc,GAAG,OAAO,CAAC"}

package/dist/core/accounting/report.d.ts

@@ -0,0 +1,38 @@
+import type { ChargeSchedule } from './charges.js';
+import type { EquityPoint } from './equity.js';
+import type { MonthlyReturn } from './monthly.js';
+import type { TradeMarker } from './markers.js';
+import type { BarMark, Contract, Money, RecordedFill } from './shapes.js';
+import type { Summary } from './statistics.js';
+import type { Trade } from './trades.js';
+/** Everything a run is reported as, and nothing a chart has to compute. */
+export interface Report {
+    readonly summary: Summary;
+    readonly trades: readonly Trade[];
+    readonly equity: readonly EquityPoint[];
+    readonly monthly: readonly MonthlyReturn[];
+    readonly markers: readonly TradeMarker[];
+}
+/**
+ * The whole report, folded from the fills, the bar closes and the schedule.
+ *
+ * **One pass, in one order, and the order is the result.** The fills are put in
+ * `seq` order once, here, and every fold below reads that same list: the
+ * charges are computed in it, the trades are built from it, the curve is marked
+ * along it and the markers come off it. A second ordering anywhere would be a
+ * report that is right to eleven digits and different in the twelfth on
+ * somebody else's engine, which is the failure this module is shaped to make
+ * impossible rather than unlikely.
+ *
+ * **A charge belongs to the fill that incurred it.** `chargeFor` rounds one
+ * fill's total once, and nothing here rounds it again or re-sums the collection
+ * in another order, so `sum(trade.charges)` and `summary.charges` are the same
+ * money and a test asserts it rather than a page claiming it.
+ *
+ * A run carried out under no schedule at all is charged nothing, which is a
+ * study of the strategy before costs and is a thing worth being able to ask
+ * for. It is not a default: `scheduleFromDeclaration` is what a run under the
+ * declaration's own commission uses, and the caller states which it wants.
+ */
+export declare function reportOf(fills: readonly RecordedFill[], marks: readonly BarMark[], schedule: ChargeSchedule | null, contract: Contract, capital: Money): Report;
+//# sourceMappingURL=report.d.ts.map

package/dist/core/accounting/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/core/accounting/report.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE1E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,2EAA2E;AAC3E,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,QAAQ,EAAE,cAAc,GAAG,IAAI,EAC/B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,KAAK,GACb,MAAM,CAiBR"}

package/dist/core/accounting/report.js

@@ -0,0 +1,63 @@
+/**
+ * The report: what a run came to, folded from its fills and its bar closes.
+ *
+ * **The evaluation order is fixed here and nowhere else**, because a report
+ * that is right to eleven digits and different in the twelfth fails a
+ * conformance comparison months later on somebody else's engine, and the cause
+ * is always a line nobody thought was arithmetic. Fills in `seq` order, charge
+ * lines in declaration order, one rounding per fill total, no collection
+ * re-summed in another order, no dependence on a map's iteration order, no wall
+ * clock and no random number generator anywhere in this module.
+ *
+ * **What the report is not is read by a script.** The money entries of the
+ * `pos` namespace stay planned and go on refusing at the call. The moment a
+ * script can read its own equity mid-run, the money layer joins the execution
+ * path, and therefore joins the conformance surface, and every formula in this
+ * module has to be agreed by a second engine before a script may branch on it.
+ * This module computes the money after the fact from a record; whether a script
+ * may read it is a later decision. That this module imports no engine is the
+ * structural half of keeping that decision open: when it is taken, the engine
+ * calls this, and there is no second implementation to disagree with.
+ */
+import { chargeFor } from './charges.js';
+import { equityOver } from './equity.js';
+import { monthlyOver } from './monthly.js';
+import { markersOf } from './markers.js';
+import { summaryOf } from './statistics.js';
+import { tradesOf } from './trades.js';
+/**
+ * The whole report, folded from the fills, the bar closes and the schedule.
+ *
+ * **One pass, in one order, and the order is the result.** The fills are put in
+ * `seq` order once, here, and every fold below reads that same list: the
+ * charges are computed in it, the trades are built from it, the curve is marked
+ * along it and the markers come off it. A second ordering anywhere would be a
+ * report that is right to eleven digits and different in the twelfth on
+ * somebody else's engine, which is the failure this module is shaped to make
+ * impossible rather than unlikely.
+ *
+ * **A charge belongs to the fill that incurred it.** `chargeFor` rounds one
+ * fill's total once, and nothing here rounds it again or re-sums the collection
+ * in another order, so `sum(trade.charges)` and `summary.charges` are the same
+ * money and a test asserts it rather than a page claiming it.
+ *
+ * A run carried out under no schedule at all is charged nothing, which is a
+ * study of the strategy before costs and is a thing worth being able to ask
+ * for. It is not a default: `scheduleFromDeclaration` is what a run under the
+ * declaration's own commission uses, and the caller states which it wants.
+ */
+export function reportOf(fills, marks, schedule, contract, capital) {
+    const ordered = fills.slice().sort((a, b) => a.seq - b.seq);
+    const charges = ordered.map((fill) => schedule === null ? 0 : chargeFor(schedule, fill, contract).total);
+    const trades = tradesOf(ordered, charges, marks, contract);
+    const equity = equityOver(trades, marks, contract, capital);
+    const summary = summaryOf(trades, equity, contract, capital);
+    return {
+        summary,
+        trades,
+        equity,
+        monthly: monthlyOver(equity, trades),
+        markers: markersOf(ordered, trades),
+    };
+}
+//# sourceMappingURL=report.js.map

package/dist/core/accounting/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../src/core/accounting/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAYvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,QAAQ,CACtB,KAA8B,EAC9B,KAAyB,EACzB,QAA+B,EAC/B,QAAkB,EAClB,OAAc;IAEd,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACnC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,KAAK,CAClE,CAAC;IAEF,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAE7D,OAAO;QACL,OAAO;QACP,MAAM;QACN,MAAM;QACN,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;QACpC,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;KACpC,CAAC;AACJ,CAAC"}