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

Inline comments:
In `@blog/flash_indexer.html`:
- Around line 463-470: Update the embedded Mermaid diagrams in the HTML so they
exactly match the standalone .mmd files: change IDX label to "IDX[Flash
Indexer]" and add the router→engine edge (R --> E1) in the workload diagram (the
block containing IDX and R), replace the colon in the radix-tree label `"block
0: W0, W1, W2"` with an em dash `"block 0 — W0, W1, W2"`, and in the read/write
diagram move the edges pointing to TREE back inside the writes subgraph and add
the reads subgraph grouping so writers and readers visually target the shared
TREE component; easiest fix is to regenerate the HTML from the updated
Markdown/.mmd sources (e.g., re-run the Pandoc build) so all three diagrams are
synchronized.

In `@blog/flash_indexer.md`:
- Around line 432-435: The loop condition can underflow when len == 0; change
the guard to check len first (e.g., while len > 0 && current_pos < len - 1) and
similarly ensure computing next_pos uses a guarded expression (e.g., let
next_pos = (current_pos + self.jump_size).min(len - 1) only when len > 0) so
that current_pos, len, active, and next_pos do not cause usize underflow; update
the while condition and any related min(len - 1) usage in the same scope (the
loop using current_pos, active, and next_pos) to perform the len > 0 check
first.
- Around line 23-26: Add a language specifier to the fenced code block
containing the rolling-hash pseudocode so markdownlint MD040 is satisfied;
update the fence from ``` to something like ```text (or ```pseudo) for the block
that shows seq_hash[0] = local_hash[0] and seq_hash[i] = hash(seq_hash[i-1] ||
local_hash[i]) so the code is treated as plain text/pseudocode and the linter
warning is resolved.
- Around line 466-515: Add concrete benchmark results and reproducibility links:
update the Benchmarking section to include a concise achieved-vs-offered
throughput summary (e.g., a sentence reporting threshold throughput and the
achieved peak ops/s for the final Positional Indexer with jump search and
optionally per-iteration ops/s), include or reference the ops vs offered curve
inflection point used to define threshold throughput, and add direct links to
the mooncake_bench harness and the public Mooncake trace data so readers can
reproduce the >10 million ops/s claim; mention the exact benchmark configuration
(worker count, duplication factor, block size) used to produce the cited number
so the claim is verifiable.
- Around line 340-353: The send on self.channels inside async fn apply_event is
currently unhandled and may be a dropped future or silently fail; update
apply_event to properly await and handle the send result for the channel type
used: if channels are tokio::sync::mpsc::Sender then call .await on
self.channels[thread_idx].send(Some(event)) and at minimum assign or log the
Result (e.g., let _ = ... .await or log Err), and if channels are synchronous
senders use send(...) and check/handle the return value (unwrap or log on Err);
ensure you modify the send call associated with apply_event and keep the sticky
assignment logic using worker_assignments, counter, and num_workers unchanged.
- Around line 197-226: In find_matches: guard against an empty query by
returning an empty scores map when query.is_empty() (or use query.first() to
safely get the initial LocalHash) instead of indexing query[0]; seed active from
that safe first element, record depth 0 scores for any workers that drop out at
the first position, and then start the for loop from the second element (i.e.,
iterate over query.iter().enumerate().skip(1) or equivalent) so you avoid a
redundant probe at depth 0 and correctly assign scores for workers removed at
position 0; update references to query length when inserting final scores for
remaining workers.

In `@blog/mermaid.lua`:
- Around line 19-29: The code calls io.open(infile) and io.popen(cmd) without
checking for errors, so f or handle can be nil and :write()/:read() will crash;
change the fopen and popen calls to capture both return values (e.g., local f,
ferr = io.open(infile, "w") and local handle, perr = io.popen(cmd)), check if f
or handle is nil, log/report the error string (ferr or perr) using the existing
stderr/error path used elsewhere in this file, and bail out gracefully (skip
converting or return the original block) instead of calling :write() or :read()
on nil; ensure you still close handles only when they are non-nil (f:close(),
handle:close()).

In `@blog/PRETTY_PDF.md`:
- Around line 1-4: The YAML frontmatter in PRETTY_PDF.md uses Cursor rule-style
fields ("name" and "description" with an instruction phrase) which makes it
appear as an AI agent rule rather than normal document metadata; either move
this frontmatter to a Cursor rules file (e.g., create
.cursor/rules/pretty-pdf.mdc and place the "name" and "description" blocks
there) or convert it into standard doc metadata in PRETTY_PDF.md (replace "name"
with "title" and rewrite "description" to a normal human-facing summary) so the
file renders correctly in Markdown viewers and Cursor picks up rules from the
proper location.

---

Nitpick comments:
In `@blog/flash_indexer.md`:
- Around line 413-421: The "scan back" label on the arrow from P64 to scan is
misleading because the function linear_scan_drain actually scans the skipped
range forward (positions 65→96); update the diagram text to reflect that (e.g.,
change the edge label from "scan back" to "scan skipped range" or "scan forward
(skipped range)") and ensure any accompanying caption or node label referring to
this traversal (scan, P64, P96, and linear_scan_drain) uses the same terminology
so the diagram matches the algorithm description.

In `@blog/mermaid_header.html`:
- Around line 11-14: Pin the CDN imports to exact versions and add SRI
integrity+crossorigin attributes for both the mermaid import (the import
statement referencing mermaid@11 and the mermaid.initialize usage) and the
water.css link (the <link rel="stylesheet"> tag) so the browser verifies
content; replace floating specifiers like "mermaid@11" and "water.css@2" with
the exact release filenames (including full semver) and compute & insert SHA384
SRI hashes (and add crossorigin="anonymous") for both resources. Ensure the
import path used by the mermaid import and the href used by the water.css link
are updated together with their respective integrity attributes so
mermaid.initialize still runs against the pinned bundle and the stylesheet loads
under the integrity check.

In `@blog/mermaid.lua`:
- Around line 4-6: The ensure_dir function currently shells out on every mermaid
block; make it run once by adding a one-time guard: introduce a local boolean
(e.g., dir_created) at module scope and update ensure_dir to check that flag,
call os.execute("mkdir -p " .. img_dir) only if dir_created is false, then set
dir_created = true; also replace any other direct mkdir calls (the other
ensure_dir call referenced at line 13) to use this guarded ensure_dir so the
directory creation is idempotent without repeated fork/execs.