create-caspian-app 1.3.6 → 1.3.7

package/dist/settings/_component_imports.py

@@ -19,6 +19,7 @@ import re
 from functools import lru_cache
 from pathlib import Path
 
+
 # Mirror of casp.string_helpers.camel_to_kebab. Kept in lockstep so the tag we
 # look for matches the tag the compiler actually resolves.
 def camel_to_kebab(name: str) -> str:

package/dist/settings/_markup_equivalence.py

@@ -0,0 +1,320 @@
+"""Rendering-equivalence oracle for PulsePoint + Jinja markup.
+
+Why this exists
+---------------
+`format.py` runs djLint over authored markup. djLint is Jinja-aware and does not
+reflow text, which makes it the only formatter that survives this project's four
+nested dialects (HTML, Jinja `{{ }}`/`{% %}`, PulsePoint `{ }`, and JS inside
+`<script>`). It is still an HTML formatter, and it will happily make changes that
+are correct for HTML but wrong here -- most notably inserting a newline between
+two `<x-*>` tags, which renders as a visible space because a custom element's
+`display` is unknowable from the markup.
+
+So the formatter does not trust djLint. Every block is formatted, then *proved*
+to render identically before it is written back. Anything unprovable is skipped
+and reported. That is what makes a bulk reformat of 500+ templates safe to run.
+
+What "equivalent" means here
+----------------------------
+Each rule below is a real rendering rule, not a heuristic:
+
+* whitespace INSIDE a tag (between attributes, before `>`) never renders
+* a whitespace RUN in text renders as a single space, but the presence vs
+  absence of whitespace between two inline elements is significant
+* whitespace touching a block-level boundary collapses and never renders
+* a text node's leading/trailing whitespace collapses when its parent is
+  block-level, but not when the parent is inline or an unknown `<x-*>` tag
+* `<pre>` / `<textarea>` text renders verbatim
+* `<script>` / `<style>` bodies are code: indentation is irrelevant
+* attribute ORDER never affects rendering; attribute VALUES always do
+* Jinja `{{x}}` and `{{ x }}` are the same expression
+
+Anything this module cannot prove, it reports as a difference. False negatives
+(claiming a real change is safe) are the only dangerous errors, so every rule
+errs toward reporting a difference.
+"""
+
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+
+LITERAL_TAGS = {"pre", "textarea"}
+CODE_TAGS = {"script", "style"}
+
+# Whitespace touching one of these collapses away. A custom `<x-*>` tag is
+# deliberately absent: its display is set by CSS the formatter cannot see, so it
+# is treated as inline and its surrounding whitespace is significant.
+# fmt: off
+BLOCK_TAGS = {
+    "html", "head", "body", "div", "p", "section", "article", "header",
+    "footer", "nav", "aside", "main", "form", "fieldset", "legend", "figure",
+    "figcaption", "blockquote", "hr", "ul", "ol", "li", "dl", "dt", "dd",
+    "table", "thead", "tbody", "tfoot", "tr", "td", "th", "caption", "colgroup",
+    "col", "h1", "h2", "h3", "h4", "h5", "h6", "pre", "details", "summary",
+    "dialog", "script", "style", "template", "option", "optgroup", "select",
+    "textarea", "video", "audio", "source", "track", "canvas", "iframe",
+    "meta", "link", "title", "address", "hgroup", "menu", "search", "noscript",
+    "br",
+    # SVG. Inside an SVG fragment, whitespace between elements is never laid out
+    # as text, so indenting the children of an inline <svg> cannot change what is
+    # drawn. `<text>`, `<tspan>` and `<textPath>` are deliberately excluded --
+    # they do render their content -- as is `<foreignObject>`, whose children are
+    # HTML again and follow HTML rules.
+    "svg", "g", "defs", "symbol", "use", "path", "circle", "ellipse", "line",
+    "polyline", "polygon", "rect", "clippath", "lineargradient",
+    "radialgradient", "stop", "mask", "pattern", "filter", "marker", "desc",
+    "animate", "animatetransform", "animatemotion", "switch", "image",
+}
+# fmt: on
+
+JINJA = re.compile(r"\{\{\s*(.*?)\s*\}\}|\{%\s*(.*?)\s*%\}", re.S)
+
+
+def _canon_jinja(text: str) -> str:
+    """`{{  x  }}` and `{{x}}` are the same expression to Jinja."""
+
+    def sub(m: re.Match[str]) -> str:
+        if m.group(1) is not None:
+            return "{{ " + re.sub(r"\s+", " ", m.group(1)) + " }}"
+        return "{% " + re.sub(r"\s+", " ", m.group(2)) + " %}"
+
+    return JINJA.sub(sub, text)
+
+
+def _canon_attr_value(value: str | None) -> str | None:
+    if value is None:
+        return None
+    return re.sub(r"\s+", " ", _canon_jinja(value)).strip()
+
+
+class _Tokens(HTMLParser):
+    """Reduce markup to a token stream where equality implies equal rendering."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=False)
+        self.out: list[tuple] = []
+        self._open: list[str] = []
+        self._raw_stack: list[str] = []
+        self._raw_buf: list[str] = []
+
+    def _in_raw(self) -> str | None:
+        return self._raw_stack[-1] if self._raw_stack else None
+
+    def _attrs(self, attrs) -> tuple:
+        return tuple(sorted((k, _canon_attr_value(v)) for k, v in attrs))
+
+    def handle_starttag(self, tag, attrs):
+        if self._in_raw():
+            self._raw_buf.append(self.get_starttag_text() or "")
+            return
+        if tag in LITERAL_TAGS | CODE_TAGS:
+            self._raw_stack.append(tag)
+            self._raw_buf = []
+        self.out.append(("start", tag, self._attrs(attrs)))
+        self._open.append(tag)
+
+    def handle_startendtag(self, tag, attrs):
+        if self._in_raw():
+            self._raw_buf.append(self.get_starttag_text() or "")
+            return
+        self.out.append(("start", tag, self._attrs(attrs)))
+        self.out.append(("end", tag))
+
+    def handle_endtag(self, tag):
+        raw = self._in_raw()
+        if raw:
+            if tag != raw:
+                self._raw_buf.append(f"</{tag}>")
+                return
+            body = "".join(self._raw_buf)
+            if raw in CODE_TAGS:
+                # Code: indentation and blank lines carry no meaning.
+                body = "\n".join(ln.strip() for ln in body.splitlines() if ln.strip())
+            self.out.append(("raw", raw, body))
+            self._raw_stack.pop()
+            self._raw_buf = []
+        self.out.append(("end", tag))
+        if tag in self._open:
+            while self._open and self._open.pop() != tag:
+                pass
+
+    def handle_data(self, data):
+        if self._in_raw():
+            self._raw_buf.append(data)
+            return
+        collapsed = re.sub(r"\s+", " ", _canon_jinja(data))
+        if collapsed == "":
+            return
+        parent = self._open[-1] if self._open else ""
+        if collapsed.strip() == "":
+            # A pure-whitespace node: its existence can separate two inline
+            # elements, so it is kept as a token, but its length is irrelevant.
+            self.out.append(("ws",))
+            return
+        self.out.append(
+            (
+                "text",
+                collapsed.strip(),
+                collapsed[0].isspace(),
+                collapsed[-1].isspace(),
+                parent,
+            )
+        )
+
+    def handle_comment(self, data):
+        if self._in_raw():
+            self._raw_buf.append(f"<!--{data}-->")
+            return
+        self.out.append(("comment", re.sub(r"\s+", " ", data).strip()))
+
+    def handle_entityref(self, name):
+        if self._in_raw():
+            self._raw_buf.append(f"&{name};")
+        else:
+            self.out.append(("entity", name))
+
+    def handle_charref(self, name):
+        if self._in_raw():
+            self._raw_buf.append(f"&#{name};")
+        else:
+            self.out.append(("charref", name))
+
+    def handle_decl(self, decl):
+        self.out.append(("decl", decl))
+
+
+def _is_block_boundary(token: tuple | None) -> bool:
+    if token is None:
+        return True  # the fragment's own edge
+    if token[0] in ("start", "end"):
+        return token[1] in BLOCK_TAGS
+    return False
+
+
+def _drop_insignificant_ws(tokens: list[tuple]) -> list[tuple]:
+    """Remove whitespace nodes that provably cannot render."""
+    out: list[tuple] = []
+    for i, tok in enumerate(tokens):
+        if tok != ("ws",):
+            out.append(tok)
+            continue
+        prev = out[-1] if out else None
+        nxt = next((t for t in tokens[i + 1 :] if t != ("ws",)), None)
+        if _is_block_boundary(prev) and _is_block_boundary(nxt):
+            continue
+        out.append(tok)
+    return out
+
+
+def _canon_text_edges(tokens: list[tuple]) -> list[tuple]:
+    """Drop edge-whitespace flags for text inside a block-level parent.
+
+    `<h1>\\n  Title\\n</h1>` -> `<h1>Title</h1>` cannot change rendering, because
+    whitespace at the edges of a block container always collapses. The same trim
+    inside a `<span>` or an `<x-*>` tag CAN change rendering (it closes a gap
+    against an adjacent inline sibling), so those keep their flags and will be
+    reported as a difference.
+    """
+    out: list[tuple] = []
+    for tok in tokens:
+        if tok[0] == "text" and tok[4] in BLOCK_TAGS:
+            out.append(("text", tok[1], False, False, tok[4]))
+        else:
+            out.append(tok)
+    return out
+
+
+def _squeeze_jinja(markup: str) -> str:
+    """Collapse padding inside Jinja delimiters before the HTML parser runs.
+
+    A Jinja tag can sit in attribute position -- `<div {{attributes}}>` is how a
+    component forwards props onto its root. djLint renders that as
+    `<div {{ attributes }}>`, which is the same template but which an HTML parser
+    reads as three attributes instead of one. Squeezing both sides first means
+    the comparison sees the Jinja tag, not the parser's guess at it.
+    """
+
+    def sub(m: re.Match[str]) -> str:
+        if m.group(1) is not None:
+            return "{{" + re.sub(r"\s+", " ", m.group(1)) + "}}"
+        return "{%" + re.sub(r"\s+", " ", m.group(2)) + "%}"
+
+    return JINJA.sub(sub, markup)
+
+
+def tokenize(markup: str) -> list[tuple] | None:
+    parser = _Tokens()
+    try:
+        parser.feed(_squeeze_jinja(markup))
+        parser.close()
+    except Exception:
+        return None
+    return _canon_text_edges(_drop_insignificant_ws(parser.out))
+
+
+def equivalent(before: str, after: str) -> tuple[bool, str]:
+    """True when `after` is guaranteed to render exactly like `before`.
+
+    The second element is a short explanation of the first difference, for the
+    skip report.
+    """
+    ta, tb = tokenize(before), tokenize(after)
+    if ta is None or tb is None:
+        return False, "markup could not be parsed"
+    if ta == tb:
+        return True, ""
+    for x, y in zip(ta, tb):
+        if x != y:
+            return False, _diff_reason(x, y)
+    extra = ta[len(tb) :] or tb[len(ta) :]
+    side = "would remove" if len(ta) > len(tb) else "would add"
+    return False, f"{side} {_describe(extra[0]) if extra else 'content'}"
+
+
+def _diff_reason(x: tuple, y: tuple) -> str:
+    """Explain one token difference in terms an author can act on."""
+    if x[0] == "text" and y[0] == "text" and x[1] == y[1]:
+        return (
+            f"would trim whitespace around {_clip(x[1])} inside <{x[4] or '?'}>, "
+            f"whose display is not known to be block-level"
+        )
+    if x[0] == "start" and y[0] == "start" and x[1] == y[1]:
+        before, after = dict(x[2]), dict(y[2])
+        names = sorted(set(before) | set(after))
+        for name in names:
+            if before.get(name) != after.get(name):
+                if name not in after:
+                    return f"would drop attribute {name!r} on <{x[1]}>"
+                if name not in before:
+                    return f"would add attribute {name!r} on <{x[1]}>"
+                return f"would change attribute {name!r} on <{x[1]}>"
+        return f"attributes on <{x[1]}> would change"
+    if x == ("ws",):
+        return f"would remove whitespace before {_describe(y)}"
+    if y == ("ws",):
+        return f"would add whitespace before {_describe(x)}"
+    if x[0] == "raw" and y[0] == "raw":
+        return f"<{x[1]}> body would change"
+    return f"{_describe(x)} would become {_describe(y)}"
+
+
+def _clip(text: str, limit: int = 40) -> str:
+    return repr(text if len(text) <= limit else text[:limit] + "…")
+
+
+def _describe(token: tuple) -> str:
+    kind = token[0]
+    if kind == "start":
+        return f"<{token[1]}>"
+    if kind == "end":
+        return f"</{token[1]}>"
+    if kind == "text":
+        return f"text {_clip(token[1])}"
+    if kind == "ws":
+        return "whitespace"
+    if kind == "raw":
+        return f"<{token[1]}> body"
+    if kind == "comment":
+        return "comment"
+    return kind

package/dist/settings/browser_log.py

@@ -68,7 +68,7 @@ LOG_FILE = PROJECT_ROOT / ".casp" / "browser-log.jsonl"
 
 try:
     sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
-except (AttributeError, ValueError):
+except AttributeError, ValueError:
     pass
 
 _TTY = sys.stdout.isatty()
@@ -254,7 +254,9 @@ def build_report(path: Path = LOG_FILE) -> LogReport:
 
         if not loads:
             routes.append(
-                RouteStatus(route=route, last_load="", errors=[], warnings=[], healed=0, recheck=recheck)
+                RouteStatus(
+                    route=route, last_load="", errors=[], warnings=[], healed=0, recheck=recheck
+                )
             )
             continue
 
@@ -336,8 +338,7 @@ _SESSION_LINES = {
     ),
     "ended": (
         "dev session ended cleanly",
-        "The dev server has shut down. The results below are from that "
-        "finished session.",
+        "The dev server has shut down. The results below are from that finished session.",
     ),
 }
 
@@ -369,7 +370,9 @@ def print_report(report: LogReport) -> None:
     if report.session == "live":
         age = _age(report.started)
         detail = f"pid {report.pid}, port {report.port}, started {_clock(report.started)}"
-        print(f"  {green('LIVE')}  dev session active {gray(f'({detail}{", " + age if age else ""})')}")
+        print(
+            f"  {green('LIVE')}  dev session active {gray(f'({detail}{", " + age if age else ""})')}"
+        )
     else:
         headline, advice = _SESSION_LINES[report.session]
         mark = yellow("WARN") if report.session != "missing" else gray("NONE")
@@ -456,7 +459,11 @@ def to_json(report: LogReport) -> str:
                     "clean": r.clean,
                     "unconfirmed": r.unconfirmed,
                     "needsRecheck": [
-                        {"message": e.get("message"), "phase": e.get("phase"), "carried": bool(e.get("carried"))}
+                        {
+                            "message": e.get("message"),
+                            "phase": e.get("phase"),
+                            "carried": bool(e.get("carried")),
+                        }
                         for e in r.recheck
                     ],
                     "errors": [

package/dist/settings/build-static.py

@@ -191,9 +191,7 @@ def build() -> int:
 
         if resp.status_code in (301, 302, 303, 307, 308):
             target = resp.headers.get("location", "?")
-            skipped.append(
-                (url, f"redirects to {target} -- likely auth-gated, needs the server")
-            )
+            skipped.append((url, f"redirects to {target} -- likely auth-gated, needs the server"))
             return
 
         if resp.status_code != 200:
@@ -232,7 +230,10 @@ def build() -> int:
                         param_sets = await _resolve_static_paths(route)
                         if not param_sets:
                             skipped.append(
-                                (url, "dynamic route -- add static_paths() to its index.py to pre-render (like getStaticPaths)")
+                                (
+                                    url,
+                                    "dynamic route -- add static_paths() to its index.py to pre-render (like getStaticPaths)",
+                                )
                             )
                             continue
                         for params in param_sets:

package/dist/settings/check.py

@@ -46,6 +46,7 @@ def _is_component_import_false_positive(issue: Issue) -> bool:
         return False
     return ci.is_component_tag_f401(issue.message, issue.path)
 
+
 # Terminal colors (disabled automatically when output is not a TTY).
 _TTY = sys.stdout.isatty()
 
@@ -53,7 +54,7 @@ _TTY = sys.stdout.isatty()
 # characters; ask for UTF-8 with a safe fallback so output never crashes.
 try:
     sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
-except (AttributeError, ValueError):
+except AttributeError, ValueError:
     pass
 
 
@@ -288,7 +289,7 @@ def run_pytest() -> Result:
         for line in (proc.stdout + proc.stderr).splitlines():
             stripped = line.strip()
             if stripped.startswith("FAILED "):
-                body = stripped[len("FAILED "):]
+                body = stripped[len("FAILED ") :]
                 nodeid, _, reason = body.partition(" - ")
                 path, _, _ = nodeid.partition("::")
                 issues.append(
@@ -362,7 +363,9 @@ def _execute(label: str, runner, *, streamed: bool) -> Result:
     elapsed = time.perf_counter() - start
     mark = green("OK  ") if result.ok else red("FAIL")
     count = len(result.issues)
-    detail = "" if result.ok else f"  ({count} issue(s))" if count else f"  ({result.note or 'failed'})"
+    detail = (
+        "" if result.ok else f"  ({count} issue(s))" if count else f"  ({result.note or 'failed'})"
+    )
     print(f"  {mark} {label}  {elapsed:0.1f}s{detail}")
     return result
 

package/dist/settings/check_templates.py

@@ -73,8 +73,7 @@ RULES: list[Rule] = [
         # `{items.map(item => (` and `{items.map((item, i) => (` -- the trailing
         # `(` is what distinguishes returning markup from a normal value map.
         re.compile(r"\{[^{}\n]*?\.map\s*\(\s*\(?[\w\s,]*\)?\s*=>\s*\(", re.MULTILINE),
-        "JSX .map() returning markup. Use <template pp-for=\"item in items\"> "
-        'with key="{item.id}".',
+        'JSX .map() returning markup. Use <template pp-for="item in items"> with key="{item.id}".',
     ),
     Rule(
         "jsx-logical",
@@ -86,8 +85,7 @@ RULES: list[Rule] = [
         "jsx-ternary-element",
         # `{cond ? <A` -- element directly after a ternary branch.
         re.compile(r"\{[^{}]*?\?\s*\(?\s*<[a-zA-Z]", re.DOTALL),
-        "JSX `{cond ? <A/> : <B/>}`. Use two elements with complementary "
-        'hidden="{...}" bindings.',
+        'JSX `{cond ? <A/> : <B/>}`. Use two elements with complementary hidden="{...}" bindings.',
     ),
     Rule(
         "unquoted-brace-attr",
@@ -114,7 +112,7 @@ RULES: list[Rule] = [
         ),
         "camelCase event prop. PulsePoint binds native lowercase event "
         'attributes: onclick="{handler()}". A component prop uses kebab-case '
-        '(on-click), which arrives as pp.props.onClick.',
+        "(on-click), which arrives as pp.props.onClick.",
     ),
     Rule(
         "jsx-fragment",
@@ -124,8 +122,7 @@ RULES: list[Rule] = [
     Rule(
         "style-object",
         re.compile(r"style\s*=\s*\{\{"),
-        "JSX style object. pp-style takes a CSS *string*: "
-        "pp-style=\"{'color: red'}\".",
+        "JSX style object. pp-style takes a CSS *string*: pp-style=\"{'color: red'}\".",
     ),
     Rule(
         "unknown-directive",
@@ -221,9 +218,7 @@ def lint_text(text: str, rel_path: str, *, is_python: bool = False) -> list[Temp
     for rule in RULES:
         for match in rule.pattern.finditer(markup):
             line, column = _position(markup, match.start())
-            issues.append(
-                TemplateIssue(rel_path, line, column, rule.code, rule.message)
-            )
+            issues.append(TemplateIssue(rel_path, line, column, rule.code, rule.message))
 
     for match in PP_FOR_TAG.finditer(markup):
         tag = match.group(1).lower()
@@ -284,6 +279,37 @@ FSTRING_MESSAGE = (
     "Return html(r'''...''', x=x) instead."
 )
 
+HTML_FORM_MESSAGE = (
+    "html(...) must take a raw triple-quoted literal: html(r'''...'''). It is "
+    "the single markup entrypoint, and one form keeps it readable and greppable. "
+    "A non-raw string silently rewrites backslashes, so a JS regex or a \\n in a "
+    "component script changes meaning between authoring and render; an f-string "
+    "additionally inverts the brace dialects and emits interpolated data raw. "
+    "Pass server values as context instead: html(r'''...{{ x }}...''', x=x)."
+)
+
+
+def _own_returns(func):
+    """The `return` statements belonging to `func` itself.
+
+    `ast.walk` would descend into nested `def`s and lambdas and attribute their
+    returns to the enclosing function. A `@component` may legitimately define a
+    private helper that builds a string fragment, so walking blind reports a
+    component that already returns `html(...)` and tells its author to do what
+    they have done -- which is how a gate loses its credibility.
+    """
+    import ast
+
+    stack = list(func.body)
+    while stack:
+        node = stack.pop()
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ClassDef)):
+            continue
+        if isinstance(node, ast.Return):
+            yield node
+            continue
+        stack.extend(ast.iter_child_nodes(node))
+
 
 def _fstring_component_returns() -> list[tuple[str, str, int, int]]:
     """Every `@component` whose return value is an f-string.
@@ -298,20 +324,19 @@ def _fstring_component_returns() -> list[tuple[str, str, int, int]]:
             continue
         try:
             tree = ast.parse(path.read_text(encoding="utf-8"))
-        except (OSError, UnicodeDecodeError, SyntaxError):
+        except OSError, UnicodeDecodeError, SyntaxError:
             continue
         rel = path.relative_to(PROJECT_ROOT).as_posix()
         for node in ast.walk(tree):
             if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 continue
             decorators = {
-                getattr(d, "id", None) or getattr(d, "attr", None)
-                for d in node.decorator_list
+                getattr(d, "id", None) or getattr(d, "attr", None) for d in node.decorator_list
             }
             if "component" not in decorators:
                 continue
-            for stmt in ast.walk(node):
-                if isinstance(stmt, ast.Return) and isinstance(stmt.value, ast.JoinedStr):
+            for stmt in _own_returns(node):
+                if isinstance(stmt.value, ast.JoinedStr):
                     found.append((rel, node.name, stmt.lineno, stmt.col_offset + 1))
                     break
     return sorted(found)
@@ -322,7 +347,7 @@ def _load_fstring_baseline() -> set[str]:
 
     try:
         raw = json.loads(FSTRING_BASELINE_PATH.read_text(encoding="utf-8"))
-    except (OSError, ValueError):
+    except OSError, ValueError:
         return set()
     return set(raw.get("allowed", []))
 
@@ -350,6 +375,52 @@ def write_fstring_baseline() -> int:
     return len(entries)
 
 
+def _html_call_template_args():
+    """Every `html(...)` call's first argument, with its source text.
+
+    Yields `(rel_path, lineno, col, source_segment, node)`.
+    """
+    import ast
+
+    for path in _iter_files():
+        if path.suffix != ".py":
+            continue
+        try:
+            source = path.read_text(encoding="utf-8")
+            tree = ast.parse(source)
+        except OSError, UnicodeDecodeError, SyntaxError:
+            continue
+        rel = path.relative_to(PROJECT_ROOT).as_posix()
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call):
+                continue
+            name = getattr(node.func, "id", None) or getattr(node.func, "attr", None)
+            if name != "html" or not node.args:
+                continue
+            arg = node.args[0]
+            segment = ast.get_source_segment(source, arg) or ""
+            yield rel, arg.lineno, arg.col_offset + 1, segment, arg
+
+
+def lint_html_call_form() -> list[TemplateIssue]:
+    """`html(...)` takes a raw triple-quoted literal -- one form, no exceptions.
+
+    Two forms drifted apart in this repo once already: 437 calls used
+    `html(r'''...''')` and 133 did not, which makes the markup surface
+    un-greppable and lets a backslash mean two different things depending on
+    which call you are reading.
+    """
+    import ast
+
+    issues: list[TemplateIssue] = []
+    for rel, line, col, segment, arg in _html_call_template_args():
+        if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+            if segment.startswith(('r"""', "r'''", 'R"""', "R'''")):
+                continue
+        issues.append(TemplateIssue(rel, line, col, "html-form", HTML_FORM_MESSAGE))
+    return issues
+
+
 def lint_fstring_components() -> list[TemplateIssue]:
     allowed = _load_fstring_baseline()
     return [
@@ -365,7 +436,7 @@ def lint_templates() -> list[TemplateIssue]:
     for path in _iter_files():
         try:
             text = path.read_text(encoding="utf-8")
-        except (OSError, UnicodeDecodeError):
+        except OSError, UnicodeDecodeError:
             continue
         # Cheap pre-filter: a file with no brace expression and no angle-bracket
         # markup cannot trip any rule.
@@ -374,6 +445,7 @@ def lint_templates() -> list[TemplateIssue]:
         rel = path.relative_to(PROJECT_ROOT).as_posix()
         issues.extend(lint_text(text, rel, is_python=path.suffix == ".py"))
     issues.extend(lint_fstring_components())
+    issues.extend(lint_html_call_form())
     return issues
 
 
@@ -400,10 +472,7 @@ def main() -> int:
     for path in sorted(by_file):
         print(path)
         for issue in sorted(by_file[path], key=lambda i: (i.line, i.column)):
-            print(
-                f"  {issue.line}:{issue.column}  "
-                f"[templates:{issue.code}] {issue.message}"
-            )
+            print(f"  {issue.line}:{issue.column}  [templates:{issue.code}] {issue.message}")
 
     print(f"\n{len(issues)} template issue(s) found.")
     return 1