setiastrosuitepro 1.7.3__py3-none-any.whl → 1.7.5__py3-none-any.whl

setiastro/saspro/stacking_suite.py

@@ -84,7 +84,7 @@ from setiastro.saspro.legacy.numba_utils import (
     finalize_drizzle_2d,
     finalize_drizzle_3d,
 )
-from setiastro.saspro.numba_utils import (
+from setiastro.saspro.legacy.numba_utils import (
     bulk_cosmetic_correction_numba,
     drizzle_deposit_numba_naive,
     drizzle_deposit_color_naive,
@@ -2295,6 +2295,36 @@ def compute_safe_chunk(height, width, N, channels, dtype, pref_h, pref_w):
 
 _DIM_RE = re.compile(r"\s*\(\d+\s*x\s*\d+\)\s*")
 
+
+def build_rejection_layers(rejection_map: dict, ref_H: int, ref_W: int, n_frames: int,
+                           *, comb_threshold_frac: float = 0.02):
+    """
+    Returns:
+      rej_cnt  : (H,W) uint16 (or uint32 if needed)
+      rej_frac : (H,W) float32 in [0..1]
+      rej_any  : (H,W) bool  (thresholded, not "ever rejected")
+    """
+    if n_frames <= 0:
+        raise ValueError("n_frames must be > 0")
+
+    # Use uint32 if you might exceed 65535 rejections (rare)
+    rej_cnt = np.zeros((ref_H, ref_W), dtype=np.uint32)
+
+    # rejection_map keys are per-file, values are coords in REGISTERED space
+    for _fpath, coords in (rejection_map or {}).items():
+        for (x, y) in coords:
+            xi = int(x); yi = int(y)
+            if 0 <= xi < ref_W and 0 <= yi < ref_H:
+                rej_cnt[yi, xi] += 1
+
+    rej_frac = (rej_cnt.astype(np.float32) / float(n_frames))
+
+    # “combined mask” becomes “rejected in >= threshold% of frames”
+    rej_any = (rej_frac >= float(comb_threshold_frac))
+
+    return rej_cnt, rej_frac, rej_any
+
+
 class _Responder(QObject):
     finished = pyqtSignal(object)   # emits the edited dict or None
 
@@ -2472,36 +2502,38 @@ def _save_master_with_rejection_layers(
     hdr: "fits.Header",
     out_path: str,
     *,
-    rej_any: "np.ndarray | None" = None,     # 2D bool
+    rej_any: "np.ndarray | None" = None,     # 2D bool (recommended: thresholded)
     rej_frac: "np.ndarray | None" = None,    # 2D float32 [0..1]
+    rej_cnt: "np.ndarray | None" = None,     # 2D uint16/uint32 counts
 ):
     """
     Writes a MEF (multi-extension FITS) file:
       - Primary HDU: the master image (2D or 3D) as float32
         * Mono: (H, W)
-        * Color: (3, H, W)  <-- channels-first for FITS
-      - Optional EXTNAME=REJ_COMB: uint8 (0/1) combined rejection mask
-      - Optional EXTNAME=REJ_FRAC: float32 fraction-of-frames rejected per pixel
+        * Color: (C, H, W) channels-first for FITS
+      - Optional EXTNAME=REJ_COMB: uint8 (0/1) thresholded rejection mask
+      - Optional EXTNAME=REJ_FRAC: float32 fraction-of-frames rejected per pixel [0..1]
+      - Optional EXTNAME=REJ_CNT : uint16/uint32 count of frames rejected per pixel
     """
+
+    from astropy.io import fits
+    from datetime import datetime
+
     # --- sanitize/shape primary data ---
     data = np.asarray(img_array, dtype=np.float32, order="C")
 
     # If channels-last, move to channels-first for FITS
     if data.ndim == 3:
-        # squeeze accidental singleton channels
         if data.shape[-1] == 1:
-            data = np.squeeze(data, axis=-1)  # becomes (H, W)
-        elif data.shape[-1] in (3, 4):       # RGB or RGBA
-            data = np.transpose(data, (2, 0, 1))  # (C, H, W)
-        # If already (C, H, W) leave it as-is.
+            data = np.squeeze(data, axis=-1)              # (H, W)
+        elif data.shape[-1] in (3, 4):
+            data = np.transpose(data, (2, 0, 1))          # (C, H, W)
 
-    # After squeeze/transpose, re-evaluate dims
     if data.ndim not in (2, 3):
         raise ValueError(f"Unsupported master image shape for FITS: {data.shape}")
 
     # --- clone + annotate header, and align NAXIS* with 'data' ---
     H = (hdr.copy() if hdr is not None else fits.Header())
-    # purge prior NAXIS keys to avoid conflicts after transpose/squeeze
     for k in ("NAXIS", "NAXIS1", "NAXIS2", "NAXIS3", "NAXIS4"):
         if k in H:
             del H[k]
@@ -2512,41 +2544,50 @@ def _save_master_with_rejection_layers(
     H["CREATOR"]  = "SetiAstroSuite"
     H["DATE-OBS"] = datetime.utcnow().isoformat()
 
-    # Fill NAXIS* to match data (optional; Astropy will infer if omitted)
     if data.ndim == 2:
         H["NAXIS"]  = 2
-        H["NAXIS1"] = int(data.shape[1])  # width
-        H["NAXIS2"] = int(data.shape[0])  # height
+        H["NAXIS1"] = int(data.shape[1])
+        H["NAXIS2"] = int(data.shape[0])
     else:
-        # data.shape == (C, H, W)
         C, Hh, Ww = data.shape
         H["NAXIS"]  = 3
-        H["NAXIS1"] = int(Ww)  # width
-        H["NAXIS2"] = int(Hh)  # height
-        H["NAXIS3"] = int(C)   # channels/planes
+        H["NAXIS1"] = int(Ww)
+        H["NAXIS2"] = int(Hh)
+        H["NAXIS3"] = int(C)
 
-    # --- build HDU list ---
     prim = fits.PrimaryHDU(data=data, header=H)
     hdul = [prim]
 
-    # Optional layers: must be 2D (H, W). Convert types safely.
+    # --- Optional layers: all must be 2D (H, W) in REGISTERED space ---
     if rej_any is not None:
         rej_any_2d = np.asarray(rej_any, dtype=bool)
         if rej_any_2d.ndim != 2:
             raise ValueError(f"REJ_COMB must be 2D, got {rej_any_2d.shape}")
         h = fits.Header()
         h["EXTNAME"] = "REJ_COMB"
-        h["COMMENT"] = "Combined rejection mask (any algorithm / any frame)"
+        h["COMMENT"] = "Thresholded rejection mask (1=frequently rejected, not merely 'ever')"
         hdul.append(fits.ImageHDU(data=rej_any_2d.astype(np.uint8, copy=False), header=h))
 
-    #if rej_frac is not None:
-    #    rej_frac_2d = np.asarray(rej_frac, dtype=np.float32)
-    #    if rej_frac_2d.ndim != 2:
-    #        raise ValueError(f"REJ_FRAC must be 2D, got {rej_frac_2d.shape}")
-    #    h = fits.Header()
-    #    h["EXTNAME"] = "REJ_FRAC"
-    #    h["COMMENT"] = "Per-pixel fraction of frames rejected [0..1]"
-    #    hdul.append(fits.ImageHDU(data=rej_frac_2d, header=h))
+    if rej_frac is not None:
+        rej_frac_2d = np.asarray(rej_frac, dtype=np.float32)
+        if rej_frac_2d.ndim != 2:
+            raise ValueError(f"REJ_FRAC must be 2D, got {rej_frac_2d.shape}")
+        h = fits.Header()
+        h["EXTNAME"] = "REJ_FRAC"
+        h["COMMENT"] = "Per-pixel fraction of frames rejected [0..1]"
+        hdul.append(fits.ImageHDU(data=rej_frac_2d, header=h))
+
+    if rej_cnt is not None:
+        rej_cnt_2d = np.asarray(rej_cnt)
+        if rej_cnt_2d.ndim != 2:
+            raise ValueError(f"REJ_CNT must be 2D, got {rej_cnt_2d.shape}")
+        # keep integer type; clamp to uint16 if you prefer smaller files
+        if rej_cnt_2d.dtype not in (np.uint16, np.uint32, np.int32, np.int64):
+            rej_cnt_2d = rej_cnt_2d.astype(np.uint32, copy=False)
+        h = fits.Header()
+        h["EXTNAME"] = "REJ_CNT"
+        h["COMMENT"] = "Per-pixel count of frames rejected"
+        hdul.append(fits.ImageHDU(data=rej_cnt_2d, header=h))
 
     fits.HDUList(hdul).writeto(out_path, overwrite=True)
 
@@ -6522,6 +6563,18 @@ class StackingSuiteDialog(QDialog):
                 w.blockSignals(True); w.setValue(v); w.blockSignals(False)
 
     def _get_drizzle_scale(self) -> float:
+        # UI combo wins if it exists
+        combo = getattr(self, "drizzle_scale_combo", None)
+        if combo is not None:
+            try:
+                txt = str(combo.currentText()).strip().lower()
+                if txt.endswith("x"):
+                    txt = txt[:-1]
+                return float(txt)
+            except Exception:
+                pass
+
+        # fallback to settings
         val = self.settings.value("stacking/drizzle_scale", "2x")
         if isinstance(val, (int, float)):
             return float(val)
@@ -6536,6 +6589,7 @@ class StackingSuiteDialog(QDialog):
         return 2.0
 
 
+
     def _set_drizzle_scale(self, r: float | str) -> None:
         if isinstance(r, str):
             try: r = float(r.rstrip("xX"))
@@ -7202,6 +7256,8 @@ class StackingSuiteDialog(QDialog):
         )
         main_layout.addWidget(self.clear_master_flat_selection_btn)
         self.override_dark_combo.currentIndexChanged[int].connect(self.override_selected_master_dark_for_flats)
+        # Connect selection change to update combobox
+        self.flat_tree.itemSelectionChanged.connect(self._on_flat_tree_selection_changed)
         self.update_override_dark_combo()
         self.rebuild_flat_tree()
     
@@ -8846,8 +8902,8 @@ class StackingSuiteDialog(QDialog):
         tab.setLayout(layout)
 
         self.drizzle_checkbox.setChecked(self.settings.value("stacking/drizzle_enabled", False, type=bool))
-        self.drizzle_scale_combo.setCurrentText(self.settings.value("stacking/drizzle_scale", "2x", type=str))
-        self.drizzle_drop_shrink_spin.setValue(self.settings.value("stacking/drizzle_drop", 0.65, type=float))
+        self.drizzle_scale_combo.setCurrentText(f"{int(self._get_drizzle_scale())}x")
+        self.drizzle_drop_shrink_spin.setValue(self._get_drizzle_pixfrac())
 
         drizzle_on = self.settings.value("stacking/drizzle_enabled", False, type=bool)
         self.cfa_drizzle_cb.setEnabled(drizzle_on)
@@ -8901,6 +8957,7 @@ class StackingSuiteDialog(QDialog):
         # wire it
         self.comet_cb.toggled.connect(lambda _v: self._refresh_comet_starless_enable())
         self.comet_save_starless_cb.toggled.connect(lambda _v: self._refresh_comet_starless_enable())  # optional belt/suspenders
+        self.drizzle_drop_shrink_spin.valueChanged.connect(self._on_drizzle_param_changed)
 
         # run once AFTER you restore all initial states from settings
         self._refresh_comet_starless_enable()
@@ -8963,11 +9020,16 @@ class StackingSuiteDialog(QDialog):
         self._update_drizzle_summary_columns()
 
     def _on_drizzle_param_changed(self, *_):
-        # Persist drizzle params whenever changed
-        self.settings.setValue("stacking/drizzle_scale", self.drizzle_scale_combo.currentText())
-        self.settings.setValue("stacking/drizzle_drop", float(self.drizzle_drop_shrink_spin.value()))
-        # If you reflect params to tree rows, update here:
-        # self._refresh_reg_tree_drizzle_column()
+        # persist scale from UI
+        if hasattr(self, "drizzle_scale_combo"):
+            self._set_drizzle_scale(self.drizzle_scale_combo.currentText())
+
+        # (optional) persist pixfrac too if you want “global controls are canonical”
+        if hasattr(self, "drizzle_drop_shrink_spin"):
+            self._set_drizzle_pixfrac(float(self.drizzle_drop_shrink_spin.value()))
+
+        self.settings.sync()
+        self._update_drizzle_summary_columns()   # if you show “1x / 0.65” in the tree
 
     def _on_star_trail_toggled(self, enabled: bool):
         """
@@ -11703,6 +11765,51 @@ class StackingSuiteDialog(QDialog):
 
 
 
+    def _on_flat_tree_selection_changed(self):
+        """Update the override_dark_combo to reflect the value stored in the selected row."""
+        items = self.flat_tree.selectedItems()
+        if not items:
+            return
+        
+        # Get the first top-level item (group row, not a leaf)
+        selected_item = None
+        for it in items:
+            if not it.parent():  # Top-level item (group row)
+                selected_item = it
+                break
+        
+        if not selected_item:
+            return
+        
+        # Read the stored value from column 2
+        ud = selected_item.data(2, Qt.ItemDataRole.UserRole)
+        
+        # Block signals to avoid triggering override_selected_master_dark_for_flats
+        self.override_dark_combo.blockSignals(True)
+        try:
+            # Find the matching index in the combobox
+            if ud is None:
+                # "None (Use Auto-Select)" should be at index 0
+                self.override_dark_combo.setCurrentIndex(0)
+            elif ud == "__NO_DARK__":
+                # "None (Use no Dark to Calibrate)" should be at index 1
+                self.override_dark_combo.setCurrentIndex(1)
+            else:
+                # Find the item with matching userData (path)
+                found_idx = -1
+                for i in range(self.override_dark_combo.count()):
+                    item_ud = self.override_dark_combo.itemData(i)
+                    if item_ud == ud:
+                        found_idx = i
+                        break
+                if found_idx >= 0:
+                    self.override_dark_combo.setCurrentIndex(found_idx)
+                else:
+                    # If not found, default to index 0
+                    self.override_dark_combo.setCurrentIndex(0)
+        finally:
+            self.override_dark_combo.blockSignals(False)
+
     def override_selected_master_dark_for_flats(self, idx: int):
         """Apply combo choice to selected flat groups; stores path/token in row + dict."""
         items = self.flat_tree.selectedItems()
@@ -15752,7 +15859,7 @@ class StackingSuiteDialog(QDialog):
             filters = "TIFF (*.tif);;PNG (*.png);;JPEG (*.jpg *.jpeg);;FITS (*.fits);;XISF (*.xisf)"
             path, chosen_filter = QFileDialog.getSaveFileName(
                 self, "Save Star-Trail Image",
-                os.path.join(self.stacking_directory, default_name),
+                os.path.join(self._master_light_dir(), default_name),
                 "TIFF (*.tif);;PNG (*.png);;JPEG (*.jpg *.jpeg);;FITS (*.fits);;XISF (*.xisf)"
             )
             if not path:
@@ -15879,8 +15986,11 @@ class StackingSuiteDialog(QDialog):
         """
         Take aligned OSC frames and produce per-band aligned mono FITS.
 
-        Uses the same classifier and grouping behavior as _split_dual_band_osc,
-        but operates on the *aligned* frames.
+        IMPORTANT (for drizzle correctness):
+        - We also populate self._split_drizzle_info so drizzle can deposit from the
+        *parent original* pixels while using the same transforms solved from originals.
+        Mapping:
+            split_aligned_path -> {"orig": <parent original>, "chan": "R"|"G"|None}
 
         Returns a new light_files-style dict:
             { "Ha - ...":   [aligned_Ha_*.fit...],
@@ -15895,18 +16005,35 @@ class StackingSuiteDialog(QDialog):
         out_dir = os.path.join(self.stacking_directory, "DualBand_Split")
         os.makedirs(out_dir, exist_ok=True)
 
+        # split_aligned_path -> {"orig": <parent original>, "chan": "R"|"G"|None}
+        if not hasattr(self, "_split_drizzle_info") or self._split_drizzle_info is None:
+            self._split_drizzle_info = {}
+        else:
+            # Clear any previous run’s mapping to avoid mixing sessions
+            self._split_drizzle_info.clear()
+
+        split_info = self._split_drizzle_info
+
         # Collect per-band file lists (some may already be mono NB)
         ha_files, sii_files, oiii_files, hb_files = [], [], [], []
-        inherit_map: dict[str, set[str]] = {}   # new_group_key -> set(parent_group)
         parent_of: dict[str, str] = {}          # new_path_or_existing -> parent_group
 
         # Snapshot old drizzle configs so we can inherit to the new NB groups
         old_drizzle = dict(getattr(self, "per_group_drizzle", {}))
         selected_groups = set(getattr(self, "_reg_selected_groups", set()))
 
+        # Normalized aligned->original map (should exist from your registration pipeline)
+        oba = getattr(self, "orig_by_aligned", {}) or {}
+
         # --- Pass 1: classify + split each aligned frame ---
         for group, files in aligned_light_files.items():
             for fp in files:
+                fpn = os.path.normpath(fp)
+
+                # Find parent original for this aligned frame (for drizzle)
+                parent_orig = oba.get(fpn) or oba.get(os.path.normpath(fp))
+                parent_orig = os.path.normpath(parent_orig) if parent_orig else None
+
                 try:
                     with fits.open(fp, memmap=False) as hdul:
                         data = hdul[0].data
@@ -15927,16 +16054,12 @@ class StackingSuiteDialog(QDialog):
                 # ----------------------------------------
                 # Detect layout: mono vs RGB, CHW vs HWC
                 # ----------------------------------------
-                layout = None
-
                 if arr.ndim == 2:
                     layout = "MONO"
                 elif arr.ndim == 3:
                     c0, c1, c2 = arr.shape
-                    # channels-first (C, H, W)
                     if c0 in (1, 3) and c1 > 8 and c2 > 8:
                         layout = "CHW"
-                    # channels-last (H, W, C)
                     elif c2 in (1, 3) and c0 > 8 and c1 > 8:
                         layout = "HWC"
                     else:
@@ -15945,7 +16068,11 @@ class StackingSuiteDialog(QDialog):
                     layout = "UNKNOWN"
 
                 # ---- MONO narrowband frames (Ha/SII/OIII/Hb) ----
-                if layout == "MONO" or (layout == "CHW" and arr.shape[0] == 1) or (layout == "HWC" and arr.shape[-1] == 1):
+                if (
+                    layout == "MONO"
+                    or (layout == "CHW" and arr.shape[0] == 1)
+                    or (layout == "HWC" and arr.shape[-1] == 1)
+                ):
                     # Treat as mono NB based on classifier
                     if cls == "MONO_HA":
                         ha_files.append(fp);   parent_of[fp] = group
@@ -15955,7 +16082,14 @@ class StackingSuiteDialog(QDialog):
                         oiii_files.append(fp); parent_of[fp] = group
                     elif cls == "MONO_HB":
                         hb_files.append(fp);   parent_of[fp] = group
-                    # UNKNOWN mono: ignore for NB split
+                    else:
+                        # Unknown mono: ignore for NB split
+                        pass
+
+                    # For drizzle mapping: if this is a split pipeline, we still may want
+                    # aligned mono to drizzle from parent original (chan None means “use mono as-is”)
+                    if parent_orig:
+                        split_info[fpn] = {"orig": parent_orig, "chan": None}
                     continue
 
                 # ---- RGB / OSC case (what we expect for dual-band) ----
@@ -15972,39 +16106,55 @@ class StackingSuiteDialog(QDialog):
                     R = arr[..., 0]
                     G = arr[..., 1]
                 else:
-                    # layout == "CHW" → (C, H, W)
-                    # C should be 3
+                    # (C, H, W)
                     R = arr[0, ...]
                     G = arr[1, ...]
 
                 base = os.path.splitext(os.path.basename(fp))[0]
 
+                def _map_split(path_written: str, chan: str):
+                    """Record drizzle info for this newly created split aligned file."""
+                    if parent_orig:
+                        split_info[os.path.normpath(path_written)] = {"orig": parent_orig, "chan": chan}
+
                 if cls == "DUAL_HA_OIII":
                     ha_path   = os.path.join(out_dir, f"{base}_Ha.fit")
                     oiii_path = os.path.join(out_dir, f"{base}_OIII.fit")
-                    self._write_band_fit(ha_path,  R, hdr, "Ha",  src_filter=filt)
+                    self._write_band_fit(ha_path,   R, hdr, "Ha",   src_filter=filt)
                     self._write_band_fit(oiii_path, G, hdr, "OIII", src_filter=filt)
+
                     ha_files.append(ha_path);     parent_of[ha_path]   = group
                     oiii_files.append(oiii_path); parent_of[oiii_path] = group
 
+                    _map_split(ha_path, "R")
+                    _map_split(oiii_path, "G")
+
                 elif cls == "DUAL_SII_OIII":
                     sii_path  = os.path.join(out_dir, f"{base}_SII.fit")
                     oiii_path = os.path.join(out_dir, f"{base}_OIII.fit")
-                    self._write_band_fit(sii_path, R, hdr, "SII",  src_filter=filt)
+                    self._write_band_fit(sii_path,  R, hdr, "SII",  src_filter=filt)
                     self._write_band_fit(oiii_path, G, hdr, "OIII", src_filter=filt)
-                    sii_files.append(sii_path);    parent_of[sii_path]  = group
-                    oiii_files.append(oiii_path);  parent_of[oiii_path] = group
+
+                    sii_files.append(sii_path);     parent_of[sii_path]  = group
+                    oiii_files.append(oiii_path);   parent_of[oiii_path] = group
+
+                    _map_split(sii_path, "R")
+                    _map_split(oiii_path, "G")
 
                 elif cls == "DUAL_SII_HB":
                     sii_path = os.path.join(out_dir, f"{base}_SII.fit")
                     hb_path  = os.path.join(out_dir, f"{base}_Hb.fit")
                     self._write_band_fit(sii_path, R, hdr, "SII", src_filter=filt)
                     self._write_band_fit(hb_path,  G, hdr, "Hb",  src_filter=filt)
+
                     sii_files.append(sii_path); parent_of[sii_path] = group
                     hb_files.append(hb_path);   parent_of[hb_path]  = group
 
+                    _map_split(sii_path, "R")
+                    _map_split(hb_path, "G")
+
                 else:
-                    # UNKNOWN dual → ignore, they won't show up in NB groups
+                    # UNKNOWN dual → ignore
                     continue
 
         # --- Pass 2: group the new files (band + exposure + size), same as before ---
@@ -16020,7 +16170,7 @@ class StackingSuiteDialog(QDialog):
                 return f"{band} - ? - ?x?"
 
         new_groups: dict[str, list[str]] = {}
-        inherit_map = {}
+        inherit_map: dict[str, set[str]] = {}
 
         for band, flist in (
             ("Ha",   ha_files),
@@ -16043,7 +16193,6 @@ class StackingSuiteDialog(QDialog):
             return aligned_light_files
 
         # --- Replace light_files with NB groups & seed drizzle configs ---
-
         self.light_files = new_groups
 
         self.per_group_drizzle = {}
@@ -16087,6 +16236,11 @@ class StackingSuiteDialog(QDialog):
         return new_groups
 
 
+    def _master_light_dir(self) -> str:
+        out_dir = os.path.join(self.stacking_directory, "Master_Light")
+        os.makedirs(out_dir, exist_ok=True)
+        return out_dir
+
     def on_registration_complete(self, success, msg):
        
         self.update_status(self.tr(msg))
@@ -16504,7 +16658,7 @@ class StackingSuiteDialog(QDialog):
 
                     group_key, frames = self._mf_queue.pop(0)
 
-                    out_dir = os.path.join(self.stacking_directory, "Masters")
+                    out_dir = self._master_light_dir()
                     os.makedirs(out_dir, exist_ok=True)
                     out_path = os.path.join(out_dir, f"MasterLight_{group_key}_MFDeconv.fit")
 
@@ -17020,22 +17174,35 @@ class StackingSuiteDialog(QDialog):
             display_group = self._label_with_dims(group_key, W, H)
             base = f"MasterLight_{display_group}_{n_frames_group}stacked"
             base = self._normalize_master_stem(base)
-            out_path_orig = self._build_out(self.stacking_directory, base, "fit")
+            out_path_orig = self._build_out(self._master_light_dir(), base, "fit")
 
             # Try to attach rejection maps that were accumulated during integration
             maps = getattr(self, "_rej_maps", {}).get(group_key)
             save_layers = self.settings.value("stacking/save_rejection_layers", True, type=bool)
 
-            if maps and save_layers:
+            save_layers = self.settings.value("stacking/save_rejection_layers", True, type=bool)
+
+            if rejection_map and save_layers:
                 try:
+                    # integrated_image is already normalized above; rejection coords are assumed in this (H,W) space
+                    rej_cnt, rej_frac, rej_any = build_rejection_layers(
+                        rejection_map=rejection_map,
+                        ref_H=H,
+                        ref_W=W,
+                        n_frames=n_frames_group,
+                        comb_threshold_frac=0.02,  # tweakable
+                    )
+
                     _save_master_with_rejection_layers(
-                        integrated_image,
-                        hdr_orig,
-                        out_path_orig,
-                        rej_any = maps.get("any"),
-                        rej_frac= maps.get("frac"),
+                        img_array=integrated_image,
+                        hdr=hdr_orig,
+                        out_path=out_path_orig,
+                        rej_any=rej_any,
+                        rej_frac=rej_frac,
+                        rej_cnt=rej_cnt,
                     )
                     log(f"✅ Saved integrated image (with rejection layers) for '{group_key}': {out_path_orig}")
+
                 except Exception as e:
                     log(f"⚠️ MEF save failed ({e}); falling back to single-HDU save.")
                     save_image(
@@ -17047,8 +17214,8 @@ class StackingSuiteDialog(QDialog):
                         is_mono=is_mono_orig
                     )
                     log(f"✅ Saved integrated image (single-HDU) for '{group_key}': {out_path_orig}")
+
             else:
-                # No maps available or feature disabled → single-HDU save
                 save_image(
                     img_array=integrated_image,
                     filename=out_path_orig,
@@ -17128,7 +17295,7 @@ class StackingSuiteDialog(QDialog):
                 display_group_crop = self._label_with_dims(group_key, Wc, Hc)
                 base_crop = f"MasterLight_{display_group_crop}_{n_frames_group}stacked_autocrop"
                 base_crop = self._normalize_master_stem(base_crop)
-                out_path_crop = self._build_out(self.stacking_directory, base_crop, "fit")
+                out_path_crop = self._build_out(self._master_light_dir(), base_crop, "fit")
 
                 save_image(
                     img_array=cropped_img,
@@ -17276,7 +17443,7 @@ class StackingSuiteDialog(QDialog):
                     Hc, Wc = comet_only.shape[:2]
                     display_group_c = self._label_with_dims(group_key, Wc, Hc)
                     comet_path = self._build_out(
-                        self.stacking_directory,
+                        self._master_light_dir(),
                         f"MasterCometOnly_{display_group_c}_{len(usable)}stacked",
                         "fit"
                     )
@@ -17303,7 +17470,7 @@ class StackingSuiteDialog(QDialog):
                         Hcc, Wcc = comet_only_crop.shape[:2]
                         display_group_cc = self._label_with_dims(group_key, Wcc, Hcc)
                         comet_path_crop = self._build_out(
-                            self.stacking_directory,
+                            self._master_light_dir(),
                             f"MasterCometOnly_{display_group_cc}_{len(usable)}stacked_autocrop",
                             "fit"
                         )
@@ -17332,7 +17499,7 @@ class StackingSuiteDialog(QDialog):
 
                         is_mono_blend = (blend.ndim == 2) or (blend.ndim == 3 and blend.shape[2] == 1)
                         blend_path = self._build_out(
-                            self.stacking_directory,
+                            self._master_light_dir(),
                             f"MasterCometBlend_{display_group_c}_{len(usable)}stacked",
                             "fit"
                         )
@@ -17352,7 +17519,7 @@ class StackingSuiteDialog(QDialog):
                             Hb, Wb = blend_crop.shape[:2]
                             display_group_bc = self._label_with_dims(group_key, Wb, Hb)
                             blend_path_crop = self._build_out(
-                                self.stacking_directory,
+                                self._master_light_dir(),
                                 f"MasterCometBlend_{display_group_bc}_{len(usable)}stacked_autocrop",
                                 "fit"
                             )
@@ -17368,19 +17535,14 @@ class StackingSuiteDialog(QDialog):
                 sasr_path = os.path.join(self.stacking_directory, f"{group_key}_rejections.sasr")
                 self.save_rejection_map_sasr(rejection_map, sasr_path)
                 log(f"✅ Saved rejection map to {sasr_path}")
-                group_integration_data[group_key] = {
-                    "integrated_image": integrated_image,
-                    "rejection_map": rejection_map,
-                    "n_frames": n_frames_group,
-                    "drizzled": True
-                }
-            else:
-                group_integration_data[group_key] = {
-                    "integrated_image": integrated_image,
-                    "rejection_map": None,
-                    "n_frames": n_frames_group,
-                    "drizzled": False
-                }
+
+            group_integration_data[group_key] = {
+                "integrated_image": integrated_image,
+                "rejection_map": rejection_map if drizzle_enabled_global else None,
+                "n_frames": n_frames_group,
+                "drizzled": False,  # <-- ALWAYS false here
+            }
+            if not drizzle_enabled_global:
                 log(f"ℹ️ Skipping rejection map save for '{group_key}' (drizzle disabled).")
 
         QApplication.processEvents()
@@ -17409,22 +17571,55 @@ class StackingSuiteDialog(QDialog):
 
             rejections_for_group = group_integration_data[group_key]["rejection_map"]
             n_frames_group = group_integration_data[group_key]["n_frames"]
+            # Build drizzle entries for each group
+            split_info = getattr(self, "_split_drizzle_info", {}) or {}
+            oba = getattr(self, "orig_by_aligned", {}) or {}
+
+            entries_by_group = {}
+            for gk, aligned_list in grouped_files.items():
+                entries = []
+                for ap in aligned_list:
+                    apn = os.path.normpath(ap)
+                    info = split_info.get(apn)
+
+                    if info and info.get("orig"):
+                        entries.append({
+                            "orig": os.path.normpath(info["orig"]),  # parent original pixels
+                            "aligned": apn,                          # split aligned (rej/weights)
+                            "chan": info.get("chan", None),          # 'R'/'G'/None
+                        })
+                    else:
+                        # normal (non-split) case
+                        op = oba.get(apn)
+                        if op:
+                            entries.append({"orig": os.path.normpath(op), "aligned": apn, "chan": None})
+
+                entries_by_group[gk] = entries
 
             log(f"📐 Drizzle for '{group_key}' at {scale_factor}× (drop={drop_shrink}) using {n_frames_group} frame(s).")
 
-            self.drizzle_stack_one_group(
-                group_key=group_key,
-                file_list=file_list,
-                original_list=originals_by_group.get(group_key, []),
-                transforms_dict=transforms_dict,
-                frame_weights=frame_weights,
-                scale_factor=scale_factor,
-                drop_shrink=drop_shrink,
-                rejection_map=rejections_for_group,
-                autocrop_enabled=autocrop_enabled,
-                rect_override=global_rect,
-                status_cb=log
-            )
+            ok = False
+            try:
+                ok = bool(self.drizzle_stack_one_group(
+                    group_key=group_key,
+                    file_list=file_list,
+                    entries=entries_by_group.get(group_key, []),
+                    transforms_dict=transforms_dict,
+                    frame_weights=frame_weights,
+                    scale_factor=scale_factor,
+                    drop_shrink=drop_shrink,
+                    rejection_map=rejections_for_group,
+                    autocrop_enabled=autocrop_enabled,
+                    rect_override=global_rect,
+                    status_cb=log
+                ))
+            except Exception as e:
+                log(f"⚠️ Drizzle failed for '{group_key}': {e!r}")
+                ok = False
+
+            if ok:
+                group_integration_data[group_key]["drizzled"] = True
+
 
         # Build summary lines
         for group_key, info in group_integration_data.items():
@@ -18019,7 +18214,7 @@ class StackingSuiteDialog(QDialog):
                 return
 
             group_key, frames = self._mf_queue.pop(0)
-            out_dir = os.path.join(self.stacking_directory, "Masters")
+            out_dir = self._master_light_dir()
             os.makedirs(out_dir, exist_ok=True)
 
             # Settings snapshot
@@ -18648,8 +18843,8 @@ class StackingSuiteDialog(QDialog):
         self,
         *,
         group_key,
-        file_list,           # registered _n_r.fit (keep for headers/metadata)
-        original_list,       # NEW: originals (normalized), used as pixel sources
+        file_list,           # still the aligned split files (for headers/metadata)
+        entries,             # NEW: list of {orig, aligned, chan}
         transforms_dict,
         frame_weights,
         scale_factor,
@@ -18659,8 +18854,15 @@ class StackingSuiteDialog(QDialog):
         rect_override,
         status_cb
     ):
-        # Load per-frame transforms (SASD v2)
-        log = status_cb or (lambda *_: None)        
+        import os
+
+        import cv2
+        from datetime import datetime
+        from astropy.io import fits
+
+        log = status_cb or (lambda *_: None)
+
+        # ---- load SASD v2 transforms (keyed by ORIGINAL path) ----
         sasd_path = os.path.join(self.stacking_directory, "alignment_transforms.sasd")
         ref_H, ref_W, xforms = self._load_sasd_v2(sasd_path)
         if not (ref_H and ref_W):
@@ -18668,26 +18870,33 @@ class StackingSuiteDialog(QDialog):
             rs = getattr(self, "ref_shape_for_drizzle", None)
             if isinstance(rs, tuple) and len(rs) == 2 and all(int(v) > 0 for v in rs):
                 ref_H, ref_W = int(rs[0]), int(rs[1])
-                status_cb(f"ℹ️ Using in-memory REF_SHAPE fallback: {ref_H}×{ref_W}")
+                log(f"ℹ️ Using in-memory REF_SHAPE fallback: {ref_H}×{ref_W}")
             else:
-                status_cb("⚠️ Missing REF_SHAPE in SASD; cannot drizzle.")
+                log("⚠️ Missing REF_SHAPE in SASD; cannot drizzle.")
                 return
 
         log(f"✅ SASD v2: loaded {len(xforms)} transform(s).")
-        # Debug (first few):
+
+        # ---- sanity: entries must exist ----
+        if not entries:
+            log(f"⚠️ Group '{group_key}' has no drizzle entries – skipping.")
+            return False
+
+        # Debug (first few)
         try:
-            sample_need = [os.path.basename(p) for p in original_list[:5]]
+            sample_need = [os.path.basename(os.path.normpath(e.get("orig", ""))) for e in entries[:5]]
             sample_have = [os.path.basename(p) for p in list(xforms.keys())[:5]]
             log(f"   originals needed (sample): {sample_need}")
             log(f"   sasd FILEs (sample):       {sample_have}")
         except Exception:
             pass
 
-        canvas_H, canvas_W = int(ref_H * scale_factor), int(ref_W * scale_factor)        
+        # ---- output canvas ----
+        canvas_H = int(ref_H * scale_factor)
+        canvas_W = int(ref_W * scale_factor)
 
-
-        # --- kernel config from settings ---
-        kernel_name = self.settings.value("stacking/drizzle_kernel", "square", type=str).lower()
+        # ---- kernel config from settings ----
+        kernel_name = (self.settings.value("stacking/drizzle_kernel", "square", type=str) or "square").lower()
         gauss_sigma = self.settings.value(
             "stacking/drizzle_gauss_sigma", float(drop_shrink) * 0.5, type=float
         )
@@ -18701,80 +18910,78 @@ class StackingSuiteDialog(QDialog):
         total_rej = sum(len(v) for v in (rejection_map or {}).values())
         log(f"🔭 Drizzle stacking for group '{group_key}' with {total_rej} total rejected pixels.")
 
+        # Need at least 2 frames to be worth it
         if len(file_list) < 2:
             log(f"⚠️ Group '{group_key}' does not have enough frames to drizzle.")
-            return
+            return False
 
-        # --- establish geometry + is_mono before choosing depositor ---
+        # ---- establish header + default dims from first aligned file (metadata only) ----
         first_file = file_list[0]
         first_img, hdr, _, _ = load_image(first_file)
         if first_img is None:
             log(f"⚠️ Could not load {first_file} to determine drizzle shape!")
-            return
+            return False
+
+        # Force mono if any entry is channel-split (dual-band drizzle output should be mono)
+        force_mono = any((e.get("chan") in ("R", "G", "B")) for e in entries)
 
-        if first_img.ndim == 2:
+        if force_mono:
             is_mono = True
-            h, w = first_img.shape
+            h, w = first_img.shape[:2]
             c = 1
         else:
-            is_mono = False
-            h, w, c = first_img.shape
+            if first_img.ndim == 2:
+                is_mono = True
+                h, w = first_img.shape
+                c = 1
+            else:
+                is_mono = False
+                h, w, c = first_img.shape
 
         # --- choose depositor ONCE (and log it) ---
-        if _kcode == 0 and drop_shrink >= 0.99:
-            # square + pixfrac≈1 → naive “one-to-one” deposit
+        use_kernelized = not (_kcode == 0 and drop_shrink >= 0.99)
+
+        if not use_kernelized:
             deposit_func = drizzle_deposit_numba_naive if is_mono else drizzle_deposit_color_naive
             kinf = "naive (square, pixfrac≈1)"
         else:
-            # Any other case → kernelized path (square/circular/gaussian)
             deposit_func = drizzle_deposit_numba_kernel_mono if is_mono else drizzle_deposit_color_kernel
             kinf = ["square", "circular", "gaussian"][_kcode]
-        log(f"Using {kinf} kernel drizzle ({'mono' if is_mono else 'color'}).")
 
-        # --- allocate buffers ---
+        log(f"Using {kinf} drizzle ({'mono' if is_mono else 'color'}).")
+
+        # ---- allocate buffers ----
         out_h = int(canvas_H)
         out_w = int(canvas_W)
         drizzle_buffer  = np.zeros((out_h, out_w) if is_mono else (out_h, out_w, c), dtype=self._dtype())
         coverage_buffer = np.zeros_like(drizzle_buffer, dtype=self._dtype())
         finalize_func   = finalize_drizzle_2d if is_mono else finalize_drizzle_3d
 
-        def _invert_2x3(A23: np.ndarray) -> np.ndarray:
-            A23 = np.asarray(A23, np.float32).reshape(2, 3)
-            A33 = np.eye(3, dtype=np.float32); A33[:2] = A23
-            return np.linalg.inv(A33)  # 3x3
+        # ---- main loop over ENTRIES ----
+        # each entry: {"orig": <original path>, "aligned": <aligned path>, "chan": "R"/"G"/None}
+        for i, ent in enumerate(entries):
+            orig_file = os.path.normpath(ent.get("orig", ""))
+            aligned_file = os.path.normpath(ent.get("aligned", ""))  # this is what rejections/weights reference
+            chan = ent.get("chan", None)
 
-        def _apply_H_point(H: np.ndarray, x: float, y: float) -> tuple[int, int]:
-            v = H @ np.array([x, y, 1.0], dtype=np.float32)
-            if abs(v[2]) < 1e-8:
-                return (int(round(v[0])), int(round(v[1])))
-            return (int(round(v[0] / v[2])), int(round(v[1] / v[2])))
-
-
-        # --- main loop ---
-        # Map original (normalized) → aligned path (for weights & rejection map lookups)
-        orig_to_aligned = {}
-        for op in original_list:
-            ap = transforms_dict.get(os.path.normpath(op))
-            if ap:
-                orig_to_aligned[os.path.normpath(op)] = os.path.normpath(ap)
-
-        for orig_file in original_list:
-            orig_key = os.path.normpath(orig_file)
-            aligned_file = orig_to_aligned.get(orig_key)
+            if not orig_file or not aligned_file:
+                log(f"⚠️ Bad drizzle entry (missing orig/aligned) – skipping: {ent}")
+                continue
 
-            weight = frame_weights.get(aligned_file, frame_weights.get(orig_key, 1.0))
+            # Weight: prefer aligned key (that matches your rejection/weights mapping)
+            weight = frame_weights.get(aligned_file, frame_weights.get(orig_file, 1.0))
 
-            kind, X = xforms.get(orig_key, (None, None))
-            log(f"🧭 Drizzle uses {kind or '-'} for {os.path.basename(orig_key)}")
+            kind, X = xforms.get(orig_file, (None, None))
+            log(f"🧭 Drizzle uses {kind or '-'} for {os.path.basename(orig_file)} (chan={chan or 'all'})")
             if kind is None:
                 log(f"⚠️ No usable transform for {os.path.basename(orig_file)} – skipping")
                 continue
 
-            # --- choose pixel source + mapping ---
+            # choose pixel source + mapping
             pixels_are_registered = False
             img_data = None
 
-            if isinstance(kind, str) and (kind.startswith("poly") or kind in ("tps","thin_plate_spline")):
+            if isinstance(kind, str) and (kind.startswith("poly") or kind in ("tps", "thin_plate_spline")):
                 # Already warped to reference during registration
                 pixel_path = aligned_file
                 if not pixel_path:
@@ -18784,6 +18991,7 @@ class StackingSuiteDialog(QDialog):
                 pixels_are_registered = True
 
             elif kind == "affine" and X is not None:
+                # Use ORIGINAL pixels + affine subpixel mapping
                 pixel_path = orig_file
                 H_canvas = np.eye(3, dtype=np.float32)
                 H_canvas[:2] = np.asarray(X, np.float32).reshape(2, 3)
@@ -18796,6 +19004,7 @@ class StackingSuiteDialog(QDialog):
                     log(f"⚠️ Failed to read {os.path.basename(pixel_path)} – skipping")
                     continue
                 H = np.asarray(X, np.float32).reshape(3, 3)
+
                 if raw_img.ndim == 2:
                     img_data = cv2.warpPerspective(
                         raw_img, H, (ref_W, ref_H),
@@ -18810,6 +19019,7 @@ class StackingSuiteDialog(QDialog):
                             borderMode=cv2.BORDER_CONSTANT, borderValue=0
                         ) for ch in range(raw_img.shape[2])
                     ], axis=2)
+
                 H_canvas = np.eye(3, dtype=np.float32)
                 pixels_are_registered = True
 
@@ -18824,28 +19034,43 @@ class StackingSuiteDialog(QDialog):
                     log(f"⚠️ Failed to read {os.path.basename(pixel_path)} – skipping")
                     continue
 
-            # --- debug bbox once ---
-            if orig_file is original_list[0]:
-                x0, y0 = 0, 0; x1, y1 = ref_W-1, ref_H-1
+            # If this is a split dual-band entry, extract channel from the pixel source
+            if chan in ("R", "G", "B"):
+                if img_data.ndim == 3 and img_data.shape[2] >= 3:
+                    ch_idx = {"R": 0, "G": 1, "B": 2}[chan]
+                    img_data = img_data[..., ch_idx]  # mono plane
+                # if already mono, leave it alone
+
+            # Debug bbox once
+            if i == 0:
+                x0, y0 = 0, 0
+                x1, y1 = ref_W - 1, ref_H - 1
                 p0 = H_canvas @ np.array([x0, y0, 1], np.float32); p0 /= max(p0[2], 1e-8)
                 p1 = H_canvas @ np.array([x1, y1, 1], np.float32); p1 /= max(p1[2], 1e-8)
-                log(f"   bbox(ref)→reg: ({p0[0]:.1f},{p0[1]:.1f}) to ({p1[0]:.1f},{p1[1]:.1f}); "
-                    f"canvas {int(ref_W*scale_factor)}×{int(ref_H*scale_factor)} @ {scale_factor}×")
+                log(
+                    f"   bbox(ref)→reg: ({p0[0]:.1f},{p0[1]:.1f}) to ({p1[0]:.1f},{p1[1]:.1f}); "
+                    f"canvas {int(ref_W * scale_factor)}×{int(ref_H * scale_factor)} @ {scale_factor}×"
+                )
 
-            # --- apply per-file rejections ---
+            # ---- apply per-file rejections (lookup by ALIGNED file) ----
             if rejection_map and aligned_file in rejection_map:
                 coords_for_this_file = rejection_map.get(aligned_file, [])
                 if coords_for_this_file:
                     dilate_px = int(self.settings.value("stacking/reject_dilate_px", 0, type=int))
-                    dilate_shape = self.settings.value("stacking/reject_dilate_shape", "square", type=str).lower()
+                    dilate_shape = (self.settings.value("stacking/reject_dilate_shape", "square", type=str) or "square").lower()
+
                     offsets = [(0, 0)]
                     if dilate_px > 0:
                         r = dilate_px
-                        offsets = [(dx, dy) for dx in range(-r, r+1) for dy in range(-r, r+1)]
+                        offsets = [(dx, dy) for dx in range(-r, r + 1) for dy in range(-r, r + 1)]
                         if dilate_shape.startswith("dia"):
-                            offsets = [(dx, dy) for (dx,dy) in offsets if (abs(dx)+abs(dy) <= r)]
+                            offsets = [(dx, dy) for (dx, dy) in offsets if (abs(dx) + abs(dy) <= r)]
 
-                    Hraw, Wraw = img_data.shape[0], img_data.shape[1]
+                    # after optional channel extraction, img_data may be 2D
+                    if img_data.ndim == 2:
+                        Hraw, Wraw = img_data.shape
+                    else:
+                        Hraw, Wraw = img_data.shape[0], img_data.shape[1]
 
                     if pixels_are_registered:
                         # Directly zero registered pixels
@@ -18853,9 +19078,12 @@ class StackingSuiteDialog(QDialog):
                             for (ox, oy) in offsets:
                                 xr, yr = x_r + ox, y_r + oy
                                 if 0 <= xr < Wraw and 0 <= yr < Hraw:
-                                    img_data[yr, xr] = 0.0
+                                    if img_data.ndim == 2:
+                                        img_data[yr, xr] = 0.0
+                                    else:
+                                        img_data[yr, xr, :] = 0.0
                     else:
-                        # Back-project via inverse affine
+                        # Back-project via inverse affine (H_canvas)
                         Hinv = np.linalg.inv(H_canvas)
                         for (x_r, y_r) in coords_for_this_file:
                             for (ox, oy) in offsets:
@@ -18864,35 +19092,43 @@ class StackingSuiteDialog(QDialog):
                                 x_raw = int(round(v[0] / max(v[2], 1e-8)))
                                 y_raw = int(round(v[1] / max(v[2], 1e-8)))
                                 if 0 <= x_raw < Wraw and 0 <= y_raw < Hraw:
-                                    img_data[y_raw, x_raw] = 0.0
+                                    if img_data.ndim == 2:
+                                        img_data[y_raw, x_raw] = 0.0
+                                    else:
+                                        img_data[y_raw, x_raw, :] = 0.0
+
+            # ---- deposit ----
+            A23 = H_canvas[:2, :]
 
-            # --- deposit (identity for registered pixels) ---
             if deposit_func is drizzle_deposit_numba_naive:
                 drizzle_buffer, coverage_buffer = deposit_func(
-                    img_data, H_canvas[:2], drizzle_buffer, coverage_buffer, scale_factor, weight
+                    img_data, A23, drizzle_buffer, coverage_buffer,
+                    scale_factor, weight
                 )
+
             elif deposit_func is drizzle_deposit_color_naive:
                 drizzle_buffer, coverage_buffer = deposit_func(
-                    img_data, H_canvas[:2], drizzle_buffer, coverage_buffer, scale_factor, drop_shrink, weight
+                    img_data, A23, drizzle_buffer, coverage_buffer,
+                    scale_factor, drop_shrink, weight
                 )
+
             else:
-                A23 = H_canvas[:2, :]
+                # kernel mono OR kernel color
                 drizzle_buffer, coverage_buffer = deposit_func(
                     img_data, A23, drizzle_buffer, coverage_buffer,
                     scale_factor, drop_shrink, weight, _kcode, float(gauss_sigma)
                 )
 
-
-        # --- finalize, save, optional autocrop ---
+        # ---- finalize ----
         final_drizzle = np.zeros_like(drizzle_buffer, dtype=np.float32)
         final_drizzle = finalize_func(drizzle_buffer, coverage_buffer, final_drizzle)
 
-        # Save original drizzle (single-HDU; no rejection layers here)
+        # ---- save (single-HDU; no rejection layers here) ----
         Hd, Wd = final_drizzle.shape[:2] if final_drizzle.ndim >= 2 else (0, 0)
         display_group_driz = self._label_with_dims(group_key, Wd, Hd)
         base_stem = f"MasterLight_{display_group_driz}_{len(file_list)}stacked_drizzle"
-        base_stem = self._normalize_master_stem(base_stem) 
-        out_path_orig = self._build_out(self.stacking_directory, base_stem, "fit")
+        base_stem = self._normalize_master_stem(base_stem)
+        out_path_orig = self._build_out(self._master_light_dir(), base_stem, "fit")
 
         hdr_orig = hdr.copy() if hdr is not None else fits.Header()
         hdr_orig["IMAGETYP"]   = "MASTER STACK - DRIZZLE"
@@ -18929,7 +19165,7 @@ class StackingSuiteDialog(QDialog):
         )
         log(f"✅ Drizzle (original) saved: {out_path_orig}")
 
-        # Optional auto-crop (respects global rect if provided)
+        # ---- optional auto-crop ----
         if autocrop_enabled:
             cropped_drizzle, hdr_crop = self._apply_autocrop(
                 final_drizzle,
@@ -18939,12 +19175,14 @@ class StackingSuiteDialog(QDialog):
                 rect_override=rect_override
             )
             hdr_crop["NCOMBINE"] = (n_frames, "Number of frames combined")
-            hdr_crop["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")            
+            hdr_crop["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")
+
             is_mono_crop = (cropped_drizzle.ndim == 2)
             display_group_driz_crop = self._label_with_dims(group_key, cropped_drizzle.shape[1], cropped_drizzle.shape[0])
             base_crop = f"MasterLight_{display_group_driz_crop}_{len(file_list)}stacked_drizzle_autocrop"
-            base_crop = self._normalize_master_stem(base_crop) 
-            out_path_crop = self._build_out(self.stacking_directory, base_crop, "fit")
+            base_crop = self._normalize_master_stem(base_crop)
+            out_path_crop = self._build_out(self._master_light_dir(), base_crop, "fit")
+
             cropped_drizzle = self._normalize_stack_01(cropped_drizzle)
             save_image(
                 img_array=cropped_drizzle,
@@ -18958,6 +19196,7 @@ class StackingSuiteDialog(QDialog):
                 self._autocrop_outputs = []
             self._autocrop_outputs.append((group_key, out_path_crop))
             log(f"✂️ Drizzle (auto-cropped) saved: {out_path_crop}")
+        return True
 
     def _load_sasd_v2(self, path: str):
         """