Add ~inode parameter to disable inode splitting for git compatibility

Tree.hash and Store.commit now accept ?inode:bool (default true).
When inode:false, large tree nodes are always written as flat nodes
instead of being split into inode tries. Existing inode nodes are
expanded back to flat format. This ensures 100% git-compatible output
without limiting tree size.

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

lib/store.ml

···
         | None -> None
         | Some commit -> Some (read_tree t (Commit.tree commit)))
 
-  let commit ?inline_threshold t ~tree ~parents ~message ~author =
+  let commit ?inline_threshold ?inode t ~tree ~parents ~message ~author =
     (* This is where delayed writes happen *)
-    let tree_hash = Tree.hash ?inline_threshold tree ~backend:t.backend in
+    let tree_hash = Tree.hash ?inline_threshold ?inode tree ~backend:t.backend in
     let c = Commit.v ~tree:tree_hash ~parents ~author ~message () in
     let data = Commit.to_bytes c in
     let h = Commit.hash c in

lib/store.mli

···
 
   val commit :
     ?inline_threshold:int ->
+    ?inode:bool ->
     t ->
     tree:Tree.t ->
     parents:hash list ->
     message:string ->
     author:string ->
     hash
-  (** [commit ?inline_threshold t ~tree ~parents ~message ~author] creates a
-      commit. This is when delayed tree writes actually happen. If
+  (** [commit ?inline_threshold ?inode t ~tree ~parents ~message ~author]
+      creates a commit. This is when delayed tree writes actually happen. If
       [inline_threshold] is given, contents smaller than that are stored
-      inline in tree nodes. *)
+      inline in tree nodes. If [inode] is [false], inodes are disabled and
+      large trees are written as flat nodes (required for git compatibility).
+      Defaults to [true]. *)
 
   (** {2 Branch Operations} *)
 

lib/tree.ml

···
         `Tree all
 
   (* Write tree to backend and return hash *)
-  let rec write_tree t ~inline_threshold ~(backend : hash Backend.t) : hash =
+  let rec write_tree t ~inline_threshold ~inode ~(backend : hash Backend.t) : hash =
     match t with
     | Contents s ->
         let h = F.hash_contents s in
···
                   (name, (`Contents h : F.entry))
               | Node _ ->
                   let child_hash =
-                    write_tree child ~inline_threshold ~backend
+                    write_tree child ~inline_threshold ~inode ~backend
                   in
                   (name, (`Node child_hash : F.entry)))
             node.children
         in
         (match node.state with
-        | Inode { hash; _ } ->
+        | Inode { hash; backend = ib } when inode ->
             (* Incremental update: only modify affected inode buckets *)
             Inode.update ~backend hash ~additions:child_entries
               ~removals:node.removed
+        | Inode { hash; backend = ib } ->
+            (* Inodes disabled: expand to flat node *)
+            let base_entries = Inode.list_all ~backend:ib hash in
+            let base =
+              List.fold_left
+                (fun n (name, entry) -> F.add n name entry)
+                F.empty_node base_entries
+            in
+            let base =
+              List.fold_left (fun n name -> F.remove n name) base node.removed
+            in
+            let final =
+              List.fold_left
+                (fun n (name, entry) -> F.add n name entry)
+                base child_entries
+            in
+            let data = F.bytes_of_node final in
+            let h = F.hash_node final in
+            backend.write h data;
+            h
         | _ ->
             (* Flat node: apply modifications, promote to inode if too large *)
             let base =
···
                 (fun n (name, entry) -> F.add n name entry)
                 base child_entries
             in
-            let entries = F.list final in
-            if List.length entries > Inode.max_entries then
-              Inode.write entries ~backend
-            else begin
+            if inode then begin
+              let entries = F.list final in
+              if List.length entries > Inode.max_entries then
+                Inode.write entries ~backend
+              else begin
+                let data = F.bytes_of_node final in
+                let h = F.hash_node final in
+                backend.write h data;
+                h
+              end
+            end else begin
               let data = F.bytes_of_node final in
               let h = F.hash_node final in
               backend.write h data;
               h
             end)
 
-  let hash ?(inline_threshold = F.inline_threshold) t ~backend =
-    write_tree t ~inline_threshold ~backend
+  let hash ?(inline_threshold = F.inline_threshold) ?(inode = true) t ~backend =
+    write_tree t ~inline_threshold ~inode ~backend
 
   type 'a force = [ `True | `False of hash -> 'a | `Shallow of hash -> 'a ]
 

lib/tree.mli

···
   (** [to_concrete t] fully materializes the tree. Forces all lazy nodes to be
       loaded. *)
 
-  val hash : ?inline_threshold:int -> t -> backend:hash Backend.t -> hash
-  (** [hash ?inline_threshold t ~backend] computes the tree hash. Writes all
+  val hash : ?inline_threshold:int -> ?inode:bool -> t -> backend:hash Backend.t -> hash
+  (** [hash ?inline_threshold ?inode t ~backend] computes the tree hash. Writes all
       accumulated changes to the backend. If [inline_threshold] is given,
       contents at or below that size (in bytes) are stored directly in the
       parent node rather than as separate blobs. Defaults to the codec's
-      [inline_threshold]. *)
+      [inline_threshold]. If [inode] is [false], large tree nodes are never
+      split into inode tries — they are always written as flat nodes. This is
+      required for git-compatible output. Defaults to [true]. *)
 
   (** {2 Force Control} *)