quantized-lab 0.9.0__tar.gz → 0.10.0__tar.gz

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantized-lab
-Version: 0.9.0
+Version: 0.10.0
 Summary: Plot, analyze, and publish lab data - magnetometry, XRD, reflectometry - with OriginPro file interop, golden-verified analysis, and reproducible pipelines.
 Project-URL: Homepage, https://github.com/pquarterman17/quantized
 Project-URL: Documentation, https://github.com/pquarterman17/quantized/wiki

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quantized-lab"
-version = "0.9.0"
+version = "0.10.0"
 description = "Plot, analyze, and publish lab data - magnetometry, XRD, reflectometry - with OriginPro file interop, golden-verified analysis, and reproducible pipelines."
 readme = "README.md"
 requires-python = ">=3.11"

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/__init__.py

@@ -7,5 +7,5 @@ Layered, enforced architecture (see CLAUDE.md):
 
 from __future__ import annotations
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"
 __all__ = ["__version__"]

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure.py

@@ -27,7 +27,7 @@ from quantized.calc.figure_labels import safe_mathtext_label  # noqa: E402
 from quantized.calc.figure_overrides import _apply_overrides, _validate_overrides  # noqa: E402
 from quantized.calc.figure_scale import apply_axis_scale, resolve_axis_scale  # noqa: E402
 from quantized.calc.figure_styles import FigureStyle, figure_style  # noqa: E402
-from quantized.calc.figure_ticks import apply_tick_formats  # noqa: E402
+from quantized.calc.figure_ticks import apply_tick_formats, apply_tick_steps  # noqa: E402
 
 __all__ = ["draw_series_axes", "render_figure", "style_rc"]
 
@@ -177,6 +177,8 @@ def draw_series_axes(
     series_styles: Sequence[Mapping[str, Any] | None] | None = None,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
 ) -> list[Any]:
     """Plot ``series`` into an EXISTING Axes: lines, scales, labels, spines,
     legend, grid, and the per-figure override sweep (:func:`_apply_overrides`).
@@ -221,8 +223,11 @@ def draw_series_axes(
         (line,) = ax.plot(xv, yv, label=label, **kw)
         _apply_fill(ax, xv, yv, series, i, spec, line.get_color())
         artists.append(line)
-    apply_axis_scale(ax, "x", resolve_axis_scale(x_scale, x_log))
-    apply_axis_scale(ax, "y", resolve_axis_scale(y_scale, y_log))
+    resolved_x_scale = resolve_axis_scale(x_scale, x_log)
+    resolved_y_scale = resolve_axis_scale(y_scale, y_log)
+    apply_axis_scale(ax, "x", resolved_x_scale)
+    apply_axis_scale(ax, "y", resolved_y_scale)
+    apply_tick_steps(ax, x_step, y_step, resolved_x_scale, resolved_y_scale)
     apply_tick_formats(ax, x_fmt, y_fmt)
     if title:
         ax.set_title(title)
@@ -242,9 +247,10 @@ def draw_series_axes(
             loc=st.legend_location,
         )
     if st.grid_alpha > 0:
-        ax.grid(True, alpha=st.grid_alpha)
+        ax.grid(True, which="major", alpha=st.grid_alpha)
+        ax.grid(True, which="minor", alpha=st.grid_alpha * 0.4)
     else:
-        ax.grid(False)
+        ax.grid(False, which="both")
     _apply_overrides(fig, ax, st, ov, n_series=len(series))
     return artists
 
@@ -270,6 +276,8 @@ def _render_impl(
     collect_map: bool = False,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
 ) -> bytes | dict[str, Any]:
     """Render ``series`` (each ``(label, y)``) against ``x`` to image bytes.
 
@@ -352,6 +360,8 @@ def _render_impl(
                 series_styles=series_styles,
                 x_fmt=x_fmt,
                 y_fmt=y_fmt,
+                x_step=x_step,
+                y_step=y_step,
             )
         fig, ax = plt.subplots(figsize=figsize)
         try:
@@ -372,6 +382,8 @@ def _render_impl(
                 series_styles=series_styles,
                 x_fmt=x_fmt,
                 y_fmt=y_fmt,
+                x_step=x_step,
+                y_step=y_step,
             )
             if not ov.get("margins"):
                 fig.tight_layout()

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_break.py

@@ -40,7 +40,7 @@ from numpy.typing import ArrayLike, NDArray  # noqa: E402
 
 from quantized.calc.figure import _plot_kwargs  # noqa: E402
 from quantized.calc.figure_scale import apply_axis_scale, resolve_axis_scale  # noqa: E402
-from quantized.calc.figure_ticks import apply_tick_formats  # noqa: E402
+from quantized.calc.figure_ticks import apply_tick_formats, apply_tick_steps  # noqa: E402
 
 __all__ = ["render_breaks_impl"]
 
@@ -65,6 +65,8 @@ def render_breaks_impl(
     series_styles: Sequence[Mapping[str, Any] | None] | None,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
 ) -> bytes:
     """Render ``series`` against ``x`` with the x-axis elided over each
     ``[lo, hi]`` pair in ``breaks`` (already sorted/validated non-overlapping
@@ -100,8 +102,11 @@ def render_breaks_impl(
                 ax.plot(x, np.asarray(y, dtype=float), label=label, **kw)
             lo, hi = bounds[i]
             ax.set_xlim(lo, hi)
-            apply_axis_scale(ax, "x", resolve_axis_scale(x_scale, x_log))
-            apply_axis_scale(ax, "y", resolve_axis_scale(y_scale, y_log))
+            resolved_x_scale = resolve_axis_scale(x_scale, x_log)
+            resolved_y_scale = resolve_axis_scale(y_scale, y_log)
+            apply_axis_scale(ax, "x", resolved_x_scale)
+            apply_axis_scale(ax, "y", resolved_y_scale)
+            apply_tick_steps(ax, x_step, y_step, resolved_x_scale, resolved_y_scale)
             apply_tick_formats(ax, x_fmt, y_fmt)
             if i == 0:
                 handles, labels_out = ax.get_legend_handles_labels()
@@ -113,7 +118,8 @@ def render_breaks_impl(
             if not st.box_on:
                 ax.spines["top"].set_visible(False)
             if st.grid_alpha > 0:
-                ax.grid(True, alpha=st.grid_alpha)
+                ax.grid(True, which="major", alpha=st.grid_alpha)
+                ax.grid(True, which="minor", alpha=st.grid_alpha * 0.4)
 
         # Diagonal break glyphs (matplotlib's standard broken-axis recipe):
         # short strokes angled across each seam, on both the outgoing panel's

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_labels.py

@@ -13,17 +13,21 @@ error an export.
 
 Screen/export WYSIWYG (bug-hunt fix): the frontend's parser
 (``frontend/src/lib/richtext.ts``) only accepts a STRICT SUBSET of
-mathtext -- Greek letters, ``\\AA \\circ \\times \\cdot \\pm \\prime \\,
-\\mathrm \\mathit``, and literal Unicode -- and rejects everything else
-(e.g. ``\\frac``, ``\\sqrt``, ``\\sum``) as invalid markup, rendering it
+mathtext -- Greek letters, the symbol/relation/arrow commands in
+``SUPPORTED_MATHTEXT_COMMANDS`` (``\\AA \\times \\leq \\approx \\infty
+\\rightarrow`` ...), the structural commands ``\\frac \\sqrt`` (MAIN #28),
+``\\, \\mathrm \\mathit``, and literal Unicode -- and rejects everything else
+(e.g. ``\\hat``, ``\\vec``, ``\\overline``) as invalid markup, rendering it
 literally on screen. Raw matplotlib accepts a much larger command set, so
-without this gate a label like ``$\\frac{1}{2}$`` would render literal text
-("Invalid markup") on screen but an actual fraction in the PDF/SVG export --
-a WYSIWYG violation. `_uses_only_supported_commands` enumerates the SAME
-command set the frontend parser accepts and rejects (falls back to literal)
-any ``$...$`` region using a command outside it, BEFORE the matplotlib trial
-parse below ever runs. Keep `SUPPORTED_MATHTEXT_COMMANDS` in sync with
-richtext.ts's ``GREEK``/``SYMBOLS`` tables + ``mathrm``/``mathit`` handling.
+without this gate a label like ``$\\vec{v}$`` would render literal text
+("Invalid markup") on screen but an actual arrow-accented vector in the
+PDF/SVG export -- a WYSIWYG violation. `_uses_only_supported_commands`
+enumerates the SAME command set the frontend parser accepts and rejects
+(falls back to literal) any ``$...$`` region using a command outside it,
+BEFORE the matplotlib trial parse below ever runs. Keep
+`SUPPORTED_MATHTEXT_COMMANDS` in sync with richtext.ts's
+``GREEK``/``SYMBOLS``/``BIGOPS`` tables + ``mathrm``/``mathit``/``frac``/
+``sqrt`` handling.
 
 Pure layer: string in -> string out. matplotlib is imported lazily (same
 convention as the figure modules -- the heavy import is paid only on export).
@@ -60,12 +64,40 @@ _GREEK_COMMANDS = frozenset(
         "Phi", "Psi", "Omega",
     }
 )
-# Mirrors richtext.ts's `SYMBOLS` table (non-Greek symbol commands).
-_SYMBOL_COMMANDS = frozenset({"AA", "circ", "times", "cdot", "pm", "prime"})
+# Mirrors richtext.ts's `SYMBOLS` table (non-Greek symbol commands): base
+# symbols + relations, analysis/geometry glyphs, and arrows. Each is verified
+# to parse in matplotlib mathtext (tools probe), so a label using them renders
+# identically on screen (richtext.ts glyph) and in export (mathtext glyph).
+_SYMBOL_COMMANDS = frozenset(
+    {
+        "AA", "circ", "times", "cdot", "pm", "mp", "div", "prime",
+        # relations
+        "leq", "geq", "neq", "approx", "equiv", "sim", "propto", "ll", "gg",
+        # analysis / geometry
+        "infty", "partial", "nabla", "perp", "parallel", "angle",
+        "cdots", "ldots", "dots",
+        # arrows
+        "rightarrow", "to", "leftarrow", "leftrightarrow", "Rightarrow",
+    }
+)
 # Mirrors richtext.ts's `\mathrm{...}` / `\mathit{...}` style-group handling.
 _STYLE_COMMANDS = frozenset({"mathrm", "mathit"})
-
-SUPPORTED_MATHTEXT_COMMANDS = _GREEK_COMMANDS | _SYMBOL_COMMANDS | _STYLE_COMMANDS
+# Mirrors richtext.ts's structural nodes: `\frac{a}{b}`, `\sqrt{x}`,
+# `\sqrt[n]{x}` (MAIN #28). matplotlib renders these natively; the frontend
+# canvas + DOM renderers draw the matching stacked/radical layout.
+_STRUCTURE_COMMANDS = frozenset({"frac", "sqrt"})
+# Mirrors richtext.ts's `BIGOPS` table (large operators). matplotlib stacks
+# \sum/\prod limits over/under and side-scripts \int/\oint inline -- the
+# frontend canvas renderer matches that limits placement.
+_BIGOP_COMMANDS = frozenset({"sum", "prod", "int", "oint"})
+
+SUPPORTED_MATHTEXT_COMMANDS = (
+    _GREEK_COMMANDS
+    | _SYMBOL_COMMANDS
+    | _STYLE_COMMANDS
+    | _STRUCTURE_COMMANDS
+    | _BIGOP_COMMANDS
+)
 
 
 def _uses_only_supported_commands(label: str) -> bool:

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_overrides.py

@@ -118,7 +118,7 @@ def _apply_overrides(
             )
 
     if "grid" in ov:
-        ax.grid(bool(ov["grid"]), alpha=st.grid_alpha or 0.3)
+        ax.grid(bool(ov["grid"]), which="both", alpha=st.grid_alpha or 0.3)
 
     for ann in ov.get("annotations", []):
         # MAIN #18: a per-annotation `size` (the pointer tool's corner-handle

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_page.py

@@ -115,6 +115,8 @@ class PagePanel:
     # (a figure page composes several independently-configured plot views).
     x_fmt: Mapping[str, Any] | None = None
     y_fmt: Mapping[str, Any] | None = None
+    x_step: float | None = None
+    y_step: float | None = None
     series_styles: Sequence[Mapping[str, Any] | None] | None = None
     overrides: Mapping[str, Any] | None = None
     label: str | None = None
@@ -256,6 +258,8 @@ def render_figure_page(
                     series_styles=p.series_styles,
                     x_fmt=p.x_fmt,
                     y_fmt=p.y_fmt,
+                    x_step=p.x_step,
+                    y_step=p.y_step,
                 )
                 text = p.label if p.label is not None else panel_label(idx, label_format)
                 _place_label(ax, safe_mathtext_label(text), label_pos, st)

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_scale.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 from typing import Any
 
 import numpy as np
-from matplotlib.ticker import Locator
+from matplotlib.ticker import Locator, LogLocator, NullFormatter
 from numpy.typing import NDArray
 
 __all__ = ["apply_axis_scale", "reciprocal_tick_values", "resolve_axis_scale"]
@@ -115,6 +115,9 @@ def apply_axis_scale(ax: Any, axis: str, scale: str) -> None:
     set_scale = ax.set_xscale if axis == "x" else ax.set_yscale
     if scale == "log":
         set_scale("log")
+        target = ax.xaxis if axis == "x" else ax.yaxis
+        target.set_minor_locator(LogLocator(base=10.0, subs=tuple(range(2, 10))))
+        target.set_minor_formatter(NullFormatter())
         return
     if scale == "reciprocal":
         set_scale("function", functions=(_reciprocal, _reciprocal))

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/figure_ticks.py

@@ -36,9 +36,9 @@ import math
 from collections.abc import Mapping
 from typing import Any
 
-from matplotlib.ticker import Formatter
+from matplotlib.ticker import Formatter, MultipleLocator
 
-__all__ = ["apply_tick_formats", "axis_tick_formatter"]
+__all__ = ["apply_tick_formats", "apply_tick_steps", "axis_tick_formatter"]
 
 _MODES = ("fixed", "sci", "eng")
 
@@ -215,3 +215,32 @@ def apply_tick_formats(
     yf = axis_tick_formatter(y_fmt)
     if yf is not None:
         ax.yaxis.set_major_formatter(yf)
+
+
+def apply_tick_steps(
+    ax: Any,
+    x_step: float | None,
+    y_step: float | None,
+    x_scale: str,
+    y_scale: str,
+) -> None:
+    """Apply saved major-tick increments to linear axes only.
+
+    Origin's decoded ``from/to/step`` triples carry a linear increment. Log
+    axes retain their scale-specific locator; reciprocal axes have their own
+    locator. Invalid or absent increments leave matplotlib's locator intact.
+    ``MultipleLocator`` anchors ticks at integer multiples of the step, the
+    same convention as the interactive ``fixedLinearAxisSplits`` helper.
+    """
+    def apply_one(axis: Any, limits: tuple[float, float], step: float | None) -> None:
+        if step is None or not math.isfinite(step) or step <= 0:
+            return
+        span = abs(float(limits[1]) - float(limits[0]))
+        if not math.isfinite(span) or span / step > 1000:
+            return
+        axis.set_major_locator(MultipleLocator(float(step)))
+
+    if x_scale == "linear":
+        apply_one(ax.xaxis, ax.get_xlim(), x_step)
+    if y_scale == "linear":
+        apply_one(ax.yaxis, ax.get_ylim(), y_step)

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/fit_bumps.py

@@ -39,6 +39,12 @@ AbortFn = Callable[[], bool]
 #: Supported bumps engine ids (bumps.fitters FITTERS ids).
 BUMPS_ENGINES = ("amoeba", "lm", "de", "dream")
 
+#: Gelman-Rubin R-hat at/above which DREAM chains are considered NOT converged
+#: (the widely-used 1.1 threshold; < ~1.01 is "well mixed"). Surfaced so the UI
+#: never presents posterior intervals as trustworthy when the chains haven't
+#: mixed (audit P1 #2).
+RHAT_THRESHOLD = 1.1
+
 _INSTALL_HINT = (
     "bumps is not installed - the optional fit engine needs "
     "'pip install quantized[bumps]' (or: uv sync --extra bumps)"
@@ -154,9 +160,11 @@ def fit_bumps(
     saved equation-builder models) or a raw ``f(x, p)`` callable. ``engine``
     is one of ``BUMPS_ENGINES``: amoeba / lm / de report Hessian-derived
     uncertainties (``uncertainty_kind='hessian'``); dream samples the
-    posterior (``uncertainty_kind='posterior'``) and additionally returns
-    per-parameter medians and central 68% intervals (plus the raw draw
-    matrix when ``return_samples`` — corner-plot food).
+    posterior (``uncertainty_kind='posterior'``) and additionally returns, in
+    ``result['posterior']``, per-parameter medians, central 68% intervals,
+    ``n_draws``, ``nChains``, and the convergence diagnostics ``rHat`` (per
+    parameter), ``rHatMax``, and ``converged`` (Gelman-Rubin, audit P1 #2) —
+    plus the raw draw matrix when ``return_samples`` (corner-plot food).
 
     ``samples`` / ``burn`` / ``pop`` tune dream only. ``progress_callback``
     (fraction in [0, 1)) and ``abort_check`` (True -> stop sampling early)
@@ -243,15 +251,33 @@ def fit_bumps(
     }
 
     if engine == "dream":
-        draw = driver.fitter.state.draw()
+        state = driver.fitter.state
+        draw = state.draw()
         pts = np.asarray(draw.points, dtype=float)[:, order]
         lo68, med, hi68 = (
             np.asarray(np.percentile(pts, q, axis=0), dtype=float) for q in (16.0, 50.0, 84.0)
         )
+        # Convergence diagnostics (audit P1 #2): the Gelman-Rubin potential
+        # scale reduction factor (R-hat) per parameter, so posterior intervals
+        # are never presented as trustworthy when the chains haven't mixed.
+        # (bumps also warns "Did not converge!" via a separate K-S test; R-hat
+        # is the standard, interpretable metric. bumps exposes no clean
+        # effective-sample-size, so ESS isn't faked from cross-chain draws.)
+        try:
+            rhat_all = np.asarray(state.gelman(), dtype=float)
+            rhat = [float(rhat_all[i]) for i in order]
+            rhat_max = float(np.max(rhat_all)) if rhat_all.size else float("nan")
+        except Exception:  # noqa: BLE001 — aborted/degenerate state (cf. stderr above)
+            rhat = [float("nan")] * n_params
+            rhat_max = float("nan")
         result["posterior"] = {
             "medians": [float(v) for v in med],
             "interval68": [[float(a), float(b)] for a, b in zip(lo68, hi68, strict=True)],
             "n_draws": int(pts.shape[0]),
+            "rHat": rhat,
+            "rHatMax": rhat_max,
+            "converged": bool(math.isfinite(rhat_max) and rhat_max < RHAT_THRESHOLD),
+            "nChains": int(getattr(state, "Npop", pop * n_params)),
         }
         if return_samples:
             result["samples"] = pts

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/fit_scan.py

@@ -31,7 +31,7 @@ from numpy.typing import ArrayLike, NDArray
 from quantized.calc.fit_autoguess import auto_guess
 from quantized.calc.fit_equation import default_guesses, equation_model
 from quantized.calc.fit_models import FIT_MODELS
-from quantized.calc.fitting import curve_fit
+from quantized.calc.fitting import curve_fit, weights_from_dy
 
 __all__ = ["aicc_from_aic", "default_candidates", "scan_models"]
 
@@ -210,12 +210,7 @@ def scan_models(
 
     weights: NDArray[np.float64] | None = None
     if dy is not None:
-        dyv = np.asarray(dy, dtype=float).ravel()
-        if dyv.size != n:
-            raise ValueError("dy must have the same length as x")
-        if not bool(np.all(np.isfinite(dyv))) or bool(np.any(dyv <= 0)):
-            raise ValueError("dy entries must be finite and > 0")
-        weights = np.asarray(1.0 / dyv**2, dtype=float)
+        weights = weights_from_dy(dy, n)
 
     names = list(models) if models is not None else default_candidates(n)
     entries: list[dict[str, Any]] = []

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/calc/fitting.py

@@ -83,6 +83,23 @@ def _numerical_hessian(
     return hmat
 
 
+def weights_from_dy(dy: ArrayLike, n: int) -> NDArray[np.float64]:
+    """Per-point 1-sigma errors ``dy`` -> least-squares weights ``1/dy**2``.
+
+    The single canonical error->weight convention shared by every fit entry
+    point (``/fit``, ``/equation/fit``, ``/scan``) so "use the plotted error
+    column" means the same thing everywhere. Validates length and that every
+    entry is finite and strictly positive (a zero error would demand infinite
+    weight).
+    """
+    dyv = np.asarray(dy, dtype=float).ravel()
+    if dyv.size != n:
+        raise ValueError("dy must have the same length as x")
+    if not bool(np.all(np.isfinite(dyv))) or bool(np.any(dyv <= 0)):
+        raise ValueError("dy entries must be finite and > 0")
+    return np.asarray(1.0 / dyv**2, dtype=float)
+
+
 def curve_fit(
     x: ArrayLike,
     y: ArrayLike,

{quantized_lab-0.9.0 → quantized_lab-0.10.0}/src/quantized/io/origin_project/curve_style_color.py

@@ -1,4 +1,4 @@
-"""Per-curve visual style (color / symbol kind / line-vs-scatter) for Origin
+"""Per-curve visual style (color / symbol kind / plot type) for Origin
 graph curves -- shared by BOTH containers (solved 2026-07-06 against the
 4-stem ``curve_style.json`` oracle: ``hc2convert`` (.opj), ``Hc2 data``,
 ``RockingCurve``, ``UnpolPlots`` (.opju)).
@@ -33,11 +33,13 @@ variants -- the 4-byte size difference sits past offset 492):
 
 * offset 23 -- **symbol kind** (Origin's symbol-gallery index; 0 = none).
   Oracle-verified 49/49 (.opj) + 43/43 (.opju).
-* offset 76 -- the **line-vs-scatter byte** (``0xc8`` line / ``0xc9``
+* offset 76 -- the **plot-type byte** (``0xc8`` line / ``0xc9``
   scatter -- the very byte ``opju_codec.curve_plot_style``'s
   ``8f 01 <style> 83`` tag writes: that tag is this record's sparse chunk
-  for offset 76). ``0xca`` (Moke) and ``0xe7``/``0xe9`` (PNR corpus) also
-  occur; unmapped -- omitted, never guessed.
+  for offset 76). ``0xca`` is line + symbol: OriginLab's official ``plotxy``
+  reference maps plot ids 200/201/202 to line/scatter/line+symbol, matching
+  these bytes exactly. ``0xe7``/``0xe9`` (PNR corpus) remain unmapped --
+  omitted, never guessed.
 * offsets 302-305 -- a constant ``0xFFFFFFF7`` "auto" sentinel u32.
 * offsets 306-309 -- the **symbol color** (ocolor u32 LE), terminator
   ``0xff`` at 310 (the validity gate: hc2convert's 24 non-oracle anchors
@@ -160,9 +162,11 @@ _SYMBOL_SHAPES = {
     8: "star",
 }
 
-# Same byte table opju_codec._STYLE_BYTES validated (fig_pairs oracle);
-# 0xca/0xe7/0xe9 also occur in the corpus but are unmapped -- never guessed.
-_CONNECT_STYLE = {0xC8: "line", 0xC9: "scatter"}
+# Same byte table opju_codec._STYLE_BYTES validated (fig_pairs oracle).
+# 0xca = Origin plot:=202, officially documented as line + symbol:
+# https://docs.originlab.com/x-function/ref/plotxy/
+# 0xe7/0xe9 remain unmapped -- never guessed.
+_CONNECT_STYLE = {0xC8: "line", 0xC9: "scatter", 0xCA: "line_symbol"}
 
 # ── auto/increment colours (2026-07-06, §13.2 #2) ────────────────────────────
 #
@@ -241,7 +245,8 @@ def style_fields(record: bytes) -> dict[str, str | float]:
     """Decoded per-curve style keys from one curve-anchor record (raw ``.opj``
     payload or :func:`opju_style_record` reconstruction): any of ``color``
     (``"#RRGGBB"``), ``symbol`` (marker shape name), ``style``
-    (``"line"``/``"scatter"``), ``lineWidth`` / ``symbolSize`` (points, the
+    (``"line"``/``"scatter"``/``"line_symbol"``), ``lineWidth`` /
+    ``symbolSize`` (points, the
     1/500-pt u16 fields at offsets 21/25 — 92/92 oracle-exact). Undecodable
     or implausible fields are simply absent, never defaulted."""
     out: dict[str, str | float] = {}

quantized_lab-0.10.0/src/quantized/io/origin_project/fidelity.py

@@ -0,0 +1,192 @@
+"""Loss-aware fidelity assessment for decoded Origin graph records.
+
+The binary decoders intentionally return every record they can identify. This
+module builds the presentation contract separately: actionable figures gain a
+conservative per-figure assessment, while filtered/internal records survive as
+diagnostic summaries in a versioned project manifest. Nothing here mutates or
+reduces the pure decoder output.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, Literal, TypedDict
+
+from quantized.io.origin_project.graph_preview import PreviewDiagnostic
+
+__all__ = ["assess_origin_figures", "origin_figure_decode_failure"]
+
+FidelityStatus = Literal["exact", "best_effort", "reference_only", "unresolved"]
+
+
+class FigureFidelity(TypedDict):
+    status: FidelityStatus
+    recovered: list[str]
+    omissions: list[str]
+
+
+class FilteredFigure(TypedDict):
+    index: int
+    name: str
+    layer: int | None
+    reason: str
+
+
+class OriginFidelityManifest(TypedDict):
+    version: int
+    container: Literal["opj", "opju"]
+    status: FidelityStatus
+    graph_records_total: int
+    graph_records_actionable: int
+    graph_records_filtered: int
+    omissions: list[str]
+    filtered_figures: list[FilteredFigure]
+    preview_diagnostics: list[PreviewDiagnostic]
+
+
+def origin_figure_decode_failure(
+    *, container: Literal["opj", "opju"]
+) -> OriginFidelityManifest:
+    """Manifest used when optional graph decode fails but workbooks survive."""
+    return {
+        "version": 1,
+        "container": container,
+        "status": "unresolved",
+        "graph_records_total": 0,
+        "graph_records_actionable": 0,
+        "graph_records_filtered": 0,
+        "omissions": ["figure_decode_error"],
+        "filtered_figures": [],
+        "preview_diagnostics": [],
+    }
+
+
+_ALWAYS_OMITTED = [
+    "graphic_objects",
+    "rich_text_run_formatting",
+    "advanced_axis_types",
+]
+
+
+def _normalized_sources(source_names: Iterable[str]) -> tuple[str, ...]:
+    return tuple(s.strip().lower() for s in source_names if s.strip())
+
+
+def _source_resolves(fig: dict[str, Any], sources: tuple[str, ...]) -> bool:
+    hint = str(fig.get("source_hint") or "").strip().lower()
+    return bool(hint) and any(hint == s or hint in s or s in hint for s in sources)
+
+
+def _filter_reason(fig: dict[str, Any], sources: tuple[str, ...]) -> str | None:
+    if fig.get("curves") or _source_resolves(fig, sources):
+        return None
+    hint = str(fig.get("source_hint") or "").strip()
+    return (
+        f'source hint "{hint}" did not match an imported workbook'
+        if hint
+        else "no bound curves or source hint"
+    )
+
+
+def _recovered_groups(fig: dict[str, Any]) -> list[str]:
+    recovered = ["axis_ranges", "axis_scales"]
+    if fig.get("saved_preview"):
+        recovered.append("saved_graph_preview")
+    if fig.get("curves"):
+        recovered.extend(("curve_bindings", "curve_order"))
+    if fig.get("x_title") is not None or fig.get("y_title") is not None:
+        recovered.append("axis_titles")
+    if fig.get("legend_labels"):
+        recovered.append("legend_labels")
+    if fig.get("annotation_marks"):
+        recovered.append("positioned_annotations")
+    if fig.get("region_shades"):
+        recovered.append("region_shades")
+    if fig.get("frame") and fig.get("page"):
+        recovered.append("layer_geometry")
+    curves = fig.get("curves")
+    if isinstance(curves, list) and curves:
+        if any(isinstance(c, dict) and c.get("style") for c in curves):
+            recovered.append("curve_style")
+        if any(isinstance(c, dict) and c.get("color") for c in curves):
+            recovered.append("curve_color")
+        if any(isinstance(c, dict) and c.get("symbol") for c in curves):
+            recovered.append("marker_shape")
+        if any(isinstance(c, dict) and c.get("lineWidth") for c in curves):
+            recovered.append("line_width")
+        if any(isinstance(c, dict) and c.get("symbolSize") for c in curves):
+            recovered.append("symbol_size")
+        if any(isinstance(c, dict) and c.get("style") == "line_symbol" for c in curves):
+            recovered.append("line_symbol_mode")
+    return recovered
+
+
+def _figure_fidelity(fig: dict[str, Any]) -> FigureFidelity:
+    omissions = list(_ALWAYS_OMITTED)
+    if not fig.get("saved_preview"):
+        omissions.append("saved_graph_preview")
+    curves = fig.get("curves")
+    if not curves:
+        omissions.append("exact_curve_bindings")
+    elif isinstance(curves, list):
+        if any(not isinstance(c, dict) or not c.get("style") for c in curves):
+            omissions.append("some_curve_styles")
+        if any(not isinstance(c, dict) or not c.get("color") for c in curves):
+            omissions.append("some_curve_colors")
+    if not (fig.get("frame") and fig.get("page")):
+        omissions.append("layer_geometry")
+    return {
+        # No current decoder proves every visual property, so "exact" is
+        # deliberately reserved for a future preview/oracle comparison gate.
+        "status": "best_effort",
+        "recovered": _recovered_groups(fig),
+        "omissions": omissions,
+    }
+
+
+def assess_origin_figures(
+    figures: list[dict[str, Any]],
+    *,
+    container: Literal["opj", "opju"],
+    source_names: Iterable[str] = (),
+    preview_diagnostics: list[PreviewDiagnostic] | None = None,
+) -> tuple[list[dict[str, Any]], OriginFidelityManifest]:
+    """Return actionable annotated figures plus a loss-aware project manifest."""
+    actionable: list[dict[str, Any]] = []
+    filtered: list[FilteredFigure] = []
+    project_omissions: set[str] = set()
+    sources = _normalized_sources(source_names)
+    for index, fig in enumerate(figures):
+        reason = _filter_reason(fig, sources)
+        if reason is not None:
+            layer = fig.get("layer")
+            filtered.append(
+                {
+                    "index": index,
+                    "name": str(fig.get("name") or "SYSTEM"),
+                    "layer": int(layer) if isinstance(layer, int) else None,
+                    "reason": reason,
+                }
+            )
+            continue
+        fidelity = _figure_fidelity(fig)
+        project_omissions.update(fidelity["omissions"])
+        actionable.append({**fig, "fidelity": fidelity})
+
+    if not figures:
+        project_omissions.add("no_graph_records")
+    elif filtered:
+        project_omissions.add("filtered_internal_graph_records")
+    status: FidelityStatus = "best_effort" if actionable else "unresolved"
+    manifest: OriginFidelityManifest = {
+        "version": 1,
+        "container": container,
+        "status": status,
+        "graph_records_total": len(figures),
+        "graph_records_actionable": len(actionable),
+        "graph_records_filtered": len(filtered),
+        "omissions": sorted(project_omissions),
+        "filtered_figures": filtered,
+        "preview_diagnostics": preview_diagnostics or [],
+    }
+    return actionable, manifest