@@ -30,9 +30,14 @@ import {
 } from "../../src/sections/contract/permissions.js";
 import { SECTIONS } from "../../src/sections/registry.js";
 import { agree } from "../../src/text.js";
+import type { UndeclaredPolicy } from "../../src/types.js";
 import { countWord } from "./lib/count-word.js";
-import { type GeneratedRegion, regenerateRegions } from "./lib/generated-regions.js";
-import { tableCell } from "./lib/markdown-table.js";
+import {
+  type GeneratedRegion,
+  regenerateRegions,
+  renderedMismatch,
+} from "./lib/generated-regions.js";
+import { renderTable, tableCell, tableRoundTrip } from "./lib/markdown-table.js";
 
 const ROOT = join(import.meta.dir, "..", "..");
 
@@ -174,6 +179,24 @@ export interface PolicyRowProse {
   readonly override: string;
 }
 
+/**
+ * Why a row's prose cannot be rendered: "" would render `delete ()` or a bare policy span, both cells tableCell()
+ * admits. The renderer refuses it at its own boundary and the parser through this same check, so what the renderer
+ * writes is exactly what the guard reads back. A structural type cannot vouch for a property a narrowing hid, so
+ * the value is inspected as unknown.
+ */
+function proseFault(row: PolicyRowProse): string | undefined {
+  const empty = (value: unknown): boolean => typeof value !== "string" || value === "";
+  return empty(row.override) || (row.caveat !== undefined && empty(row.caveat))
+    ? "has an empty caveat or override"
+    : undefined;
+}
+
+const OPPOSITE: Readonly<Record<UndeclaredPolicy, UndeclaredPolicy>> = {
+  delete: "keep",
+  keep: "delete",
+};
+
 const DEFAULTS_TABLE_HEADER = "| Section | Default | The override buys you |\n|---|---|---|";
 
 export function renderPolicyDefaultsTable(
@@ -185,19 +208,49 @@ export function renderPolicyDefaultsTable(
     if (text === undefined) {
       throw new Error(`no Defaults-per-section prose for the "${section.key}" section`);
     }
-    const caveat = text.caveat === undefined ? "" : ` (${text.caveat})`;
-    const opposite = section.undeclaredDefault === "delete" ? "keep" : "delete";
-    const cells = [
+    // Read once, so the fault check and the cells see the same values.
+    const row = { caveat: text.caveat, override: text.override };
+    const fault = proseFault(row);
+    if (fault !== undefined) {
+      throw new Error(`the "${section.key}" Defaults row ${fault}`);
+    }
+    const caveat = row.caveat === undefined ? "" : ` (${row.caveat})`;
+    return [
       `\`${section.key}\``,
       tableCell(`${section.undeclaredDefault}${caveat}`, `the ${section.key} Default cell`),
       tableCell(
-        `\`${opposite}\`: ${text.override}`,
+        `\`${OPPOSITE[section.undeclaredDefault]}\`: ${row.override}`,
         `the ${section.key} "The override buys you" cell`,
       ),
     ];
-    return `| ${cells.join(" | ")} |`;
   });
-  return [DEFAULTS_TABLE_HEADER, ...rows].join("\n");
+  return renderTable(DEFAULTS_TABLE_HEADER, rows);
+}
+
+/** A Defaults row read back to the section and prose it renders from; the opposite-policy binding and the
+ * delete-first order are then the renderer's to check, through the byte compare. The dotAll flag keeps the
+ * two Unicode line separators tableCell() admits inside the prose. */
+function policyRow(
+  cells: readonly string[],
+  key: string,
+): { readonly section: KnobbedSection; readonly prose: PolicyRowProse } | string {
+  const policy = /^(delete|keep)(?: \((.*)\))?$/s.exec(cells[1] ?? "");
+  const buys = /^`(?:delete|keep)`: (.*)$/s.exec(cells[2] ?? "")?.[1];
+  if (policy === null) {
+    return "states no delete or keep default";
+  }
+  if (buys === undefined) {
+    return "names no policy span before its override prose";
+  }
+  const row = { caveat: policy[2], override: buys };
+  const fault = proseFault(row);
+  if (fault !== undefined) {
+    return `${fault}, which the renderer refuses`;
+  }
+  return {
+    section: { key, undeclaredDefault: policy[1] === "delete" ? "delete" : "keep" },
+    prose: row,
+  };
 }
 
 /** The row every secret family shares: the value is write-only, so a wrong delete is a loss, not a drift. */
@@ -347,10 +400,6 @@ function blockShape(lines: string): RegExp {
   return new RegExp(String.raw`^\n(?:${lines}|\n)?$`);
 }
 
-function tableShape(header: string, cells: string): RegExp {
-  return blockShape(String.raw`${RegExp.escape(header)}\n(?:\| ${cells} \|\n)*`);
-}
-
 /** The emitter is its own grammar: a body is admitted when re-rendering the declarations it parses to reproduces it
  * byte for byte, so no spelling the emitter does not write gets through. A freshly placed region holds "\n" and
  * renders next. */
@@ -386,15 +435,7 @@ function roundTrip<T extends { readonly description: string }>(
     if (typeof declared === "string") {
       return `it is not a set of ${key} declarations (${declared})`;
     }
-    const rendered = `\n${render(declared)}\n`;
-    if (rendered === body) {
-      return undefined;
-    }
-    const authored = body.split("\n");
-    const expected = rendered.split("\n");
-    const differing = authored.findIndex((line, i) => line !== expected[i]);
-    const at = differing === -1 ? authored.length : differing;
-    return `line ${at} reads ${JSON.stringify(authored[at] ?? "")} where the generator writes ${JSON.stringify(expected[at] ?? "")}`;
+    return renderedMismatch(body, `\n${render(declared)}\n`);
   };
 }
 
@@ -434,10 +475,11 @@ export const GENERATED_REGIONS: Readonly<Record<string, readonly GeneratedRegion
     {
       name: "policy-defaults-table",
       placement: { kind: "under-heading", heading: "## Defaults per section" },
-      // A cell holds no pipe and no line break: tableCell() refuses both, so a row carrying one is authored, not stale output.
-      body: tableShape(
-        DEFAULTS_TABLE_HEADER,
-        String.raw`\x60[a-z_]+\x60 \| (?:delete|keep)(?: \([^\r\n|]+\))? \| \x60(?:delete|keep)\x60: [^\r\n|]+`,
+      body: tableRoundTrip(DEFAULTS_TABLE_HEADER, policyRow, (rows) =>
+        renderPolicyDefaultsTable(
+          rows.map((row) => row.section),
+          Object.fromEntries(rows.map((row) => [row.section.key, row.prose])),
+        ),
       ),
       render: block(() => renderPolicyDefaultsTable(knobbedSections(), POLICY_ROW_PROSE)),
     },
 
@@ -16,7 +16,7 @@ import { readArchitecture, renderArchitectureMermaid } from "./arch-lint.js";
 import { COVERAGE_DATA, type CoverageData } from "./coverage-data.js";
 import { ENDPOINT_ANCHORS, type EndpointAnchors } from "./endpoint-docs.js";
 import { type GeneratedRegion, regenerateRegions, regionBounds } from "./lib/generated-regions.js";
-import { tableCell } from "./lib/markdown-table.js";
+import { renderTable, tableCell, tableRoundTrip, tableRow } from "./lib/markdown-table.js";
 
 const ROOT = join(import.meta.dir, "..", "..");
 export const COVERAGE_PATH = "docs/reference/coverage.md";
@@ -106,7 +106,7 @@ export function renderSectionsTable(
       tableCell(doc.sections_table.notes, `the ${section.key} Notes cell`),
     ];
   });
-  return [TABLE_HEADER, ...rows.map((cells) => `| ${cells.join(" | ")} |`)].join("\n");
+  return renderTable(TABLE_HEADER, rows);
 }
 
 /** Text for inside a markdown code span: a cell, and a backtick would close the span early. */
@@ -244,7 +244,7 @@ function renderSection(
       `[\`${section.key}\`](${SECTIONS_PAGE})${keys}`,
       tableCell(renderCalls(section, row, claimed, carrier, anchors), `${where}'s Endpoints cell`),
     ];
-    return `| ${cells.join(" | ")} |`;
+    return tableRow(cells);
   });
   const declared = [...Object.keys(section.endpoints), ...Object.keys(section.graphql ?? {})];
   const unclaimed = declared.filter((role) => !claimed.has(role));
@@ -310,7 +310,7 @@ export function renderCoverage(
               tableCell(row.endpoints.join(", "), `${where}'s Endpoints cell`),
               tableCell(row.why, `${where}'s Why cell`),
             ];
-            return `| ${cells.join(" | ")} |`;
+            return tableRow(cells);
           }),
         ];
   return [
@@ -407,15 +407,20 @@ function patFormUrl(): string {
   );
 }
 
-// The body shape is this generator's own output (or an empty body), built from the renderer constants, so a marker
-// moved over authored prose or another table fails instead of erasing it.
+// The three prose cells are opaque; a row is this table's when its Undeclared default cell is one of the displays,
+// the one cell past the key renderSectionsTable() writes without tableCell().
+function sectionsRow(cells: readonly string[]): readonly string[] | string {
+  if (!Object.values(UNDECLARED_DEFAULT_DISPLAY).includes(cells[3] ?? "")) {
+    return "shows an Undeclared default the renderer has no display for";
+  }
+  return cells;
+}
+
 function sectionsTableRegion(name: string, heading: string): GeneratedRegion {
   return {
     name,
     placement: { kind: "under-heading", heading },
-    body: new RegExp(
-      String.raw`^\n(?:${RegExp.escape(TABLE_HEADER)}\n(?:\| \x60[a-z_]+\x60 \| [^\n]* \|\n)*)?$`,
-    ),
+    body: tableRoundTrip(TABLE_HEADER, sectionsRow, (rows) => renderTable(TABLE_HEADER, rows)),
     render: () => `\n${renderSectionsTable(SECTIONS, DOCS)}\n`,
   };
 }
 
@@ -159,6 +159,18 @@ export function bodyRefusal(shape: BodyShape, body: string): string | undefined
   return shape(body);
 }
 
+/** A round-trip guard's verdict: undefined when `body` is `rendered` byte for byte, else the first differing line. */
+export function renderedMismatch(body: string, rendered: string): string | undefined {
+  if (rendered === body) {
+    return undefined;
+  }
+  const authored = body.split("\n");
+  const expected = rendered.split("\n");
+  const differing = authored.findIndex((line, i) => line !== expected[i]);
+  const at = differing === -1 ? authored.length : differing;
+  return `line ${at} reads ${JSON.stringify(authored[at] ?? "")} where the generator writes ${JSON.stringify(expected[at] ?? "")}`;
+}
+
 interface MarkdownScan {
   /** Fenced code blocks, an unclosed one running to the end of the text. */
   readonly fenced: readonly MarkerSpan[];
 
@@ -1,13 +1,93 @@
+// The markdown tables the generators write: a header constant over one `| a | b |` row per record. The cell rule
+// and the row joiner are the whole grammar, so tableRoundTrip() reads a region back by the same rules and admits
+// only what renderTable() reproduces byte for byte.
+
+import { renderedMismatch } from "./generated-regions.js";
+
+/** Why `text` cannot be a cell: a pipe or a line break would split its row, a blank would leave its column empty. */
+function cellFault(text: string): string | undefined {
+  return text.trim() === "" || /[|\r\n]/.test(text)
+    ? 'is blank or contains "|" or a line break'
+    : undefined;
+}
+
 /**
- * A markdown table cell of authored prose, refused rather than escaped: a pipe or a line break would split its row,
- * a blank one would leave its column empty, and an escape would silently change the rendered text. `where` names
- * the cell as its author knows it.
+ * `text` as a cell of authored prose, refused rather than escaped: an escape would silently change the rendered text.
+ * `where` names the cell as its author knows it.
  */
 export function tableCell(text: string, where: string): string {
-  if (text.trim() === "" || /[|\r\n]/.test(text)) {
-    throw new Error(
-      `${where} is blank or contains "|" or a line break, which would break its table row: "${text}"`,
-    );
+  const fault = cellFault(text);
+  if (fault !== undefined) {
+    throw new Error(`${where} ${fault}, which would break its table row: "${text}"`);
   }
   return text;
 }
+
+/** A settings key in a code span: the cell every generated table opens its rows with, written without tableCell(). */
+const KEY_SPAN = /^`([a-z_]+)`$/;
+
+export function tableRow(cells: readonly string[]): string {
+  return `| ${cells.join(" | ")} |`;
+}
+
+export function renderTable(header: string, rows: ReadonlyArray<readonly string[]>): string {
+  return [header, ...rows.map(tableRow)].join("\n");
+}
+
+/** The cells of one tableRow() line; a line of another shape yields the wrong count or fails the byte compare. */
+function rowCells(line: string): string[] {
+  return line
+    .split("|")
+    .slice(1, -1)
+    .map((cell) => cell.slice(1, -1));
+}
+
+/**
+ * The body guard of a generated table region. The body splits into rows and cells the way renderTable() joined
+ * them, every cell passes cellFault(), every row opens with a key span no other row repeats (the renderers walk a
+ * registry), `parseRow` turns a row's cells into the record it renders from (a string is the refusal), and
+ * `renderRows` must reproduce the body byte for byte, so an authored spelling the renderer never writes is refused
+ * rather than erased. A freshly placed region holds "\n" and renders next.
+ */
+export function tableRoundTrip<Row>(
+  header: string,
+  parseRow: (cells: readonly string[], key: string) => Row | string,
+  renderRows: (rows: readonly Row[]) => string,
+): (body: string) => string | undefined {
+  const headerLines = header.split("\n");
+  const columns = rowCells(headerLines[0] ?? "").length;
+  return (body) => {
+    if (body === "\n") {
+      return undefined;
+    }
+    const rows: Row[] = [];
+    const keys = new Set<string>();
+    if (body.startsWith(`\n${header}\n`) && body.endsWith("\n")) {
+      const lines = body.split("\n");
+      for (let at = headerLines.length + 1; at < lines.length - 1; at += 1) {
+        const cells = rowCells(lines[at] ?? "");
+        if (cells.length !== columns) {
+          return `line ${at} has ${cells.length} cells where the table has ${columns}`;
+        }
+        const faulty = cells.findIndex((cell) => cellFault(cell) !== undefined);
+        if (faulty !== -1) {
+          return `cell ${faulty + 1} of line ${at} ${cellFault(cells[faulty] ?? "")}`;
+        }
+        const key = KEY_SPAN.exec(cells[0] ?? "")?.[1];
+        if (key === undefined) {
+          return `line ${at} does not open with a section key in a code span`;
+        }
+        if (keys.has(key)) {
+          return `line ${at} repeats the \`${key}\` row`;
+        }
+        keys.add(key);
+        const row = parseRow(cells, key);
+        if (typeof row === "string") {
+          return `line ${at} ${row}`;
+        }
+        rows.push(row);
+      }
+    }
+    return renderedMismatch(body, `\n${renderRows(rows)}\n`);
+  };
+}