openalgo-script 0.1.0-alpha.0 → 0.2.0

package/dist/core/engine/errors.js

@@ -0,0 +1,63 @@
+import { diagnosticFor } from '../diagnostics/index.js';
+import { makeSpan } from '../span/index.js';
+/** A diagnostic on its way out of the machine. */
+export class ScriptError extends Error {
+    diagnostic;
+    constructor(diagnostic) {
+        super(diagnostic.code);
+        this.name = 'ScriptError';
+        this.diagnostic = diagnostic;
+    }
+}
+/**
+ * Where a diagnostic points.
+ *
+ * A compiled program carries a line and a column per instruction and not an
+ * offset, because `debug.pos` is a position in the source rather than an index
+ * into text the engine was never given. When a host hands the engine the source
+ * file as well, the offset is worked out from the position and a renderer can
+ * draw the caret under the line; without it the line and the column still say
+ * where, which is what an error message needs.
+ */
+export function spanAt(source, line, column) {
+    if (source === undefined)
+        return makeSpan(0, 0, line, column);
+    return makeSpan(source.offsetAt({ line, column }), 0, line, column);
+}
+/** The position a load-time failure carries: the program, not a line of source. */
+export const NO_POSITION = makeSpan(0, 0, 0, 0);
+export function raise(code, span, values) {
+    throw new ScriptError(diagnosticFor(code, span, values));
+}
+export function failure(code, span, values) {
+    return diagnosticFor(code, span, values);
+}
+/**
+ * A verification failure, `compiled-program.md` 3.5.
+ *
+ * One code covers a malformed instruction list, an unreadable encoding and an
+ * input reference naming an input that was never declared, because they are not
+ * separate fixes: all three are defects of the compiler that wrote the program
+ * and none of them is repairable by hand.
+ */
+export function malformed(location, reason) {
+    return failure('OS6018', NO_POSITION, { location, reason });
+}
+/** The location half of OS6018 for an instruction, in the spelling 3.5 gives. */
+export function atInstruction(list, index) {
+    return list === 'code' ? `instruction ${index}` : `${list} instruction ${index}`;
+}
+/**
+ * Whatever escaped that was not a diagnostic.
+ *
+ * A verified program cannot underflow the stack, jump out of bounds or address
+ * a slot that does not exist, so an exception from inside the interpreter means
+ * the program is not what verification said it was. It becomes a diagnostic on
+ * this script rather than an exception in the host's render loop, which is the
+ * whole of "one script failing takes nothing else down".
+ */
+export function unexpected(where, thrown) {
+    const reason = thrown instanceof Error ? thrown.message : String(thrown);
+    return malformed(where, `the engine could not execute it: ${reason}`);
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/engine/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/core/engine/errors.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,kDAAkD;AAClD,MAAM,OAAO,WAAY,SAAQ,KAAK;IAC3B,UAAU,CAAa;IAEhC,YAAY,UAAsB;QAChC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,MAAM,CAAC,MAA8B,EAAE,IAAY,EAAE,MAAc;IACjF,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC9D,OAAO,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACtE,CAAC;AAED,mFAAmF;AACnF,MAAM,CAAC,MAAM,WAAW,GAAS,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAEtD,MAAM,UAAU,KAAK,CACnB,IAAU,EACV,IAAU,EACV,MAA8B;IAE9B,MAAM,IAAI,WAAW,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,OAAO,CACrB,IAAU,EACV,IAAU,EACV,MAA8B;IAE9B,OAAO,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,QAAgB,EAAE,MAAc;IACxD,OAAO,OAAO,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,KAAa;IACvD,OAAO,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,gBAAgB,KAAK,EAAE,CAAC;AACnF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,MAAe;IACvD,MAAM,MAAM,GAAG,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACzE,OAAO,SAAS,CAAC,KAAK,EAAE,oCAAoC,MAAM,EAAE,CAAC,CAAC;AACxE,CAAC"}

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

@@ -0,0 +1,48 @@
+/**
+ * Frames, and where an instruction came from in the source.
+ *
+ * A frame is `compiled-program.md` 3.3's seven fields. Two of them, `cellBase`
+ * and `stateBase`, are what make one function body serve many independent
+ * pieces of state: a cell operand inside a body is added to the frame's base,
+ * so the same body reaches different cells from different call sites, and the
+ * call site supplies the bases. That is `language.md` 11.4's rule that state is
+ * allocated per call site, made mechanical.
+ *
+ * **A frame's stack region is its own.** A called function cannot see or
+ * disturb the caller's operands, which is what makes the verifier's depth walk
+ * a local question rather than a whole program one.
+ *
+ * Positions are looked up rather than carried per instruction. 2.15 stores one
+ * triple per change of position and the position of any instruction is the
+ * triple with the greatest index at or below it, so a run of instructions from
+ * one expression costs one triple. The lookup runs when a diagnostic is raised
+ * and never on the path an instruction takes.
+ */
+import type { Instruction, Position } from './types.js';
+import type { Value } from './values/index.js';
+export interface Frame {
+    readonly code: readonly Instruction[];
+    pc: number;
+    readonly slots: Value[];
+    readonly cellBase: number;
+    readonly stateBase: number;
+    /** The register bound to each series parameter, from the call site. */
+    readonly series: readonly number[];
+    readonly stack: Value[];
+    /** The position table for this frame's instruction list. */
+    readonly positions: readonly Position[];
+}
+export declare function makeFrame(code: readonly Instruction[], slots: number, cellBase: number, stateBase: number, series: readonly number[], positions: readonly Position[]): Frame;
+/**
+ * The line and column of one instruction.
+ *
+ * A binary search rather than a scan, because a program with four thousand
+ * instructions raising a diagnostic inside a loop would otherwise walk the
+ * table once per raise, and a debugger stepping instruction by instruction asks
+ * for this on every step.
+ */
+export declare function positionAt(positions: readonly Position[], pc: number): {
+    readonly line: number;
+    readonly column: number;
+};
+//# sourceMappingURL=frames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../../src/core/engine/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;CACzC;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,KAAK,CAWP;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAgBA"}

package/dist/core/engine/frames.js

@@ -0,0 +1,41 @@
+import { ABSENT } from './values/index.js';
+export function makeFrame(code, slots, cellBase, stateBase, series, positions) {
+    return {
+        code,
+        pc: 0,
+        slots: new Array(slots).fill(ABSENT),
+        cellBase,
+        stateBase,
+        series,
+        stack: [],
+        positions,
+    };
+}
+/**
+ * The line and column of one instruction.
+ *
+ * A binary search rather than a scan, because a program with four thousand
+ * instructions raising a diagnostic inside a loop would otherwise walk the
+ * table once per raise, and a debugger stepping instruction by instruction asks
+ * for this on every step.
+ */
+export function positionAt(positions, pc) {
+    let low = 0;
+    let high = positions.length - 1;
+    let found;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const entry = positions[middle];
+        if (entry === undefined)
+            break;
+        if (entry[0] <= pc) {
+            found = entry;
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return found === undefined ? { line: 0, column: 0 } : { line: found[1], column: found[2] };
+}
+//# sourceMappingURL=frames.js.map

package/dist/core/engine/frames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.js","sourceRoot":"","sources":["../../../src/core/engine/frames.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAe3C,MAAM,UAAU,SAAS,CACvB,IAA4B,EAC5B,KAAa,EACb,QAAgB,EAChB,SAAiB,EACjB,MAAyB,EACzB,SAA8B;IAE9B,OAAO;QACL,IAAI;QACJ,EAAE,EAAE,CAAC;QACL,KAAK,EAAE,IAAI,KAAK,CAAQ,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QAC3C,QAAQ;QACR,SAAS;QACT,MAAM;QACN,KAAK,EAAE,EAAE;QACT,SAAS;KACV,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,SAA8B,EAAE,EAAU;IAInE,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IAAI,IAAI,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAChC,IAAI,KAA2B,CAAC;IAChC,OAAO,GAAG,IAAI,IAAI,EAAE,CAAC;QACnB,MAAM,MAAM,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,IAAI,KAAK,KAAK,SAAS;YAAE,MAAM;QAC/B,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YACnB,KAAK,GAAG,KAAK,CAAC;YACd,GAAG,GAAG,MAAM,GAAG,CAAC,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IACD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7F,CAAC"}

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

@@ -0,0 +1,25 @@
+import type { ResolvedInput } from './inputs.js';
+import type { CompiledProgram } from './types.js';
+import type { GridCell, Heap, Value } from './values/index.js';
+/** A grid the program declared, with the cells this bar wrote into it. */
+export interface Grid {
+    readonly key: string;
+    readonly rows: number;
+    readonly cols: number;
+    readonly cells: readonly GridCell[];
+}
+export declare class Grids {
+    private readonly heap;
+    private readonly declared;
+    constructor(program: CompiledProgram, inputs: readonly ResolvedInput[], heap: Heap);
+    get empty(): boolean;
+    /** Step 3: every cell buffer starts each execution of a bar empty. */
+    clear(): void;
+    /** Step 5: each grid's handle lands in the slot its declaration named. */
+    fill(slots: Value[]): void;
+    /** A grid is reachable for as long as the study is, whatever a script holds. */
+    walk(visit: (value: Value) => void): void;
+    /** The grids and the cells the last executed bar wrote into them. */
+    read(): readonly Grid[];
+}
+//# sourceMappingURL=grids.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grids.d.ts","sourceRoot":"","sources":["../../../src/core/engine/grids.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/D,0EAA0E;AAC1E,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC;AASD,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAO;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;gBAEnC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,aAAa,EAAE,EAAE,IAAI,EAAE,IAAI;IAoBlF,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,sEAAsE;IACtE,KAAK,IAAI,IAAI;IAOb,0EAA0E;IAC1E,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI;IAI1B,gFAAgF;IAChF,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAIzC,qEAAqE;IACrE,IAAI,IAAI,SAAS,IAAI,EAAE;CAYxB"}

package/dist/core/engine/grids.js

@@ -0,0 +1,77 @@
+/**
+ * The grids a program declares, and the four points in the bar cycle they touch.
+ *
+ * A grid is the one output that is neither a channel nor an instruction.
+ * `table()` emits no code at all: the declaration fixes the grid's shape before
+ * bar 0, exactly as an input's does, and the engine puts the handle in the
+ * declared slot at step 5 (`compiled-program.md` 2.8 and 5.1). Building one per
+ * bar would give a script a different object every bar for something the format
+ * calls part of the study's fixed shape, and a script that kept the handle in a
+ * `var` would be holding last bar's grid.
+ *
+ * **The cells are a buffer, not a history.** Step 3 empties every grid's cells,
+ * so what a host reads after a run is what the last executed bar wrote and
+ * nothing before it. That is why a re-executed bar rebuilds its grid rather than
+ * doubling it, why a checkpoint holds none of it, and why a hundred thousand
+ * bars of history cost a host exactly one grid to draw.
+ */
+import { fieldValue } from './inputs.js';
+import { reference } from './values/index.js';
+export class Grids {
+    heap;
+    declared;
+    constructor(program, inputs, heap) {
+        this.heap = heap;
+        const declared = [];
+        for (const one of program.outputs.tables) {
+            const rows = fieldValue(one.rows, inputs);
+            const cols = fieldValue(one.cols, inputs);
+            const id = heap.allocate({
+                kind: 'table',
+                rows: typeof rows === 'number' ? rows : 0,
+                cols: typeof cols === 'number' ? cols : 0,
+                cells: [],
+            });
+            declared.push({ key: one.key, slot: one.slot, id });
+        }
+        this.declared = declared;
+        // The grids exist before the first bar, so nothing about them belongs to a
+        // bar's undo journal.
+        heap.commit();
+    }
+    get empty() {
+        return this.declared.length === 0;
+    }
+    /** Step 3: every cell buffer starts each execution of a bar empty. */
+    clear() {
+        for (const grid of this.declared) {
+            const object = this.heap.get(grid.id);
+            if (object !== undefined && object.kind === 'table')
+                object.cells = [];
+        }
+    }
+    /** Step 5: each grid's handle lands in the slot its declaration named. */
+    fill(slots) {
+        for (const grid of this.declared)
+            slots[grid.slot] = reference(grid.id);
+    }
+    /** A grid is reachable for as long as the study is, whatever a script holds. */
+    walk(visit) {
+        for (const grid of this.declared)
+            visit(reference(grid.id));
+    }
+    /** The grids and the cells the last executed bar wrote into them. */
+    read() {
+        return this.declared.map((grid) => {
+            const object = this.heap.get(grid.id);
+            const table = object !== undefined && object.kind === 'table' ? object : undefined;
+            return {
+                key: grid.key,
+                rows: table?.rows ?? 0,
+                cols: table?.cols ?? 0,
+                cells: table?.cells ?? [],
+            };
+        });
+    }
+}
+//# sourceMappingURL=grids.js.map

package/dist/core/engine/grids.js.map

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

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

@@ -0,0 +1,4 @@
+import type { Budget } from './budget.js';
+import type { Guard } from './library/index.js';
+export declare function guardFor(budget: Budget): Guard;
+//# sourceMappingURL=guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../../src/core/engine/guard.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAkD9C"}

package/dist/core/engine/guard.js

@@ -0,0 +1,46 @@
+import { raise } from './errors.js';
+export function guardFor(budget) {
+    return {
+        array(span, name, size) {
+            budget.checkArray(span, name, size);
+        },
+        string(span, text) {
+            return budget.checkString(span, text);
+        },
+        chars(span, length) {
+            budget.checkLength(span, length);
+        },
+        drawing(span, held) {
+            budget.checkDrawing(span, held);
+        },
+        /**
+         * An argument outside its contract, OS4003.
+         *
+         * The compile-time half of this is OS3004, which the checker raises when
+         * the argument is a literal. This is the run-time half, for a length a
+         * script computed, and it names the call and the parameter so the reader is
+         * looking at one argument rather than at a line.
+         */
+        badArgument(span, name, argument, found) {
+            raise('OS4003', span, { name, argument, found });
+        },
+        badIndex(span, name, index, size) {
+            raise('OS4004', span, { index, name, size });
+        },
+        deleted(span, kind, bar) {
+            raise('OS4005', span, { kind, bar });
+        },
+        /**
+         * A timezone name the host's table does not hold, OS6005.
+         *
+         * Not absence, because an absent answer here would be indistinguishable
+         * from a host that stated no timezone at all, and not an invented offset,
+         * because an offset is silently wrong for half the year anywhere that
+         * observes a seasonal clock change.
+         */
+        badZone(span, value) {
+            raise('OS6005', span, { value });
+        },
+    };
+}
+//# sourceMappingURL=guard.js.map

package/dist/core/engine/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../../src/core/engine/guard.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,MAAM,UAAU,QAAQ,CAAC,MAAc;IACrC,OAAO;QACL,KAAK,CAAC,IAAU,EAAE,IAAY,EAAE,IAAY;YAC1C,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,CAAC,IAAU,EAAE,IAAY;YAC7B,OAAO,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;QAED,KAAK,CAAC,IAAU,EAAE,MAAc;YAC9B,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,OAAO,CAAC,IAAU,EAAE,IAAY;YAC9B,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC;QAED;;;;;;;WAOG;QACH,WAAW,CAAC,IAAU,EAAE,IAAY,EAAE,QAAgB,EAAE,KAAa;YACnE,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;QACnD,CAAC;QAED,QAAQ,CAAC,IAAU,EAAE,IAAY,EAAE,KAAa,EAAE,IAAY;YAC5D,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,OAAO,CAAC,IAAU,EAAE,IAAY,EAAE,GAAW;YAC3C,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;QACvC,CAAC;QAED;;;;;;;WAOG;QACH,OAAO,CAAC,IAAU,EAAE,KAAa;YAC/B,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACnC,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,219 @@
+/**
+ * What a host supplies, `compiled-program.md` 5.2.
+ *
+ * An engine reads all of this from the host and none of it from anywhere else.
+ * The interface is small on purpose: every fact on it is one a host already
+ * has, and nothing on it is something an engine could work out and then
+ * disagree with the host about.
+ *
+ * **The strategy's position is not here, and that is the point of the duty.**
+ * An account position is held per contract and is shared with every other
+ * strategy and every manual trade in it, so a strategy that read one would be
+ * deciding against somebody else's trade (`stdlib.md` 17.1). What the position
+ * calls read is the run's own ledger, folded from the orders this strategy sent
+ * and the fills reported for them, and that ledger lives in `ledger/`.
+ *
+ * Every fact is optional and an absent one reads as absence in a script rather
+ * than as a zero or an error. A study that sizes something by the lot size has
+ * to be able to tell "one" from "nobody told me", which is the same argument
+ * 2.10 makes for an absent volume.
+ *
+ * **There is no clock on this interface except `chart.now`.** Section 8.4 is
+ * explicit: no wall clock during a bar, except `chart.now()`, whose value the
+ * host supplies and the conformance suite fixes. The engine's own wall clock
+ * budget is passed separately, in `LoadOptions`, because it decides when to
+ * stop rather than what a script computes.
+ */
+import type { HostBar } from './bars.js';
+import type { PendingEffect } from './channels.js';
+import type { OrderIntent } from './ledger/index.js';
+import type { HostFacts } from './library/index.js';
+import type { SessionHours } from './session/index.js';
+import type { Value } from './values/index.js';
+/** The instrument record, `host-interface.md` 4.1, as the engine reads it. */
+export interface Instrument {
+    readonly symbol?: string;
+    readonly exchange?: string;
+    /** The chart's interval code, which `chart.intervalMinutes` is derived from. */
+    readonly interval?: string;
+    /** An IANA zone name, never a fixed offset, `host-interface.md` 4.1. */
+    readonly timezone?: string;
+    readonly tickSize?: number;
+    readonly lotSize?: number;
+    readonly pointValue?: number;
+    readonly currency?: string;
+    readonly instrumentType?: string;
+    /** The one fact a host must state, because no derivation recovers it. */
+    readonly hasVolume?: boolean;
+    readonly hasOpenInterest?: boolean;
+    /**
+     * The instrument's trading session, `host-interface.md` 4.3.
+     *
+     * The documented source of every per-bar session fact, and the only one: the
+     * engine derives `session.isFirstBar` and `session.isLastBar` from this
+     * hours, the bar's time and the timezone above. A host states the hours it
+     * schedules, once, and is never asked about a bar.
+     */
+    readonly session?: SessionHours;
+}
+/**
+ * Where an applied effect goes: an order route, a log, or nothing at all.
+ *
+ * An order call arrives with the intents it became (`host-interface.md` 7.1),
+ * which is what a host sends and what every frame about it carries back. A
+ * call that sent nothing, and a call with no order in it at all, arrives with
+ * none.
+ */
+export type EffectRoute = (effect: RoutedEffect, bar: number) => void;
+/** An applied effect, with what the engine minted for it at step 9. */
+export interface RoutedEffect extends PendingEffect {
+    readonly intents: readonly OrderIntent[];
+}
+/**
+ * One read, as the host is asked about it, `host-interface.md` 5.2.
+ *
+ * The whole set is handed over at load and never grows during a run: a
+ * request's identity is fixed before bar 0, which is what lets a host fetch in
+ * parallel, cache by instrument and timeframe, and have the answers in hand
+ * before the first bar runs.
+ *
+ * **Every field here is resolved.** The compiled program writes each of the
+ * three identity fields as a value, a setting to read or a chart fact to read
+ * (`compiled-program.md` 2.16), and two of its spellings mean "the chart's
+ * own": a `null` `symbol` on a `"timeframe"` read, and a `null` `exchange` on
+ * either. Both are resolved against the instrument record before this crosses,
+ * so a host is handed an identity to resolve rather than a rule to apply. A
+ * host that had to apply the rule itself would need the record it already
+ * supplied, and the two would disagree the first time one of them was wrong.
+ *
+ * **There is no range on this shape, and 5.2 says why.** The whole set is known
+ * at load, and at load the engine has been handed no bars, so it has no span to
+ * extend. `warmup` is what it does know, counted in requested bars, and the host
+ * turns it into instants from the chart's own bars.
+ */
+export interface RequestQuery {
+    /** The engine's handle, which every answer and every refusal carries back. */
+    readonly id: number;
+    readonly read: 'timeframe' | 'symbol';
+    /**
+     * The instrument, as `host-interface.md` 9 defines an identity: the one the
+     * script named, or the chart's own on a read of the chart's own instrument.
+     *
+     * Absent only where a `"symbol"` read's identity did not resolve to a string,
+     * which is a setting holding something that is not an instrument. The chart's
+     * own is never substituted there: a read of another instrument that quietly
+     * became a read of this one is a line on a chart nobody asked for.
+     */
+    readonly instrument: string | null;
+    /**
+     * Where it trades: the exchange the script named, or the chart's own when it
+     * named none, which is `stdlib.md` 15.1's documented default.
+     */
+    readonly exchange: string | null;
+    /** A timeframe string, `stdlib.md` 15.2, resolved from the program. */
+    readonly timeframe: string;
+    readonly mode: 'confirmed' | 'developing' | 'lookahead';
+    /**
+     * Requested bars of history the expression needs, or nothing when no number
+     * is known.
+     *
+     * A floor rather than a promise: a host that extends the range backwards by
+     * less gets a read that is absent for longer, never a wrong number.
+     */
+    readonly warmup: number | null;
+}
+/**
+ * Why a host cannot answer, `host-interface.md` 5.4.
+ *
+ * **A refusal is reported and is never an empty answer**, because an empty
+ * series looks exactly like an instrument that did not trade. The reason text
+ * reaches the script through `req.error(read)`, and the study keeps drawing
+ * everything that does not depend on the failed read.
+ */
+export interface RequestRefusal {
+    readonly code: 'OS6007' | 'OS6008' | 'OS6009' | 'OS6014' | 'OS6015';
+    /** The host's own words, carried and never paraphrased, for OS6009. */
+    readonly reason?: string;
+    /** The intervals the host does serve for this instrument, for OS6014. */
+    readonly available?: string;
+}
+/**
+ * What a host says about one read.
+ *
+ * `bars` is the answer: the host's own bars at the requested timeframe, oldest
+ * first, never padded or synthesised. `refused` is 5.4.
+ *
+ * `pending` is a host that is still fetching. The read is absent and
+ * `req.isReady` is false, and it stays that way for this run: 5.3 delivers an
+ * answer between bars and then recalculates the study over its whole history,
+ * which is a fresh load rather than an answer spliced into a run already past
+ * the bars it would have changed. A host that wants the engine to fold the
+ * chart's own bars instead returns nothing at all.
+ */
+export type RequestAnswer = {
+    readonly bars: readonly HostBar[];
+} | {
+    readonly pending: true;
+} | {
+    readonly refused: RequestRefusal;
+};
+/**
+ * Where the engine asks for another instrument's or another interval's bars.
+ *
+ * Returning nothing means the host does not serve this request. On a read of
+ * the chart's own instrument that is the ordinary case and the engine folds the
+ * bars it already holds; on a read of another instrument the engine holds none
+ * of them, so nothing to serve is OS6007.
+ */
+export type RequestProvider = (query: RequestQuery) => RequestAnswer | undefined;
+export interface EngineHost {
+    readonly instrument?: Instrument;
+    /** The chart clock, for `chart.now()`. Fixed by the host, never read here. */
+    readonly now?: number;
+    /**
+     * Where step 9 sends an applied effect.
+     *
+     * An engine with no route still runs every study ever written and refuses
+     * exactly the strategies, because `orders` is then a capability it does not
+     * declare and OS6006 names it at load.
+     */
+    readonly route?: EffectRoute;
+    /**
+     * Bars for another instrument or another interval, `host-interface.md` 5.
+     *
+     * Optional, and the capability follows it: a host with no provider declares
+     * no `req.symbol`, so a program that reads another instrument is refused at
+     * load with OS6006 naming the tag rather than drawing a study with a silently
+     * empty line through it. `req.timeframe` needs no provider, because the
+     * engine folds the chart's own bars, which is the read 5.1 says an engine can
+     * satisfy from what it already holds.
+     */
+    readonly requestBars?: RequestProvider;
+}
+/** A number the host stated, or absence when it stated none. */
+export declare function hostNumber(value: number | undefined): Value;
+export declare function hostString(value: string | undefined): Value;
+/** A condition the host stated, or absence when it stated none. */
+export declare function hostBool(value: boolean | undefined): Value;
+/**
+ * What the request set can say about a read, so this file need not know it.
+ *
+ * `req.isReady` and `req.error` name a read rather than taking its value, which
+ * is why the compiler resolved the name to the request's id: a value on a bar
+ * cannot say which request produced it (2.16). A read this program does not
+ * make has not been answered and has reported no reason.
+ */
+export interface RequestReplies {
+    answered(id: Value): Value;
+    failure(id: Value): Value;
+}
+/**
+ * The facts a library call reads, built over one host.
+ *
+ * The host is fetched through a function rather than captured, because a host
+ * may be replaced between two runs of one engine and every read here has to see
+ * the one in force now. Every entry is one row of `compiled-program.md` 5.2 and
+ * there is no row that is not on that list.
+ */
+export declare function hostFactsFor(of: () => EngineHost, reads: RequestReplies): HostFacts;
+//# sourceMappingURL=host.d.ts.map

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

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

package/dist/core/engine/host.js

@@ -0,0 +1,38 @@
+/** A number the host stated, or absence when it stated none. */
+export function hostNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+export function hostString(value) {
+    return typeof value === 'string' ? value : null;
+}
+/** A condition the host stated, or absence when it stated none. */
+export function hostBool(value) {
+    return typeof value === 'boolean' ? value : null;
+}
+/**
+ * The facts a library call reads, built over one host.
+ *
+ * The host is fetched through a function rather than captured, because a host
+ * may be replaced between two runs of one engine and every read here has to see
+ * the one in force now. Every entry is one row of `compiled-program.md` 5.2 and
+ * there is no row that is not on that list.
+ */
+export function hostFactsFor(of, reads) {
+    return {
+        symbol: () => hostString(of().instrument?.symbol),
+        exchange: () => hostString(of().instrument?.exchange),
+        interval: () => hostString(of().instrument?.interval),
+        timezone: () => hostString(of().instrument?.timezone),
+        tickSize: () => hostNumber(of().instrument?.tickSize),
+        lotSize: () => hostNumber(of().instrument?.lotSize),
+        pointValue: () => hostNumber(of().instrument?.pointValue),
+        currency: () => hostString(of().instrument?.currency),
+        instrumentType: () => hostString(of().instrument?.instrumentType),
+        hasVolume: () => hostBool(of().instrument?.hasVolume),
+        hasOpenInterest: () => hostBool(of().instrument?.hasOpenInterest),
+        now: () => hostNumber(of().now),
+        requestReady: (id) => reads.answered(id),
+        requestError: (id) => reads.failure(id),
+    };
+}
+//# sourceMappingURL=host.js.map

package/dist/core/engine/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../src/core/engine/host.ts"],"names":[],"mappings":"AAsMA,gEAAgE;AAChE,MAAM,UAAU,UAAU,CAAC,KAAyB;IAClD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAyB;IAClD,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,QAAQ,CAAC,KAA0B;IACjD,OAAO,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACnD,CAAC;AAeD;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,EAAoB,EAAE,KAAqB;IACtE,OAAO;QACL,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC;QACjD,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QACrD,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QACrD,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QACrD,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QACrD,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;QACnD,UAAU,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC;QACzD,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QACrD,cAAc,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC;QACjE,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,SAAS,CAAC;QACrD,eAAe,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC;QACjE,GAAG,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;QAC/B,YAAY,EAAE,CAAC,EAAS,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/C,YAAY,EAAE,CAAC,EAAS,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;KAC/C,CAAC;AACJ,CAAC"}