workspace: record BOM-guard drop in parse_frontmatter

Co-authored-by: Ralphify <noreply@ralphify.co>

Author: 2 people

workspace/ralphs/improve-codebase/coverage/_frontmatter.md

@@ -0,0 +1,52 @@
+# `_frontmatter.py` coverage
+
+Valid at: a6f4c47
+
+## Recent changes
+
+- a6f4c47 — dropped the `if text.startswith(_UTF8_BOM):` guard in
+  `parse_frontmatter` before the `text = text.removeprefix(_UTF8_BOM)`
+  call.  Python's `str.removeprefix` is already a no-op (returns the
+  same string object) when the prefix is absent, so the guard was
+  purely decorative dead code.  Behavior preserved:
+  - BOM-prefixed input still gets stripped (pinned by
+    `test_utf8_bom_does_not_break_frontmatter` in
+    `tests/test_frontmatter.py`).
+  - Non-BOM input is passed through unchanged (exercised by every
+    other parse test in the file).
+  - The CPython implementation returns the same object identity when
+    no prefix match occurs, so there's no allocation overhead either.
+
+## Shape of the module
+
+- `parse_frontmatter(text)` — public entry point.  Strips optional
+  UTF-8 BOM, splits on `---` delimiters via `_extract_frontmatter_block`,
+  runs `yaml.safe_load`, strips HTML comments from the body with
+  `_strip_html_comments`, returns `(dict, body)`.
+- `serialize_frontmatter(frontmatter, body)` — inverse; emits
+  `---`-delimited blocks only when the frontmatter is non-empty *or*
+  the body would otherwise be mis-parsed as frontmatter.
+- Constants: `RALPH_MARKER`, `FIELD_*`, `CMD_FIELD_*`, `NAME_RE`,
+  `VALID_NAME_CHARS_MSG`.  All imported by `cli.py` and
+  `_resolver.py`; each one is reused across modules so centralisation
+  is justified.
+
+## Verified live (grepped, confirmed used)
+
+- `_FRONTMATTER_DELIMITER` — used 4× in `serialize_frontmatter` (plus
+  2× in `_extract_frontmatter_block`).
+- `_FENCE_OR_COMMENT_RE` — used in `_strip_html_comments`.
+- `_UTF8_BOM` — used in `parse_frontmatter` (BOM strip).
+
+## Potential future wins (not yet taken)
+
+- `_extract_frontmatter_block` splits `text` on `"\n"` up front, then
+  re-joins slices for the body — the body slice is re-joined even when
+  the input is tiny.  Could stream with `str.find` + `str.index` to
+  avoid the list allocation, but this function runs once per
+  iteration and the input is ~1 KB in practice; not worth the churn.
+- The `serialize_frontmatter` `needs_delimiters` expression uses
+  `body.lstrip().startswith(...)` which allocates a new stripped
+  string just to check a prefix.  Could collapse via
+  `re.match(r"\s*---", body)` but the current form reads cleanly;
+  revisit only if this becomes hot.

workspace/ralphs/improve-codebase/iterations.md

@@ -2,6 +2,8 @@
 
 One line per iteration: `<sha> <summary>`.
 
+a6f4c47 refactor: drop redundant BOM-startswith guard before `removeprefix` in `parse_frontmatter` — `str.removeprefix` already returns the string unchanged when the prefix is absent, so the `if text.startswith(_UTF8_BOM):` wrapper was dead defensive code.  Behavior preserved — `test_utf8_bom_does_not_break_frontmatter` still pins the BOM-stripping path and every other test exercises the no-BOM path.  Same "drop the guard when the operation already handles the no-match case" shape as 5337d88 (empty dict → `" · ".join([])`), 4ccfa9a (empty list → `" · ".join([])`), and 8cb0d47 (redundant `max(..., 1)` floor).
+
 3a8908d refactor: use `next(reversed(...), None)` in `enter_fullscreen` history fallback — the compound `if initial_id is None and self._iteration_history:` guard mixed two concerns (only fall back when nothing is live, *and* avoid `next(reversed({}))` raising StopIteration).  Switching to the `next(it, default)` sentinel idiom lets the standard default handle empty-dict case so the outer `if` only encodes the "fall back when nothing live" intent.  Behavior preserved — the existing `if initial_id is None or panel_for(...) is None:` next branch still prints "no iterations yet" and returns False, covered by `test_enter_without_iteration_prints_hint`.
 
 59b0e34 refactor: inline `_fullscreen_page_size()` into the space/b lambdas in `_handle_fullscreen_key` — the `page` local was computed unconditionally in the non-exit branch but only consumed by the page-down (" ") and page-up ("b") action lambdas.  j/k/g/G/[/] now skip the call entirely; space/b still compute it exactly once per keypress, now at action-invocation time under the same lock.  Same Phase 4 "narrow the scope of a one-branch local" shape as 134078d / ef176bf / b19625e.