openalgo-script 0.4.0 → 0.6.0

package/dist/core/backtest/walk.js

@@ -0,0 +1,125 @@
+import { diagnosticIn } from './record.js';
+/**
+ * The bars, in order, with the venue answering between them.
+ *
+ * The one ordering rule: deliver, then append, then collect what the append
+ * reported, then ask the venue what this bar did. A driver that asked the venue
+ * before appending would price a fill against a bar the strategy had not seen.
+ */
+export function walk(engine, destination, bars, covered, keep) {
+    const fills = [];
+    const rows = [];
+    const log = [];
+    const frames = [];
+    const diagnostics = [];
+    const intents = new Map();
+    const refs = new Map();
+    const sizes = new Map();
+    let pending = [];
+    let seq = 0;
+    // The bars are a settled history, so the fold is handed all of them before
+    // bar 0 as `Engine.run` hands them. A `"lookahead"` read is the one reading
+    // that can tell (`compiled-program.md` 2.16.2): over history it reads the
+    // bucket a bar is inside in full, and a driver that fed the fold one bar at
+    // a time would answer the bucket so far, which is the live chart's reading.
+    const handed = bars.slice(0, covered.total).map(hostBarOf);
+    engine.history(handed);
+    for (let index = 0; index < covered.total; index += 1) {
+        const bar = bars[index];
+        const held = handed[index];
+        if (bar === undefined || held === undefined)
+            continue;
+        for (const one of pending) {
+            const ref = one.frame.orderRef;
+            if (typeof ref === 'string')
+                refs.set(one.frame.intentId, ref);
+            engine.deliver(one.frame);
+            frames.push(one);
+        }
+        pending = [];
+        const result = engine.append(held, { isConfirmed: true, isRealtime: false }, covered.total);
+        for (const intent of intentsIn(result))
+            intents.set(intent.intentId, intent);
+        seq = settle(result, index, bar, { intents, refs, sizes }, fills, seq);
+        if (result.diagnostic !== undefined) {
+            diagnostics.push(diagnosticIn(result.diagnostic, index));
+            break;
+        }
+        if (keep.rows === true)
+            rows.push([...result.columns]);
+        if (keep.log === true) {
+            for (const one of result.effects) {
+                if (one.effect === 'log')
+                    log.push({ barIndex: index, time: bar.time, value: one.args[0] ?? null });
+            }
+        }
+        pending = destination.answers(index);
+    }
+    return { fills, frames, diagnostics, rows, log };
+}
+/** A recorded bar as the engine is handed one. */
+function hostBarOf(bar) {
+    return {
+        time: bar.time, open: bar.open, high: bar.high, low: bar.low, close: bar.close,
+        volume: bar.volume, oi: bar.oi,
+    };
+}
+/**
+ * The fills one bar's fold settled.
+ *
+ * **The position sizes either side of step 6 are kept here and not read back
+ * from the engine**, because the engine reports a leg's net and a fill settles
+ * against one position reference: the two are different numbers whenever a leg
+ * holds more than one position, which is every flip. They are folded in the
+ * order the frames were folded in, from the same deltas, so they are the same
+ * arithmetic the position book did rather than a second reading of its result.
+ * When `FrameOutcome` carries them, these two lines come from the engine and
+ * this fold keeps only the sequence number.
+ *
+ * A refused frame settles nothing and is not a fill. Today the fold reports the
+ * refusal as a word rather than a code, so nothing here can write it into the
+ * record as a diagnostic; that is OS7018 and OS7019, and both are deferred.
+ */
+function settle(result, index, bar, books, fills, from) {
+    let seq = from;
+    for (const outcome of result.frames) {
+        if (outcome.refused !== undefined)
+            continue;
+        if (outcome.delta <= 0 || outcome.price === null)
+            continue;
+        const intent = books.intents.get(outcome.intentId);
+        if (intent === undefined || intent.side === null)
+            continue;
+        const before = books.sizes.get(intent.positionRef) ?? 0;
+        const after = before + (intent.side === 'sell' ? -outcome.delta : outcome.delta);
+        books.sizes.set(intent.positionRef, after);
+        seq += 1;
+        fills.push({
+            seq,
+            intentId: outcome.intentId,
+            orderRef: books.refs.get(outcome.intentId) ?? '',
+            tag: intent.tag,
+            positionRef: intent.positionRef,
+            side: intent.side,
+            units: outcome.delta,
+            price: outcome.price,
+            // The bar the fold happened at, which is the bar the position exists
+            // from. Where the fill itself traded is the bar before it or this bar's
+            // own open, and neither is a bar the strategy could have acted on it in.
+            barIndex: index,
+            barTime: bar.time,
+            refSizeBefore: before,
+            refSizeAfter: after,
+        });
+    }
+    return seq;
+}
+/** Every intent one bar handed over, in the order the bar applied them. */
+function intentsIn(result) {
+    const out = [];
+    for (const effect of result.effects)
+        for (const intent of effect.intents)
+            out.push(intent);
+    return out;
+}
+//# sourceMappingURL=walk.js.map

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

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

package/dist/core/catalogue/catalogue.generated.d.ts

@@ -9,6 +9,7 @@ export declare const STAGE_LABELS: {
     readonly check: "checker";
     readonly runtime: "engine";
     readonly host: "host";
+    readonly import: "importer";
 };
 export declare const ENTRIES: {
     readonly OS1001: {
@@ -814,6 +815,28 @@ export declare const ENTRIES: {
         readonly fix: "Give the title something to say: input(2, \"Precision\").";
         readonly placeholders: readonly [];
     };
+    readonly OS3025: {
+        readonly code: "OS3025";
+        readonly title: "A setting is part of a larger expression here";
+        readonly severity: "error";
+        readonly stage: "check";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{option} is fixed before the first bar and holds an input() only as the whole of its value, so it cannot hold an expression over one.";
+        readonly fix: "Declare the setting as the value itself, with an input() written as the whole of {option}, or write the value out as a literal.";
+        readonly placeholders: readonly ["option"];
+    };
+    readonly OS3026: {
+        readonly code: "OS3026";
+        readonly title: "This option cannot be a setting";
+        readonly severity: "error";
+        readonly stage: "check";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{option} is written into the compiled program as a plain value, so a setting cannot choose it in this format version.";
+        readonly fix: "Write the option out as a string literal and drop the input(): style = \"step\", for instance, is one of the values OS3008 names.";
+        readonly placeholders: readonly ["option"];
+    };
     readonly OS4001: {
         readonly code: "OS4001";
         readonly title: "History index is not usable";
@@ -1196,7 +1219,7 @@ export declare const ENTRIES: {
         readonly since: 1;
         readonly autofix: false;
         readonly message: "The host did not supply {fact} for {symbol}.";
-        readonly fix: "Supply {fact} in the host's instrument record, or stop depending on it: round with a number the script chooses rather than chart.tickSize.";
+        readonly fix: "Supply {fact} in the host's instrument record for {symbol}, or leave the session out of the record, which makes every session read absent rather than wrong.";
         readonly placeholders: readonly ["fact", "symbol"];
     };
     readonly OS6013: {
@@ -1295,7 +1318,7 @@ export declare const ENTRIES: {
         readonly since: 1;
         readonly autofix: false;
         readonly message: "{setting} cannot be applied: {problem}.";
-        readonly fix: "State the setting so it can be carried out: declare a charge line after every line it is levied on, supply the tick size a slippage in ticks is measured in, or write down the reason a tolerance needs a bound. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.";
+        readonly fix: "State the setting so it can be carried out: declare a charge line after every line it is levied on, supply the tick size a slippage in ticks is measured in, write down the reason a tolerance needs a bound, or bring a bound past the cap back inside it. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.";
         readonly placeholders: readonly ["setting", "problem"];
     };
     readonly OS6022: {
@@ -1320,6 +1343,28 @@ export declare const ENTRIES: {
         readonly fix: "Supply the schedule and leave the declaration's commission at its default of zero, or state the commission in the declaration and supply no schedule. A schedule is the one of the two that can carry a floor, a cap, a charge levied on a charge, and a cost that falls on one side of the trade only.";
         readonly placeholders: readonly ["commission", "commissionType"];
     };
+    readonly OS6024: {
+        readonly code: "OS6024";
+        readonly title: "The host cannot draw something this study declares";
+        readonly severity: "error";
+        readonly stage: "host";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "This host cannot draw {what}: {limit}.";
+        readonly fix: "Declare what this host draws, or run the study on a host that draws {what}.";
+        readonly placeholders: readonly ["what", "limit"];
+    };
+    readonly OS6025: {
+        readonly code: "OS6025";
+        readonly title: "A bar has no time";
+        readonly severity: "error";
+        readonly stage: "host";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "Bar {index} was handed over with no time.";
+        readonly fix: "State the bar's open instant in whole milliseconds since the Unix epoch, UTC, and leave out a bar the host cannot date rather than handing it over without a time.";
+        readonly placeholders: readonly ["index"];
+    };
     readonly OS7001: {
         readonly code: "OS7001";
         readonly title: "Only a strategy can do that";
@@ -1738,6 +1783,138 @@ export declare const ENTRIES: {
         readonly fix: "Assign none to the name on the same path as the delete, and where the object came out of an array, remove the element as well as deleting the object.";
         readonly placeholders: readonly ["name", "kind", "line"];
     };
+    readonly OS9001: {
+        readonly code: "OS9001";
+        readonly title: "Version not read by the importer";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "The importer reads scripts written for version 5 or 6 of the source dialect, and this one {found}.";
+        readonly fix: "Bring the script up to version 5 or 6 in the source dialect, or translate it by hand, and import it again.";
+        readonly placeholders: readonly ["found"];
+    };
+    readonly OS9002: {
+        readonly code: "OS9002";
+        readonly title: "Construct with no equivalent";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "The importer cannot translate {construct}, so the statement holding it was kept as a comment.";
+        readonly fix: "Translate that statement by hand from the comment that holds it: the rest of the script was translated around it.";
+        readonly placeholders: readonly ["construct"];
+    };
+    readonly OS9003: {
+        readonly code: "OS9003";
+        readonly title: "Built-in with no mapping";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{name} is not one of the built-ins the importer maps, so the statement holding it was kept as a comment.";
+        readonly fix: "Find the OpenScript library call that does the same job, check how it treats its first bars and absent values, and write the statement by hand.";
+        readonly placeholders: readonly ["name"];
+    };
+    readonly OS9004: {
+        readonly code: "OS9004";
+        readonly title: "Declaration the importer cannot place";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "The importer writes the declaration from one indicator or strategy call at the top level, and this script {found}.";
+        readonly fix: "Give the source script exactly one indicator or strategy declaration at the top level, and import it again.";
+        readonly placeholders: readonly ["found"];
+    };
+    readonly OS9005: {
+        readonly code: "OS9005";
+        readonly title: "Reads a statement that was not translated";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{name} is declared by the statement at line {line}, which was not translated, so this statement that reads it was kept as a comment too.";
+        readonly fix: "Translate the statement at line {line} by hand first, then this one, which was kept as a comment only because it reads {name}.";
+        readonly placeholders: readonly ["name", "line"];
+    };
+    readonly OS9006: {
+        readonly code: "OS9006";
+        readonly title: "Argument with no equivalent";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{argument} changes what {call} computes or trades, and OpenScript has no equivalent the importer can write.";
+        readonly fix: "Translate the call by hand, deciding what OpenScript should do in place of {argument}, or remove {argument} from the source script if the script does not depend on it.";
+        readonly placeholders: readonly ["argument", "call"];
+    };
+    readonly OS9007: {
+        readonly code: "OS9007";
+        readonly title: "Warmup and absent bars follow OpenScript";
+        readonly severity: "warning";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{call} became {target} here and wherever else the script calls it, and {target} follows OpenScript's own warmup, arithmetic and handling of absent values, which the original is not guaranteed to share.";
+        readonly fix: "Compare the first bars of the translation with the original, and where the script depends on them, write the value as an explicit recurrence held in var, seeded the way the original seeds it.";
+        readonly placeholders: readonly ["call", "target"];
+    };
+    readonly OS9008: {
+        readonly code: "OS9008";
+        readonly title: "Whole-number division in version 5";
+        readonly severity: "warning";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "Both sides of this division are whole-number constants, which version 5 of the source dialect divides without a fractional part, and OpenScript keeps the fraction.";
+        readonly fix: "If the script relied on the whole-number result, wrap the translated division in trunc(); otherwise leave it as it is.";
+        readonly placeholders: readonly [];
+    };
+    readonly OS9009: {
+        readonly code: "OS9009";
+        readonly title: "Presentation argument left out";
+        readonly severity: "warning";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{argument} changes how {call} is displayed or what it may allocate, not what it computes, and OpenScript has no equivalent, so the translation leaves it out.";
+        readonly fix: "Nothing needs to change unless the display mattered; where it did, restyle the translated call with the arguments OpenScript does have, such as its colour, width and style.";
+        readonly placeholders: readonly ["argument", "call"];
+    };
+    readonly OS9010: {
+        readonly code: "OS9010";
+        readonly title: "Order placed under OpenScript's order model";
+        readonly severity: "warning";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "{call} was translated into OpenScript's order calls here and wherever else the script uses it, and OpenScript decides when an order fills, how a reversal and a repeated entry are handled and when an exit level starts to apply by its own order model.";
+        readonly fix: "Backtest the translation beside the original and compare the two trade lists before relying on it, and adjust the order calls by hand where they part.";
+        readonly placeholders: readonly ["call"];
+    };
+    readonly OS9011: {
+        readonly code: "OS9011";
+        readonly title: "Equality over two absent values";
+        readonly severity: "warning";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "Both sides of {operator} can be absent on the same bar, and OpenScript counts two absent values as equal, which the original is not guaranteed to do.";
+        readonly fix: "If the original relied on two absent values never comparing equal, guard the translated comparison with isNone() on either side.";
+        readonly placeholders: readonly ["operator"];
+    };
+    readonly OS9012: {
+        readonly code: "OS9012";
+        readonly title: "The translation does not compile";
+        readonly severity: "error";
+        readonly stage: "import";
+        readonly since: 1;
+        readonly autofix: false;
+        readonly message: "The OpenScript compiler refused the translation of this statement with {code}, so the statement was kept as a comment.";
+        readonly fix: "Look up {code} in this catalogue and translate the statement by hand in the form that code's fix describes.";
+        readonly placeholders: readonly ["code"];
+    };
 };
 /** Every code the compiler and the engines may emit. Nothing else is one. */
 export type DiagnosticCode = keyof typeof ENTRIES;

package/dist/core/catalogue/catalogue.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalogue.generated.d.ts","sourceRoot":"","sources":["../../../src/core/catalogue/catalogue.generated.ts"],"names":[],"mappings":"AAQA,uEAAuE;AACvE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,oDAAoD;AACpD,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,+FAA+F;AAC/F,eAAO,MAAM,YAAY;;;;;;CAM2B,CAAC;AAErD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8JyC,CAAC;AAE9D,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,OAAO,CAAC"}
+{"version":3,"file":"catalogue.generated.d.ts","sourceRoot":"","sources":["../../../src/core/catalogue/catalogue.generated.ts"],"names":[],"mappings":"AAQA,uEAAuE;AACvE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,oDAAoD;AACpD,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,+FAA+F;AAC/F,eAAO,MAAM,YAAY;;;;;;;CAO2B,CAAC;AAErD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8KyC,CAAC;AAE9D,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,OAAO,CAAC"}

package/dist/core/catalogue/catalogue.generated.js

@@ -13,6 +13,7 @@ export const STAGE_LABELS = {
     check: "checker",
     runtime: "engine",
     host: "host",
+    import: "importer",
 };
 export const ENTRIES = {
     OS1001: { code: "OS1001", title: "Unexpected character", severity: "error", stage: "lex", since: 1, autofix: true, message: "Unexpected character {char}. {suggestion}", fix: "Delete the character or replace it with the plain ASCII spelling the message names: a plain space for a non-breaking space, a straight quote for a typographic one, not for !, and for &&, or for ||, pow(a, b) for ^.", placeholders: ["char", "suggestion"] },
@@ -88,6 +89,8 @@ export const ENTRIES = {
     OS3022: { code: "OS3022", title: "Two inputs share a settings key", severity: "error", stage: "check", since: 1, autofix: false, message: "This input is keyed by its title {name}, which is already the name of the input at line {line}.", fix: "Give this one a title of its own, or rename the input at line {line}.", placeholders: ["name", "line"] },
     OS3023: { code: "OS3023", title: "An order names a leg this file does not declare", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} was given a {argument}, and this file declares none.", fix: "Leave {argument} out. A file that declares no leg has exactly one, and every order acts on it.", placeholders: ["name", "argument"] },
     OS3024: { code: "OS3024", title: "An input written in place has an empty title", severity: "error", stage: "check", since: 1, autofix: false, message: "An input() assigned to no name is named by its title, and this one's title is empty.", fix: "Give the title something to say: input(2, \"Precision\").", placeholders: [] },
+    OS3025: { code: "OS3025", title: "A setting is part of a larger expression here", severity: "error", stage: "check", since: 1, autofix: false, message: "{option} is fixed before the first bar and holds an input() only as the whole of its value, so it cannot hold an expression over one.", fix: "Declare the setting as the value itself, with an input() written as the whole of {option}, or write the value out as a literal.", placeholders: ["option"] },
+    OS3026: { code: "OS3026", title: "This option cannot be a setting", severity: "error", stage: "check", since: 1, autofix: false, message: "{option} is written into the compiled program as a plain value, so a setting cannot choose it in this format version.", fix: "Write the option out as a string literal and drop the input(): style = \"step\", for instance, is one of the values OS3008 names.", placeholders: ["option"] },
     OS4001: { code: "OS4001", title: "History index is not usable", severity: "error", stage: "runtime", since: 1, autofix: false, message: "[{index}] is not a whole number of bars at or above zero.", fix: "Wrap the index in floor() or round(), and clamp a computed index with max(0, n).", placeholders: ["index"] },
     OS4002: { code: "OS4002", title: "History index is deeper than the retained depth", severity: "error", stage: "runtime", since: 1, autofix: false, message: "[{index}] reaches past the retained depth of {depth} bars.", fix: "Raise the depth in one place: limits(history = {suggested}).", placeholders: ["index", "depth", "suggested"] },
     OS4003: { code: "OS4003", title: "A whole number was required here", severity: "error", stage: "runtime", since: 1, autofix: false, message: "{name}'s {argument} was {found} on this bar; a whole number was required.", fix: "Round the value before passing it: floor() towards zero, round() to nearest.", placeholders: ["name", "argument", "found"] },
@@ -122,7 +125,7 @@ export const ENTRIES = {
     OS6009: { code: "OS6009", title: "The request failed", severity: "error", stage: "host", since: 1, autofix: false, message: "The host could not fetch {symbol} at {timeframe}: {reason}.", fix: "Act on {reason} in the host: it is a connection, permission or quota problem. Where the value can be derived from the chart's own bars, derive it and drop the request.", placeholders: ["symbol", "timeframe", "reason"] },
     OS6010: { code: "OS6010", title: "The engine was given no bars", severity: "error", stage: "host", since: 1, autofix: false, message: "There are no bars for {symbol} at {timeframe}, so the script cannot run.", fix: "Choose an instrument and interval that have history, or widen the chart's date range until bars exist.", placeholders: ["symbol", "timeframe"] },
     OS6011: { code: "OS6011", title: "The bars are not in order", severity: "error", stage: "host", since: 1, autofix: false, message: "Bar {index} is dated {time}, which is not after bar {previous}.", fix: "Reload the history; if the same bar repeats, the feed is sending duplicates and the host has to sort and deduplicate the bars before the engine runs.", placeholders: ["index", "time", "previous"] },
-    OS6012: { code: "OS6012", title: "An instrument fact is not known", severity: "error", stage: "host", since: 1, autofix: false, message: "The host did not supply {fact} for {symbol}.", fix: "Supply {fact} in the host's instrument record, or stop depending on it: round with a number the script chooses rather than chart.tickSize.", placeholders: ["fact", "symbol"] },
+    OS6012: { code: "OS6012", title: "An instrument fact is not known", severity: "error", stage: "host", since: 1, autofix: false, message: "The host did not supply {fact} for {symbol}.", fix: "Supply {fact} in the host's instrument record for {symbol}, or leave the session out of the record, which makes every session read absent rather than wrong.", placeholders: ["fact", "symbol"] },
     OS6013: { code: "OS6013", title: "The request changed after the first bar", severity: "error", stage: "runtime", since: 1, autofix: false, message: "This request asked for {first} on bar 0 and for {found} on bar {bar}.", fix: "Compute the symbol and the timeframe from literals or inputs, not from bar data.", placeholders: ["first", "found", "bar"] },
     OS6014: { code: "OS6014", title: "The feed does not offer this timeframe", severity: "error", stage: "host", since: 1, autofix: false, message: "The host has no {timeframe} data for {symbol}; it offers {available}.", fix: "Request one of {available}, or derive the interval you want from a lower one the host does serve.", placeholders: ["timeframe", "symbol", "available"] },
     OS6015: { code: "OS6015", title: "The requested timeframe does not fold into the chart's", severity: "error", stage: "host", since: 1, autofix: false, message: "{requested} is not a whole multiple of {chart}.", fix: "Request a multiple of {chart}, for example {suggestion}.", placeholders: ["requested", "chart", "suggestion"] },
@@ -131,9 +134,11 @@ export const ENTRIES = {
     OS6018: { code: "OS6018", title: "The compiled program is malformed", severity: "error", stage: "host", since: 1, autofix: false, message: "The program failed verification at {location}: {reason}.", fix: "Recompile the script from its source; a program that fails verification came from a broken compiler or was edited after it was written, and neither is repairable by hand.", placeholders: ["location", "reason"] },
     OS6019: { code: "OS6019", title: "A host setting fails the input's validation", severity: "error", stage: "host", since: 1, autofix: false, message: "The host supplied {value} for {key}, and {validation}.", fix: "Correct the value in the settings dialog, or widen the input's own min, max or options so the value is allowed.", placeholders: ["value", "key", "validation"] },
     OS6020: { code: "OS6020", title: "The report window holds no bars", severity: "error", stage: "host", since: 1, autofix: false, message: "The window from {from} to {to} holds none of the {count} bars supplied.", fix: "Widen the window until it covers bars, or supply the bars it covers. Both bounds are inclusive and are compared against the times of the bars supplied rather than against a calendar, so a window that falls inside a gap in the data is empty however wide it looks.", placeholders: ["from", "to", "count"] },
-    OS6021: { code: "OS6021", title: "A run setting cannot be applied as stated", severity: "error", stage: "host", since: 1, autofix: false, message: "{setting} cannot be applied: {problem}.", fix: "State the setting so it can be carried out: declare a charge line after every line it is levied on, supply the tick size a slippage in ticks is measured in, or write down the reason a tolerance needs a bound. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.", placeholders: ["setting", "problem"] },
+    OS6021: { code: "OS6021", title: "A run setting cannot be applied as stated", severity: "error", stage: "host", since: 1, autofix: false, message: "{setting} cannot be applied: {problem}.", fix: "State the setting so it can be carried out: declare a charge line after every line it is levied on, supply the tick size a slippage in ticks is measured in, write down the reason a tolerance needs a bound, or bring a bound past the cap back inside it. Nothing has been computed at the point this is refused, so correcting the setting and running again costs one run.", placeholders: ["setting", "problem"] },
     OS6022: { code: "OS6022", title: "The bars are not the bars the record was made from", severity: "error", stage: "host", since: 1, autofix: false, message: "The bars supplied hash to {found}, and the record was made from {expected}.", fix: "Replay against the bars the record names. Where the revision is the point, make a second record over the revised bars and compare the two runs, rather than overwriting one run with the other under one name.", placeholders: ["found", "expected"] },
     OS6023: { code: "OS6023", title: "Two cost models are stated at once", severity: "error", stage: "host", since: 1, autofix: false, message: "A charge schedule was supplied, and the declaration states a commission of {commission} in {commissionType}.", fix: "Supply the schedule and leave the declaration's commission at its default of zero, or state the commission in the declaration and supply no schedule. A schedule is the one of the two that can carry a floor, a cap, a charge levied on a charge, and a cost that falls on one side of the trade only.", placeholders: ["commission", "commissionType"] },
+    OS6024: { code: "OS6024", title: "The host cannot draw something this study declares", severity: "error", stage: "host", since: 1, autofix: false, message: "This host cannot draw {what}: {limit}.", fix: "Declare what this host draws, or run the study on a host that draws {what}.", placeholders: ["what", "limit"] },
+    OS6025: { code: "OS6025", title: "A bar has no time", severity: "error", stage: "host", since: 1, autofix: false, message: "Bar {index} was handed over with no time.", fix: "State the bar's open instant in whole milliseconds since the Unix epoch, UTC, and leave out a bar the host cannot date rather than handing it over without a time.", placeholders: ["index"] },
     OS7001: { code: "OS7001", title: "Only a strategy can do that", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} is available only in a file declared with strategy().", fix: "Change study(...) on line {line} to strategy(...), or replace {name} with signal(\"...\") to mark the bar without trading.", placeholders: ["name", "line"] },
     OS7002: { code: "OS7002", title: "An order argument is absent", severity: "error", stage: "runtime", since: 1, autofix: false, message: "{name}'s {argument} is absent on this bar.", fix: "Guard the call with isNone({argument}), or supply a fallback with orElse() where one is genuinely correct.", placeholders: ["name", "argument"] },
     OS7003: { code: "OS7003", title: "An order function inside a request expression", severity: "error", stage: "check", since: 1, autofix: false, message: "{name} inside a request expression would place an order from another instrument's bars.", fix: "Read the value with the request, and place the order at the top level from the result.", placeholders: ["name"] },
@@ -172,5 +177,17 @@ export const ENTRIES = {
     OS8017: { code: "OS8017", title: "The condition is constant", severity: "warning", stage: "check", since: 1, autofix: false, message: "This condition is {value} on every bar.", fix: "Restore the test that was meant, or delete the branch that never runs.", placeholders: ["value"] },
     OS8018: { code: "OS8018", title: "An input is never used", severity: "warning", stage: "check", since: 1, autofix: false, message: "The input {title} is declared at line {line} and never read.", fix: "Use the name the input assigns, or delete the input() and its dialog row.", placeholders: ["title", "line"] },
     OS8019: { code: "OS8019", title: "A deleted object is still held", severity: "warning", stage: "check", since: 1, autofix: false, message: "{name} still holds the {kind} deleted at line {line}.", fix: "Assign none to the name on the same path as the delete, and where the object came out of an array, remove the element as well as deleting the object.", placeholders: ["name", "kind", "line"] },
+    OS9001: { code: "OS9001", title: "Version not read by the importer", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer reads scripts written for version 5 or 6 of the source dialect, and this one {found}.", fix: "Bring the script up to version 5 or 6 in the source dialect, or translate it by hand, and import it again.", placeholders: ["found"] },
+    OS9002: { code: "OS9002", title: "Construct with no equivalent", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer cannot translate {construct}, so the statement holding it was kept as a comment.", fix: "Translate that statement by hand from the comment that holds it: the rest of the script was translated around it.", placeholders: ["construct"] },
+    OS9003: { code: "OS9003", title: "Built-in with no mapping", severity: "error", stage: "import", since: 1, autofix: false, message: "{name} is not one of the built-ins the importer maps, so the statement holding it was kept as a comment.", fix: "Find the OpenScript library call that does the same job, check how it treats its first bars and absent values, and write the statement by hand.", placeholders: ["name"] },
+    OS9004: { code: "OS9004", title: "Declaration the importer cannot place", severity: "error", stage: "import", since: 1, autofix: false, message: "The importer writes the declaration from one indicator or strategy call at the top level, and this script {found}.", fix: "Give the source script exactly one indicator or strategy declaration at the top level, and import it again.", placeholders: ["found"] },
+    OS9005: { code: "OS9005", title: "Reads a statement that was not translated", severity: "error", stage: "import", since: 1, autofix: false, message: "{name} is declared by the statement at line {line}, which was not translated, so this statement that reads it was kept as a comment too.", fix: "Translate the statement at line {line} by hand first, then this one, which was kept as a comment only because it reads {name}.", placeholders: ["name", "line"] },
+    OS9006: { code: "OS9006", title: "Argument with no equivalent", severity: "error", stage: "import", since: 1, autofix: false, message: "{argument} changes what {call} computes or trades, and OpenScript has no equivalent the importer can write.", fix: "Translate the call by hand, deciding what OpenScript should do in place of {argument}, or remove {argument} from the source script if the script does not depend on it.", placeholders: ["argument", "call"] },
+    OS9007: { code: "OS9007", title: "Warmup and absent bars follow OpenScript", severity: "warning", stage: "import", since: 1, autofix: false, message: "{call} became {target} here and wherever else the script calls it, and {target} follows OpenScript's own warmup, arithmetic and handling of absent values, which the original is not guaranteed to share.", fix: "Compare the first bars of the translation with the original, and where the script depends on them, write the value as an explicit recurrence held in var, seeded the way the original seeds it.", placeholders: ["call", "target"] },
+    OS9008: { code: "OS9008", title: "Whole-number division in version 5", severity: "warning", stage: "import", since: 1, autofix: false, message: "Both sides of this division are whole-number constants, which version 5 of the source dialect divides without a fractional part, and OpenScript keeps the fraction.", fix: "If the script relied on the whole-number result, wrap the translated division in trunc(); otherwise leave it as it is.", placeholders: [] },
+    OS9009: { code: "OS9009", title: "Presentation argument left out", severity: "warning", stage: "import", since: 1, autofix: false, message: "{argument} changes how {call} is displayed or what it may allocate, not what it computes, and OpenScript has no equivalent, so the translation leaves it out.", fix: "Nothing needs to change unless the display mattered; where it did, restyle the translated call with the arguments OpenScript does have, such as its colour, width and style.", placeholders: ["argument", "call"] },
+    OS9010: { code: "OS9010", title: "Order placed under OpenScript's order model", severity: "warning", stage: "import", since: 1, autofix: false, message: "{call} was translated into OpenScript's order calls here and wherever else the script uses it, and OpenScript decides when an order fills, how a reversal and a repeated entry are handled and when an exit level starts to apply by its own order model.", fix: "Backtest the translation beside the original and compare the two trade lists before relying on it, and adjust the order calls by hand where they part.", placeholders: ["call"] },
+    OS9011: { code: "OS9011", title: "Equality over two absent values", severity: "warning", stage: "import", since: 1, autofix: false, message: "Both sides of {operator} can be absent on the same bar, and OpenScript counts two absent values as equal, which the original is not guaranteed to do.", fix: "If the original relied on two absent values never comparing equal, guard the translated comparison with isNone() on either side.", placeholders: ["operator"] },
+    OS9012: { code: "OS9012", title: "The translation does not compile", severity: "error", stage: "import", since: 1, autofix: false, message: "The OpenScript compiler refused the translation of this statement with {code}, so the statement was kept as a comment.", fix: "Look up {code} in this catalogue and translate the statement by hand in the form that code's fix describes.", placeholders: ["code"] },
 };
 //# sourceMappingURL=catalogue.generated.js.map