1 files changed, 37 insertions, 19 deletions

diff --git a/lib/naming/config.ml b/lib/naming/config.ml
index 0fafd1f..7d87d62 100644
--- a/lib/naming/config.ml
+++ b/lib/naming/config.ml
@@ -33,27 +33,45 @@ let of_string text =
           (fun (s : OI.section) -> if s.OI.name = "defaults" then None else Some s.OI.name)
           sections
       in
+      (* Merge EVERY section named [defaults], not just the first: [lang.ml]'s
+         [of_string] was fixed this morning to fold over all matching
+         sections rather than take [List.find_opt]'s first match, because a
+         hand-edited file WILL grow duplicate headers as a user appends to it
+         over time. Both modules parse the same reader
+         ([Overlay_ini.parse_sections]) over the same file format, so they
+         must not disagree about what a duplicate [section] header means --
+         taking only the first [defaults] block here silently discarded every
+         later one, with nothing pointing back at the parser. Folding a
+         single accumulator across every matching section, in file order,
+         keeps this consistent with the within-section behaviour below (last
+         [k]-match wins): a scalar key repeated across two blocks resolves to
+         the LATER value, and [overlay] keeps accumulating across every
+         block, not only its first. *)
+      let defaults_sections =
+        List.filter (fun (s : OI.section) -> s.OI.name = "defaults") sections
+      in
       let acc =
-        match List.find_opt (fun (s : OI.section) -> s.OI.name = "defaults") sections with
-        | None -> empty
-        | Some s ->
-            (* Cons then reverse once at the end, not `@ [v]` per line: the
-               latter is O(n^2) over the field count, a real hang on a
-               machine-generated file with many overlay lines. *)
-            let acc =
-              List.fold_left
-                (fun acc (k, v) ->
-                  match k with
-                  | "lang" -> { acc with lang = Some v }
-                  | "template" -> { acc with template = Some v }
-                  | "format" -> { acc with format = Some v }
-                  (* accumulates: a user has more than one overlay *)
-                  | "overlay" -> { acc with overlays = v :: acc.overlays }
-                  | other -> { acc with unknown_keys = other :: acc.unknown_keys })
-                empty s.OI.fields
-            in
-            { acc with overlays = List.rev acc.overlays; unknown_keys = List.rev acc.unknown_keys }
+        (* Cons then reverse once at the very end, not `@ [v]` per line: the
+           latter is O(n^2) over the field count, a real hang on a
+           machine-generated file with many overlay lines. Reversing only
+           after every section has been folded (not once per section) is
+           what keeps [overlay] and [unknown_keys] in file order across
+           block boundaries, not merely within one block. *)
+        List.fold_left
+          (fun acc (s : OI.section) ->
+            List.fold_left
+              (fun acc (k, v) ->
+                match k with
+                | "lang" -> { acc with lang = Some v }
+                | "template" -> { acc with template = Some v }
+                | "format" -> { acc with format = Some v }
+                (* accumulates: a user has more than one overlay *)
+                | "overlay" -> { acc with overlays = v :: acc.overlays }
+                | other -> { acc with unknown_keys = other :: acc.unknown_keys })
+              acc s.OI.fields)
+          empty defaults_sections
       in
+      let acc = { acc with overlays = List.rev acc.overlays; unknown_keys = List.rev acc.unknown_keys } in
       Ok { acc with unknown_sections }
 
 let resolve ~flag ~config ~default =