@pineforge/codegen-pyodide 1.0.1 → 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:
@@ -40,4 +44,5 @@ def transpile_json(source: str) -> str:
     # A script that transpiled carries its warnings in the same entry format.
     return json.dumps({"ok": True, "cpp": full["cpp"], "inputs": full["inputs"],
                        "strategyParams": full["strategyParams"],
-                       "diagnostics": _diagnostic_entries(full["diagnostics"])})
+                       "diagnostics": _diagnostic_entries(full["diagnostics"]),
+                       "requests": full["requests"]})

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@pineforge/codegen-pyodide",
-  "version": "1.0.1",
+  "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
@@ -13,6 +14,7 @@ from .finite_ta_length import expand_finite_choice_extrema_lengths
 from .library_inline import inline_libraries
 from .limits import TimeBudget, check_ast_depth, check_source_size, ensure_recursion_headroom
 from .pragmas import extract_pf_trace_pragmas
+from .request_discovery import discover_requests, request_sites
 from .security_contexts import specialize_security_contexts
 from .block_locals import rename_block_locals
 from .support_checker import check_support as _support_diagnostics
@@ -52,7 +54,9 @@ def _generate(pine_source: str, check_support: bool, filename: str,
     the member of its name cannot hold gets a name of its own, and the
     pipeline runs again (``block_locals``).
 
-    Returns ``(codegen, ctx, cpp, support_diagnostics)``."""
+    Returns ``(codegen, ctx, cpp, support_diagnostics, sites)``: ``sites``
+    are the requests of another symbol's data the support checker lowered
+    (``request_discovery.request_sites``)."""
     budget = None
     clones: frozenset[str] = frozenset()
     renamed: frozenset = frozenset()
@@ -67,6 +71,7 @@ def _generate(pine_source: str, check_support: bool, filename: str,
             if any(d.level == Level.ERROR for d in support_diagnostics):
                 raise CompileError(support_diagnostics)
         budget.check(phase=Phase.ANALYZER)
+        sites = request_sites(ast)
         ast = lower_no_data_requests(ast)
         ast = specialize_security_contexts(ast, filename=filename)
         ast = bind_builtin_keywords(expand_finite_choice_extrema_lengths(ast))
@@ -86,18 +91,18 @@ def _generate(pine_source: str, check_support: bool, filename: str,
         apart = gen.block_locals_needing_names - renamed
         if apart:
             renamed |= apart
-            del ast, ctx, gen, cpp
+            del ast, ctx, gen, cpp, sites
             continue
         needed = gen.session_functions_needing_clones
         if not needed:
-            return gen, ctx, cpp, support_diagnostics
+            return gen, ctx, cpp, support_diagnostics, sites
         # Only uncloned functions ask, so the set grows each time and the
         # loop ends by the time every function that reads a flag at an
         # offset is cloned.
         if needed <= clones:
             raise AssertionError("a cloned function asked for session clones again")
         clones |= needed
-        del ast, ctx, gen, cpp
+        del ast, ctx, gen, cpp, sites
 
 
 def transpile(pine_source: str, *, check_support: bool = True, filename: str = "<input>",
@@ -140,7 +145,8 @@ def transpile(pine_source: str, *, check_support: bool = True, filename: str = "
     Returns:
         Generated C++ source string.
     """
-    _gen, _ctx, cpp, _support = _generate(pine_source, check_support, filename, libraries)
+    _gen, _ctx, cpp, _support, _sites = _generate(pine_source, check_support, filename,
+                                                  libraries)
     return cpp
 
 
@@ -161,26 +167,36 @@ def transpile_full(pine_source: str, *, check_support: bool = True,
       source order). Each has ``title`` / ``type`` /
       ``default`` and optionally ``min`` / ``max`` / ``step`` / ``options``
       (omitted when the corresponding signature argument is absent or
-      references a non-const value). See
-      :meth:`CodeGen.extract_input_manifest`.
+      references a non-const value); an ``input.symbol`` entry also has
+      ``kind: "symbol"``. See :meth:`CodeGen.extract_input_manifest`.
     - ``strategyParams``: the literal ``strategy(...)`` kwargs the analyzer
       surfaced (e.g. ``initial_capital``, ``pyramiding``).
     - ``diagnostics``: the warnings (:class:`~pineforge_codegen.errors.Diagnostic`,
       ``Level.WARNING``) the support checker and the analyzer raised for a
       script that transpiled -- e.g. an approximated ``ta.vwap`` anchor. An
       error still raises ``CompileError``, which carries the warnings too.
+    - ``requests``: every request site that reads another symbol's feed,
+      by line: its symbol and timeframe as registration computes them
+      before the first bar (``literal`` / ``input`` / ``computed`` /
+      ``unresolvable``; ``literal`` / ``chart`` / ``input`` / ``computed``),
+      ``lookahead``, ``gaps`` and ``ignore_invalid_symbol``. A site lowered
+      to ``na`` (its value reaches display sinks only) or in a helper
+      nothing reaches is not listed. See
+      :mod:`pineforge_codegen.request_discovery`.
 
     Args mirror :func:`transpile`.
 
     Returns:
         ``{"cpp": str, "inputs": list[dict], "strategyParams": dict,
-        "diagnostics": list[Diagnostic]}``.
+        "diagnostics": list[Diagnostic], "requests": list[dict]}``.
     """
-    gen, ctx, cpp, support_diagnostics = _generate(pine_source, check_support, filename, libraries)
+    gen, ctx, cpp, support_diagnostics, sites = _generate(
+        pine_source, check_support, filename, libraries)
     return {
         "cpp": cpp,
         "inputs": gen.extract_input_manifest(),
         "strategyParams": dict(ctx.strategy_params),
         "diagnostics": [d for d in (*support_diagnostics, *ctx.diagnostics)
                         if d.level == Level.WARNING],
+        "requests": discover_requests(gen, ctx, sites),
     }

package/pineforge_codegen/analyzer/base.py

@@ -3797,6 +3797,7 @@ class Analyzer(CallHandlers, DiagnosticsHelper, TypeHelper):
                     symbol=sec.symbol,
                     foreign=sec.foreign,
                     ignore_invalid=sec.ignore_invalid,
+                    loc=sec.loc,
                 )
                 new_calls.append(clone)
                 next_sec_id += 1

package/pineforge_codegen/analyzer/call_handlers.py

@@ -876,6 +876,7 @@ class CallHandlers:
                 dead=bool(notes.get(DEAD_ANNOTATION)),
                 foreign=notes.get(LOWERING_ANNOTATION) == FEED_LOWERING,
                 ignore_invalid=node.kwargs.get("ignore_invalid_symbol"),
+                loc=node.loc,
             ))
 
             return PineType.STRING if string_result else PineType.FLOAT
@@ -998,6 +999,7 @@ class CallHandlers:
             is_lower_tf_array=True,
             context_resolved=context is not None,
             dead=bool(notes.get(DEAD_ANNOTATION)),
+            loc=node.loc,
         ))
 
         # ``request.security_lower_tf`` returns an array; the value-level

package/pineforge_codegen/analyzer/contracts.py

@@ -196,6 +196,9 @@ class SecurityCallInfo:
     # ``symbol`` string and ``ignore_invalid_symbol`` (the node, or None).
     foreign: bool = False
     ignore_invalid: Any = None
+    # The request call's source location (``request_discovery`` names the
+    # site by its line).
+    loc: Any = None
 
 
 @dataclass

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()