at least some cross-compiling releases

Cargo.toml

···
 # Crypto curves and JOSE
 p256 = "0.13"
 jose-jwk = "0.1"
-
-
-[workspace.package.metadata.binstall]
-pkg-url = "https://github.com/rsform/jacquard/releases/download/v{ version }/{ name }_{ target }_v{ version }{ archive-suffix }"
-bin-dir = "{ name }_{ target }_v{ version }/{ bin }{ binary-ext }"
-pkg-fmt = "txz"

binaries/SHA256SUMS

···
-4c047bb41a4001d92451bd3c5223657143a27f3dee4d73583a12f08fccaebd7b  jacquard-codegen_x86_64-unknown-linux-gnu.tar.xz
-af356cb142953a43bbc56b2b2c9fa4f38a41ed727634d70eeafc906da3a4ca8d  lex-fetch_x86_64-unknown-linux-gnu.tar.xz
+6e690739ec8d6349bd584ef743bdf34bbf61b531dbfc4922ba3db276fcb5f973  jacquard-codegen_aarch64-unknown-linux-gnu.tar.xz
+8edd99321d52e85da26e31a551ee0476d7bc6653dfce2aaa41191119f41cba80  jacquard-codegen_x86_64-unknown-linux-gnu.tar.xz
+831cd4cb95e6f944145907fc480625dc19044ee21a2cb794f4a387520a580c00  lex-fetch_aarch64-unknown-linux-gnu.tar.xz
+4b6495f0cb60396f348a2afb24fed7bf5081f6f41970de0aa080ceb27960ebb7  lex-fetch_x86_64-unknown-linux-gnu.tar.xz
+76d102081c02b9a33ea84433fea80665ff58e2297257ccb1a4ef235cfdf877ab  jacquard-codegen_x86_64-pc-windows-gnu.zip
+4405fd615292bfe8c28d9592fa451e0adeeada66573d020fde652b0d69877445  lex-fetch_x86_64-pc-windows-gnu.zip

crates/jacquard-lexicon/Cargo.toml

···
 
 [package.metadata.binstall]
 pkg-url = "https://github.com/rsform/jacquard/releases/download/v{ version }/{ name }_{ target }_v{ version }{ archive-suffix }"
-bin-dir = "{ name }_{ target }_v{ version }/{ bin }{ binary-ext }"
+bin-dir = "{ name }_{ target }_v{ version }/bin/{ bin }{ binary-ext }"
 pkg-fmt = "txz"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-gnu]
+pkg-fmt = "zip"
+bin-dir = "{ name }_{ target }_v{ version }/{ bin }{ binary-ext }"

flake.lock

···
   "nodes": {
     "crane": {
       "locked": {
+        "lastModified": 1759893430,
+        "narHash": "sha256-yAy4otLYm9iZ+NtQwTMEbqHwswSFUbhn7x826RR6djw=",
+        "owner": "ipetkov",
+        "repo": "crane",
+        "rev": "1979a2524cb8c801520bd94c38bb3d5692419d93",
+        "type": "github"
+      },
+      "original": {
+        "owner": "ipetkov",
+        "repo": "crane",
+        "type": "github"
+      }
+    },
+    "crane_2": {
+      "locked": {
         "lastModified": 1758758545,
         "narHash": "sha256-NU5WaEdfwF6i8faJ2Yh+jcK9vVFrofLcwlD/mP65JrI=",
         "owner": "ipetkov",
···
     },
     "root": {
       "inputs": {
+        "crane": "crane",
         "flake-parts": "flake-parts",
         "git-hooks": "git-hooks",
         "nixpkgs": "nixpkgs",
         "rust-flake": "rust-flake",
+        "rust-overlay": "rust-overlay_2",
         "systems": "systems"
       }
     },
     "rust-flake": {
       "inputs": {
-        "crane": "crane",
+        "crane": "crane_2",
         "nixpkgs": [
           "nixpkgs"
         ],
···
         "owner": "oxalica",
         "repo": "rust-overlay",
         "rev": "5bfedf3fbbf5caf8e39f7fcd62238f54d82aa1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "rust-overlay_2": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1760754684,
+        "narHash": "sha256-B4+gmoRuvjZGKvDQtMjYkqyA89gZLjrXObZrXFrcKOk=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "16c233757f1b200936f1b39961c901733936c616",
         "type": "github"
       },
       "original": {

flake.nix

···
     #process-compose-flake.url = "github:Platonic-Systems/process-compose-flake";
     #cargo-doc-live.url = "github:srid/cargo-doc-live";
 
+    # For cross-compilation
+    crane.url = "github:ipetkov/crane";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+    rust-overlay.inputs.nixpkgs.follows = "nixpkgs";
+
     git-hooks.url = "github:cachix/git-hooks.nix";
     git-hooks.flake = false;
   };

nix/modules/cross.nix

···
     # Get the filtered source from rust-project
     src = config.rust-project.src;
 
+    # Import nixpkgs with rust-overlay for getting rust toolchains (not cross)
+    pkgs-rust = import inputs.nixpkgs {
+      inherit system;
+      overlays = [(import inputs.rust-overlay)];
+    };
+
     # Helper to create a cross-compiled package
     mkCrossPackage = {
       crossSystem,
       rustTarget,
       extraArgs ? {}
     }: let
-      # Import nixpkgs with cross-compilation configured
+      # Import nixpkgs with cross-compilation configured (no overlays)
       pkgs-cross = import inputs.nixpkgs {
         inherit crossSystem;
         localSystem = system;
-        overlays = [(import inputs.rust-overlay)];
       };
 
-      # Set up crane with rust-overlay toolchain for the target
-      craneLib = (inputs.crane.mkLib pkgs-cross).overrideToolchain (p:
-        p.rust-bin.stable.latest.default.override {
-          targets = [rustTarget];
-        }
-      );
+      # Get rust toolchain from host system with the cross target added
+      rustToolchain = pkgs-rust.rust-bin.stable.latest.default.override {
+        targets = [rustTarget];
+      };
+
+      # Set up crane with the rust toolchain
+      craneLib = (inputs.crane.mkLib pkgs-cross).overrideToolchain rustToolchain;
 
       # Common crane args
       commonArgs = {
···
         rustTarget = "x86_64-pc-windows-gnu";
       };
 
-      jacquard-lexicon-aarch64-windows = mkCrossPackage {
-        crossSystem = {
-          config = "aarch64-w64-mingw32";
-          libc = "msvcrt";
-        };
-        rustTarget = "aarch64-pc-windows-gnullvm";
-      };
+      # TODO: aarch64-windows cross-compilation broken in nixpkgs
+      # Issue: mingw-w64-pthreads build fails with missing winver.h header
+      # The aarch64-w64-mingw32 toolchain setup in nixpkgs is incomplete
+      # Workaround: build on actual Windows with MSVC or wait for nixpkgs fix
+      # jacquard-lexicon-aarch64-windows = mkCrossPackage {
+      #   crossSystem = {
+      #     config = "aarch64-w64-mingw32";
+      #     useLLVM = true;
+      #   };
+      #   rustTarget = "aarch64-pc-windows-gnullvm";
+      # };
     };
   };
 }

nix/modules/devshell.nix

···
         cargo-semver-checks
         cargo-binstall
         cargo-dist
+        zip
       ];
     };
   };

scripts/package-binaries.sh

···
 CURRENT_SYSTEM=$(nix eval --impure --expr 'builtins.currentSystem' --raw)
 echo "Current system: $CURRENT_SYSTEM"
 
-# Map target triples to nix package names and friendly names
+# Map target triples to nix package names
 declare -A TARGET_TO_PACKAGE=(
     ["x86_64-unknown-linux-gnu"]="jacquard-lexicon-x86_64-linux"
     ["aarch64-unknown-linux-gnu"]="jacquard-lexicon-aarch64-linux"
···
 TARGETS=()
 case "$CURRENT_SYSTEM" in
     x86_64-linux)
-        # Linux can cross-compile to everything
+        # Linux can cross-compile to other Linux archs and Windows x86_64
+        # macOS requires remote builders or actual macOS hardware
+        # aarch64-windows: nixpkgs mingw-w64-pthreads broken for aarch64 (missing winver.h)
         TARGETS=(
             "x86_64-unknown-linux-gnu"
             "aarch64-unknown-linux-gnu"
-            "x86_64-apple-darwin"
-            "aarch64-apple-darwin"
             "x86_64-pc-windows-gnu"
-            "aarch64-pc-windows-gnullvm"
+            # "aarch64-pc-windows-gnullvm"  # TODO: nixpkgs cross-compile broken
         )
-        echo "Building from x86_64-linux: All targets (Linux, macOS, Windows for x86_64 and aarch64)"
+        echo "Building from x86_64-linux: Linux (x86_64, aarch64) + Windows (x86_64)"
+        echo "Note: macOS cross-compilation requires remote builders or macOS hardware"
+        echo "Note: aarch64-windows cross-compilation broken in nixpkgs (mingw-w64-pthreads build fails)"
         ;;
     aarch64-linux)
-        # Linux can cross-compile to everything
+        # Linux can cross-compile to other Linux archs and Windows x86_64
+        # macOS requires remote builders or actual macOS hardware
+        # aarch64-windows: nixpkgs mingw-w64-pthreads broken for aarch64 (missing winver.h)
         TARGETS=(
             "aarch64-unknown-linux-gnu"
             "x86_64-unknown-linux-gnu"
-            "x86_64-apple-darwin"
-            "aarch64-apple-darwin"
             "x86_64-pc-windows-gnu"
-            "aarch64-pc-windows-gnullvm"
+            # "aarch64-pc-windows-gnullvm"  # TODO: nixpkgs cross-compile broken
         )
-        echo "Building from aarch64-linux: All targets (Linux, macOS, Windows for x86_64 and aarch64)"
+        echo "Building from aarch64-linux: Linux (aarch64, x86_64) + Windows (x86_64)"
+        echo "Note: macOS cross-compilation requires remote builders or macOS hardware"
+        echo "Note: aarch64-windows cross-compilation broken in nixpkgs (mingw-w64-pthreads build fails)"
         ;;
     x86_64-darwin)
         # macOS cross-compilation is limited
···
             "x86_64-apple-darwin"
         )
         echo "Building from x86_64-darwin: x86_64-darwin only"
-        echo "Note: Cross to aarch64-darwin needs rosetta, cross to Linux/Windows needs more setup"
         ;;
     aarch64-darwin)
         # macOS aarch64 can build both macOS targets via rosetta
···
             "x86_64-apple-darwin"
         )
         echo "Building from aarch64-darwin: macOS targets (aarch64 + x86_64 via rosetta)"
-        echo "Note: Cross to Linux/Windows needs more setup"
         ;;
     *)
         echo "Error: Unknown system: $CURRENT_SYSTEM"
···
         return 1
     fi
 
+    # Package each binary separately
+    for BINARY in lex-fetch jacquard-codegen; do
+        echo "  Packaging binary: $BINARY"
+        package_binary "$TARGET" "$BINARY"
+    done
+
+    # Cleanup
+    rm -f "$PROJECT_ROOT/result-${TARGET}"
+    cd "$PROJECT_ROOT"
+}
+
+# Helper function to package a single binary
+package_binary() {
+    local TARGET=$1
+    local BINARY=$2
+
+    # Determine binary extension
+    local BINARY_EXT=""
+    if [[ "$TARGET" == *"windows"* ]]; then
+        BINARY_EXT=".exe"
+    fi
+
+    # Check if binary exists
+    if [[ ! -f "result-${TARGET}/bin/${BINARY}${BINARY_EXT}" ]]; then
+        echo "  Warning: ${BINARY}${BINARY_EXT} not found, skipping"
+        return 0
+    fi
+
     # Names for versioned and unversioned archives
-    local VERSIONED_NAME="jacquard-lexicon_${TARGET}_v${VERSION}"
-    local UNVERSIONED_NAME="jacquard-lexicon_${TARGET}"
+    local VERSIONED_NAME="${BINARY}_${TARGET}_v${VERSION}"
+    local UNVERSIONED_NAME="${BINARY}_${TARGET}"
 
     # Create staging directory
     local STAGE_DIR="/tmp/${VERSIONED_NAME}"
···
 
     # Detect if this is a Windows target
     if [[ "$TARGET" == *"windows"* ]]; then
-        # Windows: just binaries, README, LICENSE, example config
-        mkdir -p "$STAGE_DIR/bin"
-        cp "result-${TARGET}"/bin/*.exe "$STAGE_DIR/bin/" 2>/dev/null || true
+        # Windows: binary, README, LICENSE, example config (for lex-fetch only)
+        cp "result-${TARGET}/bin/${BINARY}.exe" "$STAGE_DIR/"
         cp LICENSE "$STAGE_DIR/"
         cp README.md "$STAGE_DIR/"
 
-        # Copy example config to a more Windows-friendly location
-        mkdir -p "$STAGE_DIR/examples"
-        cp crates/jacquard-lexicon/lexicons.kdl.example "$STAGE_DIR/examples/" 2>/dev/null || true
+        # Only include example config for lex-fetch
+        if [[ "$BINARY" == "lex-fetch" ]]; then
+            mkdir -p "$STAGE_DIR/examples"
+            cp crates/jacquard-lexicon/lexicons.kdl.example "$STAGE_DIR/examples/" 2>/dev/null || true
+        fi
     else
-        # Unix (Linux/macOS): full structure with man pages and completions
-        cp -r "result-${TARGET}"/* "$STAGE_DIR/"
+        # Unix (Linux/macOS): binary, man page, completions, README, LICENSE
+        mkdir -p "$STAGE_DIR/bin"
+        cp "result-${TARGET}/bin/${BINARY}" "$STAGE_DIR/bin/"
+
         cp LICENSE "$STAGE_DIR/"
         cp README.md "$STAGE_DIR/"
+
+        # Copy man page if it exists
+        if [[ -f "result-${TARGET}/share/man/man1/${BINARY}.1.gz" ]]; then
+            mkdir -p "$STAGE_DIR/share/man/man1"
+            cp "result-${TARGET}/share/man/man1/${BINARY}.1.gz" "$STAGE_DIR/share/man/man1/"
+        fi
+
+        # Copy completions if they exist
+        for shell_dir in bash fish zsh; do
+            local comp_dir="result-${TARGET}/share/$shell_dir/site-functions"
+            if [[ "$shell_dir" == "bash" ]]; then
+                comp_dir="result-${TARGET}/share/bash-completion/completions"
+            elif [[ "$shell_dir" == "fish" ]]; then
+                comp_dir="result-${TARGET}/share/fish/vendor_completions.d"
+            fi
+
+            if [[ -d "$comp_dir" ]]; then
+                for comp in "$comp_dir"/*; do
+                    local comp_name=$(basename "$comp")
+                    # Only copy completions for this specific binary
+                    if [[ "$comp_name" == "${BINARY}"* ]] || [[ "$comp_name" == "_${BINARY}" ]]; then
+                        mkdir -p "$STAGE_DIR/share/$(dirname "${comp#result-${TARGET}/share/}")"
+                        cp "$comp" "$STAGE_DIR/share/$(dirname "${comp#result-${TARGET}/share/}")/"
+                    fi
+                done
+            fi
+        done
+
+        # Only include example config for lex-fetch
+        if [[ "$BINARY" == "lex-fetch" ]]; then
+            mkdir -p "$STAGE_DIR/share/doc/jacquard-lexicon"
+            cp crates/jacquard-lexicon/lexicons.kdl.example "$STAGE_DIR/share/doc/jacquard-lexicon/" 2>/dev/null || true
+        fi
     fi
 
     # Create versioned archive (for releases)
···
 
     # Cleanup
     rm -rf "$UNVERSIONED_NAME"
-    rm -f "$PROJECT_ROOT/result-${TARGET}"
+
+    # Return to project root
     cd "$PROJECT_ROOT"
 }