diff --git a/common/DetectorOrientation.cpp b/common/DetectorOrientation.cpp
index 4e7095c4c..e11ec56e7 100644
--- a/common/DetectorOrientation.cpp
+++ b/common/DetectorOrientation.cpp
@@ -46,6 +46,18 @@ RotMatrix DetectorOrientation::Matrix() const {
     return {rz_x, mirror_y ? -rz_y : rz_y, {0, 0, 1}};
 }
 
+std::optional<DetectorOrientation> DetectorOrientation::Match(const Coord &fast, const Coord &slow) {
+    for (int64_t quarter_turns = 0; quarter_turns < 4; quarter_turns++) {
+        for (const bool mirror_y: {false, true}) {
+            const DetectorOrientation orientation(mirror_y, quarter_turns);
+            const RotMatrix m = orientation.Matrix();
+            if (((m.Column(0) - fast).Length() < 1e-3f) && ((m.Column(1) - slow).Length() < 1e-3f))
+                return orientation;
+        }
+    }
+    return {};
+}
+
 bool DetectorOrientation::operator==(const DetectorOrientation &other) const {
     return (mirror_y == other.mirror_y) && (quarter_turns == other.quarter_turns);
 }
diff --git a/common/DetectorOrientation.h b/common/DetectorOrientation.h
index e9a48a2ce..d6a25d43a 100644
--- a/common/DetectorOrientation.h
+++ b/common/DetectorOrientation.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <optional>
+
 #include "Coord.h"
 
 // How the stored image is laid out in the detector plane: mirrored in Y, and/or turned by a multiple
@@ -38,5 +40,11 @@ public:
     // Rz(quarter_turns * 90 deg) * diag(1,-1,1)^mirror_y. Entries are exactly 0 and +-1.
     [[nodiscard]] RotMatrix Matrix() const;
 
+    // The orientation whose fast and slow axes are the two directions given, or nothing when they are
+    // not one of the eight. Nothing means the image is turned in its own plane by something that is
+    // not a multiple of 90 degrees, which is a continuous rotation of the detector and belongs in the
+    // PONI angles - it cannot be told apart from the tilt by looking at the two directions alone.
+    [[nodiscard]] static std::optional<DetectorOrientation> Match(const Coord &fast, const Coord &slow);
+
     bool operator==(const DetectorOrientation &other) const;
 };
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 862358d7a..4e4d39a7e 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -1,6 +1,8 @@
 # Changelog
 ## 1.0.0
 ### 1.0.0-rc.166
+* A miniCBF sweep takes the mounting from the imgCIF axis table its header carries: which laboratory direction the image's columns and rows run along, and which the spindle turns about. Where there is no table, a `+SLOW` on the `Oscillation_axis` line still says the spindle runs along the image's slow direction. All three were previously assumed, and two instruments are not what was assumed.
+* Naming a miniCBF frame with no directory - a frame in the working directory - finds its sweep instead of reporting that no images were found.
 * A detector swung out on a 2theta arm is placed where it stands, from the depends_on transformation chain of an NXmx master or the `Detector_2theta` line of a miniCBF header; both were previously read and then ignored.
 * `jfjoch_viewer` opens PILATUS miniCBF sweeps - naming any frame opens the whole sweep - and can run a processing job on one.
 * A detector whose stored image is mirrored in Y or mounted at a multiple of 90 degrees can be described as such, in the detector configuration or with `--detector-mirror-y` / `--detector-quarter-turns`, rather than having to be expressed as a detector rotation.
diff --git a/docs/DETECTOR_GEOMETRY.md b/docs/DETECTOR_GEOMETRY.md
index 3cc216692..2b62eeafe 100644
--- a/docs/DETECTOR_GEOMETRY.md
+++ b/docs/DETECTOR_GEOMETRY.md
@@ -59,6 +59,30 @@ rot2 = asin(-slow.z)         rot1 = atan2(-fast.z, normal.z)         rot3 = atan
 with `rot2` in [-90°, 90°]. The angles are what is stored and what is written out, so a geometry
 given as angles comes back exactly as it was given.
 
+## What a miniCBF header states about the mounting
+
+A PILATUS miniCBF gives the geometry twice. The `# ` lines every writer produces carry the distance, the
+beam centre and the angles; some beamlines then append a CBF template block holding a full **imgCIF axis
+table**, which states the laboratory direction of the image's fast and slow pixel directions, of the base
+goniometer axis, and of a 2theta arm where there is one. Where that table is present it is read, in
+preference to any assumption - it is the same information NXmx puts in `fast_pixel_direction` /
+`slow_pixel_direction` and the goniometer `vector`, in the form this format states it.
+
+imgCIF's laboratory frame has Z from the sample towards the source and Y opposite gravity, so it differs
+from the internal frame by a half turn about x - a rotation, not a mirror, so an axis carried through it
+turns the same way by the same angle.
+
+Two things a header can state that an assumption gets wrong by 90 degrees, which no refinement recovers
+and which the run's axis-sign rescue cannot reach either, a quarter turn not being a sign:
+
+* the image mounted a quarter turn round, so its columns run vertically;
+* a spindle that turns about the **vertical** rather than the horizontal.
+
+Where a header carries no axis table, a `+SLOW` on its `# Oscillation_axis` line still says the spindle
+runs along the image's slow direction rather than its fast one. The axis *name* on that line is not
+usable - one header says `X.CW +SLOW` where its own table says the axis is Y - but the direction token is,
+and on the header that states both they agree.
+
 ## A detector swung out on a 2theta arm
 
 Chemical crystallography reaches high angle by swinging the detector out on a 2theta arm rather than by
diff --git a/reader/HDF5MetadataSource.cpp b/reader/HDF5MetadataSource.cpp
index ac68aaa60..20bef0df3 100644
--- a/reader/HDF5MetadataSource.cpp
+++ b/reader/HDF5MetadataSource.cpp
@@ -42,18 +42,7 @@ static std::optional<DetectorOrientation> ReadModuleOrientation(HDF5Object *file
     if ((f.size() != 3) || (s.size() != 3))
         return {};
 
-    const Coord fast = McStasToInternal(f);
-    const Coord slow = McStasToInternal(s);
-
-    for (int64_t quarter_turns = 0; quarter_turns < 4; quarter_turns++) {
-        for (bool mirror_y: {false, true}) {
-            const DetectorOrientation orientation(mirror_y, quarter_turns);
-            const RotMatrix m = orientation.Matrix();
-            if (((m.Column(0) - fast).Length() < 1e-3f) && ((m.Column(1) - slow).Length() < 1e-3f))
-                return orientation;
-        }
-    }
-    return {};
+    return DetectorOrientation::Match(McStasToInternal(f), McStasToInternal(s));
 }
 
 // Where the detector stands, from the chain of transformations the file says it depends on.
diff --git a/reader/JFJochCBFReader.cpp b/reader/JFJochCBFReader.cpp
index a08639663..c60033e11 100644
--- a/reader/JFJochCBFReader.cpp
+++ b/reader/JFJochCBFReader.cpp
@@ -7,6 +7,7 @@
 #include <cctype>
 #include <cstring>
 #include <filesystem>
+#include <array>
 #include <map>
 #include <optional>
 
@@ -57,7 +58,12 @@ std::optional<Template> TemplateOf(const std::string &filename) {
 std::vector<std::string> CollectSweep(const std::string &path) {
     std::filesystem::path p(path);
     const bool is_dir = std::filesystem::is_directory(p);
-    const std::filesystem::path dir = is_dir ? p : p.parent_path();
+    // A frame named with no directory at all is in this one - parent_path() of a bare filename is
+    // empty, and iterating an empty path finds nothing, so naming a frame from inside its own
+    // directory found no sweep.
+    std::filesystem::path dir = is_dir ? p : p.parent_path();
+    if (dir.empty())
+        dir = ".";
 
     // Naming a frame selects ITS sweep. Naming a directory selects the sweep with the most frames in
     // it, which is the one a user pointing at a data directory means.
@@ -90,19 +96,54 @@ std::vector<std::string> CollectSweep(const std::string &path) {
     return out;
 }
 
-// The base rotation axis of the instrument, in the internal frame (x along increasing detector
-// column, y along increasing row, z along the beam). Both the spindle and the detector arm turn
-// about it: the spindle in RotationAxis below, and the 2theta arm in ReadFiles.
-const Coord BASE_AXIS(-1.0f, 0.0f, 0.0f);
+// An imgCIF laboratory direction in the internal frame. imgCIF puts Z from the sample towards the
+// source and Y opposite gravity, while the internal frame has z along the beam and y along increasing
+// row, so the two differ by a half turn about x - a rotation and not a mirror, so an axis carried
+// through it turns the same way by the same angle. (writer/HDF5NXmx.cpp states the same relation from
+// the other side, where it separates this from the McStas one, which is a half turn about z.)
+Coord ImgCIFToInternal(const std::array<double, 3> &v) {
+    return {static_cast<float>(v[0]), static_cast<float>(-v[1]), static_cast<float>(-v[2])};
+}
+
+// The base rotation axis where a header states nothing about it, in the internal frame (x along
+// increasing detector column, y along increasing row, z along the beam). It is a convention: such a
+// header names its rotation axis but gives no direction, so this is the sign an NXmx master writes
+// for the same instruments, and a file that needs the other one is settled from the data by the run's
+// axis-sign rescue.
+const Coord ASSUMED_BASE_AXIS(-1.0f, 0.0f, 0.0f);
+
+// The base rotation axis of the instrument, in the internal frame.
+//
+// Two headers in every corpus examined here state it and were being overruled by the assumption. One
+// beamline's PILATUS turns about the VERTICAL: its axis table says so outright, and its "# Oscillation
+// _axis" line says so a second way, by naming the image direction the spindle runs along rather than a
+// vector. Assuming the horizontal axis put the spindle 90 degrees out - which no amount of refinement
+// recovers, and which a sign rescue cannot reach either, since it is not a sign - and the run indexed
+// nothing. The sign is still the rescue's business; the DIRECTION is the file's.
+Coord BaseAxis(const minicbf::Header &h) {
+    if (h.spindle_axis.has_value())
+        return ImgCIFToInternal(*h.spindle_axis);
+    if (h.spindle_along_slow)
+        return {0.0f, -1.0f, 0.0f};     // minus the slow direction, as the default is minus the fast
+    return ASSUMED_BASE_AXIS;
+}
+
+// How the stored image sits in the detector plane, where the header's axis table states it - the same
+// thing the NXmx module directions say, in the form this format says it. Nothing comes back when the
+// header carries no table, or when what it states is not one of the eight discrete orientations.
+std::optional<DetectorOrientation> ImageOrientation(const minicbf::Header &h) {
+    if (!h.fast_direction.has_value() || !h.slow_direction.has_value())
+        return {};
+    return DetectorOrientation::Match(ImgCIFToInternal(*h.fast_direction),
+                                      ImgCIFToInternal(*h.slow_direction));
+}
 
 // The axis a miniCBF sweep turns about, in the internal frame (x along increasing detector column,
 // y along increasing row, z along the beam).
 //
-// The base axis is a convention: a miniCBF names its rotation axis but never states a direction, so
-// this is the sign an NXmx master writes for the same instruments, and a file that needs the other
-// one is settled from the data by the run's axis-sign rescue. The sense of the omega rotation below
-// follows that same convention, so a sweep parked at a non-zero omega inherits whichever sign the
-// base axis turns out to have.
+// The base axis comes from the header where it states one (BaseAxis above) and is otherwise assumed.
+// The sense of the omega rotation below follows the base axis, so a sweep parked at a non-zero omega
+// inherits whichever direction it turns out to have.
 //
 // The head is base -> chi -> phi, so only the axes OUTSIDE the scanned one can tilt it. An omega
 // scan turns about the base axis however the cradle is set - which is why a header carrying a large
@@ -111,7 +152,7 @@ const Coord BASE_AXIS(-1.0f, 0.0f, 0.0f);
 // source; internal z points the other way, hence the minus. A kappa arm cannot be expressed at all:
 // its inclination is a property of the hardware that no miniCBF header states.
 Coord RotationAxis(const minicbf::Header &h) {
-    const Coord base = BASE_AXIS;
+    const Coord base = BaseAxis(h);
     if (!minicbf::ScansPhi(h))
         return base;
 
@@ -158,6 +199,8 @@ void JFJochCBFReader::ReadFiles(const std::string &path) {
     // Images are handed out as signed 32-bit whatever the file stored, so that is the depth the rest
     // of the code must see; the real overflow is the header's Count_cutoff, set above.
     detector.BitDepthImage(32);
+    if (const auto orientation = ImageOrientation(header0_))
+        detector.ImageOrientation(orientation.value());
     detector.MinFrameTime(std::chrono::microseconds(0));
     detector.MinCountTime(std::chrono::microseconds(0));
     detector.ReadOutTime(std::chrono::nanoseconds(0));
@@ -172,12 +215,14 @@ void JFJochCBFReader::ReadFiles(const std::string &path) {
     // Detector_distance stays the distance along the detector normal and Beam_xy stays the point of
     // normal incidence, neither of which the swing moves - which is exactly what the PONI convention
     // wants, so the swing is a PONI rotation and nothing else in the header changes. It turns about
-    // the base spindle axis, the four-circle geometry these headers describe having the arm and the
-    // spindle on one axis; the imgCIF axis table such a header carries states the two with the same
-    // vector.
+    // the axis the header's table gives the arm, and otherwise about the base spindle axis: on the
+    // four-circle geometry these headers describe the arm and the spindle are one axis, and the one
+    // header here that states both states them with the same vector.
     if (header0_.two_theta_deg != 0.0) {
+        const Coord axis = header0_.detector_axis.has_value()
+                               ? ImgCIFToInternal(*header0_.detector_axis) : BaseAxis(header0_);
         float rot1 = 0, rot2 = 0, rot3 = 0;
-        PoniAnglesFromMatrix(RotMatrix(static_cast<float>(header0_.two_theta_deg * PI / 180.0), BASE_AXIS),
+        PoniAnglesFromMatrix(RotMatrix(static_cast<float>(header0_.two_theta_deg * PI / 180.0), axis),
                              rot1, rot2, rot3);
         dataset_->experiment.PoniRot1_rad(rot1).PoniRot2_rad(rot2).PoniRot3_rad(rot3);
     }
diff --git a/reader/MiniCBF.cpp b/reader/MiniCBF.cpp
index ae26dc65f..99ad1fe95 100644
--- a/reader/MiniCBF.cpp
+++ b/reader/MiniCBF.cpp
@@ -8,7 +8,9 @@
 #include <cstring>
 #include <fstream>
 #include <limits>
+#include <map>
 #include <regex>
+#include <stdexcept>
 
 #include "../common/JFJochException.h"
 
@@ -48,6 +50,133 @@ std::optional<double> Angle(const std::string &text, const char *pattern) {
     return v;
 }
 
+// One "loop_" of the imgCIF template block these headers carry, as rows keyed by tag. Tags and values
+// are both read as whitespace-separated tokens rather than by line, because a template packs several
+// tags onto one line ("_axis.vector[1] _axis.vector[2] _axis.vector[3]") and the rows that follow are
+// laid out to match the tags, not the lines.
+std::vector<std::map<std::string, std::string>> ParseLoop(const std::string &text, const std::string &tag) {
+    // The loop_ that introduces the tag, not the tag's own position: everything before it is another
+    // loop's data.
+    const size_t tag_at = text.find("\n" + tag);
+    if (tag_at == std::string::npos)
+        return {};
+    const size_t loop_at = text.rfind("loop_", tag_at);
+    if (loop_at == std::string::npos)
+        return {};
+
+    // Bare tokens, and the quoted ones a CIF value may be - a quoted value holding spaces would
+    // otherwise be counted as several columns and shift every row after it.
+    std::vector<std::string> tokens;
+    for (size_t i = loop_at + 5; i < text.size();) {
+        while ((i < text.size()) && std::isspace(static_cast<unsigned char>(text[i])))
+            i++;
+        if (i >= text.size())
+            break;
+        size_t end;
+        if ((text[i] == '\'') || (text[i] == '"')) {
+            end = text.find(text[i], i + 1);
+            if (end == std::string::npos)
+                break;
+            tokens.push_back(text.substr(i + 1, end - i - 1));
+            end++;
+        } else {
+            end = i;
+            while ((end < text.size()) && !std::isspace(static_cast<unsigned char>(text[end])))
+                end++;
+            tokens.push_back(text.substr(i, end - i));
+        }
+        // A second loop_, or a tag belonging to another category, ends this one.
+        if ((tokens.back() == "loop_")
+                || (tokens.back().starts_with("_") && !tokens.back().starts_with(tag.substr(0, tag.find('.') + 1)))) {
+            tokens.pop_back();
+            break;
+        }
+        i = end;
+    }
+
+    std::vector<std::string> names;
+    size_t first_value = 0;
+    while ((first_value < tokens.size()) && tokens[first_value].starts_with("_"))
+        names.push_back(tokens[first_value++]);
+    if (names.empty())
+        return {};
+
+    std::vector<std::map<std::string, std::string>> rows;
+    for (size_t i = first_value; i + names.size() <= tokens.size(); i += names.size()) {
+        std::map<std::string, std::string> row;
+        for (size_t j = 0; j < names.size(); j++)
+            row[names[j]] = tokens[i + j];
+        rows.push_back(std::move(row));
+    }
+    return rows;
+}
+
+std::string Field(const std::map<std::string, std::string> &row, const std::string &name) {
+    const auto it = row.find(name);
+    return (it == row.end()) ? std::string() : it->second;
+}
+
+// The imgCIF axis table: which axis turns or translates in which laboratory direction, and which two
+// axes the image's columns and rows run along. Absent from most headers, which say nothing about any
+// of this and are left exactly as they were read before.
+//
+// The element vectors are stated in the frame of the axis they depend on. Between them and the
+// detector's own rotation every header seen has translations only, so they describe the image in the
+// unswung detector frame - which is where the image orientation belongs, with the arm applied on top.
+void ParseAxisTable(const std::string &text, Header &h) {
+    const auto axes = ParseLoop(text, "_axis.id");
+    if (axes.empty())
+        return;
+
+    std::map<std::string, std::array<double, 3>> vector_of;
+    for (const auto &row: axes) {
+        const std::string id = Field(row, "_axis.id");
+        const std::string type = Field(row, "_axis.type");
+        const std::string equipment = Field(row, "_axis.equipment");
+        const std::string depends_on = Field(row, "_axis.depends_on");
+        std::array<double, 3> v{};
+        try {
+            for (int i = 0; i < 3; i++)
+                v[i] = std::stod(Field(row, "_axis.vector[" + std::to_string(i + 1) + "]"));
+        } catch (const std::exception &) {
+            continue;   // "." for a vector: the table states no direction for this axis
+        }
+        vector_of[id] = v;
+
+        // The base spindle and the detector arm are the rotations that hang off nothing: everything
+        // further in is carried by them. Naming neither, so a beamline is free to call them anything.
+        if ((type == "rotation") && (depends_on == ".")) {
+            if (equipment == "goniometer")
+                h.spindle_axis = v;
+            else if (equipment == "detector")
+                h.detector_axis = v;
+        }
+    }
+
+    // Which axis the fast index runs along, and which the slow, through the two tables that say so.
+    std::map<std::string, std::string> axis_of_set;
+    for (const auto &row: ParseLoop(text, "_array_structure_list_axis.axis_set_id"))
+        axis_of_set[Field(row, "_array_structure_list_axis.axis_set_id")]
+                = Field(row, "_array_structure_list_axis.axis_id");
+
+    for (const auto &row: ParseLoop(text, "_array_structure_list.array_id")) {
+        const std::string set = Field(row, "_array_structure_list.axis_set_id");
+        const auto id = axis_of_set.contains(set) ? axis_of_set[set] : set;
+        const auto it = vector_of.find(id);
+        if (it == vector_of.end())
+            continue;
+        std::array<double, 3> v = it->second;
+        if (Field(row, "_array_structure_list.direction") == "decreasing")
+            for (double &c: v)
+                c = -c;
+        const std::string index = Field(row, "_array_structure_list.index");
+        if (index == "1")
+            h.fast_direction = v;
+        else if (index == "2")
+            h.slow_direction = v;
+    }
+}
+
 int16_t ReadI16(const uint8_t *p) { int16_t v; std::memcpy(&v, p, 2); return v; }
 int32_t ReadI32(const uint8_t *p) { int32_t v; std::memcpy(&v, p, 4); return v; }
 int64_t ReadI64(const uint8_t *p) { int64_t v; std::memcpy(&v, p, 8); return v; }
@@ -99,6 +228,11 @@ Header ParseHeader(const char *data, size_t size) {
     h.period_s       = Num(t, R"(#\s*Exposure_period\s+([\d.eE+-]+))");
     h.count_cutoff   = Int(t, R"(#\s*Count_cutoff\s+(\d+))");
     h.axis_name      = Match(t, R"(#\s*Oscillation_axis\s+(\S+))").value_or("omega");
+    // "+SLOW" / "+FAST" on that same line: which of the image's two directions the spindle runs
+    // along. Some writers state that instead of an axis name, and it is the only thing a header with
+    // no axis table says about the spindle's direction at all.
+    h.spindle_along_slow = Match(t, R"(#\s*Oscillation_axis[^\r\n]*\+(SLOW|slow))").has_value();
+    ParseAxisTable(t, h);
 
     // "# Silicon sensor, ..." / "# CdTe sensor, ...". The rest of the code compares the material
     // against "CdTe" (BraggIntegrationEngine), so an unnormalised "Silicon" would silently give a
diff --git a/reader/MiniCBF.h b/reader/MiniCBF.h
index 9a6d99277..78a178955 100644
--- a/reader/MiniCBF.h
+++ b/reader/MiniCBF.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -44,6 +45,21 @@ struct Header {
     int64_t count_cutoff = 0;      // saturation
     std::string axis_name = "omega";
     bool byte_offset = false;      // the only conversion supported
+
+    // The imgCIF axis table the CBF template block carries after the "# " lines, as the file states
+    // it: vectors in the imgCIF laboratory frame (Z from the sample towards the source, Y opposite
+    // gravity, X completing a right-handed set). Turning them into any other frame is the caller's
+    // business, not this format reader's. Most headers carry no such table and leave all of these
+    // empty, which is not the same as their stating the usual mounting.
+    std::optional<std::array<double, 3>> fast_direction;   // laboratory direction of a +1 column step
+    std::optional<std::array<double, 3>> slow_direction;   // ... of a +1 row step
+    std::optional<std::array<double, 3>> spindle_axis;     // the base goniometer rotation axis
+    std::optional<std::array<double, 3>> detector_axis;    // the detector's own rotation axis: a 2theta arm
+    // "# Oscillation_axis X.CW +SLOW". Some writers say which of the two image directions the spindle
+    // runs along instead of stating a vector. The axis NAME on that line is a poor discriminator (see
+    // ScansPhi, and note that the one header carrying both a name and a table says "X" where its table
+    // says Y) but this token is not: where both are present they agree.
+    bool spindle_along_slow = false;
 };
 
 // Whether the sweep turns PHI rather than the base (omega) axis. What moved is the axis with a
diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp
index 89c0c3a1c..ce35635c3 100644
--- a/tests/JFJochReaderTest.cpp
+++ b/tests/JFJochReaderTest.cpp
@@ -7,9 +7,14 @@
 #include "../common/ScanResultGenerator.h"
 #include "../writer/FileWriter.h"
 #include "../reader/JFJochHDF5Reader.h"
+#include "../reader/JFJochCBFReader.h"
+#include "../reader/MiniCBF.h"
 #include "../compression/JFJochCompressor.h"
 
+#include <fstream>
 #include <future>
+#include <iomanip>
+#include <sstream>
 
 TEST_CASE("HDF5DataType_Sign","[HDF5]") {
     HDF5DataType type_u8((uint8_t)0), type_fl(0.0f), type_i32((int32_t) 0), type_u32((uint32_t) 0);
@@ -3773,3 +3778,160 @@ TEST_CASE("JFJochReader_DetectorChainDoesNotDoubleTheTilt", "[HDF5][Full]") {
     remove("test_ponichain_data_000001.h5");
     REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0);
 }
+
+// A miniCBF header states more about the instrument than the "# " lines do: the CBF template block
+// some beamlines write carries a full imgCIF axis table, saying which laboratory direction the image's
+// columns and rows run along and which the spindle turns about. The reader assumed all three, and two
+// instruments in the corpus are not what it assumed - one stores its image a quarter turn round, the
+// other turns about the VERTICAL. Either way the spindle ends up 90 degrees from the image, which is
+// not a sign and so is beyond the axis-sign rescue; both indexed nothing at all.
+namespace {
+    // Two frames of a sweep whose pixels are all zero. Every delta of a zero image is zero, so the
+    // byte-offset stream is one 0x00 per pixel - which is a valid stream and enough to open a sweep.
+    void WriteMiniCBFSweep(const std::string &prefix, const std::string &header_body,
+                           int64_t nx, int64_t ny) {
+        for (int frame = 1; frame <= 2; frame++) {
+            std::ostringstream head;
+            head << "###CBF: VERSION 1.5\n_array_data.header_convention \"PILATUS_1.2\"\n"
+                 << "_array_data.header_contents\n"
+                 << "# Detector: PILATUS3 6M, S/N 60-0119\n"
+                 << "# Pixel_size 172e-6 m x 172e-6 m\n"
+                 << "# Silicon sensor, thickness 0.000450 m\n"
+                 << "# Exposure_time 0.1 s\n# Exposure_period 0.1 s\n# Count_cutoff 768595 counts\n"
+                 << "# Wavelength 0.96864 A\n# Detector_distance 0.33161 m\n"
+                 << "# Beam_xy (12.00, 8.00) pixels\n"
+                 << "# Start_angle " << (frame - 1) * 0.1 << " deg.\n# Angle_increment 0.1000 deg.\n"
+                 << "# Omega " << (frame - 1) * 0.1 << " deg.\n# Omega_increment 0.1000 deg.\n"
+                 << "# Phi 0.0000 deg.\n# Phi_increment 0.0000 deg.\n"
+                 << "# Chi 0.0000 deg.\n# Chi_increment 0.0000 deg.\n"
+                 << header_body
+                 << "_array_data.data\n--CIF-BINARY-FORMAT-SECTION--\n"
+                 << "Content-Type: application/octet-stream;\n"
+                 << "     conversions=\"x-CBF_BYTE_OFFSET\"\n"
+                 << "Content-Transfer-Encoding: BINARY\n"
+                 << "X-Binary-Size: " << nx * ny << "\n"
+                 << "X-Binary-Element-Type: \"signed 32-bit integer\"\n"
+                 << "X-Binary-Number-of-Elements: " << nx * ny << "\n"
+                 << "X-Binary-Size-Fastest-Dimension: " << nx << "\n"
+                 << "X-Binary-Size-Second-Dimension: " << ny << "\n\n";
+
+            std::ostringstream name;
+            name << prefix << "_" << std::setfill('0') << std::setw(4) << frame << ".cbf";
+            std::ofstream f(name.str(), std::ios::binary);
+            const std::string text = head.str();
+            f.write(text.data(), static_cast<std::streamsize>(text.size()));
+            f.write(reinterpret_cast<const char *>(minicbf::BINARY_SEPARATOR),
+                    sizeof(minicbf::BINARY_SEPARATOR));
+            const std::vector<char> zeros(static_cast<size_t>(nx * ny), 0);
+            f.write(zeros.data(), static_cast<std::streamsize>(zeros.size()));
+        }
+    }
+
+    void RemoveMiniCBFSweep(const std::string &prefix) {
+        for (int frame = 1; frame <= 2; frame++) {
+            std::ostringstream name;
+            name << prefix << "_" << std::setfill('0') << std::setw(4) << frame << ".cbf";
+            remove(name.str().c_str());
+        }
+    }
+
+    // The axis table in the form these headers write it, several tags to a line.
+    std::string AxisTable(const std::string &rows, int64_t nx, int64_t ny) {
+        return "loop_\n_axis.id\n_axis.type\n_axis.equipment\n_axis.depends_on\n"
+               "_axis.vector[1] _axis.vector[2] _axis.vector[3]\n"
+               "_axis.offset[1] _axis.offset[2] _axis.offset[3]\n"
+             + rows +
+               "loop_\n_array_structure_list.array_id\n_array_structure_list.index\n"
+               "_array_structure_list.dimension\n_array_structure_list.precedence\n"
+               "_array_structure_list.direction\n_array_structure_list.axis_set_id\n"
+               "ARRAY1 1 " + std::to_string(nx) + " 1 increasing ELEMENT_X\n"
+               "ARRAY1 2 " + std::to_string(ny) + " 2 increasing ELEMENT_Y\n"
+               "loop_\n_array_structure_list_axis.axis_set_id\n_array_structure_list_axis.axis_id\n"
+               "_array_structure_list_axis.displacement\n_array_structure_list_axis.displacement_increment\n"
+               "ELEMENT_X ELEMENT_X 0.0 0.1720\nELEMENT_Y ELEMENT_Y 0.0 0.1720\n";
+    }
+}
+
+TEST_CASE("JFJochCBFReader_AxisTableStatesTheMounting", "[HDF5][Full]") {
+    const int64_t nx = 24, ny = 16;
+
+    // A header that states nothing: the assumption, and the behaviour of nearly every file there is.
+    SECTION("no table, no hint - the assumption stands") {
+        WriteMiniCBFSweep("cbfaxis_plain", "# Detector_2theta 0.0000 deg.\n# Oscillation_axis OMEGA\n",
+                          nx, ny);
+        JFJochCBFReader reader;
+        REQUIRE_NOTHROW(reader.ReadFiles("cbfaxis_plain_0001.cbf"));
+        const auto x = reader.GetDataset()->experiment;
+        REQUIRE(x.GetGoniometer().has_value());
+        CHECK((x.GetGoniometer()->GetAxis() - Coord(-1, 0, 0)).Length() < 1e-6f);
+        CHECK(x.GetDetectorSetup().GetImageOrientation().IsIdentity());
+        CHECK(x.GetDiffractionGeometry().GetPoniRot2_rad() == 0.0f);
+        reader.Close();
+        RemoveMiniCBFSweep("cbfaxis_plain");
+    }
+
+    // A spindle that turns about the VERTICAL, with the image mounted the usual way round. imgCIF Y is
+    // up and the internal frame's y is down, so the stated (0,1,0) is internal (0,-1,0) - and NOT the
+    // (-1,0,0) that was assumed, which is 90 degrees away and indexes nothing.
+    SECTION("vertical spindle, standard image") {
+        WriteMiniCBFSweep("cbfaxis_vert",
+                          "# Detector_2theta 0.0000 deg.\n# Oscillation_axis X.CW +SLOW\n"
+                          + AxisTable("GON_OMEGA rotation goniometer . 0 1 0 . . .\n"
+                                      "DET_Z translation detector . 0 0 -1 0 0 0\n"
+                                      "ELEMENT_X translation detector DET_Z 1 0 0 -1 1 0\n"
+                                      "ELEMENT_Y translation detector ELEMENT_X 0 -1 0 0 0 0\n", nx, ny),
+                          nx, ny);
+        JFJochCBFReader reader;
+        REQUIRE_NOTHROW(reader.ReadFiles("cbfaxis_vert_0001.cbf"));
+        const auto x = reader.GetDataset()->experiment;
+        REQUIRE(x.GetGoniometer().has_value());
+        CHECK((x.GetGoniometer()->GetAxis() - Coord(0, -1, 0)).Length() < 1e-6f);
+        // The image itself is standard, so nothing about it is turned - the axis was the whole error.
+        CHECK(x.GetDetectorSetup().GetImageOrientation().IsIdentity());
+        reader.Close();
+        RemoveMiniCBFSweep("cbfaxis_vert");
+    }
+
+    // The same vertical spindle, stated only by the "+SLOW" token, which is all a header with no axis
+    // table says. Two datasets from that instrument are in this state.
+    SECTION("vertical spindle from the +SLOW token alone") {
+        WriteMiniCBFSweep("cbfaxis_slow", "# Detector_2theta 0.0000 deg.\n# Oscillation_axis X.CW +SLOW\n",
+                          nx, ny);
+        JFJochCBFReader reader;
+        REQUIRE_NOTHROW(reader.ReadFiles("cbfaxis_slow_0001.cbf"));
+        const auto x = reader.GetDataset()->experiment;
+        REQUIRE(x.GetGoniometer().has_value());
+        CHECK((x.GetGoniometer()->GetAxis() - Coord(0, -1, 0)).Length() < 1e-6f);
+        reader.Close();
+        RemoveMiniCBFSweep("cbfaxis_slow");
+    }
+
+    // An image stored a quarter turn round, on a detector swung out to 30 degrees. The two are read
+    // together or not at all: the arm turns about a laboratory axis, and which way that runs across
+    // the stored image is exactly what the mounting says.
+    SECTION("quarter-turned image on a swung arm") {
+        WriteMiniCBFSweep("cbfaxis_turn",
+                          "# Detector_2theta 30.0000 deg.\n# Oscillation_axis OMEGA\n"
+                          + AxisTable("GON_OMEGA rotation goniometer . 1 0 0 . . .\n"
+                                      "DET_2THETA rotation detector . 1 0 0 . . .\n"
+                                      "DET_Z translation detector DET_2THETA 0 0 -1 0 0 0\n"
+                                      "ELEMENT_X translation detector DET_Z 0 1 0 -1 1 0\n"
+                                      "ELEMENT_Y translation detector ELEMENT_X 1 0 0 0 0 0\n", nx, ny),
+                          nx, ny);
+        JFJochCBFReader reader;
+        REQUIRE_NOTHROW(reader.ReadFiles("cbfaxis_turn_0001.cbf"));
+        const auto x = reader.GetDataset()->experiment;
+        REQUIRE(x.GetGoniometer().has_value());
+        CHECK((x.GetGoniometer()->GetAxis() - Coord(1, 0, 0)).Length() < 1e-6f);
+        // fast = imgCIF (0,1,0) = internal (0,-1,0), slow = imgCIF (1,0,0) = internal (1,0,0)
+        CHECK(x.GetDetectorSetup().GetImageOrientation() == DetectorOrientation(false, 3));
+        // and the arm turns about its own stated axis, internal +x, by the stated 30 degrees
+        const auto geom = x.GetDiffractionGeometry();
+        const RotMatrix expected = RotMatrix(static_cast<float>(30.0 * PI / 180.0), {1, 0, 0})
+                                 * DetectorOrientation(false, 3).Matrix();
+        for (int64_t column = 0; column < 3; column++)
+            CHECK((geom.GetDetectorMatrix().Column(column) - expected.Column(column)).Length() < 1e-5f);
+        reader.Close();
+        RemoveMiniCBFSweep("cbfaxis_turn");
+    }
+}