@pineforge/codegen-pyodide 1.1.0 → 1.2.0

package/LICENSE

@@ -0,0 +1,245 @@
+PineForge Source License 1.1
+============================
+
+Copyright 2025-2026 pineforge, LLC
+
+Required Notice: Copyright 2025-2026 pineforge, LLC (https://github.com/pineforge-4pass/pineforge-codegen-oss)
+
+The software is free of charge for the permitted purposes below, including
+Personal Trading. Commercial Use, defined below, needs a separate commercial
+license from the licensor.
+
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both
+strict obligations and conditions to all your licenses.
+
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything
+you might do with the software that would otherwise infringe the licensor's
+copyright in it for any permitted purpose. However, you may only distribute
+the software according to the Distribution License section, and make changes
+or new works based on the software according to the Changes and New Works
+License section.
+
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies
+of the software. Your license to distribute covers distributing the software
+with changes and new works permitted by the Changes and New Works License
+section. Unless it is a permitted purpose, distributing the software, changed
+or not, embedded in or bundled with a product or service made available to
+others is Commercial Use under (3) of the Commercial Use section, which your
+license to distribute does not cover. Distributing copies under this section
+is not Commercial Use, and it gives the people who get them no license beyond
+these terms.
+
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms or a link to them, as well as copies of
+any plain-text lines beginning with `Required Notice:` that the licensor
+provided with the software. For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and
+new works based on the software for any permitted purpose.
+
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent
+claims the licensor can license, or becomes able to license, that you would
+infringe by using the software for a permitted purpose.
+
+
+## Permitted Purposes
+
+Each of the following is a permitted purpose:
+
+- **Noncommercial purposes.** Any noncommercial purpose.
+
+- **Personal uses.** Personal use for research, experiment, and testing for
+  the benefit of public knowledge, personal study, private entertainment,
+  hobby projects, amateur pursuits, or religious observance, without any
+  anticipated commercial application.
+
+- **Noncommercial organizations.** Use by any charitable organization,
+  educational institution, public research organization, public safety or
+  health organization, environmental protection organization, or government
+  institution for its teaching, research and other operations, regardless of
+  the source of funding or obligations resulting from the funding.
+
+- **Personal Trading**, as defined in the next section.
+
+Investment Management, defined in the Commercial Use section, is never a
+permitted purpose, except as Personal Trading. That is so even when it is done
+by a noncommercial organization or for a noncommercial purpose.
+
+
+## Personal Trading
+
+**Personal Trading** means use of the software by a natural person to do any
+of the following, solely for trades that meet conditions (a) and (b) below:
+research, develop or backtest trading strategies, or execute trades in
+securities, derivatives, currencies, crypto-assets, commodities or other
+financial instruments.
+
+  (a) The trades are, or will be, placed for that person's own account.
+
+  (b) The trades are, or will be, funded solely by that person's own
+      capital.
+
+For Personal Trading:
+
+  - A person's **household** is that person, their spouse or domestic
+    partner, and their dependants.
+
+  - A person's **own account** includes an account held by the person alone
+    or jointly with members of their household; an account of a member of
+    their household; and a retirement, pension, education-savings or other
+    tax-advantaged account, or an account of a revocable trust, held for the
+    benefit of the person or members of their household.
+
+  - A person's **own capital** includes capital belonging to members of
+    their household, and capital borrowed in the ordinary course from a
+    broker, bank or other lender, such as margin, leverage or credit on a
+    trading account, for which the person or their household is liable.
+    Money the person has received outright, such as pay, a gift or an
+    inheritance, is the person's own capital.
+
+  - Trading in the person's own name, for their own account and with their
+    own capital, is Personal Trading even when it is the person's business
+    or livelihood.
+
+  - Publishing or teaching about the person's own Personal Trading,
+    including its results, is part of Personal Trading even when the person
+    is paid for it, as long as they do not give Output to others.
+
+  - An account of a company, partnership, fund, trust or other
+    organization, other than an account described under own account above,
+    is not the person's own account, even if the person wholly owns or
+    controls it.
+
+  - Capital that an employer, a proprietary-trading firm, a funded-trader
+    program or anyone else outside the person's household provides or
+    allocates to the person to trade, and that the provider still owns or
+    whose losses the provider bears, is not the person's own capital, even
+    if the person shares in the profits.
+
+
+## Commercial Use
+
+**Investment Management** means using the software to manage, advise on, or
+trade investment capital; to research, develop or backtest strategies for
+investment capital that you, or anyone you do the work for, manage, advise on
+or trade; or to operate the software for others who do any of these things;
+in each case whoever the capital belongs to and whether or not for a fee.
+
+**Investment capital** means any money or other assets held for investment or
+trading, including capital belonging to any other person or entity, such as a
+friend or relative, clients or investors, an endowment, a pension or
+retirement fund, a sovereign or other public fund, or the treasury or reserves
+of a foundation or other organization.
+
+**Commercial Use** means any use of the software that is not a permitted
+purpose, other than distributing copies under the Distribution License
+section. Investment Management is Commercial Use for every individual and
+every organization, including the noncommercial organizations listed under
+Permitted Purposes, whatever its purpose, unless it is Personal Trading.
+Unless it is a permitted purpose, each of the following is also Commercial
+Use:
+
+  (1) managing, advising on, or trading capital belonging to any other person
+      or entity, whether or not for a fee;
+
+  (2) use by, for, or on behalf of any company, fund, partnership, or other
+      organization, including use by an individual in the course of work for
+      such an organization;
+
+  (3) embedding the software or its Output, changed or not, into any product
+      or service made available to others, or distributing either bundled
+      with such a product or service, including using the software to
+      generate Output for such a product or service; and
+
+  (4) operating any hosted, software-as-a-service, or otherwise public-facing
+      service through which others can run the software or receive its
+      Output.
+
+Commercial Use requires a separate commercial license from the licensor. To
+obtain one, contact: enterprise@pineforge.dev
+
+
+## Output
+
+**Output** means code that the software generates, such as the C++ source
+code it generates from PineScript, and any program or library built from that
+code. Backtest results, charts, reports and trade signals are not Output.
+
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do
+not limit them.
+
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses
+to anyone else, or prevent the licensor from granting licenses to anyone
+else. These terms do not imply any other licenses.
+
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to
+infringement of any patent, your patent license for the software granted
+under these terms ends immediately. If your company makes such a claim, your
+patent license ends immediately for work on behalf of your company.
+
+
+## Violations
+
+The first time you are notified in writing that you have violated any of
+these terms, or done anything with the software not covered by your licenses,
+your licenses can nonetheless continue if you come into full compliance with
+these terms, and take practical steps to correct past violations, within 32
+days of receiving notice. Otherwise, all your licenses end immediately.
+
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty
+or condition, and the licensor will not be liable to you for any damages
+arising out of these terms or the use or nature of the software, under any
+kind of legal claim.***
+
+
+## Definitions
+
+The **licensor** is pineforge, LLC, and the **software** is the software the
+licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control
+over, are under the control of, or are under common control with that
+organization. **Control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**Use** means anything you do with the software requiring one of your
+licenses.

package/README.md

@@ -16,6 +16,10 @@ Stable releases are on the `latest` dist-tag. A prerelease (for example
 - `transpile.worker.mjs` — an ES module worker that runs the glue in Pyodide.
 - `index.mjs` — exports `release`, `tables`, `archivePath`, `sourceRoot`, `codegenSourceDir`,
   `workerPath` and `glue`.
+- `pineforge_codegen/diagnostics_catalog.json` — the diagnostics catalog (since 1.2.0), also
+  importable as `@pineforge/codegen-pyodide/diagnostics_catalog.json`; the repository's
+  `docs/PUBLIC_CONTRACT.md` describes it.
+- `LICENSE` — the PineForge Source License 1.1 (since 1.2.0), which `package.json` names.
 
 ## Publishing (maintainers)
 A `v*` tag push, which the release workflow makes, publishes through npm OIDC Trusted

package/glue.py

@@ -23,6 +23,10 @@ def _diagnostic_entries(diagnostics) -> list:
             "col": loc.col if loc else 1,
             "message": message,
             "severity": getattr(d.level, "value", "error"),
+            # The stable code and named arguments of the catalog templates the
+            # message (and the hint after " — ") render from.
+            "code": d.code,
+            "args": d.args,
         }
         end_col = getattr(loc, "end_col", None) if loc else None
         if end_col is not None:

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Gate-validated Pyodide payload for the PineScript v6 -> C++ transpiler: archive (run in Pyodide), unpacked source, introspected tables, and release metadata.",
   "type": "module",
   "main": "index.mjs",
   "exports": {
     ".": "./index.mjs",
     "./tables.json": "./tables.json",
-    "./release.json": "./release.json"
+    "./release.json": "./release.json",
+    "./diagnostics_catalog.json": "./pineforge_codegen/diagnostics_catalog.json"
   },
   "files": [
     "index.mjs",
@@ -16,7 +17,8 @@
     "tables.json",
     "release.json",
     "transpile.worker.mjs",
-    "glue.py"
+    "glue.py",
+    "LICENSE"
   ],
   "engines": {
     "node": ">=20"
@@ -35,5 +37,5 @@
     "type": "git",
     "url": "git+https://github.com/pineforge-4pass/pineforge-codegen-oss.git"
   },
-  "license": "PolyForm-Noncommercial-1.0.0"
+  "license": "SEE LICENSE IN LICENSE"
 }

package/pineforge_codegen/__init__.py

@@ -6,6 +6,7 @@ from .lexer import Lexer
 from .parser import Parser
 from .analyzer import Analyzer
 from .codegen import CodeGen
+from .diagnostic_codes import diagnostics_catalog, render_diagnostic
 from .errors import CompileError, Level, Phase
 from .external_requests import lower_no_data_requests
 from .builtin_keywords import bind_builtin_keywords

package/pineforge_codegen/codegen/base.py

@@ -4414,7 +4414,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             return None
 
     def generate(self) -> str:
-        """Generate C++ source from the AnalyzerContext."""
+        """Generate C++ source from the AnalyzerContext.
+
+        An error the settings metadata finds in an input's arguments (emitted
+        in the constructor, ahead of the body: ``checked_settings``) is held
+        until the rest is generated; the error raised is the first in source
+        order, as before that metadata visited the arguments."""
+        self._deferred_settings_errors: list[CompileError] | None = []
+        try:
+            try:
+                cpp = self._generate_cpp()
+            except CompileError as error:
+                first = self._first_settings_error_before(error)
+                if first is None:
+                    raise
+                raise first from None
+            if self._deferred_settings_errors:
+                raise self._deferred_settings_errors[0]
+            return cpp
+        finally:
+            self._deferred_settings_errors = None
+
+    def _defer_settings_error(self, error: CompileError) -> None:
+        held = getattr(self, "_deferred_settings_errors", None)
+        if held is None:   # outside generate(): nothing holds it
+            raise error
+        held.append(error)
+
+    def _first_settings_error_before(self, error: CompileError) -> CompileError | None:
+        """A held settings error located before ``error``, else None."""
+        def where(err: CompileError):
+            loc = err.diagnostics[0].location if err.diagnostics else None
+            return (loc.line, loc.col) if loc is not None else (float("inf"), 0)
+        held = sorted(self._deferred_settings_errors, key=where)
+        if held and where(held[0]) < where(error):
+            return held[0]
+        return None
+
+    def _generate_cpp(self) -> str:
         # Every input is keyed by its title: refuse a non-constant one first,
         # then flag inputs one override key would reach together.
         self._check_input_titles()

package/pineforge_codegen/codegen/capabilities.py

@@ -0,0 +1,186 @@
+"""Immutable execution metadata; it does not alter generated computation."""
+
+import json
+import math
+
+from ..ast_nodes import BoolLiteral, FuncCall, Identifier, MemberAccess, NumberLiteral, StrategyDecl, StringLiteral, UnaryOp, VarDecl
+from ..external_requests import CAPABILITY_UNPINNED_ANNOTATION
+from ..limits import iter_ast_nodes
+
+
+STRATEGY_PARAMETERS = (
+    "title", "shorttitle", "overlay", "format", "precision", "scale", "pyramiding",
+    "calc_on_order_fills", "calc_on_every_tick", "max_bars_back",
+    "backtest_fill_limits_assumption", "default_qty_type", "default_qty_value",
+    "initial_capital", "currency", "slippage", "commission_type", "commission_value",
+    "process_orders_on_close", "close_entries_rule", "margin_long", "margin_short",
+    "explicit_plot_zorder", "max_lines_count", "max_labels_count", "max_boxes_count",
+    "calc_bars_count", "risk_free_rate", "use_bar_magnifier", "fill_orders_on_standard_ohlc",
+    "max_polylines_count", "dynamic_requests", "behind_chart", "calc_on_every_history_tick",
+)
+
+
+DECLARATION_DEFAULTS = {
+    "calc_on_every_tick": False,
+    "calc_on_order_fills": False,
+    "process_orders_on_close": False,
+    "use_bar_magnifier": False,
+    "fill_orders_on_standard_ohlc": False,
+    "backtest_fill_limits_assumption": 0,
+    "currency": "currency.NONE",
+    "timeframe": "",
+    "timeframe_gaps": True,
+    "dynamic_requests": True,
+    "calc_on_every_history_tick": False,
+}
+
+
+def _expression(node):
+    if isinstance(node, (StringLiteral, NumberLiteral, BoolLiteral)):
+        return node.value
+    if isinstance(node, Identifier):
+        return node.name
+    if isinstance(node, MemberAccess):
+        return f"{_expression(node.object)}.{node.member}"
+    if isinstance(node, FuncCall):
+        return f"{_expression(node.callee)}({','.join(str(_expression(arg)) for arg in node.args)})"
+    return None
+
+
+def _literal(node):
+    if isinstance(node, (StringLiteral, NumberLiteral, BoolLiteral)):
+        return node.value, True
+    if isinstance(node, UnaryOp) and node.op in ("+", "-"):
+        value, valid = _literal(node.operand)
+        if valid and type(value) in (int, float):
+            return value if node.op == "+" else -value, True
+    if isinstance(node, MemberAccess):
+        value = _expression(node)
+        if value and value.split(".")[0] in ("currency", "format", "scale", "strategy"):
+            return value, True
+    return _expression(node), False
+
+
+def capabilities_document(emitter) -> str:
+    declarations = dict(DECLARATION_DEFAULTS)
+    unresolved = []
+    requests = []
+    lower_symbols = {}
+    intrabar = False
+    recorded = False
+    for node, _depth in iter_ast_nodes(emitter.ctx.ast):
+        if isinstance(node, StrategyDecl):
+            arguments = {STRATEGY_PARAMETERS[index] if index < len(STRATEGY_PARAMETERS)
+                         else f"strategy() positional argument {index + 1}": argument
+                         for index, argument in enumerate(node.args)}
+            unresolved.extend(arguments.keys() & node.kwargs.keys())
+            arguments.update(node.kwargs)
+            for name, argument in arguments.items():
+                value, valid = _literal(argument)
+                default = DECLARATION_DEFAULTS.get(name)
+                if name in DECLARATION_DEFAULTS:
+                    valid &= type(value) is type(default)
+                    if name == "backtest_fill_limits_assumption":
+                        valid = (type(value) is int and value >= 0) or (
+                            type(value) is float and math.isfinite(value) and value >= 0 and value == int(value))
+                        if valid:
+                            value = int(value)
+                    declarations[name] = value
+                if not valid or name not in STRATEGY_PARAMETERS and name not in DECLARATION_DEFAULTS:
+                    unresolved.append(name)
+        elif isinstance(node, VarDecl):
+            intrabar |= node.is_varip
+        elif isinstance(node, FuncCall):
+            name, namespace = emitter._resolve_callee(node.callee)
+            if namespace == "request" and name == "security_lower_tf":
+                expression = node.args[2] if len(node.args) > 2 else node.kwargs.get("expression")
+                lower_symbols[id(expression)] = node.args[0] if node.args else node.kwargs.get("symbol")
+            parts = (node.annotations or {}).get("pf_recorded_key")
+            if parts is not None:
+                recorded = True
+                requests.append({
+                    "function": f"{namespace}.{name}",
+                    "symbol": _expression(node.args[0]) if node.args else None,
+                    "timeframe": "",
+                    "lookahead": f"barmerge.lookahead_{parts.get('lookahead', 'off')}",
+                    "gaps": f"barmerge.gaps_{parts.get('gaps', 'off')}",
+                    "heikinashi": False,
+                    "feed": "recorded",
+                })
+        if isinstance(node, Identifier) and node.name == "timenow":
+            unresolved.append("timenow (bar timestamp approximation)")
+        if isinstance(node, Identifier) and node.name in ("last_bar_index", "last_bar_time"):
+            unresolved.append(f"{node.name} (stream endpoint is not batch-equivalent)")
+        if isinstance(node, MemberAccess) and _expression(node) == "barstate.isrealtime":
+            unresolved.append("barstate.isrealtime (compiled historical-only approximation)")
+        if isinstance(node, MemberAccess) and _expression(node) in (
+                "barstate.islast", "barstate.islastconfirmedhistory"):
+            unresolved.append(f"{_expression(node)} (stream endpoint is not batch-equivalent)")
+
+    auxiliary = False
+    for site in emitter._security_calls:
+        symbol_node = site.get("symbol_node")
+        if site.get("is_lower_tf_array"):
+            symbol_node = lower_symbols.get(id(site.get("expr_node")), symbol_node)
+        if isinstance(symbol_node, FuncCall) and site.get("heikinashi") and symbol_node.args:
+            symbol_node = symbol_node.args[0]
+        symbol = _expression(symbol_node) if symbol_node is not None else "syminfo.tickerid"
+        timeframe = _expression(site.get("tf_node"))
+        lookahead = _expression(site.get("lookahead_node")) or "barmerge.lookahead_off"
+        gaps = _expression(site.get("gaps_node")) or "barmerge.gaps_off"
+        if isinstance(symbol_node, Identifier) and symbol_node.name not in emitter._global_mutable_infos:
+            symbol = _expression((getattr(emitter.ctx, "global_expr_map", {}) or {}).get(
+                symbol_node.name, symbol_node))
+        feed = "chart" if symbol in ("syminfo.tickerid", "syminfo.ticker", "") else "auxiliary"
+        auxiliary |= feed == "auxiliary"
+        if not isinstance(site.get("tf_node"), StringLiteral) and timeframe != "timeframe.period":
+            unresolved.append(f"request.security[{site['sec_id']}].timeframe")
+        if lookahead not in ("barmerge.lookahead_off", "barmerge.lookahead_on"):
+            unresolved.append(f"request.security[{site['sec_id']}].lookahead")
+        requests.append({
+            "function": "request.security_lower_tf" if site.get("is_lower_tf_array") else "request.security",
+            "symbol": symbol,
+            "timeframe": timeframe,
+            "lookahead": lookahead,
+            "gaps": gaps,
+            "heikinashi": bool(site.get("heikinashi")),
+            "feed": feed,
+        })
+    for index, site in enumerate((emitter.ctx.ast.annotations or {}).get(CAPABILITY_UNPINNED_ANNOTATION, ())):
+        requests.append({
+            "function": site["function"],
+            "symbol": _expression(site["symbol_node"]),
+            "timeframe": _expression(site["tf_node"]) if site["function"] in (
+                "request.security", "request.security_lower_tf") else "",
+            "lookahead": _expression(site["lookahead_node"]) or "barmerge.lookahead_off",
+            "gaps": _expression(site["gaps_node"]) or "barmerge.gaps_off",
+            "heikinashi": False,
+            "feed": "unpinned",
+        })
+        unresolved.append(f"{site['function']}[unpinned:{index}]")
+    requirements = {
+        "auxiliary_security_feeds": auxiliary,
+        "native_security_feeds": False,
+        "fx_curve": declarations["currency"] != "currency.NONE",
+        "recorded_series": recorded,
+        "historical_probe_overrides": False,
+        "intrabar_persistence": intrabar,
+    }
+    return json.dumps({"version": 1, "declarations": declarations, "requests": requests,
+                       "requirements": requirements, "unresolved": sorted(set(unresolved))},
+                      sort_keys=True, separators=(",", ":"), allow_nan=False)
+
+
+def emit_capabilities_exports(emitter, lines: list[str]) -> None:
+    literal = json.dumps(capabilities_document(emitter))
+    lines.extend([
+        "#ifdef PF_SETTINGS_API_VERSION",
+        "#ifdef PF_CAPABILITIES_API_VERSION",
+        "    uint32_t strategy_capabilities_api_version(void) { return PF_CAPABILITIES_API_VERSION; }",
+        "    int strategy_capabilities_receipt(void* s, char* json, size_t capacity, size_t* required, char* error, size_t error_capacity) {",
+        "        if (required) *required = 0;",
+        "        return ::pineforge::checked_settings::boundary(error, error_capacity, [&] {",
+        '            ::pineforge::checked_settings::require(s != nullptr, "null strategy");',
+        f"            ::pineforge::checked_settings::receipt({literal}, json, capacity, required);",
+        "        });", "    }", "#endif", "#endif",
+    ])

package/pineforge_codegen/codegen/checked_settings.py

@@ -1,6 +1,19 @@
 """Opt-in settings metadata, validation and exception-contained C exports."""
 
 from ..ast_nodes import Identifier, MemberAccess
+from ..errors import CompileError
+
+
+def _visit_setting_arg(emitter, expr) -> str:
+    """An input argument's C++ for the settings metadata. The metadata is
+    emitted in the constructor, ahead of the script body: an error here is
+    held until the body is generated (``CodeGen.generate``), so the script's
+    first error in source order is the one raised."""
+    try:
+        return emitter._visit_expr(expr)
+    except CompileError as error:
+        emitter._defer_settings_error(error)
+        return "0"
 
 
 def emit_settings_members(emitter, lines: list[str], constructor: list[str]) -> None:
@@ -38,7 +51,7 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         key = emitter._input_key_literal(name)
         default = emitter._get_input_default(node)
         getter = emitter._input_getter_for_call(node, func_name, namespace)
-        default_cpp = emitter._visit_expr(default) if default is not None else "0"
+        default_cpp = _visit_setting_arg(emitter, default) if default is not None else "0"
         default_cpp = emitter._coerce_string_input_default(getter, default_cpp)
         value_type = {
             "get_input_int": "int", "get_input_int64": "int",
@@ -89,7 +102,7 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
             declared = getattr(arguments.get("options"), "elements", None)
             if declared:
                 for option in declared:
-                    option_cpp = emitter._visit_expr(option)
+                    option_cpp = _visit_setting_arg(emitter, option)
                     options.append(option_cpp if getter == "get_input_string" else
                                    f'::pineforge::checked_settings::number({option_cpp})')
             expression = f'{getter}({key}, {default_cpp})'
@@ -98,7 +111,7 @@ def emit_settings_members(emitter, lines: list[str], constructor: list[str]) ->
         if default_serialized is None:
             default_serialized = (default_cpp if value_type in ("string", "source") else
                                   f'::pineforge::checked_settings::number({default_cpp})')
-        constraints = [emitter._visit_expr(arguments[name]) if arguments.get(name) is not None
+        constraints = [_visit_setting_arg(emitter, arguments[name]) if arguments.get(name) is not None
                        else "std::numeric_limits<double>::quiet_NaN()"
                        for name in ("minval", "maxval", "step")]
         metadata = (f'{{{key}, "{value_type}", {default_serialized}, '

package/pineforge_codegen/codegen/emit_top.py

@@ -1998,6 +1998,8 @@ class TopLevelEmitter:
         lines.append("    }")
         from .checked_settings import emit_settings_exports
         emit_settings_exports(lines)
+        from .capabilities import emit_capabilities_exports
+        emit_capabilities_exports(self, lines)
         if self._declares_bar_magnifier():
             # TradingView runs a script that declares use_bar_magnifier = true
             # on its bar magnifier; the host reads this export to run it on

package/pineforge_codegen/codegen/helpers.py

@@ -282,6 +282,7 @@ CPP_EMITTER_NAMES = frozenset("""
     configure_security_evaluators snapshot_script_state restore_script_state
     commit_script_state set_strategy_override set_input
     set_magnifier_volume_weighted strategy_declares_bar_magnifier fill_report run
+    strategy_capabilities_api_version strategy_capabilities_receipt
     precalculate
     strategy_entry strategy_close strategy_close_all strategy_exit
     strategy_exit_cancel_bracket strategy_cancel strategy_cancel_all strategy_order