fix: handle arbitrarily deep BAB nesting in phantom-BAB filter

The previous filter only checked direct children of each top-level BAB
node when determining whether it had pasal content. This missed the
BAB → Bagian → Paragraf → Pasal nesting depth documented in the schema,
causing those BABs to be silently filtered out.

Replace with a parent→children map + recursive hasDescendantPasal()
that walks the full subtree at any depth, so a BAB is only filtered if
no structural node in its entire subtree is a direct parent of a pasal.

Co-authored-by: Claude <noreply@anthropic.com>

Author: daffaromero

apps/web/src/app/[locale]/peraturan/[type]/[slug]/page.tsx

@@ -301,7 +301,7 @@ async function LawReaderSection({
 
   const pageUrl = `https://pasal.id/peraturan/${type.toLowerCase()}/${slug}`;
 
-  // Build a set of structural node IDs that have at least one pasal child.
+  // Build a set of structural node IDs that have at least one pasal child (at any depth).
   // Used to skip empty structural nodes (e.g. TOC entries parsed as BAB nodes).
   const structuralIdsWithPasals = new Set(
     (pasalParentIds || []).map((r) => r.parent_id).filter(Boolean),
@@ -311,6 +311,25 @@ async function LawReaderSection({
   const allStructuralNodes = structuralNodes || [];
   const allPasals = pasalNodes || [];
 
+  // Pre-build a parent→children map for O(n) descendant traversal.
+  const structuralChildrenMap = new Map<number, number[]>();
+  for (const n of allStructuralNodes) {
+    if (n.parent_id !== null) {
+      const siblings = structuralChildrenMap.get(n.parent_id) ?? [];
+      siblings.push(n.id);
+      structuralChildrenMap.set(n.parent_id, siblings);
+    }
+  }
+
+  /** Returns true if nodeId or any of its structural descendants has a pasal. */
+  function hasDescendantPasal(nodeId: number): boolean {
+    if (structuralIdsWithPasals.has(nodeId)) return true;
+    for (const childId of structuralChildrenMap.get(nodeId) ?? []) {
+      if (hasDescendantPasal(childId)) return true;
+    }
+    return false;
+  }
+
   // Filter out structural nodes (BABs, Bagians) that have no pasal content in the DB.
   // This removes table-of-contents entries that the parser mistakenly captures as structural
   // nodes — common in ratification laws (e.g. UU 6/2023) where the attached law's TOC
@@ -320,15 +339,9 @@ async function LawReaderSection({
   const babNodes = allStructuralNodes.filter((node) => {
     // Keep sub-sections unconditionally — they're filtered indirectly via their parent BAB.
     if (node.parent_id !== null) return true;
-    // For top-level structural nodes, keep only those that have at least one pasal
-    // directly or through any of their direct children (Bagian/Paragraf).
-    const childIds = new Set(
-      allStructuralNodes.filter((n) => n.parent_id === node.id).map((n) => n.id),
-    );
-    return (
-      structuralIdsWithPasals.has(node.id) ||
-      [...childIds].some((id) => structuralIdsWithPasals.has(id))
-    );
+    // For top-level structural nodes, keep only those with at least one pasal at any depth
+    // (handles BAB → Bagian → Paragraf → Pasal nesting, not just direct children).
+    return hasDescendantPasal(node.id);
   });
 
   const mainContent = (