[BenHuddart]

Three defects in what gleplot writes, all of which the existing test batteries structurally could not catch: they round-trip generated GLE as text and never compile it. Each was found by compiling with the real gle binary (4.3.10) and measuring the result.

1. feat: grid decoration margins are sized like the lone plot's

Figure._auto_margins_cm had three margin policies — one for a lone plot (hei-proportional, measured in G2.2) and two for grids (fixed centimetres, predating any measurement). A grid's margins bound the whole layout, so what has to fit in them is the decoration of its outermost row and column — exactly the decoration a lone plot carries. The two cases cannot want different numbers, and it now has one policy for every layout shape, sharing mode and grid size.

The old grid margin (left 1.0 cm plain / 1.5 cm shared) is less than the ~1.32 cm a rotated y-axis title plus tick labels like -0.5 occupy at 12 pt, so a 2×2 grid with axis labels drew off the left edge of the page.

Overhang past the page edge, in cm (positive = clipped off-page), 8×6 in figures with x/y titles and -1/-0.5 tick labels:

figure	before	after
2×2 grid	L +0.476	L −0.217
1×2 / 3×1 grid	L +0.476	L −0.217
2×2 at 18 pt	L +1.214, B +0.429	L −0.326, B −0.475
2×2 sharex+sharey	L −0.024 (0.2 mm slack)	L −0.217
1×1	L −0.217	unchanged

This moves every existing multi-plot figure's frames — cells shrink slightly and shift right and up. That is the visible cost of the fix, and the reason this is a feat. Single-plot output is byte-identical. Five battery figures' geometry changed; the fixed-point invariant still holds with an empty exemption set.

2. fix: log-axis limits resolve to a range GLE will compile

GLE rejects a log axis whose range reaches zero, and it derives the range from the data when the script omits a bound — so an omitted bound is no escape. Each of these produced a file that could not be compiled at all:

ax.set_ylim(0, 400); ax.set_yscale("log")     # explicit, on x / y / y2
ax.plot(x, [0, 2, 3]); ax.set_yscale("log")   # autoscaled over a zero
ax.plot(x, [-1, 2, 3]); ax.set_xscale("log")  # ... or a negative

The reported case was the narrowest one: the secondary_yaxis builder in the golden and project batteries has been asking for set_ylim(0, 400, axis="y2") with a log y2.

The fix follows matplotlib, which keeps drawing rather than failing: mask non-positive values when autoscaling a log axis, replace a non-positive explicit bound with the smallest positive value plotted, and warn. gleplot additionally has to write the resolved range down, since leaving a bound out hands the decision back to GLE, which fails on the same raw data.

It stays out of the way of everything GLE already handles — positive data keeps its ordinary autoscaled range, a positive y2 with no limits keeps emitting a bare y2axis log, a file series keeps its autoscale (gleplot never read those numbers; inventing a range would be worse than the error it avoids), and linear axes are untouched.

3. feat: descending limits invert an axis, via GLE's negate

ax.set_ylim(3, 1) — matplotlib's idiom for inverting an axis — emitted yaxis min 3 max 1, which GLE refuses outright (illegal range for yaxis). So the normal way to draw depth below ground produced an unusable file.

GLE does support this: negate mirrors data coordinates inside an ascending range, and graph_ygraph() honours it, so text and guides placed via xg()/yg() follow the flip. Descending limits now emit an ascending range plus negate — what the caller asked for, rather than a normalization of it.

The descending pair stays the model, as in matplotlib: no separate inverted flag to serialize, get_ylim() returns what was set, and the recognizer recovers an inversion by reading negate back as a descending pair. GLEWriter._axis_direction is the single place model becomes GLE.

Log axes are the exception, and the reason is measurable: GLE's negate mirrors linearly and only then takes the logarithm, so yaxis min 1 max 100 log negate puts 1, 10 and 100 at 7.00, 6.88 and 1.00 cm — the decades smeared, not reversed. There is no way to spell a reversed log axis, so the inversion is dropped with a warning rather than drawn wrong. It composes with (2): set_ylim(3, 0) on a log axis comes out as min 1 max 3 log.

Reviewer notes

• Measurement method. Off-page ink cannot be seen by a raster or PDF-bbox measurement — the page clips it away, which is how it survived. The script body is wrapped in a begin name block and its corner points printed (ptx/pty), giving the true ink box including ink outside the page. Axis direction is measured the same way, by printing GLE's own yg()/xg() mapping: on an inverted y axis, y=1 lands at 14.6 cm and y=3 at 1.27 cm. Those measurements are now the three tests/integration/test_* files; all skip without a GLE binary, so runners without one keep the model-level coverage in tests/unit/.
• Guards are non-vacuous: 9/14 ink-box cases, 18/25 log-limit cases and 11/20 inverted-axis cases fail without their respective fix.
• Two ratio assertions in test_axes.py were loosened. They compared numbers read back from emitted text at places=6; the writer emits 6 significant digits, so they were only ever good to ~1e-5 relative and passed by luck of the old margins being round numbers. They now go through an assertEmittedAlmostEqual helper that says so.
• 39 of 40 battery figures now compile with real GLE (the 40th, passthrough_and_metadata, carries a deliberately unmodelled directive) and none has off-page ink. Full suite: 2149 passed, 2 skipped.

Known gap, deliberately not fixed here

Inner-panel gaps are still fixed centimetres (default_hspace_cm = 1.5) and carry the same decoration an outer margin does. That clears the measured requirement at 12 pt but not at 18 pt, where inner panels need subplots_adjust(wspace=…). Noted in the code.

🤖 Generated with Claude Code