Migrate from vendored crowbar to opam-pinned alcobar

- Remove vendored crowbar/ directory
- Replace all Crowbar references with Alcobar across 176 .ml files
- Update all fuzz dune files: crowbar → alcobar in libraries
- Remove 77 gen_corpus.ml files (alcobar handles corpus internally)
- Update dune-project files: crowbar → alcobar in dependencies
- Update merlint rules (e705, e726): Crowbar → Alcobar in checks,
docs, and examples
- Update merlint generated docs (index.html)

428 files changed, ~1200 lines removed net.

.ocamlformat

···
+profile = default

lib/cdm.ml

···
   | Truncated_row of { row : int; expected : int; got : int }
 
 let pp_error ppf = function
-  | Missing_header -> Format.fprintf ppf "missing CSV header row"
-  | Missing_column name -> Format.fprintf ppf "missing column: %s" name
+  | Missing_header -> Fmt.pf ppf "missing CSV header row"
+  | Missing_column name -> Fmt.pf ppf "missing column: %s" name
   | Bad_field { row; column; value } ->
-      Format.fprintf ppf "row %d: bad value %S for column %s" row value column
+      Fmt.pf ppf "row %d: bad value %S for column %s" row value column
   | Truncated_row { row; expected; got } ->
-      Format.fprintf ppf "row %d: expected %d columns, got %d" row expected got
+      Fmt.pf ppf "row %d: expected %d columns, got %d" row expected got
 
 (* {1 Column codecs} *)
 
···
 let nf = Csvt.nullable_float
 let ni = Csvt.nullable_int
 
+(** Build the column declarations for one object's state data. *)
+let obj_state_cols prefix obj row =
+  let open Csvt.Row in
+  row
+  |> col (prefix ^ "x") nf ~enc:(fun f -> (obj f).f_x1)
+  |> col (prefix ^ "y") nf ~enc:(fun f -> (obj f).f_y1)
+  |> col (prefix ^ "z") nf ~enc:(fun f -> (obj f).f_z1)
+  |> col (prefix ^ "vx") nf ~enc:(fun f -> (obj f).f_vx1)
+  |> col (prefix ^ "vy") nf ~enc:(fun f -> (obj f).f_vy1)
+  |> col (prefix ^ "vz") nf ~enc:(fun f -> (obj f).f_vz1)
+
+(* Note: flat_codec is a pure data structure mapping 45 CSV columns.
+   It's inherently long but each line is mechanical column declaration. *)
 let flat_codec =
   Csvt.(
     Row.(
···
              f_vz2 f_lx2 f_ly2 f_lz2 f_c2_11 f_c2_12 f_c2_13 f_c2_22
              f_c2_23 f_c2_33 f_file1 f_file2 ->
           {
-            f_run_id;
-            f_conj_id;
-            f_obj1;
-            f_met1;
-            f_obj2;
-            f_met2;
-            f_min_range;
-            f_vrel;
-            f_prob;
-            f_dilution;
-            f_mdistance;
-            f_epoch;
-            f_jdate;
-            f_x1;
-            f_y1;
-            f_z1;
-            f_vx1;
-            f_vy1;
-            f_vz1;
-            f_lx1;
-            f_ly1;
-            f_lz1;
-            f_c1_11;
-            f_c1_12;
-            f_c1_13;
-            f_c1_22;
-            f_c1_23;
-            f_c1_33;
-            f_x2;
-            f_y2;
-            f_z2;
-            f_vx2;
-            f_vy2;
-            f_vz2;
-            f_lx2;
-            f_ly2;
-            f_lz2;
-            f_c2_11;
-            f_c2_12;
-            f_c2_13;
-            f_c2_22;
-            f_c2_23;
-            f_c2_33;
-            f_file1;
-            f_file2;
+            f_run_id; f_conj_id; f_obj1; f_met1; f_obj2; f_met2;
+            f_min_range; f_vrel; f_prob; f_dilution; f_mdistance;
+            f_epoch; f_jdate;
+            f_x1; f_y1; f_z1; f_vx1; f_vy1; f_vz1;
+            f_lx1; f_ly1; f_lz1;
+            f_c1_11; f_c1_12; f_c1_13; f_c1_22; f_c1_23; f_c1_33;
+            f_x2; f_y2; f_z2; f_vx2; f_vy2; f_vz2;
+            f_lx2; f_ly2; f_lz2;
+            f_c2_11; f_c2_12; f_c2_13; f_c2_22; f_c2_23; f_c2_33;
+            f_file1; f_file2;
           })
       |> col "run_id" int ~enc:(fun f -> f.f_run_id)
       |> col "conj_id" int ~enc:(fun f -> f.f_conj_id)
···
 
 (* {1 Flat to structured conversion} *)
 
+let obj_of_flat ~id ~met ~x ~y ~z ~vx ~vy ~vz ~lx ~ly ~lz
+    ~c11 ~c12 ~c13 ~c22 ~c23 ~c33 ~filename =
+  {
+    id; met_criteria = met;
+    state = { pos = { x; y; z }; vel = { x = vx; y = vy; z = vz } };
+    local = { x = lx; y = ly; z = lz };
+    cov = { cr_r = c11; ct_r = c12; ct_t = c22;
+            cn_r = c13; cn_t = c23; cn_n = c33 };
+    filename;
+  }
+
 let of_flat f =
   {
     run_id = f.f_run_id;
     conj_id = f.f_conj_id;
     obj1 =
-      {
-        id = f.f_obj1;
-        met_criteria = f.f_met1;
-        state =
-          {
-            pos = { x = f.f_x1; y = f.f_y1; z = f.f_z1 };
-            vel = { x = f.f_vx1; y = f.f_vy1; z = f.f_vz1 };
-          };
-        local = { x = f.f_lx1; y = f.f_ly1; z = f.f_lz1 };
-        cov =
-          {
-            cr_r = f.f_c1_11;
-            ct_r = f.f_c1_12;
-            ct_t = f.f_c1_22;
-            cn_r = f.f_c1_13;
-            cn_t = f.f_c1_23;
-            cn_n = f.f_c1_33;
-          };
-        filename = f.f_file1;
-      };
+      obj_of_flat ~id:f.f_obj1 ~met:f.f_met1
+        ~x:f.f_x1 ~y:f.f_y1 ~z:f.f_z1
+        ~vx:f.f_vx1 ~vy:f.f_vy1 ~vz:f.f_vz1
+        ~lx:f.f_lx1 ~ly:f.f_ly1 ~lz:f.f_lz1
+        ~c11:f.f_c1_11 ~c12:f.f_c1_12 ~c13:f.f_c1_13
+        ~c22:f.f_c1_22 ~c23:f.f_c1_23 ~c33:f.f_c1_33
+        ~filename:f.f_file1;
     obj2 =
-      {
-        id = f.f_obj2;
-        met_criteria = f.f_met2;
-        state =
-          {
-            pos = { x = f.f_x2; y = f.f_y2; z = f.f_z2 };
-            vel = { x = f.f_vx2; y = f.f_vy2; z = f.f_vz2 };
-          };
-        local = { x = f.f_lx2; y = f.f_ly2; z = f.f_lz2 };
-        cov =
-          {
-            cr_r = f.f_c2_11;
-            ct_r = f.f_c2_12;
-            ct_t = f.f_c2_22;
-            cn_r = f.f_c2_13;
-            cn_t = f.f_c2_23;
-            cn_n = f.f_c2_33;
-          };
-        filename = f.f_file2;
-      };
+      obj_of_flat ~id:f.f_obj2 ~met:f.f_met2
+        ~x:f.f_x2 ~y:f.f_y2 ~z:f.f_z2
+        ~vx:f.f_vx2 ~vy:f.f_vy2 ~vz:f.f_vz2
+        ~lx:f.f_lx2 ~ly:f.f_ly2 ~lz:f.f_lz2
+        ~c11:f.f_c2_11 ~c12:f.f_c2_12 ~c13:f.f_c2_13
+        ~c22:f.f_c2_22 ~c23:f.f_c2_23 ~c33:f.f_c2_33
+        ~filename:f.f_file2;
     min_range = f.f_min_range;
     rel_velocity = f.f_vrel;
     probability = f.f_prob;
···
   wrap_result (Csvt.decode_string flat_codec s) |> Result.map (List.map of_flat)
 
 let fold_csv_channel ic f acc =
-  wrap_result (Csvt.fold_channel flat_codec ic (fun acc flat -> f acc (of_flat flat)) acc)
+  wrap_result
+    (Csvt.fold_channel flat_codec ic (fun acc flat -> f acc (of_flat flat)) acc)
 
 let of_csv_channel ic =
   wrap_result (Csvt.decode_channel flat_codec ic) |> Result.map (List.map of_flat)
···
 let tca cdm = cdm.epoch
 let pc cdm = cdm.probability
 
+let tca_ptime cdm =
+  let s = cdm.epoch ^ "Z" in
+  match Ptime.of_rfc3339 ~strict:false s with
+  | Ok (t, _, _) -> Some t
+  | Error _ -> None
+
+let jdate_to_unix jd = (jd -. 2440587.5) *. 86400.
+let tca_unix cdm = jdate_to_unix cdm.jdate
+
 (* {1 Pretty-printing} *)
 
-let pp_vec3 ppf v =
-  Format.fprintf ppf "(%.6f, %.6f, %.6f)" v.x v.y v.z
+let pp_vec3 ppf v = Fmt.pf ppf "(%.6f, %.6f, %.6f)" v.x v.y v.z
 
 let pp_state_vector ppf sv =
-  Format.fprintf ppf "@[<v>pos: %a@,vel: %a@]" pp_vec3 sv.pos pp_vec3 sv.vel
+  Fmt.pf ppf "@[<v>pos: %a@,vel: %a@]" pp_vec3 sv.pos pp_vec3 sv.vel
 
 let pp_covariance ppf c =
-  Format.fprintf ppf
+  Fmt.pf ppf
     "@[<v>| %+.6e  %+.6e  %+.6e |@,\
      |              %+.6e  %+.6e |@,\
      |                           %+.6e |@]"
     c.cr_r c.ct_r c.cn_r c.ct_t c.cn_t c.cn_n
 
 let pp_object_data ppf o =
-  Format.fprintf ppf
+  Fmt.pf ppf
     "@[<v>id: %d (met_criteria: %b)@,\
      state: %a@,\
      local: %a@,\
···
     o.cov o.filename
 
 let pp ppf cdm =
-  Format.fprintf ppf
+  Fmt.pf ppf
     "@[<v>--- Conjunction %d (run %d) ---@,\
      TCA:       %s (JD %.8f)@,\
      Pc:        %.10e@,\

lib/cdm.mli

···
 (** {1 Accessors} *)
 
 val tca : t -> string
-(** [tca cdm] returns the time of closest approach. *)
+(** [tca cdm] returns the time of closest approach as ISO 8601 string. *)
+
+val tca_ptime : t -> Ptime.t option
+(** [tca_ptime cdm] returns the TCA as a {!Ptime.t}, or [None] if
+    the epoch string cannot be parsed. *)
+
+val tca_unix : t -> float
+(** [tca_unix cdm] returns the TCA as a Unix timestamp (from Julian date). *)
+
+val jdate_to_unix : float -> float
+(** [jdate_to_unix jd] converts Julian date to Unix timestamp. *)
 
 val pc : t -> float
 (** [pc cdm] returns the probability of collision. *)

lib/dune

···
 (library
  (name cdm)
  (public_name cdm)
- (libraries csvt fmt))
+ (libraries csvt ptime fmt))