Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@tests/test_checker.py`:
- Around line 2155-2193: Add negative type tests for the HTML built-ins: update
the existing test methods (test_html_query, test_html_text_fn, test_html_attr)
to include _check_err cases that pass wrong argument types. For html_query add
one case where the first arg is not a HtmlNode (e.g. 42) and one where the
selector is not a String (e.g. 42) using _check_err(..., "type"); for html_text
add a case where the arg is not a HtmlNode (e.g. "not a node") using
_check_err(..., "type"); for html_attr add a case where the node arg is wrong
and a case where the attribute name arg is not a String (e.g. 42) using
_check_err(..., "type"). Ensure each new test mirrors the existing test
structure and uses the same return types (Array<HtmlNode>, String,
Option<String>) in the checked snippet.

In `@tests/test_codegen.py`:
- Around line 9171-9196: Expand WAT import-gating tests to cover each HTML
builtin individually: add per-operation assertions like in
test_html_parse_wat_import for html_to_string, html_query, and html_text (e.g.,
new tests similar to test_html_parse_wat_import that compile a tiny program
calling each builtin and assert the corresponding string appears in result.wat)
and extend test_html_no_imports_when_unused to verify each of '"html_parse"',
'"html_to_string"', '"html_query"', and '"html_text"' are absent when not used;
follow the existing JSON/Http per-op test patterns and reuse the _compile_ok
flow and assertion style from test_html_parse_wat_import to ensure sibling
absence checks are included.
- Around line 9105-9118: The current test_html_query_by_tag only exercises tag
selectors ("p"); extend this test (or add sibling tests) to cover class
selectors (e.g., elements with class="..."), ID selectors (e.g., "#id"),
attribute-presence selectors (e.g., "[attr]"), and descendant selectors (e.g.,
"div p") by parsing HTML with representative nodes via html_parse and asserting
html_query returns expected counts for each selector; update assertions to
include calls to html_query(`@HtmlNode.0`, "<selector>") for each selector type
and match the Ok/Err pattern used in the existing test so failures surface for
html_query, html_parse, and HtmlNode handling.

In `@vera/browser/runtime.mjs`:
- Around line 1775-1783: The htmlToString serializer builds attrStr from
node.attrs without escaping special characters, so attribute values containing &
or " (and other special chars) can break output; update htmlToString to escape
attribute values before concatenation (e.g., implement a small helper like
escapeAttr and call it when iterating node.attrs to replace & with &amp;, " with
&quot;, < with &lt; and > with &gt;), then use the escaped value when appending
to attrStr (refer to htmlToString, attrStr and node.attrs to locate the change).

In `@vera/codegen/api.py`:
- Around line 1676-1697: The serializer _html_to_string_py must HTML-escape node
text, attribute values and comment content before emitting strings: in the
"text" branch escape &, <, >; when building attr_str escape &, <, > and
double-quote characters in attribute values; in the "comment" branch ensure the
content does not contain the sequence "-->" (or replace/encode it) before
wrapping in <!-- -->; implement these escapes where _html_to_string_py reads
node.get("content", "") and where it iterates attrs.items() so round-trip
serialisation produces valid HTML.

---

Outside diff comments:
In `@tests/test_verifier.py`:
- Around line 1590-1603: Update the docstring on test_overall_tier_counts to
match the current expected totals: change "145 T1 / 15 T3 without module
resolution." to reflect "167 T1 / 20 T3 / 187 total" (or equivalent wording);
locate the test by the function name test_overall_tier_counts and its usage of
EXAMPLES_DIR, parse_to_ast, typecheck, verify and ensure the new docstring
matches the assertions for t1, t3, and total.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@tests/test_codegen.py`:
- Around line 9222-9266: Add a new test method alongside
test_html_query_by_class/test_html_query_by_id/test_html_query_descendant that
exercises attribute-presence selectors (e.g., name it
test_html_query_attribute_presence); create a source string that calls
html_parse on HTML containing an element with an attribute (like <div
data-foo="x"> or <div data-foo></div>) plus another element without it, then
match the Result and call array_length(html_query(`@HtmlNode.0`, "[data-foo]"))
and assert _run(source) == 1 to verify the selector returns only the element
with the attribute.
- Around line 9195-9220: Update test_html_query_wat_import so it does not call
html_parse: change the source to invoke html_query directly with an HtmlNode
literal (analogous to test_html_text using HtmlText("hello")), then assert
'"html_query"' is in result.wat and assert '"html_parse"' is not in result.wat;
refer to the test function name test_html_query_wat_import and the symbols
html_query and html_parse to locate and modify the test.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@TESTING.md`:
- Line 316: Update the stale example count in TESTING.md: change the table entry
that reads "All 27 `.vera` examples pass `vera check` + `vera verify`" to
reflect 29 examples (i.e., "All 29 `.vera` examples pass `vera check` + `vera
verify`"). Locate the table row referencing `check_examples.py` and update the
numeric count only so it matches the new examples/html.vera addition.

In `@tests/test_codegen.py`:
- Around line 9328-9349: The test test_html_parse_with_attributes currently uses
a vacuous assertion (assert result >= 0); update the test so it actually
verifies the attribute value by querying the parsed HTML and asserting the
"class" attribute equals "main" (or that its length is 4). Concretely, in the
source snippet use html_query to select the div node returned by html_parse,
call html_attr on that node for "class", and replace the final assert with a
concrete check (e.g. assert attr == "main" or assert string_length(attr) == 4)
referencing the symbols html_parse, html_query, and html_attr.

---

Outside diff comments:
In `@TESTING.md`:
- Line 82: Update the stale count string "62 small, focused programs" in
TESTING.md to "63 small, focused programs" so it matches the Overview table and
directory structure note (this is the phrase to search for and replace; no code
changes required beyond updating that text).
- Line 154: Update the stale test count in the header "Via pytest (parametrized
— 305 tests)" to reflect the current total of 315 tests (derived from
test_conformance.py having 63 programs × 5 levels = 315); locate the header
string "Via pytest (parametrized — 305 tests)" and change the displayed number
to 315 so it matches the Test Files table and the actual parametrized tests for
test_conformance.py.

---

Duplicate comments:
In `@tests/test_codegen.py`:
- Around line 9171-9221: Tests for per-operation HTML import gating are leaking:
test_html_query embeds html_parse and most tests don't assert that other html_*
imports are absent. Update each test (test_html_parse_wat_import,
test_html_to_string_wat_import, test_html_query_wat_import,
test_html_text_wat_import) so they only exercise the single operation under test
(e.g., make test_html_query stop calling html_parse and instead construct an
HtmlNode/HtmlText directly or use an API that doesn't import html_parse) and add
explicit sibling-absence assertions in every test: when asserting the expected
import (e.g., '"html_query"'), also assert the other three imports
('"html_parse"', '"html_to_string"', '"html_text"') are not in result.wat, and
do the analogous checks in the other tests to ensure full isolation.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@TESTING.md`:
- Line 358: Update the stale count text for the `check_examples.py` entry in the
validation scripts table: change the referenced "All 27 examples" to "All 29
examples" so it matches the other table entry (line referencing 29) and the
repository's current total; locate the table row containing the string
`check_examples.py` and update only the numeric count to 29 to keep validation
expectations consistent.

In `@tests/test_codegen.py`:
- Around line 9307-9319: The test test_html_attr_value_escaping currently only
asserts result > 0; change it to call html_to_string(HtmlElement(...)) to get
the serialized string and assert the escaping contract directly: that the
attribute value for "title" does not contain a raw double-quote and is escaped
(e.g. contains title="a"b" or the equivalent HTML entity) — use
html_to_string, HtmlElement, and the map_insert/map_new construction already in
the test to build the element and assert the exact escaped substring instead of
a numeric check.

---

Outside diff comments:
In `@TESTING.md`:
- Line 291: Update the stale example count in the Round-Trip Testing section:
change the sentence that currently says "27 example programs" to "29 example
programs" (this refers to the descriptive line about examples in `examples/`
being tested through every pipeline stage in TESTING.md) so the documented count
matches the newly added examples like `examples/html.vera`.
- Line 207: Update the stale count in the "Contract Verification Coverage"
section that currently reads "all 27 example programs" to reflect the new total
"all 29 example programs" (the PR added examples/html.vera); locate the phrase
in TESTING.md within the Contract Verification Coverage paragraph and change the
numeric count to 29 so it matches the other references (lines that already show
29).
- Around line 233-267: Add a new row to the Language Feature Coverage table for
the Html stdlib feature immediately after the Json entry: add "Ch 9: Stdlib |
Html | test_codegen, test_checker, test_html | ch09_html | html_examples" (or
the actual test-suite and conformance id you use, e.g., test_html and ch09_html)
so the table mirrors other Ch 9 entries; ensure the new "ch09_html" conformance
id and test file names match your existing validation scripts so HTML-related
examples are picked up by the validation pipeline.

---

Duplicate comments:
In `@tests/test_codegen.py`:
- Around line 9200-9215: The test test_html_query_wat_import currently calls
html_parse and html_query together, so it does not prove html_query import is
independently gated; change the test to exercise only html_query (remove the
html_parse call and any match branches that rely on HtmlNode construction from
html_parse) so the compiled result.wat contains the "html_query" import without
also requiring other HTML imports like html_parse; update the source string in
test_html_query_wat_import to produce or reference an HtmlNode value usable by
html_query (e.g., provide a dummy HtmlNode literal or construct the call site to
directly call html_query with a minimal HtmlNode value) and keep the final
assertion assert '"html_query"' in result.wat.

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@TESTING.md`:
- Around line 207-214: The contract coverage numbers in the "Across all 29
example programs" table are inconsistent: it lists "Tier 1 (static) 162", "Total
177", and "91.0%" (which is ~91.5%), and this conflicts with the other overview
metric "162 of 179"; confirm the actual contract counts from the test
output/codebase and then update the table and the overview metric so both show
the same total and a correctly computed percentage (e.g., 162/177 → 91.5% or
162/179 → 90.5%); ensure you update the numeric cells "Tier 1 (static) 162",
"Tier 3 (runtime) 16", "Total X" and the percentage string wherever "162 of 177"
or "162 of 179" appear so all instances match and the derived percent is
accurate.

---

Duplicate comments:
In `@tests/test_codegen.py`:
- Around line 9090-9104: The test test_html_to_string_roundtrip uses a weak
oracle (assert _run(source) > 0); update it to assert the actual contract by
invoking _run(source) and comparing the returned HTML/text to expected values
(e.g., that html_to_string roundtrips to "<p>hi</p>" or that
string_length(html_to_string(...)) equals the expected length and that
comments/nested text are preserved). Locate the test function
test_html_to_string_roundtrip and the helper _run, replace the > 0 check with
precise assertions against the expected serialized HTML/text and length, and
apply the same tightening to the related tests referenced (the tests around the
other occurrences that call _run).