WillTools 2026-09-09 -- clean snapshot of the development repo for review

History-free snapshot of the private development repository at 77a82eb.
Code, docs and the public catalogue only: no plant or job knowledge
layers, no client, job or producer names (tools/scrub.py clean against
the widened term list; a second word-level grep clean). The intro deck is
left out because its slide images cannot be checked for job drawings.

WillTools.extension/tests/test_pa_criteria.py

@@ -0,0 +1,641 @@
+# -*- coding: utf-8 -*-
+"""Tests for `vibe.pa_criteria.page` -- the Design Criteria section layout.
+
+No Revit and no WPF renderer are available here (see `conftest.py`'s
+docstring for why `vibe` imports this way), so this suite cannot check that
+the page LOOKS right -- nobody has run this inside Revit and this file does
+not claim otherwise. What it can and does check mechanically:
+
+  * `page()` never raises, on an empty dict, a filled dict, `None` values,
+    `None` reads, or a `values` object that is not even a dict.
+  * every block returned is a well-formed member of the block vocabulary
+    `page()`'s docstring promises (`heading`, `columns`, `field`, `kv`,
+    `sentence`, `table`, `rule`, `space`) -- an unknown `kind` renders as
+    nothing on the real form, so a typo here would be a silently missing
+    block that only this test would catch.
+  * every `field` block carries a non-empty, plain-English `label` and a
+    non-empty `hint` -- the owner's whole complaint about the old form was
+    that a field carried only its engineering symbol.
+  * a field key with no backing entry in `panelanalysisform.FIELDS` still
+    renders (an empty editor), and is named in `problems` -- never silently
+    dropped.
+  * `values` is never mutated by a call to `page()`.
+  * the block list is stable: calling `page()` twice on the same input
+    produces the same output.
+"""
+import copy
+import sys
+from pathlib import Path
+
+TESTS_DIR = Path(__file__).resolve().parent
+if str(TESTS_DIR) not in sys.path:
+    sys.path.insert(0, str(TESTS_DIR))
+
+from vibe import pa_criteria as pc  # noqa: E402
+
+
+KNOWN_KINDS = set(['heading', 'columns', 'field', 'kv', 'sentence', 'table',
+                   'lc_table', 'rule', 'space'])
+KNOWN_EDITORS = set(['text', 'num', 'check', 'choice'])
+
+
+def _walk(blocks):
+    """Yield every block in the tree, including nested `columns` children."""
+    for b in blocks:
+        yield b
+        if b.get('kind') == 'columns':
+            for col in b.get('columns') or []:
+                for sub in _walk(col):
+                    yield sub
+
+
+def _assert_well_formed(blocks):
+    for b in blocks:
+        assert isinstance(b, dict), 'block is not a dict: {0!r}'.format(b)
+        kind = b.get('kind')
+        assert kind in KNOWN_KINDS, 'unknown block kind {0!r}'.format(kind)
+
+        if kind == 'heading':
+            assert isinstance(b['text'], str) and b['text'].strip()
+            assert b['level'] in (1, 2, 3)
+
+        elif kind == 'columns':
+            assert isinstance(b['columns'], list) and b['columns']
+            for col in b['columns']:
+                assert isinstance(col, list)
+                _assert_well_formed(col)
+
+        elif kind == 'field':
+            assert isinstance(b['key'], str) and b['key']
+            assert isinstance(b['label'], str) and b['label'].strip(), (
+                'field {0!r} has no plain-English label'.format(b['key']))
+            assert isinstance(b['hint'], str) and b['hint'].strip(), (
+                'field {0!r} has no hint'.format(b['key']))
+            assert b['symbol'] is None or isinstance(b['symbol'], str)
+            assert isinstance(b['required'], bool)
+            assert b['editor'] in KNOWN_EDITORS, (
+                'field {0!r} has unknown editor {1!r}'
+                .format(b['key'], b['editor']))
+            if b['editor'] == 'choice':
+                assert b['choices'], (
+                    'choice field {0!r} has no choices'.format(b['key']))
+            else:
+                assert b['choices'] is None
+
+        elif kind == 'kv':
+            assert isinstance(b['rows'], list)
+            for row in b['rows']:
+                assert len(row) == 2
+
+        elif kind == 'sentence':
+            assert isinstance(b['text'], str) and b['text'].strip()
+
+        elif kind == 'table':
+            assert isinstance(b['headers'], list) and b['headers']
+            assert isinstance(b['rows'], list)
+            for row in b['rows']:
+                assert len(row) == len(b['headers']), (
+                    'table row {0!r} does not match headers {1!r}'
+                    .format(row, b['headers']))
+                for cell in row:
+                    if isinstance(cell, dict):
+                        # `_render_table` grew support for ANY editor kind in
+                        # a cell, not just a tick box (see its own comment,
+                        # "ANY editor kind, not just 'check'") -- that is what
+                        # let Resistance Factors move from a squeezed
+                        # `columns`-of-`field`s to a `table` of live `num`
+                        # editors on 2026-09-04 (WPA655). A cell dict is no
+                        # longer only ever a checkbox.
+                        assert cell.get('editor') in KNOWN_EDITORS
+                        assert cell.get('key')
+                    else:
+                        assert isinstance(cell, str)
+
+        elif kind == 'lc_table':
+            # The load-combination grid: same row/header contract as `table`,
+            # plus a `name` naming the table and a `factors` list the renderer
+            # needs to build an added row's cells. Unlike `table`, a cell may
+            # carry ANY editor kind -- the factors are editable now.
+            assert isinstance(b['name'], str) and b['name']
+            assert isinstance(b['headers'], list) and b['headers']
+            assert isinstance(b['factors'], list) and b['factors']
+            assert isinstance(b['rows'], list)
+            for row in b['rows']:
+                assert len(row) == len(b['headers']), (
+                    'lc_table row {0!r} does not match headers {1!r}'
+                    .format(row, b['headers']))
+                for cell in row:
+                    if isinstance(cell, dict):
+                        assert cell.get('editor') in KNOWN_EDITORS
+                        assert cell.get('key')
+                    else:
+                        assert isinstance(cell, str)
+
+        elif kind == 'rule':
+            assert set(b.keys()) == set(['kind'])
+
+        elif kind == 'space':
+            assert isinstance(b['h'], int)
+
+
+def _field_keys(blocks):
+    return [b['key'] for b in _walk(blocks) if b.get('kind') == 'field']
+
+
+# --------------------------------------------------------------------- tests
+
+def test_empty_values_never_raises_and_is_well_formed():
+    blocks, problems = pc.page({})
+    assert isinstance(blocks, list) and blocks
+    assert isinstance(problems, list)
+    _assert_well_formed(blocks)
+
+
+def test_none_values_and_none_reads_never_raises():
+    blocks, problems = pc.page(None, None)
+    assert isinstance(blocks, list) and blocks
+    _assert_well_formed(blocks)
+
+
+def test_non_dict_values_degrades_rather_than_raising():
+    blocks, problems = pc.page('not a dict')
+    assert isinstance(blocks, list) and blocks
+    _assert_well_formed(blocks)
+
+
+def test_filled_values_never_raises_and_is_well_formed():
+    values = {
+        'fc_psi': '6000', 'fci_psi': '3500', 'unit_weight_pcf': '150',
+        'concrete_type': 'Normalweight', 'rebar_fy_ksi': '60',
+        'rebar_es_ksi': '29000', 'ps_fpu_ksi': '270', 'strand_ep_ksi': '28500',
+        'ps_loss_method': 'PCI', 'ps_loss_humidity_pct': '75',
+        'design_criteria.rvalue_calc_enabled': 'yes',
+        'design_criteria.min_reinf_checked': 'true',
+    }
+    blocks, problems = pc.page(values, {'mark': 'sample_mark',
+                                         'design_number': 'PNL1.0'})
+    assert isinstance(blocks, list) and blocks
+    _assert_well_formed(blocks)
+
+
+def test_values_dict_is_never_mutated():
+    values = {'fc_psi': '6000'}
+    before = copy.deepcopy(values)
+    pc.page(values, {'mark': 'sample_mark'})
+    assert values == before
+
+
+def test_reads_dict_is_never_mutated():
+    reads = {'mark': 'sample_mark', 'design_number': 'PNL1.0'}
+    before = copy.deepcopy(reads)
+    pc.page({}, reads)
+    assert reads == before
+
+
+def test_block_list_is_stable_for_the_same_input():
+    values = {'fc_psi': '6000', 'unit_weight_pcf': '150'}
+    reads = {'mark': 'sample_mark'}
+    a, pa = pc.page(values, reads)
+    b, pb = pc.page(values, reads)
+    assert a == b
+    assert pa == pb
+
+
+def test_missing_key_degrades_to_a_field_and_names_a_problem():
+    blocks, problems = pc.page({})
+    keys = set(_field_keys(blocks))
+    # A key this file invented because Eriksson's page has no home for it
+    # yet in panelanalysisform.FIELDS.
+    assert 'design_criteria.analysis_beta_d' in keys
+    joined = ' '.join(problems)
+    assert 'design_criteria.analysis_beta_d' in joined
+
+
+def test_existing_form_key_is_not_reported_as_missing():
+    blocks, problems = pc.page({})
+    joined = ' '.join(problems)
+    # fc_psi is a real, long-standing panelanalysisform.FIELDS key.
+    assert "'fc_psi'" not in joined or 'fc_psi) has no backing' not in joined
+    for p in problems:
+        assert 'fc_psi)' not in p
+
+
+def test_every_field_key_appears_at_most_once():
+    blocks, _problems = pc.page({})
+    keys = _field_keys(blocks)
+    dupes = [k for k in set(keys) if keys.count(k) > 1]
+    assert not dupes, 'field key(s) rendered more than once: {0}'.format(dupes)
+
+
+def test_section_heading_is_present():
+    blocks, _problems = pc.page({})
+    headings = [b['text'] for b in blocks if b.get('kind') == 'heading']
+    assert 'Design Criteria' in headings
+    assert headings[0] == 'Design Criteria'
+
+
+def test_prime_notation_used_not_ascii_apostrophe():
+    blocks, _problems = pc.page({})
+    for b in _walk(blocks):
+        if b.get('kind') != 'field':
+            continue
+        symbol = b.get('symbol') or ''
+        # f'c / f'ci style ASCII apostrophes must never appear; the real
+        # prime character (U+2032) is what the renderer turns into a
+        # subscript.
+        assert "f'c" not in symbol and "f'ci" not in symbol
+        if u"f′" in symbol or u"E′" in symbol:
+            assert True  # sanity: the prime character is reachable at all
+
+
+def test_load_combination_tables_have_include_checkboxes():
+    blocks, problems = pc.page({})
+    tables = [b for b in _walk(blocks) if b.get('kind') == 'lc_table']
+    assert len(tables) == 2
+    assert set(t['name'] for t in tables) == set(['strength', 'service'])
+    for t in tables:
+        assert t['headers'][-1] == 'Include'
+        for row in t['rows']:
+            cell = row[-1]
+            assert isinstance(cell, dict) and cell['editor'] == 'check'
+            assert cell['key'].startswith(
+                'load_combo.{0}.'.format(t['name']))
+            assert cell['key'].endswith('.include')
+    # The Include ticks used to be reported as having "no backing fields yet".
+    # They do now (`panelanalysisform.load_combo_include_key`, pre-ticked by
+    # `prefill`), so that problem is gone rather than standing stale.
+    joined = ' '.join(problems)
+    assert 'no backing fields yet' not in joined
+
+
+def test_load_combination_factor_cells_are_editable_and_keyed():
+    """Owner, 2026-09-03: the ACI factors are the user's to change. Every
+    factor cell must be a live numeric editor with a key of its own, not the
+    plain printed text the old `table` block carried."""
+    blocks, _problems = pc.page({})
+    tables = [b for b in _walk(blocks) if b.get('kind') == 'lc_table']
+    assert tables
+    for t in tables:
+        assert t['factors'] == ['D', 'L', 'R', 'W', 'E', 'T', 'H']
+        for row in t['rows']:
+            rid = row[0]
+            assert isinstance(rid, str) and rid
+            for i, col in enumerate(t['factors']):
+                cell = row[i + 1]
+                assert isinstance(cell, dict), (
+                    'factor cell {0} of row {1} is not an editor'
+                    .format(col, rid))
+                assert cell['editor'] == 'num'
+                assert cell['key'] == 'load_combo.{0}.{1}.{2}'.format(
+                    t['name'], rid, col)
+
+
+def test_load_combination_defaults_match_the_form_modules_table():
+    """The local ACI tuples are a fallback for an unimportable sibling module
+    (see `_combo_table`); they must not drift from the live copy."""
+    from vibe import panelanalysisform as paf
+    assert pc._STRENGTH_COMBOS == paf.LOAD_COMBO_ROWS['strength']
+    assert pc._SERVICE_COMBOS == paf.LOAD_COMBO_ROWS['service']
+
+
+def test_a_user_added_row_shows_up_in_the_table():
+    """A row the user added exists only as keys in `values`; the table has to
+    rebuild it from there or the row would vanish on the next render."""
+    values = {'load_combo.strength.u1.include': 'yes',
+              'load_combo.strength.u1.D': '1.05'}
+    blocks, _problems = pc.page(values)
+    strength = [b for b in _walk(blocks)
+                if b.get('kind') == 'lc_table' and b['name'] == 'strength'][0]
+    ids = [row[0] for row in strength['rows']]
+    assert ids[-1] == 'u1'
+    assert len(ids) == 9          # the eight ACI rows, then the user's
+
+
+def test_soil_blocks_are_sentences_not_editors():
+    blocks, problems = pc.page({})
+    sentences = [b['text'] for b in _walk(blocks) if b.get('kind') == 'sentence']
+    assert any('no exterior soil loads' in s for s in sentences)
+    assert any('no interior soil loads' in s for s in sentences)
+    assert any('soil loads are not collected' in p for p in problems)
+
+
+def test_prestress_loss_group_is_a_sentence_when_blank():
+    blocks, _problems = pc.page({})
+    sentences = [b['text'] for b in _walk(blocks) if b.get('kind') == 'sentence']
+    assert any('No prestress loss assumptions' in s for s in sentences)
+    # And its fields must NOT be rendered while blank -- shown only once
+    # something in the group is filled in.
+    keys = set(_field_keys(blocks))
+    assert 'ps_loss_method' not in keys
+
+
+def test_prestress_loss_group_becomes_fields_when_filled():
+    blocks, _problems = pc.page({'ps_loss_method': 'PCI'})
+    keys = set(_field_keys(blocks))
+    assert 'ps_loss_method' in keys
+    assert 'ps_loss_humidity_pct' in keys
+
+
+def test_filling_one_group_field_does_not_file_a_phantom_problem_for_others():
+    # Regression guard: `_group_or_sentence` must not evaluate the
+    # filled-in branch (and thus call `F(key)`, which files a "missing"
+    # problem) when the sentence branch is the one actually shown.
+    _blocks, problems_blank = pc.page({})
+    joined = ' '.join(problems_blank)
+    assert 'ps_loss_method' not in joined
+    assert 'ps_loss_humidity_pct' not in joined
+
+
+def test_rvalue_and_min_reinforcement_default_sentences_present():
+    blocks, _problems = pc.page({})
+    sentences = [b['text'] for b in _walk(blocks) if b.get('kind') == 'sentence']
+    assert any('R-value is not being calculated' in s for s in sentences)
+    assert any('Minimum steel is not being checked' in s for s in sentences)
+
+
+def test_concrete_grid_has_release_and_inplace_strength_fields():
+    blocks, _problems = pc.page({})
+    keys = set(_field_keys(blocks))
+    assert 'fci_psi' in keys
+    assert 'fc_psi' in keys
+    assert 'conc_eci_psi' in keys
+    assert 'conc_ec_psi' in keys
+
+
+def test_ksi_reconciliation_hint_on_psi_keys():
+    blocks, _problems = pc.page({})
+    for b in _walk(blocks):
+        if b.get('kind') == 'field' and b['key'] in ('fc_psi', 'fci_psi'):
+            assert 'ksi' in b['hint'].lower()
+
+
+def test_required_fields_match_panelanalysisform_where_it_exists():
+    from vibe import panelanalysisform as pf
+    blocks, _problems = pc.page({})
+    required_here = dict((b['key'], b['required'])
+                         for b in _walk(blocks) if b.get('kind') == 'field')
+    for f in pf.FIELDS:
+        key = f['key']
+        if key in required_here:
+            assert required_here[key] == f['required'], (
+                'required flag mismatch for {0!r}'.format(key))
+
+
+def test_panel_header_kv_shown_only_when_reads_present():
+    blocks_no_reads, _ = pc.page({}, {})
+    kvs_no_reads = [b for b in blocks_no_reads if b.get('kind') == 'kv']
+    blocks_with_reads, _ = pc.page({}, {'mark': 'sample_mark'})
+    kvs_with_reads = [b for b in blocks_with_reads if b.get('kind') == 'kv']
+    assert len(kvs_with_reads) >= len(kvs_no_reads) + 1
+
+
+def test_page_import_survives_a_broken_panelanalysisform(monkeypatch):
+    """Simulates the sibling agent's file being mid-edit / unimportable.
+
+    `_existing_keys()` is the one function that reaches for
+    `panelanalysisform`; monkeypatching it directly to behave the way it
+    would if the import raised (returning `None`) exercises the same
+    "could not judge" path `page()` must degrade through, without depending
+    on the interpreter's module-cache mechanics for a package (`vibe`)
+    that other tests in this same process have already imported
+    `panelanalysisform` onto as an attribute.
+    """
+    monkeypatch.setattr(pc, '_existing_keys', lambda: None)
+    blocks, problems = pc.page({})
+    assert isinstance(blocks, list) and blocks
+    assert any('could not read panelanalysisform' in p for p in problems)
+
+
+def test_choice_field_has_choices():
+    blocks, _problems = pc.page({})
+    for b in _walk(blocks):
+        if b.get('kind') == 'field' and b['key'] == 'concrete_type':
+            assert b['editor'] == 'choice'
+            assert 'Normalweight' in b['choices']
+
+
+# ------------------------------------------------ 2026-09-04 dropdown pass
+#
+# Owner: "很多东西应该是选项，而不是让用户填写" -- governing code, ASCE
+# chapters and the rest of the enumerated Design Criteria settings become
+# pick-lists. Vocabulary is pinned exactly because `vibe.pa_defaults` (a
+# sibling module) writes these values verbatim.
+
+def test_design_spec_is_a_choice_field():
+    blocks, _problems = pc.page({})
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    f = fields['design_spec']
+    assert f['editor'] == 'choice'
+    assert f['choices'] == ['ACI 318-19', 'ACI 318-14', 'ACI 318-11']
+
+
+def test_design_criteria_settings_fields_are_choice_editors():
+    blocks, _problems = pc.page({})
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    expected = {
+        'design_criteria.analysis_beta_d': ['Non-Sway', 'Sway'],
+        'design_criteria.cracking_method': ['Mast Method', 'Uncracked',
+                                            'Cracked'],
+        'design_criteria.flexure_method': ['Whitney Stress Block',
+                                           'Strain Compatibility'],
+        'design_criteria.flexure_cracking_check': ['None', '1.2 Mcr',
+                                                    '1.33 Mu'],
+        'design_criteria.deflection_cantilever_limit': ['L/75', 'L/120',
+                                                         'L/150'],
+    }
+    for key, choices in expected.items():
+        f = fields[key]
+        assert f['editor'] == 'choice', '{0} is not a choice editor'.format(
+            key)
+        assert f['choices'] == choices
+
+
+def test_yes_no_design_criteria_fields_stay_checkboxes():
+    blocks, _problems = pc.page({})
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    for key in (
+        'design_criteria.deflection_add_bow',
+        'design_criteria.deflection_check_cantilever',
+        'design_criteria.rvalue_calc_enabled',
+        'design_criteria.min_reinf_checked',
+        'design_criteria.stress_failure_if_cracked',
+        'design_criteria.stress_ignore_lateral_ecc',
+        'design_criteria.stress_use_principal_axis',
+        'design_criteria.shear_treat_as_column',
+        'design_criteria.axial_ignore_tensile_failures',
+        'design_criteria.axial_ignore_buckling_failures',
+    ):
+        assert fields[key]['editor'] == 'check', key
+        assert fields[key]['choices'] is None
+
+
+def test_cracking_assumption_now_renders_as_a_choice_field():
+    """`cracking_assumption` is a real `panelanalysisform.FIELDS` key with a
+    Cracked/Uncracked vocabulary (and a `PREFILL_DEFAULTS` entry) that no
+    page module surfaced before this change -- added beside `second_order`
+    in Structural Analysis so a pre-filled value has somewhere to be seen
+    and edited."""
+    blocks, _problems = pc.page({})
+    keys = set(_field_keys(blocks))
+    assert 'cracking_assumption' in keys
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    f = fields['cracking_assumption']
+    assert f['editor'] == 'choice'
+    assert f['choices'] == ['Cracked', 'Uncracked']
+
+
+# ------------------------------------------------ 2026-09-04 headless review
+#
+# WPA655's rendered Design Criteria tab was reviewed by eye and five findings
+# were filed; these tests pin the fix for each. See the module docstring's
+# "UPDATE 2026-09-04" note for the Resistance Factors layout change and the
+# `ps_loss_humidity_pct` comment above the Prestress Losses block.
+
+def _table_blocks(blocks):
+    """Every `table`-kind block anywhere in the tree, `columns` descended."""
+    return [b for b in _walk(blocks) if b.get('kind') == 'table']
+
+
+def _table_cell_keys(blocks):
+    """Every editor key embedded in a `table` cell. These live inside
+    `table.rows`, not as `field` blocks -- `_field_keys` cannot see them,
+    which is exactly why the Resistance Factors phi editors need their own
+    check rather than reusing that helper."""
+    keys = []
+    for t in _table_blocks(blocks):
+        for row in t.get('rows') or []:
+            for cell in row:
+                if isinstance(cell, dict) and cell.get('key'):
+                    keys.append(cell['key'])
+    return keys
+
+
+_PHI_KEYS = ('phi_flexure', 'design_criteria.phi_tension_transfer',
+             'design_criteria.phi_compression', 'phi_shear',
+             'design_criteria.phi_shear_transfer')
+
+
+def test_every_resistance_factor_phi_has_a_visible_table_editor():
+    """Finding 1: the old two-column `Developed | Transferring` `columns` of
+    `field` blocks squeezed every phi editor to zero width. All five phi
+    keys must now show up as live editors somewhere on the page."""
+    blocks, _problems = pc.page({})
+    keys = set(_table_cell_keys(blocks))
+    for key in _PHI_KEYS:
+        assert key in keys, '{0} has no visible editor'.format(key)
+
+
+def test_resistance_factor_phi_cells_are_live_num_editors_not_text():
+    blocks, _problems = pc.page({})
+    cells_by_key = {}
+    for t in _table_blocks(blocks):
+        for row in t.get('rows') or []:
+            for cell in row:
+                if isinstance(cell, dict) and cell.get('key') in _PHI_KEYS:
+                    cells_by_key[cell['key']] = cell
+    assert set(cells_by_key) == set(_PHI_KEYS)
+    for key, cell in cells_by_key.items():
+        assert cell['editor'] == 'num', '{0} is not a num editor'.format(key)
+
+
+def test_resistance_factors_table_marks_compression_transferring_na():
+    """The one phi that genuinely does not apply (compression once the
+    strand has fully transferred) stays a plain text cell, not an editor --
+    same discipline as the old `sentence`, just inside the new table."""
+    blocks, _problems = pc.page({})
+    tables = [t for t in _table_blocks(blocks) if t['headers'][0] == u'φ']
+    assert len(tables) == 1
+    rows = dict((row[0], row) for row in tables[0]['rows'])
+    assert 'Compression' in rows
+    na_cell = rows['Compression'][2]  # the 'Transferring' column
+    assert isinstance(na_cell, str)
+    assert 'not applicable' in na_cell.lower()
+
+
+def test_resistance_factor_missing_backing_field_problems_still_filed():
+    """Moving the three `design_criteria.phi_*` keys into table cells must
+    not silently drop the existing 'no backing field yet' bookkeeping --
+    `_cell()` routes every key through `F()` first specifically to keep it."""
+    _blocks, problems = pc.page({})
+    joined = ' '.join(problems)
+    for key in ('design_criteria.phi_tension_transfer',
+                'design_criteria.phi_compression',
+                'design_criteria.phi_shear_transfer'):
+        assert key in joined, '{0} missing-field problem was dropped'.format(
+            key)
+
+
+def test_mesh_material_fields_are_collected():
+    """Finding 2: `mesh_fy_ksi` / `mesh_es_ksi` exist in
+    `panelanalysisform.FIELDS` (80 ksi / 29000 ksi defaults) but this page
+    used to render only a 'not collected yet' sentence for Mesh -- now shown
+    the same way Rebar's fy / Es are."""
+    blocks, problems = pc.page({})
+    keys = set(_field_keys(blocks))
+    assert 'mesh_fy_ksi' in keys
+    assert 'mesh_es_ksi' in keys
+    joined = ' '.join(problems)
+    # `_field()`'s missing-backing-field message quotes the key inside
+    # parens -- "(mesh_fy_ksi)" -- and must not appear, since both keys are
+    # real `panelanalysisform.FIELDS` entries.
+    assert '(mesh_fy_ksi)' not in joined
+    assert '(mesh_es_ksi)' not in joined
+    sentences = [b['text'] for b in _walk(blocks) if b.get('kind') == 'sentence']
+    assert not any('No mesh material properties' in s for s in sentences)
+
+
+def test_inplace_tension_sqrt_row_present_above_modulus_of_rupture():
+    """Finding 3: the uncracked in-place tension limit
+    (`inplace_tension_sqrt`, 7.5 sqrt(f'c)) is a real `panelanalysisform`
+    key this page never surfaced. All three In-Place Stress Limits rows
+    must be present and named the way Eriksson prints them."""
+    blocks, _problems = pc.page({})
+    keys = set(_field_keys(blocks))
+    assert 'inplace_tension_sqrt' in keys
+    assert 'design_criteria.inplace_modulus_rupture_sqrt_fc' in keys
+    assert 'inplace_comp_ratio' in keys
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    assert fields['inplace_tension_sqrt']['label'] == u'Tension, uncracked'
+    assert (fields['design_criteria.inplace_modulus_rupture_sqrt_fc']['label']
+            == u'Tension, transition (modulus of rupture)')
+    assert fields['inplace_comp_ratio']['label'] == u'Compression'
+
+
+def test_inplace_tension_sqrt_precedes_modulus_of_rupture_in_col_b():
+    """Order matters, not just presence -- the uncracked tension row belongs
+    above the modulus-of-rupture row, as on Eriksson's own printout."""
+    blocks, _problems = pc.page({})
+    field_keys = _field_keys(blocks)
+    i_tension = field_keys.index('inplace_tension_sqrt')
+    i_rupture = field_keys.index(
+        'design_criteria.inplace_modulus_rupture_sqrt_fc')
+    assert i_tension < i_rupture
+
+
+def test_prestress_loss_percent_symbol_field_still_present_and_editable():
+    """Finding 4: the '%' unit on `ps_loss_humidity_pct` must stay attached
+    to a live editor after the group's fields moved from one wide column
+    into a 2x2 layout -- only the layout changed, not the field itself."""
+    blocks, _problems = pc.page({'ps_loss_method': 'PCI'})
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    f = fields['ps_loss_humidity_pct']
+    assert f['symbol'] == '%'
+    assert f['editor'] == 'num'
+
+
+def test_sway_condition_field_is_a_choice_editor():
+    """Finding 6: keep the label, make sure the choice editor is used."""
+    blocks, _problems = pc.page({})
+    fields = dict((b['key'], b) for b in _walk(blocks)
+                  if b.get('kind') == 'field')
+    f = fields['design_criteria.analysis_beta_d']
+    assert f['label'] == u'Sway condition for 2nd-order analysis'
+    assert f['symbol'] == u'βd'
+    assert f['editor'] == 'choice'
+    assert f['choices'] == ['Non-Sway', 'Sway']