openalgo-script 0.1.0-alpha.0 → 0.2.0

package/dist/core/engine/ledger/holdings.js

@@ -0,0 +1,237 @@
+import { isTerminal } from './row.js';
+function sideOf(signed) {
+    return signed > 0 ? 'buy' : 'sell';
+}
+/**
+ * Every position reference this leg holds, oldest first.
+ *
+ * Oldest first is the order the references were minted in, which is the order
+ * the rows first name them in, and it is the order a reducing order takes them
+ * in: the position opened first is the position closed first.
+ *
+ * A reference with nothing left on it is not here. It has no room for an
+ * opposing order and nothing for a close to send, and it is either already back
+ * at zero or has its whole quantity spoken for by orders that are still going.
+ */
+export function holdings(ctx) {
+    const tallies = new Map();
+    const minted = [];
+    for (const row of ctx.rows()) {
+        let tally = tallies.get(row.positionRef);
+        if (tally === undefined) {
+            tally = {
+                settled: ctx.sizeOf(row.positionRef),
+                working: 0,
+                against: 0,
+                unreadable: null,
+                blocked: false,
+            };
+            tallies.set(row.positionRef, tally);
+            minted.push(row.positionRef);
+        }
+        // An order that has ended has nothing more coming from it, whatever it
+        // filled: the fill is already in the settled figure above, and the rest is
+        // released. That is how a strategy whose order was rejected gets its room
+        // back.
+        if (isTerminal(row.status))
+            continue;
+        const sign = row.side === 'buy' ? 1 : -1;
+        // **Every row is read the same way, by the order's own quantity in units**,
+        // because this sum is compared against what has settled on this reference
+        // and both halves have to fall together when a fill arrives.
+        //
+        // A reduction used to be read by what it claimed of the leg when it was
+        // sent (`row.ts`, `Reduction`), which is a number about the leg rather than
+        // about the order: a second stated close claims nothing, because the first
+        // already spoke for the whole leg, and it still fills and still takes what
+        // it filled off what has settled here. The settled half fell, the claimed
+        // half did not, the sum went negative, the reference read as the side it is
+        // not on, and an entry opposing it was handed it as an order that adds. It
+        // then opened long and settled short with every order answered in full.
+        const remaining = row.units === null ? null : Math.max(0, row.units - row.filledQty);
+        const reduces = Math.sign(tally.settled) === -sign;
+        if (remaining === null) {
+            tally.unreadable = row.side;
+            // Nothing is sent against a position an order the engine cannot read is
+            // working against. Between a close that sends nothing and an order that
+            // crosses zero, `stdlib.md` 17.1 has already chosen.
+            if (reduces)
+                tally.blocked = true;
+            continue;
+        }
+        tally.working += sign * remaining;
+        if (reduces)
+            tally.against += remaining;
+    }
+    const held = [];
+    for (const ref of minted) {
+        const tally = tallies.get(ref);
+        const outstanding = tally.settled + tally.working;
+        if (outstanding === 0 && tally.unreadable === null)
+            continue;
+        const side = outstanding === 0 ? tally.unreadable : sideOf(outstanding);
+        // A reference holding a quantity the engine cannot read holds an unknown
+        // number of units, and understating it is the safe half of that: an
+        // opposing order divided against too small a number opens the remainder on
+        // a reference of its own, which crosses nothing.
+        const units = outstanding === 0 ? null : Math.abs(outstanding);
+        // **What a close may send is what settled here and is not already coming
+        // off**, and only where what settled is on this side. A reference whose
+        // working orders run past its settled quantity reads as the other side,
+        // because that is what it will hold, and nothing of that side has settled
+        // yet: a reference two long with nine of sell working offered a close seven
+        // units to send against it, which took its own book to five long.
+        const facing = side === 'buy' ? 1 : -1;
+        const settled = tally.blocked || Math.sign(tally.settled) !== facing
+            ? 0
+            : Math.max(0, Math.abs(tally.settled) - tally.against);
+        held.push({ ref, side, units, settled });
+    }
+    return held;
+}
+/**
+ * The references an order of this side reduces, oldest first.
+ *
+ * A reference is reduced by the side it is not on, which is the same test a
+ * close makes on the leg as a whole and is why `closingSide` and this agree.
+ */
+export function opposing(book, side) {
+    return book.filter((one) => one.side !== side);
+}
+/**
+ * The position an order the engine cannot size is sent against, `stdlib.md`
+ * 17.1, or none where the leg names no position at all.
+ *
+ * **A close is never minted a position of its own.** It is named for reducing,
+ * so it goes on the position it is closing, and where the engine cannot read
+ * the quantity it states, that position is the one the order may take past
+ * zero: the one shape of 17.1 an engine does not keep, waiting on the lot size
+ * OS7005 is deferred on.
+ *
+ * **What has settled comes first, and the book's own list second.** A reference
+ * whose settled quantity is entirely spoken for by orders that are still going
+ * is not in the book above, because it has nothing left for an engine-sized
+ * close to send. An order the engine cannot size is not choosing a quantity, so
+ * that exclusion does not apply to it: the position it is closing is still that
+ * one. Taking the book's answer alone sent a close on a reference an entry was
+ * opening on the other side, which is an order named close adding to a
+ * position: with the leg's whole long inside a close the destination still had,
+ * `close(qty = 1)` in cash was handed the reference a short entry had just
+ * opened, and was a sell on it.
+ *
+ * A reference with nothing settled either way is the second answer rather than
+ * the first, because a position being opened is a position under 17.1 and an
+ * order that reduces the leg has to name one of them.
+ */
+export function outgoingFor(ctx, book, side) {
+    const facing = side === 'buy' ? -1 : 1;
+    const seen = new Set();
+    for (const row of ctx.rows()) {
+        if (seen.has(row.positionRef))
+            continue;
+        seen.add(row.positionRef);
+        if (Math.sign(ctx.sizeOf(row.positionRef)) === facing)
+            return row.positionRef;
+    }
+    return opposing(book, side)[0]?.ref ?? null;
+}
+/**
+ * The position a bracket protects, or none where the leg holds none,
+ * `stdlib.md` 17.7 and `host-interface.md` 7.1.
+ *
+ * **Holding first, opening second, which is the order 17.7 states them in.** A
+ * bracket appends no row and moves no position, so it has nothing of its own to
+ * name: it names what the leg has, and what the leg has is what its own fills
+ * settled. Only where nothing has settled at all is the answer the position the
+ * leg is opening, which is the ordinary shape of an `exit()` written beside the
+ * entry it protects.
+ *
+ * **The newest of them where the leg holds more than one**, which it does
+ * whenever an order that opposes it is outstanding. The newest is the one an
+ * entry on that side would join (`joining`), so a bracket set after an entry
+ * names the position that entry is in.
+ *
+ * **Derived here rather than kept as the last reference minted.** A stored slot
+ * answered neither question: it was set by the mint and cleared when that one
+ * reference returned to zero, so a leg whose newer position closed while an
+ * older one was still held was reported as holding none, and `exit()` handed a
+ * host `0` with ten units on the books. The mirror of it is the same slot read
+ * the other way: a reference minted for an order the destination then refused
+ * stayed the answer, and the bracket named a position that never opened while
+ * the leg's own sat on another reference. Neither needs a slot to answer, and
+ * both are wrong in the direction a host cannot check: `0` says the leg holds
+ * nothing, and 7.1 tells a host to look a reference up only when it is not `0`.
+ */
+export function protecting(ctx) {
+    let held = null;
+    const seen = new Set();
+    for (const row of ctx.rows()) {
+        if (seen.has(row.positionRef))
+            continue;
+        seen.add(row.positionRef);
+        // Rows are oldest first and references are minted in order, so the last one
+        // this loop keeps is the newest reference something has settled on.
+        if (ctx.sizeOf(row.positionRef) !== 0)
+            held = row.positionRef;
+    }
+    if (held !== null)
+        return held;
+    const book = holdings(ctx);
+    return book.length === 0 ? null : book[book.length - 1].ref;
+}
+/**
+ * The reference an order that adds to a position joins, or none to mint one.
+ *
+ * The newest open reference on that side, so that two entries sent on two bars
+ * before either fills belong to one position rather than to two, which is what
+ * `stdlib.md` 17.7 means by a reference being kept while a position is being
+ * opened.
+ *
+ * **A reference whose whole quantity is already going is not open to join.** A
+ * leg long ten with a close of ten working is on its way out: an entry joining
+ * it would settle into a position that reaches zero and ends, and 17.7's
+ * sentence would then have to happen twice for one reference. The entry takes a
+ * reference of its own, and if the close is rejected the leg simply holds two
+ * positions on one side, each of which a close can still send.
+ */
+export function joining(book, side) {
+    for (let index = book.length - 1; index >= 0; index -= 1) {
+        const one = book[index];
+        if (one.side === side)
+            return one.ref;
+    }
+    return null;
+}
+/**
+ * How a quantity is divided across the references it reduces, oldest first.
+ *
+ * **A reducing order that spans two positions is two orders**, for the reason
+ * 17.1 already gives for a flip: one order against two positions would leave a
+ * late fill with no way to say which of them it settled. A leg holds more than
+ * one position whenever an order that opposes it is outstanding, and before
+ * this the whole of a leg's closable quantity was attached to a single
+ * reference with nothing asking whether that reference could absorb it.
+ *
+ * `room` is which of the two numbers a holding offers is the ceiling here: what
+ * an opposing order may take, or what has settled. The caller chooses, because
+ * the caller knows whether the quantity is the script's or the engine's.
+ *
+ * What is left over when every reference is full is the caller's to open or to
+ * drop. Nothing is ever sent past a reference's own ceiling.
+ */
+export function divide(book, side, units, room) {
+    const shares = [];
+    let left = units;
+    for (const one of opposing(book, side)) {
+        if (left <= 0)
+            break;
+        const ceiling = room(one);
+        if (ceiling === null || ceiling <= 0)
+            continue;
+        const take = Math.min(left, ceiling);
+        shares.push({ ref: one.ref, units: take });
+        left -= take;
+    }
+    return { shares, left };
+}
+//# sourceMappingURL=holdings.js.map

package/dist/core/engine/ledger/holdings.js.map

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

package/dist/core/engine/ledger/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The ledger: what this strategy sent, and what became of it.
+ *
+ * One module because it is one fact with three faces. An intent leaves, a row
+ * records it, a frame folds into that row, and the position every `pos` call
+ * reads is the sum of the fills those frames settled. Splitting them would put
+ * the fold in one place and the field names it folds into in another, which is
+ * how a cumulative quantity becomes a double counted one.
+ *
+ * The door carries the shapes that cross a boundary and the one class that
+ * holds state. The fold, the position book, the mapping from a call to an
+ * order and the refusals stay behind it: they are one algorithm with one
+ * caller.
+ */
+export type { Identity, IntentBar, IntentKind, OrderFrame, OrderIntent, OrderSide, OrderType, } from './intent.js';
+export { Ledger } from './ledger.js';
+export type { LedgerOptions, PlacedCall } from './ledger.js';
+export type { FrameOutcome, FrameRefusal, LedgerRow, OrderStatus } from './row.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/engine/ledger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,YAAY,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,UAAU,EACV,WAAW,EACX,SAAS,EACT,SAAS,GACV,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/core/engine/ledger/index.js

@@ -0,0 +1,2 @@
+export { Ledger } from './ledger.js';
+//# sourceMappingURL=index.js.map

package/dist/core/engine/ledger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/engine/ledger/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/core/engine/ledger/intent.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The two shapes that cross the order boundary, `host-interface.md` 7.1 and
+ * 7.2.
+ *
+ * **An intent is not an order.** The engine states what the strategy decided
+ * and the destination makes the order, which is the whole reason the duty is
+ * shaped as two messages rather than one call. An engine that named a
+ * destination's own order id at the moment a script called `buy()` would be
+ * handing the script an identifier for something that may never exist.
+ *
+ * **A frame is cumulative.** Every frame restates the whole life of one order
+ * rather than what changed since the frame before it, which is what makes a
+ * repeat, a pair that crossed in flight and a reconnecting session that resends
+ * its last frames all harmless. The fold that depends on it is `row.ts`.
+ *
+ * Nothing here parses an identity. A resolved identity may be a string, a
+ * number, a pair or a row in the host's own table (`host-interface.md` 9.1), so
+ * the engine carries the one it was given and hands it back unchanged.
+ */
+/** The side of an order, `stdlib.md` 17.2. */
+export type OrderSide = 'buy' | 'sell';
+/** The type of an order, `stdlib.md` 17.2. */
+export type OrderType = 'market' | 'limit' | 'stop' | 'stopLimit';
+/** What an intent asks the destination to do, `host-interface.md` 7.1. */
+export type IntentKind = 'place' | 'cancel' | 'bracket';
+/**
+ * The instrument an order names, as the chart's record states it.
+ *
+ * A pair, which is one of the spellings section 9.1 allows an identity to take.
+ * It is carried and compared and never split, formatted or inferred from.
+ */
+export interface Identity {
+    readonly symbol: string | null;
+    readonly exchange: string | null;
+}
+/** The bar whose close decided an order, `host-interface.md` 7.1. */
+export interface IntentBar {
+    readonly index: number;
+    readonly time: number | null;
+}
+/**
+ * What the engine hands over, `host-interface.md` 7.1.
+ *
+ * `qty` carries the unit its `qtyType` names rather than a count of units the
+ * engine worked out for itself. A lot is the venue's own fact and the host owns
+ * symbology, so an engine that multiplied by a lot size the host never stated
+ * would send a quantity nobody asked for, which is the substitution rule of
+ * duty 2 read from the order side. A quantity the engine computed from the
+ * ledger, as a flattening order's is, states units because that is what a
+ * filled quantity is counted in.
+ */
+export interface OrderIntent {
+    readonly intentId: number;
+    readonly kind: IntentKind;
+    readonly instrument: Identity;
+    /** Stated by an order that places one, absent on a cancellation. */
+    readonly side: OrderSide | null;
+    readonly qty: number | null;
+    /** The unit `qty` is counted in, `language.md` 13.3, passed untranslated. */
+    readonly qtyType: string;
+    readonly type: OrderType | null;
+    readonly limit: number | null;
+    readonly trigger: number | null;
+    /** A bracket's target, as a price. */
+    readonly target: number | null;
+    /** A bracket's stop, as a price. */
+    readonly stop: number | null;
+    /**
+     * A bracket's target and stop as distances from the entry, where the script
+     * stated them that way.
+     *
+     * Carried as distances rather than resolved into prices, because the entry a
+     * distance is measured from is the fill of the order this bracket's tag
+     * names, and that fill reaches the destination before it reaches the engine.
+     * The common shape is an entry and its bracket on one bar, where the entry
+     * has not filled and there is no price to measure from yet.
+     */
+    readonly profit: number | null;
+    readonly loss: number | null;
+    readonly tag: string;
+    /** The strategy's own product word, passed untranslated. */
+    readonly product: string;
+    readonly positionRef: number;
+    readonly bar: IntentBar;
+}
+/**
+ * What a host reports back about one order, `host-interface.md` 7.2.
+ *
+ * Every field but `intentId`, `status` and `filledQty` is one a destination may
+ * not have said anything about yet, so the shape carries absence rather than a
+ * substituted zero or an empty string.
+ */
+export interface OrderFrame {
+    readonly intentId: number;
+    readonly status: string;
+    /** Cumulative filled quantity, from the beginning of this order's life. */
+    readonly filledQty: number;
+    readonly avgFillPrice?: number | null;
+    readonly orderRef?: string | null;
+    readonly sentInstrument?: Identity | null;
+    readonly sentProduct?: string | null;
+    readonly time?: number | null;
+    readonly text?: string | null;
+    readonly seq?: number | null;
+}
+//# sourceMappingURL=intent.d.ts.map

package/dist/core/engine/ledger/intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/intent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8CAA8C;AAC9C,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC,8CAA8C;AAC9C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,CAAC;AAElE,0EAA0E;AAC1E,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B"}

package/dist/core/engine/ledger/intent.js

@@ -0,0 +1,21 @@
+/**
+ * The two shapes that cross the order boundary, `host-interface.md` 7.1 and
+ * 7.2.
+ *
+ * **An intent is not an order.** The engine states what the strategy decided
+ * and the destination makes the order, which is the whole reason the duty is
+ * shaped as two messages rather than one call. An engine that named a
+ * destination's own order id at the moment a script called `buy()` would be
+ * handing the script an identifier for something that may never exist.
+ *
+ * **A frame is cumulative.** Every frame restates the whole life of one order
+ * rather than what changed since the frame before it, which is what makes a
+ * repeat, a pair that crossed in flight and a reconnecting session that resends
+ * its last frames all harmless. The fold that depends on it is `row.ts`.
+ *
+ * Nothing here parses an identity. A resolved identity may be a string, a
+ * number, a pair or a row in the host's own table (`host-interface.md` 9.1), so
+ * the engine carries the one it was given and hands it back unchanged.
+ */
+export {};
+//# sourceMappingURL=intent.js.map

package/dist/core/engine/ledger/intent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.js","sourceRoot":"","sources":["../../../../src/core/engine/ledger/intent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/core/engine/ledger/ledger.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The strategy's own order and fill ledger, `stdlib.md` 17.7.
+ *
+ * **Each strategy owns one.** It is the strategy's record of what it has
+ * actually done, it is what every position figure in the language is folded
+ * from, and it is per strategy rather than per account because an account
+ * position is shared with every other strategy and every manual trade in the
+ * same contract.
+ *
+ * **Nothing is read from a host's position row.** The engine is neither handed
+ * one nor asks for one. What it reads back is what it sent and what the
+ * destination said became of it, which is the only record whose owner is this
+ * strategy.
+ *
+ * **Frames fold at a bar boundary**, never during an execution. A frame that
+ * arrived while bar four hundred was still moving is folded before bar four
+ * hundred and one begins, so every position fact is constant for the length of
+ * one execution and a re-execution of a moving bar sees exactly what the first
+ * execution saw (`host-interface.md` 7.4).
+ */
+import type { Diagnostic } from '../../diagnostics/index.js';
+import type { Span } from '../../span/index.js';
+import type { Identity, IntentBar, OrderFrame, OrderIntent } from './intent.js';
+import type { FrameOutcome, LedgerRow } from './row.js';
+/** What the declaration and the chart fix before bar 0. */
+export interface LedgerOptions {
+    readonly instrument: Identity;
+    readonly product: string;
+    readonly qtyType: string;
+    readonly declaredQty: number;
+    /** The instrument's tick size, absent where the host states none. */
+    readonly tickSize: number | null;
+    /** Entries allowed in one direction before one is refused. */
+    readonly pyramiding: number;
+}
+/**
+ * What one order call sent, or why it sent nothing.
+ *
+ * The two are exclusive, and that is the shape rather than an accident: a
+ * refused call mints no id, appends no row and returns no intent, so there is
+ * nothing for a host to send and nothing to take back afterwards.
+ */
+export interface PlacedCall {
+    readonly intents: readonly OrderIntent[];
+    /** Why the call was refused, `errors.md` OS7002 to OS7013 and OS7017. */
+    readonly refusal: Diagnostic | undefined;
+}
+export declare class Ledger {
+    private readonly byIntent;
+    private readonly placed;
+    private readonly positions;
+    private waiting;
+    private next;
+    private readonly options;
+    /** The bar `sent` describes, so the list empties when a new one begins. */
+    private at;
+    /**
+     * The orders this bar has sent, which is what OS7013 is asked about.
+     *
+     * The bar is the right scope for that one rule and for nothing else. What a
+     * reducing order is measured against used to be read from here too, and the
+     * defect that made obvious was the plainest one there is: a close still
+     * working when the next bar closed again was invisible, because this list is
+     * emptied the moment the bar index changes. The rows below outlive the bar
+     * and say which orders the destination still has, so that reading moved to
+     * `closable.ts` and this list kept the question that really is a bar's.
+     */
+    private sent;
+    constructor(options: LedgerOptions);
+    /**
+     * Step 9 sent an order call. It becomes intents, and each becomes a row.
+     *
+     * A row is appended when the order is sent, at `placed`, which is the
+     * engine's own status: an intent has left and nothing has come back, and a
+     * host cannot report a state the destination has never described.
+     *
+     * **The whole call is read, mapped and refused before any of it is sent.**
+     * Every order the call produces is held against `refuse.ts` first, and only
+     * then does any of them take an id, so a refused call appends no row and
+     * returns no intent: there is nothing for a host to send and nothing to take
+     * back afterwards. A call that sends two orders sends both or neither.
+     *
+     * **The bar is the same promise one scope up**, and `discard` below is how
+     * it is kept. A refusal anywhere on a bar hands none of the bar's orders to a
+     * destination, so none of the bar's rows may survive it either, including the
+     * rows of calls that had already been mapped when the refusal happened. That
+     * is not the ledger rewriting a record backwards: nothing was handed over, so
+     * there is no record of a hand-over to rewrite.
+     */
+    place(name: string, params: readonly string[], args: readonly unknown[], bar: IntentBar, at: Span): PlacedCall;
+    /**
+     * The bar sent nothing after all: every row it appended is taken back.
+     *
+     * A refusal anywhere on a bar hands none of the bar's orders over, because
+     * every call is mapped before any of them is routed (`orders.ts`). Until this
+     * existed, the rows of the calls that had already been mapped stayed: a bar
+     * that placed an order and then met a refusal left `orders()` reporting an
+     * order at `placed` that no destination was ever handed, and a host
+     * reconciling after a stopped run saw an order it never received. 17.7 says a
+     * row is appended when the order is sent, and nothing had been sent.
+     *
+     * **Taken back rather than never written.** A row has to be there while the
+     * rest of the bar is mapped: `cancel` asks whether a tag names a working
+     * order, pyramiding counts the entries a position already holds, and a close
+     * measures what one tag entered, all from rows this same bar may have
+     * appended. Deferring the append would make an entry and a cancellation of it
+     * on one bar into OS7009. So the bar writes its rows and a refused bar undoes
+     * them, which is the same shape the moving bar already uses on the cells.
+     *
+     * The intent ids the bar minted are not reissued. An id is unique within a
+     * run (`stdlib.md` 17.7), a frame that quoted one must never match a later
+     * order, and a gap in the numbering is invisible to a host, so the cheap
+     * invariant is the one worth keeping.
+     *
+     * **`from` is the row count the routing pass began at**, and it is held by
+     * that pass rather than by a bar index kept here. A bar declared
+     * `onUnconfirmed` applies its effects on every execution of itself, so one bar
+     * can route more than once, and a mark taken when the bar index last changed
+     * would take back rows whose orders a previous execution really did hand over.
+     * The promise belongs to the pass that made it, so the mark does too.
+     */
+    discard(from: number): void;
+    /** A frame from the destination, held until the next bar boundary. */
+    deliver(frame: OrderFrame): void;
+    /**
+     * Folds every frame that has arrived, in the order it arrived in.
+     *
+     * A host does not have to put its frames in order before it sends them. A
+     * repeat, a pair that crossed in flight and one that arrives after the order
+     * ended are ordinary traffic, and the fold is what says what each of them
+     * does.
+     */
+    settle(): readonly FrameOutcome[];
+    /** The leg's net position in units, `0` while flat. */
+    size(): number;
+    /** The average price of the open position, absent while flat. */
+    avgPrice(): number | null;
+    /** Every row, oldest first, for a host that reports what the run did. */
+    rows(): readonly LedgerRow[];
+    private append;
+    private contextFor;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/core/engine/ledger/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../../../src/core/engine/ledger/ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,WAAW,EAGZ,MAAM,aAAa,CAAC;AAOrB,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAa,MAAM,UAAU,CAAC;AAEnE,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAAC;CAC1C;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,2EAA2E;IAC3E,OAAO,CAAC,EAAE,CAAM;IAChB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,IAAI,CAAmB;gBAEnB,OAAO,EAAE,aAAa;IAIlC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CACH,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,GAAG,EAAE,SAAS,EACd,EAAE,EAAE,IAAI,GACP,UAAU;IAyCb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAU3B,sEAAsE;IACtE,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIhC;;;;;;;OAOG;IACH,MAAM,IAAI,SAAS,YAAY,EAAE;IAiCjC,uDAAuD;IACvD,IAAI,IAAI,MAAM;IAId,iEAAiE;IACjE,QAAQ,IAAI,MAAM,GAAG,IAAI;IAIzB,yEAAyE;IACzE,IAAI,IAAI,SAAS,SAAS,EAAE;IAI5B,OAAO,CAAC,MAAM;IAsCd,OAAO,CAAC,UAAU;CAgBnB"}