diff --git a/WARP.md b/WARP.md
new file mode 100644
index 0000000..d5ab2f7
--- /dev/null
+++ b/WARP.md
@@ -0,0 +1,223 @@
+# WARP.md
+
+This file provides guidance to WARP (warp.dev) when working with code in this repository.
+
+## Project Overview
+
+FastStack is an ultra-fast JPEG viewer for Windows designed for culling and selecting RAW files for focus stacking. It displays JPEGs as proxies for RAW files, optimized for instant next/prev navigation, smooth zoom/pan, and integration with Helicon Focus for processing focus stacks.
+
+**Key Technologies:**
+- Python 3.11+ with PySide6 (Qt6) for UI
+- Qt Quick (QML) for the rendering layer
+- PyTurboJPEG (libjpeg-turbo) for fast JPEG decoding
+- Byte-aware LRU caching for image data
+- ThreadPoolExecutor for concurrent prefetching
+
+## Development Commands
+
+### Running the Application
+
+```powershell
+# Development run with path argument
+python -m faststack.app "C:\path\to\images"
+
+# Or from the inner faststack directory
+python -m faststack.app "C:\path\to\images"
+
+# Run from the installed package entry point (if installed)
+faststack "C:\path\to\images"
+```
+
+### Testing
+
+```powershell
+# Run all tests
+pytest
+
+# Run tests from the faststack directory
+pytest faststack/faststack/tests
+
+# Run specific test file
+pytest faststack/faststack/tests/test_cache.py
+
+# Run with verbose output
+pytest -v
+```
+
+### Building Distribution
+
+```powershell
+# Build standalone Windows executable using PyInstaller
+pyinstaller faststack/faststack.spec
+
+# Output will be in dist/FastStack/FastStack.exe
+```
+
+### Installing Dependencies
+
+```powershell
+# Install from requirements.txt (preferred for dev)
+pip install -r faststack/requirements.txt
+
+# Or install the package in editable mode
+pip install -e faststack/
+```
+
+## Architecture
+
+### Core Module Structure
+
+The codebase follows a modular architecture split into distinct concerns:
+
+**faststack/faststack/** (main package):
+- `app.py` - Main entry point, `AppController` manages application state and coordinates all subsystems
+- `config.py` - Configuration management via INI file (`%APPDATA%\faststack\faststack.ini`)
+- `models.py` - Core data models (`ImageFile`, `EntryMetadata`, `DecodedImage`, `Sidecar`)
+- `logging_setup.py` - Application logging setup
+
+**faststack/faststack/imaging/** - Image processing and caching:
+- `jpeg.py` - JPEG decoding with PyTurboJPEG (fallback to Pillow), supports resized decoding
+- `cache.py` - Byte-aware LRU cache (`ByteLRUCache`) that tracks memory usage in bytes
+- `prefetch.py` - Background prefetching using `ThreadPoolExecutor` with generation-based cancellation
+
+**faststack/faststack/io/** - I/O operations:
+- `indexer.py` - Directory scanning, JPG→RAW pairing by stem and timestamp proximity (±2s)
+- `sidecar.py` - Manages `faststack.json` sidecar file with atomic writes
+- `watcher.py` - Filesystem watching for directory changes
+- `helicon.py` - Launches Helicon Focus with selected RAW files
+
+**faststack/faststack/ui/** - UI components:
+- `provider.py` - `ImageProvider` for Qt image handling, `UIState` for QML bindings
+- `keystrokes.py` - Keyboard event handling (`Keybinder`)
+
+**faststack/faststack/qml/** - QML UI files:
+- `Main.qml` - Main window and image viewer
+- `Components.qml` - Reusable QML components
+- `SettingsDialog.qml` - Settings dialog
+- `FilterDialog.qml` - Filtering interface
+
+### Key Architectural Patterns
+
+#### 1. Two-Tier Caching with Display-Aware Prefetching
+
+The app uses a sophisticated caching strategy:
+- **Display generation tracking**: When window size or zoom state changes, `display_generation` increments, invalidating cached images
+- **Cache keys**: Format `{index}_{display_generation}` ensures stale images are not reused
+- **Prefetch radius**: Configurable (default 4), decodes images at indices `[i-N, i+N]`
+- **Generation-based cancellation**: When navigating, `prefetcher.generation` increments, and workers check this before caching to avoid stale work
+
+#### 2. Zero-Copy Image Pipeline
+
+To minimize memory overhead:
+- JPEG decoding produces contiguous `numpy` arrays (uint8, h×w×3)
+- QImage is created with a direct pointer to the numpy buffer (`QImage(buf, w, h, w*3, Format_RGB888)`)
+- The numpy array reference is kept alive for the QImage lifetime to prevent dangling pointers
+- This approach is implemented via `DecodedImage.buffer` which stores a `memoryview`
+
+#### 3. RAW-JPG Pairing Logic
+
+`indexer.py` pairs JPEGs with RAWs by:
+1. Scanning directory for JPGs and RAWs
+2. Matching by stem (e.g., `IMG_0123.JPG` → `IMG_0123.CR3`)
+3. Validating timestamp proximity (±2 seconds) to handle burst shooting
+4. Supporting multiple RAW formats: `.CR3`, `.CR2`, `.ARW`, `.NEF`, `.ORF`, `.RW2`, `.RAF`, `.DNG`
+
+#### 4. Sidecar Metadata Management
+
+All user edits are non-destructive, stored in `faststack.json`:
+- Schema version 2 format
+- Tracks: flags, rejections, stack IDs, stacking status/date
+- Atomic writes: write to temp file, then replace
+- Filesystem watcher paused during writes to avoid recursion
+
+#### 5. Performance Optimizations
+
+Key techniques for sub-10ms cache hits:
+- **Memory-mapped file I/O**: `mmap` for faster JPEG loading
+- **PyTurboJPEG scaling factors**: Use hardware-accelerated downscaling (1/8, 1/4, 1/2) before Pillow resizing
+- **Debounced resize handling**: 150ms debounce for window resize events
+- **Optimal thread pool sizing**: `min(cpu_count() * 2, 8)` workers for I/O-bound JPEG decoding
+- **Selective cache clearing**: Only clear when display dimensions or zoom state changes
+- **BILINEAR resampling**: For large downscales (>4x), use faster BILINEAR instead of LANCZOS
+
+## Development Guidelines
+
+### Adding New Keyboard Shortcuts
+
+Edit `ui/keystrokes.py` (`Keybinder.handle_key_press()`) to add new key bindings. The method maps Qt key events to AppController methods.
+
+### Modifying Cache Behavior
+
+The cache size and prefetch radius are configurable in `%APPDATA%\faststack\faststack.ini`:
+```ini
+[core]
+cache_size_gb = 1.5
+prefetch_radius = 4
+```
+
+Access via `config.getfloat('core', 'cache_size_gb')` or `config.getint('core', 'prefetch_radius')`.
+
+### Adding Support for New RAW Formats
+
+Add extensions to `RAW_EXTENSIONS` set in `io/indexer.py`:
+```python
+RAW_EXTENSIONS = {
+    ".ORF", ".RW2", ".CR2", ".CR3", ".ARW", ".NEF", ".RAF", ".DNG",
+    ".orf", ".rw2", ".cr2", ".cr3", ".arw", ".nef", ".raf", ".dng",
+}
+```
+
+### Extending Sidecar Metadata
+
+To add new metadata fields:
+1. Update `EntryMetadata` dataclass in `models.py`
+2. Update `Sidecar.version` in `models.py` if breaking changes
+3. Handle migration logic in `SidecarManager.load()` in `io/sidecar.py`
+
+### Working with the UI (QML)
+
+- QML files are in `qml/` directory
+- `Main.qml` is the entry point, connected to `AppController` via Qt signals/slots
+- UI state is exposed via `UIState` object in `ui/provider.py`
+- Use `@Slot` decorator for methods callable from QML
+- Emit `dataChanged` signal from AppController to trigger UI updates
+
+### PyInstaller Builds
+
+The `faststack.spec` file handles packaging:
+- Collects all PySide6 data files
+- Includes turbojpeg binaries from `turbojpeg.lib_path`
+- Adds hidden imports for `PySide6.QtQml`
+- Produces single-folder distribution in `dist/FastStack/`
+
+To add resources or fix missing imports, edit `faststack.spec`.
+
+## Common Pitfalls
+
+### Image Decode Performance Issues
+
+If decoding is slow:
+- Verify PyTurboJPEG is installed correctly (check logs for "PyTurboJPEG is available")
+- Check if `turbojpeg.dll` is found (Windows) - should be in PyInstaller build
+- Consider increasing prefetch radius for smoother navigation at cost of memory
+
+### Cache Not Invalidating on Window Resize
+
+The app uses debounced resize handling. If cache seems stale:
+- Check `display_generation` is incrementing (logged as "Display size changed to...")
+- Verify `cache_key = f"{index}_{display_generation}"` format in `prefetch.py`
+- Ensure `sync_ui_state()` is called after generation increment
+
+### Sidecar File Corruption
+
+If `faststack.json` becomes corrupted:
+- The app will log error and start with empty sidecar
+- Consider implementing backup strategy in `SidecarManager.save()`
+- Version number mismatch triggers fresh start
+
+### Threading Issues with Prefetcher
+
+When adding features that interact with the prefetcher:
+- Always increment `generation` when invalidating work
+- Check `self.generation != local_generation` before cache operations
+- Use `cancel_all()` before clearing image list or display changes
diff --git a/docs/COLOR_PROFILE_FIX.md b/docs/COLOR_PROFILE_FIX.md
new file mode 100644
index 0000000..54e2e69
--- /dev/null
+++ b/docs/COLOR_PROFILE_FIX.md
@@ -0,0 +1,121 @@
+# ICC Color Profile Support - Fix for Oversaturated Colors
+
+## Problem
+Images displayed in FastStack appeared overly bright and "cartoonish" compared to the same images viewed in Photoshop. The colors looked unrealistic and oversaturated.
+
+## Root Cause
+**FastStack was ignoring embedded ICC color profiles in JPEG files.**
+
+When digital cameras or photo editing software save JPEG files, they often embed an ICC (International Color Consortium) color profile that describes the color space of the image. Common profiles include:
+- **sRGB** - Standard RGB, most common for web and general use
+- **Adobe RGB (1998)** - Wider gamut, common in professional photography
+- **ProPhoto RGB** - Even wider gamut, used in high-end photography
+
+The raw pixel values in a JPEG are meaningless without knowing what color space they're in. For example:
+- RGB value (255, 0, 0) in sRGB is a different red than (255, 0, 0) in Adobe RGB
+- Adobe RGB can represent more saturated colors than sRGB
+
+### What Was Happening
+1. **Photoshop** reads the embedded ICC profile and correctly transforms colors to the display's color space (usually sRGB)
+2. **FastStack (before fix)** was decoding JPEGs and displaying the raw pixel values without any color transformation
+3. This caused colors to appear incorrect - typically oversaturated and too bright
+
+### Technical Details
+Both TurboJPEG and Pillow's basic `Image.open()` extract raw RGB pixel values but **do not** automatically apply ICC profile transformations. The embedded profile is available via `Image.info['icc_profile']`, but must be explicitly processed.
+
+## Solution
+Added proper ICC color management to the JPEG decoding pipeline using Pillow's `ImageCms` module (which wraps the industry-standard LittleCMS2 library).
+
+### Changes Made to `faststack/imaging/jpeg.py`
+
+1. **Added ICC Profile Support Functions:**
+   - `_get_srgb_profile()` - Creates/caches an sRGB display profile
+   - `_apply_icc_profile(img)` - Transforms images from their embedded color space to sRGB
+
+2. **Updated All Decode Functions:**
+   - `decode_jpeg_rgb()` - Now applies ICC transformation
+   - `decode_jpeg_thumb_rgb()` - Now applies ICC transformation  
+   - `decode_jpeg_resized()` - Now applies ICC transformation BEFORE resizing
+
+3. **Color Transformation Process:**
+   ```python
+   # 1. Open JPEG and read embedded ICC profile
+   img = Image.open(io.BytesIO(jpeg_bytes))
+   
+   # 2. Extract embedded profile from image metadata
+   source_profile = ImageCms.ImageCmsProfile(io.BytesIO(img.info['icc_profile']))
+   
+   # 3. Create sRGB display profile
+   srgb_profile = ImageCms.createProfile('sRGB')
+   
+   # 4. Transform from source color space to sRGB for display
+   img_converted = ImageCms.profileToProfile(
+       img, 
+       source_profile, 
+       srgb_profile,
+       renderingIntent=ImageCms.Intent.PERCEPTUAL
+   )
+   ```
+
+4. **Rendering Intent:**
+   We use `PERCEPTUAL` rendering intent, which is designed for photographic images and preserves the overall appearance while mapping out-of-gamut colors intelligently.
+
+### Hybrid Approach: Best of Both Worlds
+The implementation uses a **hybrid approach** that combines speed and accuracy:
+
+1. **ICC Profile Extraction**: First, Pillow quickly extracts the ICC profile metadata (very fast, no full decode)
+2. **Fast Decoding**: TurboJPEG decodes the raw pixel data at maximum speed
+3. **Color Transformation**: If an ICC profile exists, transform the decoded array to sRGB using ImageCms
+4. **Smart Caching**: ICC profiles and transformations are cached - when all photos in a directory use the same profile (typical for camera photos), only the first image pays the full cost
+
+This gives us:
+- ✅ **Fast decoding** with TurboJPEG (2-3x faster than Pillow for large images)
+- ✅ **Accurate colors** with proper ICC profile handling
+- ✅ **Smart caching** - 2.3x faster color transformation for subsequent images with same profile
+- ✅ **Fallback to Pillow** if TurboJPEG is unavailable or fails
+
+### Performance Impact
+
+**First image with a new ICC profile (cold cache):**
+- ICC profile extraction: ~0.5ms (metadata-only read)
+- Profile object creation: ~5ms
+- Transform creation: ~7ms
+- Color transformation: ~10ms
+- **Total overhead**: ~22ms
+
+**Subsequent images with same ICC profile (warm cache):**
+- ICC profile extraction: ~0.5ms
+- Profile hash lookup: <0.1ms
+- Cached transform application: ~9ms
+- **Total overhead**: ~10ms
+- **Speedup**: 2.3x faster than cold cache
+
+**Images without ICC profiles:**
+- No overhead at all - uses raw decoded data
+
+**Real-world scenario:**
+- A typical photo shoot with 100 images from the same camera:
+  - First image: 22ms overhead
+  - Next 99 images: 10ms overhead each
+  - Average: 10.1ms per image
+- Without caching, every image would be 22ms
+
+## Testing
+Run `test_icc.py` to verify ICC profile handling:
+```bash
+python test_icc.py <path_to_jpeg>
+```
+
+The test will:
+1. Check if the JPEG has an embedded ICC profile
+2. Decode it with color management
+3. Display statistics about the decoded image
+
+## References
+- [ICC Color Management](https://en.wikipedia.org/wiki/ICC_profile)
+- [Pillow ImageCms Documentation](https://pillow.readthedocs.io/en/stable/reference/ImageCms.html)
+- [LittleCMS](https://www.littlecms.com/)
+- [Understanding Color Spaces](https://www.cambridgeincolour.com/tutorials/color-spaces.htm)
+
+## Result
+Images now display with accurate, natural-looking colors that match what you see in Photoshop and other color-managed applications.
diff --git a/faststack/ChangeLog.md b/faststack/ChangeLog.md
index dd070ad..f8b38cc 100644
--- a/faststack/ChangeLog.md
+++ b/faststack/ChangeLog.md
@@ -1,5 +1,41 @@
 # ChangeLog
 
+## [0.7.0] - 2025-11-20
+
+### Added
+- **High-DPI Display Support:** Images now render at full physical pixel resolution on 4K displays by accounting for `devicePixelRatio` in display size calculations.
+- **Ctrl+0 Zoom Reset:** Added keyboard shortcut to reset zoom and pan to fit window (like Photoshop), with visual feedback.
+- **Active Filter Indicator:** Footer now displays active filename filter in yellow bold text for better visibility.
+- **Directory Path Display:** Title bar now shows the current working directory path, centered between menu and window controls.
+- **WARP.md Documentation:** Created comprehensive development guide for Warp AI assistant with architecture, commands, and development patterns.
+
+### Security
+- **Executable Path Validation:** Added comprehensive validation for Photoshop and Helicon Focus executables:
+  - Validates executable exists and is in safe location (Program Files)
+  - Checks file type (.exe on Windows)
+  - Warns about executables outside known safe paths
+  - Detects directory traversal attempts
+- **Subprocess Security Hardening:**
+  - Replaced unsafe `.split()` with `shlex.split()` for proper argument parsing
+  - Explicitly set `shell=False` to prevent shell injection attacks
+  - Added file descriptor management (`stdin`, `stdout`, `stderr` redirection)
+  - Validates file paths before subprocess execution
+  - Uses `close_fds=True` to prevent information leakage
+- **Input Validation:** Added pre-execution validation for image file paths in both Photoshop and Helicon Focus launchers.
+
+### Fixed
+- **Property Name Mismatch:** Corrected `get_stack_summary` to `stackSummary` in UIState to match QML property naming conventions.
+- **FilterDialog Theme Support:** Enhanced FilterDialog with proper Material theme support and background styling for consistent dark/light mode appearance.
+- **Missing Signal Emissions:** Added `stackSummaryChanged` signal emission when stacks are created, cleared, or processed.
+
+### Changed
+- **Improved Error Handling:** Replaced broad `Exception` catches with specific exception types (`OSError`, `subprocess.SubprocessError`, `FileNotFoundError`, `IOError`, `PermissionError`).
+- **Better Logging:** Changed `log.error()` to `log.exception()` to include full tracebacks for debugging.
+- **Argument Parsing:** Now uses `shlex.split()` with platform-aware parsing (Windows vs POSIX) for proper handling of quoted paths and special characters.
+
+### Testing
+- **Executable Validator Tests:** Added comprehensive test suite for executable path validation with 8 test cases covering various security scenarios.
+
 ## [0.6.0] - 2025-11-03
 
 ### Fixed
diff --git a/faststack/README.md b/faststack/README.md
index 7a65297..8f2ce7e 100644
--- a/faststack/README.md
+++ b/faststack/README.md
@@ -17,6 +17,11 @@ This tool is optimized for speed, using `libjpeg-turbo` for decoding, aggressive
 - **Helicon Focus Integration:** Launch Helicon Focus with your selected RAW files with a single keypress (`Enter`).
 - **Sidecar Metadata:** Saves flags, rejections, and stack groupings to a non-destructive `faststack.json` file.
 - **Configurable:** Adjust cache sizes, prefetch behavior, and Helicon Focus path via a settings dialog and a persistent `.ini` file.
+- **Photoshop Integration:** Edit current image in Photoshop (E key)
+- **Clipboard Support:** Copy image path to clipboard (Ctrl+C)
+- **Image Filtering:** Filter images by filename
+- **Drag & Drop:** Drag images to external applications
+- **Theme Support:** Toggle between light and dark themes
 
 ## Installation & Usage
 
@@ -41,3 +46,6 @@ This tool is optimized for speed, using `libjpeg-turbo` for decoding, aggressive
 - `Space`: Toggle Flag
 - `X`: Toggle Reject
 - `Enter`: Launch Helicon Focus with selected RAWs
+- `E`: Edit in Photoshop
+- `Ctrl+C`: Copy image path to clipboard
+- `C`: Clear all stacks
diff --git a/faststack/faststack.egg-info/PKG-INFO b/faststack/faststack.egg-info/PKG-INFO
new file mode 100644
index 0000000..832e8b8
--- /dev/null
+++ b/faststack/faststack.egg-info/PKG-INFO
@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: faststack
+Version: 0.6
+Summary: Ultra-fast JPG Viewer for Focus Stacking Selection
+Author-email: Alan Rockefeller <alanrockefeller@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6<7.0,>=6.0
+Requires-Dist: PyTurboJPEG<2.0,>=1.8
+Requires-Dist: numpy<3.0,>=2.0
+Requires-Dist: cachetools<6.0,>=5.0
+Requires-Dist: watchdog<5.0,>=4.0
+Requires-Dist: typer<1.0,>=0.12
+Requires-Dist: Pillow<11.0,>=10.0
+Requires-Dist: pytest<9.0,>=8.0
+Dynamic: license-file
+
+# FastStack
+
+# Version 0.4 - November 2, 2025
+# By Alan Rockefeller
+
+Ultra-fast, caching JPG viewer designed for culling and selecting RAW files for focus stacking.
+
+This tool is optimized for speed, using `libjpeg-turbo` for decoding, aggressive prefetching, and byte-aware LRU caches to provide a fluid experience when reviewing thousands of images.
+
+## Features
+
+- **Instant Navigation:** Sub-10ms next/previous image switching on cache hits.
+- **High-Performance Decoding:** Uses `PyTurboJPEG` for fast JPEG decoding, with a fallback to `Pillow`.
+- **Zoom & Pan:** Smooth, mipmapped zooming and panning.
+- **RAW Pairing:** Automatically maps JPGs to their corresponding RAW files (`.CR3`, `.ARW`, `.NEF`, etc.).
+- **Stack Selection:** Group images into stacks (`[`, `]`) and select them for processing (`S`).
+- **Helicon Focus Integration:** Launch Helicon Focus with your selected RAW files with a single keypress (`Enter`).
+- **Sidecar Metadata:** Saves flags, rejections, and stack groupings to a non-destructive `faststack.json` file.
+- **Configurable:** Adjust cache sizes, prefetch behavior, and Helicon Focus path via a settings dialog and a persistent `.ini` file.
+
+## Installation & Usage
+
+1.  **Install Dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+2.  **Run the App:**
+    ```bash
+    python -m faststack.app "C:\path\to\your\images"
+    ```
+
+## Keyboard Shortcuts
+
+- `J` / `Right Arrow`: Next Image
+- `K` / `Left Arrow`: Previous Image
+- `G`: Toggle Grid View
+- `S`: Toggle selection of current image for stacking
+- `[`: Begin new stack group
+- `]`: End current stack group
+- `Space`: Toggle Flag
+- `X`: Toggle Reject
+- `Enter`: Launch Helicon Focus with selected RAWs
diff --git a/faststack/faststack.egg-info/SOURCES.txt b/faststack/faststack.egg-info/SOURCES.txt
new file mode 100644
index 0000000..49773ce
--- /dev/null
+++ b/faststack/faststack.egg-info/SOURCES.txt
@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+faststack/__init__.py
+faststack/app.py
+faststack/config.py
+faststack/logging_setup.py
+faststack/models.py
+faststack.egg-info/PKG-INFO
+faststack.egg-info/SOURCES.txt
+faststack.egg-info/dependency_links.txt
+faststack.egg-info/entry_points.txt
+faststack.egg-info/requires.txt
+faststack.egg-info/top_level.txt
\ No newline at end of file
diff --git a/faststack/faststack.egg-info/dependency_links.txt b/faststack/faststack.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/faststack/faststack.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/faststack/faststack.egg-info/entry_points.txt b/faststack/faststack.egg-info/entry_points.txt
new file mode 100644
index 0000000..31dfe0b
--- /dev/null
+++ b/faststack/faststack.egg-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+faststack = faststack.app:main
diff --git a/faststack/faststack.egg-info/requires.txt b/faststack/faststack.egg-info/requires.txt
new file mode 100644
index 0000000..5694239
--- /dev/null
+++ b/faststack/faststack.egg-info/requires.txt
@@ -0,0 +1,8 @@
+PySide6<7.0,>=6.0
+PyTurboJPEG<2.0,>=1.8
+numpy<3.0,>=2.0
+cachetools<6.0,>=5.0
+watchdog<5.0,>=4.0
+typer<1.0,>=0.12
+Pillow<11.0,>=10.0
+pytest<9.0,>=8.0
diff --git a/faststack/faststack.egg-info/top_level.txt b/faststack/faststack.egg-info/top_level.txt
new file mode 100644
index 0000000..81352aa
--- /dev/null
+++ b/faststack/faststack.egg-info/top_level.txt
@@ -0,0 +1 @@
+faststack
diff --git a/faststack/faststack/app.py b/faststack/faststack/app.py
index 80137d0..b150ac3 100644
--- a/faststack/faststack/app.py
+++ b/faststack/faststack/app.py
@@ -3,6 +3,7 @@
 import logging
 import sys
 import struct
+import shlex
 from pathlib import Path
 from typing import Optional, List, Dict
 from datetime import date
@@ -35,12 +36,12 @@
 from faststack.io.sidecar import SidecarManager
 from faststack.io.watcher import Watcher
 from faststack.io.helicon import launch_helicon_focus
+from faststack.io.executable_validator import validate_executable_path
 from faststack.imaging.cache import ByteLRUCache, get_decoded_image_size
 from faststack.imaging.prefetch import Prefetcher
 from faststack.ui.provider import ImageProvider
 from faststack.ui.keystrokes import Keybinder
 
-
 def make_hdrop(paths):
     """
     Build a real CF_HDROP (DROPFILES) payload for Windows drag-and-drop.
@@ -129,6 +130,7 @@ def apply_filter(self, filter_string: str):
         self._filter_enabled = True
         self.refresh_image_list()
         self.dataChanged.emit()
+        self.ui_state.filterStringChanged.emit()  # Notify UI of filter change
 
         # reset to start of filtered list
         self.current_index = 0
@@ -148,6 +150,7 @@ def clear_filter(self):
         self._filter_string = ""
         self.refresh_image_list()
         self.dataChanged.emit()
+        self.ui_state.filterStringChanged.emit()  # Notify UI of filter change
         self.current_index = min(self.current_index, max(0, len(self.image_files) - 1))
         self.sync_ui_state()
         self.prefetcher.update_prefetch(self.current_index)
@@ -171,7 +174,7 @@ def on_display_size_changed(self, width: int, height: int):
 
     def _handle_resize(self):
         """Actual resize handler, called after debounce period."""
-        log.info(f"Display size changed to: {self.pending_width}x{self.pending_height}")
+        log.info(f"Display size changed to: {self.pending_width}x{self.pending_height} (physical pixels)")
         self.display_width = self.pending_width
         self.display_height = self.pending_height
         self.display_generation += 1
@@ -363,6 +366,7 @@ def end_current_stack(self):
             self.stack_start_index = None
             self._metadata_cache_index = (-1, -1) # Invalidate cache
             self.dataChanged.emit() # Notify QML of data change
+            self.ui_state.stackSummaryChanged.emit() # Update stack summary in dialog
             self.sync_ui_state()
         else:
             log.warning("No stack start marked. Press '[' first.")
@@ -406,6 +410,7 @@ def launch_helicon(self):
                 else:
                     log.warning(f"No valid RAW files found for stack [{start}, {end}].")
             
+            # clear_all_stacks() already emits stackSummaryChanged
             self.clear_all_stacks()
 
         else:
@@ -452,6 +457,7 @@ def clear_all_stacks(self):
         self.sidecar.save()
         self._metadata_cache_index = (-1, -1) # Invalidate cache
         self.dataChanged.emit() # Notify QML of data change
+        self.ui_state.stackSummaryChanged.emit() # Update stack summary in dialog
         self.sync_ui_state()
 
     def get_helicon_path(self):
@@ -593,23 +599,61 @@ def edit_in_photoshop(self):
         photoshop_exe = config.get('photoshop', 'exe')
         photoshop_args = config.get('photoshop', 'args')
 
-        if not photoshop_exe or not Path(photoshop_exe).exists():
-            self.update_status_message("Photoshop executable not configured or not found.")
-            log.error(f"Photoshop executable not found: {photoshop_exe}")
+        # Validate executable path securely
+        is_valid, error_msg = validate_executable_path(
+            photoshop_exe,
+            app_type="photoshop",
+            allow_custom_paths=True
+        )
+        
+        if not is_valid:
+            self.update_status_message(f"Photoshop validation failed: {error_msg}")
+            log.error(f"Photoshop executable validation failed: {error_msg}")
+            return
+        
+        # Validate that the file path exists and is a file
+        if not current_image_path.exists() or not current_image_path.is_file():
+            self.update_status_message(f"Image file not found: {current_image_path.name}")
+            log.error(f"Image file not found or not a file: {current_image_path}")
             return
 
         try:
+            # Build command list safely
             command = [photoshop_exe]
+            
+            # Parse additional args safely using shlex (handles quotes and escapes properly)
             if photoshop_args:
-                command.extend(photoshop_args.split())
-            command.append(str(current_image_path))
+                try:
+                    # Use shlex to properly parse arguments with quotes/escapes
+                    # On Windows, use posix=False to handle Windows-style paths
+                    parsed_args = shlex.split(photoshop_args, posix=(os.name != 'nt'))
+                    command.extend(parsed_args)
+                except ValueError as e:
+                    log.error(f"Invalid photoshop_args format: {e}")
+                    self.update_status_message("Invalid Photoshop arguments configured")
+                    return
+            
+            # Add the file path as the last argument
+            # Convert to string but keep it as a list element (not shell-interpolated)
+            command.append(str(current_image_path.resolve()))
             
-            subprocess.Popen(command)
+            # SECURITY: Explicitly disable shell execution
+            subprocess.Popen(
+                command,
+                shell=False,  # CRITICAL: Never use shell=True with user input
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                close_fds=True  # Close unused file descriptors
+            )
             self.update_status_message(f"Opened {current_image_path.name} in Photoshop.")
             log.info(f"Launched Photoshop with: {command}")
-        except Exception as e:
+        except (OSError, subprocess.SubprocessError) as e:
             self.update_status_message(f"Failed to open in Photoshop: {e}")
-            log.error(f"Error launching Photoshop: {e}")
+            log.exception(f"Error launching Photoshop: {e}")
+        except FileNotFoundError as e:
+            self.update_status_message(f"Photoshop executable not found: {e}")
+            log.exception(f"Photoshop executable not found: {e}")
 
     @Slot()
     def copy_path_to_clipboard(self):
@@ -622,6 +666,13 @@ def copy_path_to_clipboard(self):
         self.update_status_message(f"Copied: {current_image_path}")
         log.info(f"Copied path to clipboard: {current_image_path}")
 
+    @Slot()
+    def reset_zoom_pan(self):
+        """Resets zoom and pan to fit the image in the window (like Ctrl+0 in Photoshop)."""
+        log.info("Resetting zoom and pan to fit window")
+        self.ui_state.resetZoomPan()
+        self.update_status_message("Reset zoom and pan")
+
     def update_status_message(self, message: str, timeout: int = 3000):
         """
         Updates the UI status message and clears it after a timeout.
diff --git a/faststack/faststack/app.py.bak b/faststack/faststack/app.py.bak
new file mode 100644
index 0000000..d67a59d
--- /dev/null
+++ b/faststack/faststack/app.py.bak
@@ -0,0 +1,638 @@
+"""Main application entry point for FastStack."""
+
+import logging
+import sys
+import struct
+from pathlib import Path
+from typing import Optional, List, Dict
+from datetime import date
+import os
+import typer
+import concurrent.futures
+import threading
+from faststack.ui.provider import ImageProvider, UIState
+from PySide6.QtGui import QDrag
+from PySide6.QtCore import (
+    QUrl,
+    QTimer,
+    QObject,
+    QEvent,
+    Signal,
+    Slot,
+    QMimeData,
+    Qt
+)
+from PySide6.QtWidgets import QApplication, QFileDialog
+from PySide6.QtQml import QQmlApplicationEngine
+
+# ⬇️ these are the ones that went missing
+from faststack.config import config
+from faststack.logging_setup import setup_logging
+from faststack.models import ImageFile, DecodedImage, EntryMetadata
+from faststack.io.indexer import find_images
+from faststack.io.sidecar import SidecarManager
+from faststack.io.watcher import Watcher
+from faststack.io.helicon import launch_helicon_focus
+from faststack.imaging.cache import ByteLRUCache, get_decoded_image_size
+from faststack.imaging.prefetch import Prefetcher
+from faststack.ui.provider import ImageProvider
+from faststack.ui.keystrokes import Keybinder
+
+
+def make_hdrop(paths):
+    """
+    Build a real CF_HDROP (DROPFILES) payload for Windows drag-and-drop.
+    paths: list[str]
+    """
+    files_part = ("\0".join(paths) + "\0\0").encode("utf-16le")
+
+    # DROPFILES header (20 bytes): <IiiII
+    pFiles = 20
+    pt_x = 0
+    pt_y = 0
+    fNC = 0
+    fWide = 1  # wide chars
+    header = struct.pack("<IiiII", pFiles, pt_x, pt_y, fNC, fWide)
+    return header + files_part
+
+log = logging.getLogger(__name__)
+
+class AppController(QObject):
+    class ProgressReporter(QObject):
+        progress_updated = Signal(int)
+        finished = Signal()
+
+    def __init__(self, image_dir: Path, engine: QQmlApplicationEngine):
+        super().__init__()
+        self.image_dir = image_dir
+        self.image_files: List[ImageFile] = []
+        self.current_index: int = 0
+        self.ui_refresh_generation = 0
+        self.main_window: Optional[QObject] = None
+        self.engine = engine
+
+        self.display_width = 0
+        self.display_height = 0
+        self.display_generation = 0
+        self.is_zoomed = False
+
+        # -- Backend Components --
+        self.watcher = Watcher(self.image_dir, self.refresh_image_list)
+        self.sidecar = SidecarManager(self.image_dir, self.watcher)
+        
+        # -- Caching & Prefetching --
+        cache_size_gb = config.getfloat('core', 'cache_size_gb', 1.5)
+        cache_size_bytes = int(cache_size_gb * 1024**3)
+        self.image_cache = ByteLRUCache(max_bytes=cache_size_bytes, size_of=get_decoded_image_size)
+        self.prefetcher = Prefetcher(
+            image_files=self.image_files,
+            cache_put=self.image_cache.__setitem__,
+            prefetch_radius=config.getint('core', 'prefetch_radius', 4),
+            get_display_info=self.get_display_info
+        )
+
+        # -- UI State --
+        self.ui_state = UIState(self)
+        self.keybinder = Keybinder(self)
+
+        # -- Stacking State --
+        self.stack_start_index: Optional[int] = None
+        self.stacks: List[List[int]] = []
+        self.selected_raws: set[Path] = set()
+        self._filter_string: str = "stacked" # Default filter
+
+        self._metadata_cache = {}
+        self._metadata_cache_index = -1
+
+        self.resize_timer = QTimer()
+        self.resize_timer.setSingleShot(True)
+        self.resize_timer.timeout.connect(self._handle_resize)
+        self.pending_width = None
+        self.pending_height = None
+
+    def apply_filter(self, filter_string: str):
+        if self._filter_string != filter_string:
+            self._filter_string = filter_string
+            self.refresh_image_list()
+            self.ui_state.filterStringChanged.emit()
+
+    def get_display_info(self):
+        if self.is_zoomed:
+            return 0, 0, self.display_generation
+        return self.display_width, self.display_height, self.display_generation
+
+    def on_display_size_changed(self, width: int, height: int):
+        """Debounces display size change events to prevent spamming resizes."""
+        if self.display_width == width and self.display_height == height:
+            return
+        
+        # Debounce resize events
+        self.pending_width = width
+        self.pending_height = height
+        self.resize_timer.start(150)  # 150ms debounce
+
+    def _handle_resize(self):
+        """Actual resize handler, called after debounce period."""
+        log.info(f"Display size changed to: {self.pending_width}x{self.pending_height}")
+        self.display_width = self.pending_width
+        self.display_height = self.pending_height
+        self.display_generation += 1
+        self.image_cache.clear()
+        self.prefetcher.cancel_all()
+        self.prefetcher.update_prefetch(self.current_index)
+        self.sync_ui_state() # To refresh the image
+
+    def set_zoomed(self, zoomed: bool):
+        if self.is_zoomed == zoomed:
+            return
+        self.is_zoomed = zoomed
+        log.info(f"Zoom state changed to: {zoomed}")
+        self.display_generation += 1 # Invalidate cache
+        self.image_cache.clear()
+        self.prefetcher.cancel_all()
+        self.prefetcher.update_prefetch(self.current_index)
+        self.sync_ui_state()
+        self.ui_state.isZoomedChanged.emit()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        if watched == self.main_window and event.type() == QEvent.Type.KeyPress:
+            handled = self.keybinder.handle_key_press(event)
+            if handled:
+                return True
+        return super().eventFilter(watched, event)
+
+    def load(self):
+        """Loads images, sidecar data, and starts services."""
+        self.refresh_image_list()
+        if not self.image_files:
+            self.current_index = 0
+        else:
+            self.current_index = max(0, min(self.sidecar.data.last_index, len(self.image_files) - 1))
+        self.stacks = self.sidecar.data.stacks # Load stacks from sidecar
+        self.watcher.start()
+        self.prefetcher.update_prefetch(self.current_index)
+        
+        # Defer initial UI sync until after images are loaded
+        self.sync_ui_state()
+
+
+    def refresh_image_list(self):
+        """Rescans the directory for images and applies the current filter."""
+        all_images = find_images(self.image_dir)
+        if self._filter_string:
+            self.image_files = [img for img in all_images if self._filter_string.lower() in img.path.stem.lower()]
+        else:
+            self.image_files = all_images
+
+        self.prefetcher.set_image_files(self.image_files)
+        self._metadata_cache_index = (-1, -1) # Invalidate cache
+        self.ui_state.imageCountChanged.emit()
+
+    def get_decoded_image(self, index: int) -> Optional[DecodedImage]:
+        """Retrieves a decoded image, from cache or by decoding."""
+        if not self.image_files: # Handle empty image list
+            log.warning("get_decoded_image called with empty image_files.")
+            return None
+
+        _, _, display_gen = self.get_display_info()
+        cache_key = f"{index}_{display_gen}"
+
+        if cache_key in self.image_cache:
+            return self.image_cache[cache_key]
+        
+        # If not in cache, this was likely a cache miss. 
+        # The prefetcher should have it, but we can do a blocking load if needed.
+        log.warning(f"Cache miss for index {index} (gen: {display_gen}). Forcing synchronous load.")
+        future = self.prefetcher.submit_task(index, self.prefetcher.generation)
+        if future:
+            try:
+                # Wait for the result and then retrieve from cache
+                result = future.result()
+                if result:
+                    decoded_index, decoded_display_gen = result
+                    cache_key = f"{decoded_index}_{decoded_display_gen}"
+                    if cache_key in self.image_cache:
+                        return self.image_cache[cache_key]
+            except concurrent.futures.CancelledError:
+                log.warning(f"Prefetch task for index {index} was cancelled. Attempting synchronous load.")
+                return None
+        return None
+
+    def sync_ui_state(self):
+        """Forces the UI to update by emitting all state change signals."""
+        self.ui_refresh_generation += 1
+        self._metadata_cache_index = (-1, -1)  # Invalidate cache
+        self.ui_state.currentIndexChanged.emit()
+        self.ui_state.currentImageSourceChanged.emit()
+        self.ui_state.metadataChanged.emit()
+        log.debug(f"UI State Synced: Index={self.ui_state.currentIndex}, Count={self.ui_state.imageCount}")
+        log.debug(f"Metadata Synced: Filename={self.ui_state.currentFilename}, Flagged={self.ui_state.isFlagged}, Rejected={self.ui_state.isRejected}, StackInfo='{self.ui_state.stackInfoText}'")
+
+    # --- Actions --- 
+
+    def next_image(self):
+        if self.current_index < len(self.image_files) - 1:
+            self.current_index += 1
+            self.prefetcher.update_prefetch(self.current_index)
+            self.sync_ui_state()
+
+    def prev_image(self):
+        if self.current_index > 0:
+            self.current_index -= 1
+            self.prefetcher.update_prefetch(self.current_index)
+            self.sync_ui_state()
+
+    def toggle_grid_view(self):
+        log.warning("Grid view not implemented yet.")
+
+    def get_current_metadata(self) -> Dict:
+        if not self.image_files:
+            log.debug("get_current_metadata: image_files is empty, returning {}.")
+            return {}
+        
+        # Cache hit check
+        cache_key = (self.current_index, self.ui_refresh_generation)
+        if cache_key == self._metadata_cache_index:
+            return self._metadata_cache
+        
+        # Compute and cache
+        stem = self.image_files[self.current_index].path.stem
+        meta = self.sidecar.get_metadata(stem)
+        stack_info = self._get_stack_info(self.current_index)
+        
+        self._metadata_cache = {
+            "filename": self.image_files[self.current_index].path.name,
+            "flag": meta.flag,
+            "reject": meta.reject,
+            "stacked": meta.stacked,
+            "stacked_date": meta.stacked_date or "",
+            "stack_info_text": stack_info
+        }
+        self._metadata_cache_index = cache_key
+        return self._metadata_cache
+
+    def toggle_current_flag(self):
+        stem = self.image_files[self.current_index].path.stem
+        meta = self.sidecar.get_metadata(stem)
+        meta.flag = not meta.flag
+        self.sidecar.save()
+        self._metadata_cache_index = (-1, -1) # Invalidate cache
+        self.ui_state.metadataChanged.emit()
+
+    def toggle_current_reject(self):
+        stem = self.image_files[self.current_index].path.stem
+        meta = self.sidecar.get_metadata(stem)
+        meta.reject = not meta.reject
+        self.sidecar.save()
+        self._metadata_cache_index = (-1, -1) # Invalidate cache
+        self.ui_state.metadataChanged.emit()
+
+    def begin_new_stack(self):
+        self.stack_start_index = self.current_index
+        log.info(f"Stack start marked at index {self.stack_start_index}")
+        self._metadata_cache_index = (-1, -1) # Invalidate cache
+        self.ui_state.metadataChanged.emit() # Update UI to show start marker
+
+    def end_current_stack(self):
+        log.info(f"end_current_stack called. stack_start_index: {self.stack_start_index}")
+        if self.stack_start_index is not None:
+            start = min(self.stack_start_index, self.current_index)
+            end = max(self.stack_start_index, self.current_index)
+            self.stacks.append([start, end])
+            self.stacks.sort() # Keep stacks sorted by start index
+            self.sidecar.data.stacks = self.stacks
+            self.sidecar.save()
+            log.info(f"Defined new stack: [{start}, {end}]")
+            self.stack_start_index = None
+            self._metadata_cache_index = (-1, -1) # Invalidate cache
+            self.ui_state.metadataChanged.emit()
+        else:
+            log.warning("No stack start marked. Press '[' first.")
+
+    def toggle_selection(self):
+        """Toggles the selection status of the current image's RAW file."""
+        if not self.image_files:
+            return
+
+        image_file = self.image_files[self.current_index]
+        if image_file.raw_pair:
+            if image_file.raw_pair in self.selected_raws:
+                self.selected_raws.remove(image_file.raw_pair)
+                log.info(f"Removed {image_file.raw_pair.name} from selection.")
+            else:
+                self.selected_raws.add(image_file.raw_pair)
+                log.info(f"Added {image_file.raw_pair.name} to selection.")
+            
+            # In a real app, we'd update a selection indicator in the UI.
+            # For now, we just log and can use it for batch operations.
+            self.sync_ui_state() # This will trigger a UI refresh
+
+
+    def launch_helicon(self):
+        """Launches Helicon Focus with selected RAWs or all RAWs in defined stacks."""
+        if self.selected_raws:
+            log.info(f"Launching Helicon with {len(self.selected_raws)} selected RAW files.")
+            self._launch_helicon_with_files(sorted(list(self.selected_raws)))
+            self.selected_raws.clear()
+
+        elif self.stacks:
+            log.info(f"Launching Helicon for {len(self.stacks)} defined stacks.")
+            for start, end in self.stacks:
+                raw_files_to_process = []
+                for idx in range(start, end + 1):
+                    if idx < len(self.image_files) and self.image_files[idx].raw_pair:
+                        raw_files_to_process.append(self.image_files[idx].raw_pair)
+                
+                if raw_files_to_process:
+                    self._launch_helicon_with_files(raw_files_to_process)
+                else:
+                    log.warning(f"No valid RAW files found for stack [{start}, {end}].")
+            
+            self.clear_all_stacks()
+
+        else:
+            log.warning("No selection or stacks defined to launch Helicon Focus.")
+            return
+
+        self.sync_ui_state()
+
+    def _launch_helicon_with_files(self, raw_files: List[Path]):
+        """Helper to launch Helicon with a specific list of files."""
+        log.info(f"Launching Helicon Focus with {len(raw_files)} RAW files.")
+        unique_raw_files = sorted(list(set(raw_files)))
+        success, tmp_path = launch_helicon_focus(unique_raw_files)
+        if success and tmp_path:
+            # Schedule delayed deletion of the temporary file
+            QTimer.singleShot(5000, lambda: self._delete_temp_file(tmp_path))
+
+            # Record stacking metadata
+            today = date.today().isoformat()
+            for raw_path in unique_raw_files:
+                # Find the corresponding image file to get the stem
+                for img_file in self.image_files:
+                    if img_file.raw_pair == raw_path:
+                        stem = img_file.path.stem
+                        meta = self.sidecar.get_metadata(stem)
+                        meta.stacked = True
+                        meta.stacked_date = today
+                        break
+            self.sidecar.save()
+            self._metadata_cache_index = (-1, -1) # Invalidate cache
+
+    def _delete_temp_file(self, tmp_path: Path):
+        if tmp_path.exists():
+            try:
+                os.remove(tmp_path)
+                log.info(f"Deleted temporary file: {tmp_path}")
+            except OSError as e:
+                log.error(f"Error deleting temporary file {tmp_path}: {e}")
+
+    def clear_all_stacks(self):
+        log.info("Clearing all defined stacks.")
+        self.stacks = []
+        self.sidecar.data.stacks = self.stacks
+        self.sidecar.save()
+        self._metadata_cache_index = (-1, -1) # Invalidate cache
+        self.ui_state.metadataChanged.emit() # Refresh UI to show no stacks
+
+    def get_helicon_path(self):
+        return config.get('helicon', 'exe')
+
+    def set_helicon_path(self, path):
+        config.set('helicon', 'exe', path)
+        config.save()
+
+    def open_file_dialog(self):
+        dialog = QFileDialog()
+        dialog.setFileMode(QFileDialog.FileMode.ExistingFile)
+        dialog.setNameFilter("Executables (*.exe)")
+        if dialog.exec():
+            return dialog.selectedFiles()[0]
+        return ""
+
+    def check_path_exists(self, path):
+        return os.path.exists(path)
+
+    def get_cache_size(self):
+        return config.getfloat('core', 'cache_size_gb')
+
+    def set_cache_size(self, size):
+        config.set('core', 'cache_size_gb', size)
+        config.save()
+
+    def get_prefetch_radius(self):
+        return config.getint('core', 'prefetch_radius')
+
+    def set_prefetch_radius(self, radius):
+        config.set('core', 'prefetch_radius', radius)
+        config.save()
+        self.prefetcher.prefetch_radius = radius
+        self.prefetcher.update_prefetch(self.current_index)
+
+    def get_theme(self):
+        return 0 if config.get('core', 'theme') == 'dark' else 1
+
+    def set_theme(self, theme_index):
+        theme = 'dark' if theme_index == 0 else 'light'
+        config.set('core', 'theme', theme)
+        config.save()
+        self.ui_state.themeChanged.emit()
+
+    def get_default_directory(self):
+        return config.get('core', 'default_directory')
+
+    def set_default_directory(self, path):
+        config.set('core', 'default_directory', path)
+        config.save()
+
+    def open_directory_dialog(self):
+        dialog = QFileDialog()
+        dialog.setFileMode(QFileDialog.FileMode.Directory)
+        if dialog.exec():
+            return dialog.selectedFiles()[0]
+        return ""
+
+    def preload_all_images(self):
+        if self.ui_state.isPreloading:
+            log.info("Preloading is already in progress.")
+            return
+
+        log.info("Starting to preload all images.")
+        self.ui_state.isPreloading = True
+        self.ui_state.preloadProgress = 0
+
+        self.reporter = self.ProgressReporter()
+        self.reporter.progress_updated.connect(self._update_preload_progress)
+        self.reporter.finished.connect(self._finish_preloading)
+
+        # Use existing prefetch executor (better resource utilization)
+        total = len(self.image_files)
+        
+        if total == 0:
+            log.info("No images to preload.")
+            self.reporter.progress_updated.emit(100) # Or 0, depending on desired UX
+            self.reporter.finished.emit()
+            return
+
+        completed = 0
+        
+        def _on_done(_future):
+            nonlocal completed
+            completed += 1
+            progress = int((completed / total) * 100)
+            self.reporter.progress_updated.emit(progress)
+            if completed == total:
+                self.reporter.finished.emit()
+        
+        for i in range(total):
+            future = self.prefetcher.submit_task(i, self.prefetcher.generation)
+            if future:
+                future.add_done_callback(_on_done)
+
+    def _update_preload_progress(self, progress: int):
+        log.debug(f"Updating preload progress in UI: {progress}%")
+        self.ui_state.preloadProgress = progress
+
+    def _finish_preloading(self):
+        self.ui_state.isPreloading = False
+        self.ui_state.preloadProgress = 0
+        log.info("Finished preloading all images.")
+
+    def shutdown(self):
+        log.info("Application shutting down.")
+        # Clear QML context property to prevent TypeErrors during shutdown
+        if self.engine:
+            log.info("Clearing uiState context property in QML.")
+            del self.engine # Explicitly delete the engine
+
+        self.watcher.stop()
+        self.prefetcher.shutdown()
+        self.sidecar.set_last_index(self.current_index)
+        self.sidecar.save()
+
+
+    @Slot()
+    def start_drag_current_image(self):
+        # 1) sanity checks
+        if not self.image_files or self.current_index >= len(self.image_files):
+            return
+
+        file_path = self.image_files[self.current_index].path
+        if not file_path.exists():
+            log.error(f"File does not exist, cannot start drag: {file_path}")
+            return
+
+        if self.main_window is None:
+            return
+
+        # 2) build the drag
+        drag = QDrag(self.main_window)
+        mime_data = QMimeData()
+
+        # Windows: send a real file-drop (CF_HDROP) so Chrome/iNat can upload it
+        if sys.platform.startswith("win"):
+            hdrop = make_hdrop([str(file_path)])
+            mime_data.setData('application/x-qt-windows-mime;value="FileDrop"', hdrop)
+            mime_data.setData(
+                'application/x-qt-windows-mime;value="FileNameW"',
+                (str(file_path) + "\0").encode("utf-16le")
+            )
+            mime_data.setData(
+                'application/x-qt-windows-mime;value="FileName"',
+                (str(file_path) + "\0").encode("mbcs", errors="replace")
+            )
+        else:
+            # fallback for non-Windows
+            mime_data.setUrls([QUrl.fromLocalFile(str(file_path))])
+
+        drag.setMimeData(mime_data)
+        log.info(f"Starting drag for {file_path}")
+        drag.exec(Qt.CopyAction)
+
+    def _get_stack_info(self, index: int) -> str:
+        info = ""
+        for i, (start, end) in enumerate(self.stacks):
+            if start <= index <= end:
+                count_in_stack = end - start + 1
+                pos_in_stack = index - start + 1
+                info = f"Stack {i+1} ({pos_in_stack}/{count_in_stack})"
+                break
+        if not info and self.stack_start_index is not None and self.stack_start_index == index:
+            info = "Stack Start Marked"
+        log.info(f"_get_stack_info for index {index}: {info}")
+        return info
+
+    def get_stack_summary(self) -> str:
+        if not self.stacks:
+            return "No stacks defined."
+        summary = []
+        for i, (start, end) in enumerate(self.stacks):
+            summary.append(f"Stack {i+1}: {start}-{end}")
+        return "; ".join(summary)
+
+    def is_stacked(self) -> bool:
+        if not self.image_files:
+            return False
+        stem = self.image_files[self.current_index].path.stem
+        meta = self.sidecar.get_metadata(stem)
+        return meta.stacked
+
+def main(image_dir: Optional[Path] = typer.Argument(None, help="Directory of images to view")):
+    """FastStack Application Entry Point"""
+    setup_logging()
+    log.info("Starting FastStack")
+
+    os.environ["QT_QUICK_CONTROLS_STYLE"] = "Material"
+
+    app = QApplication(sys.argv) # Moved here
+
+    if image_dir is None:
+        image_dir_str = config.get('core', 'default_directory')
+        if not image_dir_str:
+            log.warning("No image directory provided and no default directory set. Opening directory selection dialog.")
+            selected_dir = QFileDialog.getExistingDirectory(None, "Select Image Directory")
+            if not selected_dir:
+                log.error("No image directory selected. Exiting.")
+                sys.exit(1)
+            image_dir_str = selected_dir
+        image_dir = Path(image_dir_str)
+
+    if not image_dir.is_dir():
+        log.error(f"Image directory not found: {image_dir}")
+        sys.exit(1)
+    app.setOrganizationName("FastStack")
+    app.setOrganizationDomain("faststack.dev")
+    app.setApplicationName("FastStack")
+
+    engine = QQmlApplicationEngine()
+    controller = AppController(image_dir, engine)
+    image_provider = ImageProvider(controller)
+    engine.addImageProvider("provider", image_provider)
+
+    # Expose controller and UI state to QML
+    context = engine.rootContext()
+    context.setContextProperty("uiState", controller.ui_state)
+    context.setContextProperty("controller", controller)
+
+    qml_file = Path(__file__).parent / "qml" / "Main.qml"
+    engine.load(QUrl.fromLocalFile(str(qml_file)))
+
+    if not engine.rootObjects():
+        log.error("Failed to load QML.")
+        sys.exit(-1)
+
+    # Connect key events from the main window
+    main_window = engine.rootObjects()[0]
+    controller.main_window = main_window
+    main_window.installEventFilter(controller)
+
+    # Load data and start services
+    controller.load()
+
+    # Graceful shutdown
+    app.aboutToQuit.connect(controller.shutdown)
+
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    typer.run(main)
diff --git a/faststack/faststack/io/executable_validator.py b/faststack/faststack/io/executable_validator.py
new file mode 100644
index 0000000..b78b0b1
--- /dev/null
+++ b/faststack/faststack/io/executable_validator.py
@@ -0,0 +1,112 @@
+"""Secure validation of executable paths before execution."""
+
+import logging
+import os
+from pathlib import Path
+from typing import Optional, List
+
+log = logging.getLogger(__name__)
+
+# Known safe installation directories for common applications on Windows
+KNOWN_SAFE_PATHS = [
+    r"C:\Program Files",
+    r"C:\Program Files (x86)",
+]
+
+# Known executable names that are safe to run
+KNOWN_SAFE_EXECUTABLES = {
+    "photoshop": ["Photoshop.exe"],
+    "helicon": ["HeliconFocus.exe"],
+}
+
+
+def validate_executable_path(
+    exe_path: str,
+    app_type: Optional[str] = None,
+    allow_custom_paths: bool = True
+) -> tuple[bool, Optional[str]]:
+    """
+    Validates an executable path before execution.
+    
+    Args:
+        exe_path: Path to the executable to validate
+        app_type: Type of application (e.g., 'photoshop', 'helicon') for additional checks
+        allow_custom_paths: Whether to allow executables outside known safe paths
+        
+    Returns:
+        Tuple of (is_valid, error_message)
+        If valid, error_message is None
+        If invalid, error_message contains reason
+    """
+    if not exe_path:
+        return False, "Executable path is empty"
+    
+    try:
+        path = Path(exe_path).resolve()
+    except (ValueError, OSError) as e:
+        log.error(f"Invalid path format: {exe_path}: {e}")
+        return False, f"Invalid path format: {e}"
+    
+    # Check if file exists
+    if not path.exists():
+        return False, f"Executable not found: {exe_path}"
+    
+    if not path.is_file():
+        return False, f"Path is not a file: {exe_path}"
+    
+    # Check if it's actually an executable
+    if not _is_executable(path):
+        return False, f"File is not executable: {exe_path}"
+    
+    # Check if the executable name matches expected names for the app type
+    if app_type and app_type in KNOWN_SAFE_EXECUTABLES:
+        expected_names = KNOWN_SAFE_EXECUTABLES[app_type]
+        if path.name not in expected_names:
+            log.warning(
+                f"Executable name '{path.name}' does not match expected names "
+                f"for {app_type}: {expected_names}"
+            )
+            # This is a warning, not a hard failure, but log it
+    
+    # Check if in known safe directory
+    in_safe_path = any(
+        _is_subpath(path, Path(safe_path))
+        for safe_path in KNOWN_SAFE_PATHS
+    )
+    
+    if not in_safe_path:
+        if not allow_custom_paths:
+            return False, f"Executable not in allowed directory: {exe_path}"
+        else:
+            log.warning(
+                f"Executable '{exe_path}' is not in a known safe directory. "
+                f"Proceeding with caution."
+            )
+    
+    # Check for suspicious paths (potential directory traversal, etc.)
+    try:
+        normalized = os.path.normpath(exe_path)
+        if ".." in normalized or normalized != str(path):
+            log.warning(f"Suspicious path detected: {exe_path}")
+    except Exception as e:
+        log.error(f"Error normalizing path: {e}")
+        return False, f"Path validation error: {e}"
+    
+    return True, None
+
+
+def _is_executable(path: Path) -> bool:
+    """Check if a file is executable (has .exe extension on Windows)."""
+    if os.name == 'nt':  # Windows
+        return path.suffix.lower() == '.exe'
+    else:  # Unix-like
+        return os.access(path, os.X_OK)
+
+
+def _is_subpath(path: Path, parent: Path) -> bool:
+    """Check if path is a subpath of parent."""
+    try:
+        path.resolve().relative_to(parent.resolve())
+        return True
+    except (ValueError, RuntimeError):
+        return False
diff --git a/faststack/faststack/io/helicon.py b/faststack/faststack/io/helicon.py
index 5784952..98bbfe2 100644
--- a/faststack/faststack/io/helicon.py
+++ b/faststack/faststack/io/helicon.py
@@ -1,12 +1,15 @@
 """Handles launching Helicon Focus with a list of RAW files."""
 
 import logging
+import os
+import shlex
 import subprocess
 import tempfile
 from pathlib import Path
 from typing import List, Optional, Tuple
 
 from faststack.config import config
+from faststack.io.executable_validator import validate_executable_path
 
 log = logging.getLogger(__name__)
 
@@ -24,10 +27,15 @@ def launch_helicon_focus(raw_files: List[Path]) -> Tuple[bool, Optional[Path]]:
         log.error("Helicon Focus executable path not configured or invalid.")
         return False, None
 
-    helicon_path = Path(helicon_exe)
-    if not helicon_path.is_file():
-        log.error(f"Helicon Focus executable not found at: {helicon_exe}")
-        # In a real app, this would trigger a dialog to find the exe.
+    # Validate executable path securely
+    is_valid, error_msg = validate_executable_path(
+        helicon_exe,
+        app_type="helicon",
+        allow_custom_paths=True
+    )
+    
+    if not is_valid:
+        log.error(f"Helicon Focus executable validation failed: {error_msg}")
         return False, None
 
     if not raw_files:
@@ -37,21 +45,46 @@ def launch_helicon_focus(raw_files: List[Path]) -> Tuple[bool, Optional[Path]]:
     try:
         with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt", encoding='utf-8') as tmp:
             for f in raw_files:
-                tmp.write(f"{f}\n")
+                # Ensure file path is resolved and exists
+                if not f.exists():
+                    log.warning(f"RAW file does not exist, skipping: {f}")
+                    continue
+                tmp.write(f"{f.resolve()}\n")
             tmp_path = Path(tmp.name)
 
         log.info(f"Temporary file for Helicon Focus: {tmp_path}")
 
-        args = [helicon_exe, "-i", str(tmp_path)]
+        # Build command list safely
+        args = [helicon_exe, "-i", str(tmp_path.resolve())]
+        
+        # Parse additional args safely using shlex (handles quotes and escapes properly)
         extra_args = config.get("helicon", "args")
         if extra_args:
-            args.extend(extra_args.split())
+            try:
+                # Use shlex to properly parse arguments with quotes/escapes
+                # On Windows, use posix=False to handle Windows-style paths
+                parsed_args = shlex.split(extra_args, posix=(os.name != 'nt'))
+                args.extend(parsed_args)
+            except ValueError as e:
+                log.error(f"Invalid helicon args format: {e}")
+                return False, None
 
         log.info(f"Launching Helicon Focus with {len(raw_files)} files.")
         log.info(f"Helicon Focus command: {args}") # Log the full command
-        log.debug(f"Command: {args}")
-        subprocess.Popen(args)
+        
+        # SECURITY: Explicitly disable shell execution
+        subprocess.Popen(
+            args,
+            shell=False,  # CRITICAL: Never use shell=True with user input
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            close_fds=True  # Close unused file descriptors
+        )
         return True, tmp_path
-    except Exception as e:
-        log.error(f"Failed to launch Helicon Focus: {e}")
+    except (OSError, subprocess.SubprocessError) as e:
+        log.exception(f"Failed to launch Helicon Focus: {e}")
+        return False, None
+    except (IOError, PermissionError) as e:
+        log.exception(f"Failed to create temporary file for Helicon Focus: {e}")
         return False, None
diff --git a/faststack/faststack/qml/Components.qml b/faststack/faststack/qml/Components.qml
index 3edd2c8..224be5b 100644
--- a/faststack/faststack/qml/Components.qml
+++ b/faststack/faststack/qml/Components.qml
@@ -1,4 +1,5 @@
 import QtQuick
+import QtQuick.Window
 
 // This file is intended to hold QML components like the main image view.
 // For simplicity, we'll start with just the main image view.
@@ -7,6 +8,17 @@ Item {
     id: loupeView
     anchors.fill: parent
 
+    // Connection to handle zoom/pan reset signal from Python
+    Connections {
+        target: uiState
+        function onResetZoomPanRequested() {
+            scaleTransform.xScale = 1.0
+            scaleTransform.yScale = 1.0
+            panTransform.x = 0
+            panTransform.y = 0
+        }
+    }
+
     // The main image display
     Image {
         id: mainImage
@@ -17,7 +29,8 @@ Item {
 
         Component.onCompleted: {
             if (width > 0 && height > 0) {
-                uiState.onDisplaySizeChanged(width, height)
+                var dpr = Screen.devicePixelRatio
+                uiState.onDisplaySizeChanged(Math.round(width * dpr), Math.round(height * dpr))
             }
         }
 
@@ -63,7 +76,8 @@ Item {
         running: false
         onTriggered: {
             if (mainImage.width > 0 && mainImage.height > 0) {
-                uiState.onDisplaySizeChanged(mainImage.width, mainImage.height)
+                var dpr = Screen.devicePixelRatio
+                uiState.onDisplaySizeChanged(Math.round(mainImage.width * dpr), Math.round(mainImage.height * dpr))
             }
             running = false
         }
diff --git a/faststack/faststack/qml/FilterDialog.qml b/faststack/faststack/qml/FilterDialog.qml
new file mode 100644
index 0000000..92f0582
--- /dev/null
+++ b/faststack/faststack/qml/FilterDialog.qml
@@ -0,0 +1,70 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Controls.Material 2.15
+
+Dialog {
+    id: filterDialog
+    title: "Filter Images"
+    modal: true
+    standardButtons: Dialog.Ok | Dialog.Cancel
+    width: 400
+    height: 200
+
+    property string filterString: ""
+
+    // Match the app's theme dynamically
+    Material.theme: uiState && uiState.theme === 0 ? Material.Dark : Material.Light
+
+    background: Rectangle {
+        color: Material.theme === Material.Dark ? "#1e1e1e" : "white"
+        border.color: Material.theme === Material.Dark ? "#404040" : "#c0c0c0"
+        border.width: 1
+        radius: 4
+    }
+
+    contentItem: Column {
+        spacing: 16
+        anchors.fill: parent
+        anchors.margins: 20
+
+        Label {
+            text: "Show only images whose filename contains:"
+            wrapMode: Text.WordWrap
+            width: parent.width
+        }
+
+        TextField {
+            id: filterField
+            text: filterDialog.filterString
+            placeholderText: "Enter text to filter (e.g., 'stacked', 'IMG_001')..."
+            width: parent.width
+            selectByMouse: true
+            focus: true
+            
+            onTextChanged: {
+                filterDialog.filterString = text
+            }
+            
+            Keys.onReturnPressed: {
+                filterDialog.accept()
+            }
+        }
+
+        Label {
+            text: "Leave empty to show all images."
+            font.italic: true
+            opacity: 0.7
+            wrapMode: Text.WordWrap
+            width: parent.width
+        }
+    }
+
+    onOpened: {
+        // Load current filter string from controller
+        var current = controller.get_filter_string ? controller.get_filter_string() : ""
+        filterDialog.filterString = current || ""
+        filterField.text = filterDialog.filterString
+        filterField.forceActiveFocus()
+        filterField.selectAll()
+    }
+}
diff --git a/faststack/faststack/qml/Main.qml b/faststack/faststack/qml/Main.qml
index 95aac22..a2fdf3a 100644
--- a/faststack/faststack/qml/Main.qml
+++ b/faststack/faststack/qml/Main.qml
@@ -80,6 +80,12 @@ ApplicationWindow {
                 color: "lightgreen"
                 visible: uiState.isStacked
             }
+            Label {
+                text: ` | Filter: "${uiState.filterString}"`
+                color: "yellow"
+                font.bold: true
+                visible: uiState.filterString !== ""
+            }
             Rectangle {
                 visible: uiState.isPreloading
                 Layout.preferredWidth: 200
@@ -194,9 +200,19 @@ ApplicationWindow {
 
         
 
-                    Item { Layout.fillWidth: true } // Spacer
+                    Item { Layout.fillWidth: true } // Left spacer
 
-        
+                    Label {
+                        text: uiState.currentDirectory
+                        color: root.currentTextColor
+                        font.pixelSize: 12
+                        elide: Text.ElideMiddle
+                        Layout.maximumWidth: 600
+                        Layout.alignment: Qt.AlignVCenter
+                        horizontalAlignment: Text.AlignHCenter
+                    }
+
+                    Item { Layout.fillWidth: true } // Right spacer
 
                     Row {
 
@@ -257,6 +273,7 @@ ApplicationWindow {
                       "<b>Viewing:</b><br>" +
                       "&nbsp;&nbsp;Mouse Wheel: Zoom in/out<br>" +
                       "&nbsp;&nbsp;Left-click + Drag: Pan image<br>" +
+                      "&nbsp;&nbsp;Ctrl+0: Reset zoom and pan to fit window<br>" +
                       "&nbsp;&nbsp;G: Toggle Grid View (not implemented)<br><br>" +
                       "<b>Rating & Stacking:</b><br>" +
                       "&nbsp;&nbsp;Space: Toggle Flag<br>" +
diff --git a/faststack/faststack/qml/Main.qml.bak b/faststack/faststack/qml/Main.qml.bak
new file mode 100644
index 0000000..3c9ca9f
--- /dev/null
+++ b/faststack/faststack/qml/Main.qml.bak
@@ -0,0 +1,295 @@
+import QtQuick
+import QtQuick.Window
+import QtQuick.Controls 2.15
+import QtQuick.Controls.Material 2.15
+import QtQuick.Layouts 1.15
+import "."
+
+ApplicationWindow {
+    id: root
+    visible: true
+    width: 1200
+    height: 800
+    minimumWidth: 800
+    minimumHeight: 500
+    flags: Qt.FramelessWindowHint | Qt.Window
+    title: "FastStack"
+
+    Material.theme: uiState.theme === 0 ? Material.Dark : Material.Light
+
+    property bool isDarkTheme: uiState.theme === 0
+    property color currentBackgroundColor: isDarkTheme ? "#000000" : "white"
+    property color currentTextColor: isDarkTheme ? "white" : "black"
+
+    background: Rectangle { color: root.currentBackgroundColor }
+
+    function toggleTheme() {
+        uiState.theme = (uiState.theme === 0 ? 1 : 0) // 0 for dark, 1 for light
+    }
+
+    Connections {
+        target: uiState
+        function onThemeChanged() {
+            root.isDarkTheme = uiState.theme === 0
+        }
+    }
+
+    // Expose the Python UIState object to QML
+    // This is set from Python via setContextProperty("uiState", ...)
+
+    // Main view: either the loupe viewer or the grid
+    Loader {
+        id: mainViewLoader
+        anchors.fill: parent
+        anchors.topMargin: titleBar.height
+        source: "Components.qml"
+    }
+
+    // Keyboard focus and event handling
+
+    // Status bar
+    footer: Rectangle {
+        id: footerRect
+        implicitHeight: footerRow.implicitHeight + 10 // Add some padding
+        anchors.left: parent.left
+        anchors.right: parent.right
+        color: "#80000000" // Semi-transparent black
+
+        RowLayout {
+            id: footerRow
+            spacing: 10
+            Label {
+                Layout.leftMargin: 10
+                text: `Image: ${uiState.currentIndex + 1} / ${uiState.imageCount}`
+                color: root.currentTextColor
+            }
+            Label {
+                text: ` | File: ${uiState.currentFilename || 'N/A'}`
+                color: root.currentTextColor
+            }
+            Label {
+                text: ` | Flag: ${uiState.isFlagged}`
+                color: uiState.isFlagged ? "lightgreen" : root.currentTextColor
+            }
+            Label {
+                text: ` | Rejected: ${uiState.isRejected}`
+                color: uiState.isRejected ? "red" : root.currentTextColor
+            }
+            Label {
+                text: ` | Stacked: ${uiState.stackedDate}`
+                color: "lightgreen"
+                visible: uiState.isStacked
+            }
+            Rectangle {
+                visible: uiState.isPreloading
+                Layout.preferredWidth: 200
+                height: 10 // give it some height
+                color: "gray"
+                border.color: "red"
+                border.width: 1
+
+                Rectangle {
+                    color: "lightblue"
+                    width: parent.width * (uiState.preloadProgress / 100)
+                    height: parent.height
+                }
+            }
+            Rectangle {
+                Layout.fillWidth: true
+                color: uiState.stackInfoText ? "orange" : "transparent" // Brighter background
+                radius: 3
+                implicitWidth: stackInfoLabel.implicitWidth + 10
+                implicitHeight: stackInfoLabel.implicitHeight + 5
+                Label {
+                    id: stackInfoLabel
+                    anchors.centerIn: parent
+                    text: `Stack: ${uiState.stackInfoText || 'N/A'}`
+                    color: "black" // Black text for contrast on orange
+                    font.bold: true
+                    font.pixelSize: 16
+                }
+            }
+        }
+    }
+
+    header: Rectangle {
+        id: titleBar
+        height: 30
+        color: root.currentBackgroundColor
+
+        MouseArea {
+            anchors.fill: parent
+            property point lastMousePos: Qt.point(0, 0)
+            onPressed: function(mouse) {
+                lastMousePos = Qt.point(mouse.x, mouse.y)
+            }
+            onPositionChanged: function(mouse) {
+                var delta = Qt.point(mouse.x - lastMousePos.x, mouse.y - lastMousePos.y)
+                root.x += delta.x
+                root.y += delta.y
+            }
+        }
+
+                RowLayout {
+
+                    id: menuAndControls
+
+                    anchors.fill: parent
+
+        
+
+                    MenuBar {
+                        id: menuBar
+                        Layout.preferredWidth: 300 // Give it some width
+                        background: Rectangle {
+                            color: root.currentBackgroundColor
+                        }
+                        palette.buttonText: root.currentTextColor
+                        palette.button: root.currentBackgroundColor
+                        palette.window: root.currentBackgroundColor
+                        palette.text: root.currentTextColor
+
+                        Menu {
+                            title: "&File"
+                            Action { text: "&Open Folder..." }
+                            Action {
+                                text: "&Settings..."
+                                onTriggered: {
+                                    settingsDialog.heliconPath = uiState.get_helicon_path()
+                                    settingsDialog.cacheSize = uiState.get_cache_size()
+                                    settingsDialog.prefetchRadius = uiState.get_prefetch_radius()
+                                    settingsDialog.theme = uiState.theme
+                                    settingsDialog.defaultDirectory = uiState.get_default_directory()
+                                    settingsDialog.open()
+                                }
+                            }
+                            Action { text: "&Exit"; onTriggered: Qt.quit() }
+                        }
+                        Menu {
+                            title: "&View"
+                            Action { text: "Toggle Light/Dark Mode"; onTriggered: root.toggleTheme() }
+                        }
+                        Menu {
+                            title: "&Actions"
+                            Action { text: "Run Stacks"; onTriggered: uiState.launch_helicon() }
+                            Action { text: "Clear Stacks"; onTriggered: uiState.clear_all_stacks() }
+                            Action { text: "Show Stacks"; onTriggered: showStacksDialog.open() }
+                            Action { text: "Preload All Images"; onTriggered: uiState.preloadAllImages() }
+                            Action { text: "Filter Images..."; onTriggered: filterDialog.open() }
+                        }
+                        Menu {
+                            title: "&Help"
+                            Action { text: "&Key Bindings"; onTriggered: aboutDialog.open() }
+                        }
+                    }
+
+        
+
+                    Item { Layout.fillWidth: true } // Spacer
+
+        
+
+                    Row {
+
+                        // Removed anchors
+
+                        spacing: 10
+
+        
+
+                        Button {
+
+                            text: "-"
+
+                            onClicked: root.showMinimized()
+
+                        }
+
+                        Button {
+
+                            text: "[]"
+
+                            onClicked: root.visibility === Window.Maximized ? root.showNormal() : root.showMaximized()
+
+                        }
+
+                        Button {
+
+                            text: "X"
+
+                            onClicked: Qt.quit()
+
+                        }
+
+                    }
+
+                }
+    }
+
+    Dialog {
+        id: aboutDialog
+        title: "Key Bindings"
+        standardButtons: Dialog.Ok
+        modal: true
+        width: 400
+        height: 400
+
+        background: Rectangle {
+            color: root.currentBackgroundColor
+        }
+
+        contentItem: Text {
+            text: "<b>FastStack Keyboard and Mouse Commands</b><br><br>" +
+                  "<b>Navigation:</b><br>" +
+                  "&nbsp;&nbsp;J / Right Arrow: Next Image<br>" +
+                  "&nbsp;&nbsp;K / Left Arrow: Previous Image<br><br>" +
+                  "<b>Viewing:</b><br>" +
+                  "&nbsp;&nbsp;Mouse Wheel: Zoom in/out<br>" +
+                  "&nbsp;&nbsp;Left-click + Drag: Pan image<br>" +
+                  "&nbsp;&nbsp;G: Toggle Grid View (not implemented)<br><br>" +
+                  "<b>Rating & Stacking:</b><br>" +
+                  "&nbsp;&nbsp;Space: Toggle Flag<br>" +
+                  "&nbsp;&nbsp;X: Toggle Reject<br>" +
+                  "&nbsp;&nbsp;S: Add to selection for Helicon<br>" +
+                  "&nbsp;&nbsp;[: Begin new stack<br>" +
+                  "&nbsp;&nbsp;]: End current stack<br>" +
+                  "&nbsp;&nbsp;C: Clear all stacks<br><br>" +
+                  "<b>Actions:</b><br>" +
+                  "&nbsp;&nbsp;Enter: Launch Helicon Focus"
+            padding: 10
+            wrapMode: Text.WordWrap
+            color: root.currentTextColor
+        }
+    }
+
+    Dialog {
+        id: showStacksDialog
+        title: "Stack Information"
+        standardButtons: Dialog.Ok
+        modal: true
+        width: 400
+        height: 300
+
+        background: Rectangle {
+            color: root.currentBackgroundColor
+        }
+
+        contentItem: Text {
+            text: uiState.stackSummary || "No stacks defined."
+            padding: 10
+            wrapMode: Text.WordWrap
+            color: root.currentTextColor
+        }
+    }
+
+    SettingsDialog {
+        id: settingsDialog
+    }
+
+    FilterDialog {
+        id: filterDialog
+        onAccepted: {
+            uiState.applyFilter(filterString)
+        }
+    }
+}
\ No newline at end of file
diff --git a/faststack/faststack/tests/test_executable_validator.py b/faststack/faststack/tests/test_executable_validator.py
new file mode 100644
index 0000000..ac0815d
--- /dev/null
+++ b/faststack/faststack/tests/test_executable_validator.py
@@ -0,0 +1,130 @@
+"""Tests for executable path validation."""
+
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from faststack.io.executable_validator import (
+    validate_executable_path,
+    _is_executable,
+    _is_subpath,
+)
+
+
+def test_empty_path():
+    """Test that empty path is rejected."""
+    is_valid, error = validate_executable_path("")
+    assert not is_valid
+    assert "empty" in error.lower()
+
+
+def test_nonexistent_file():
+    """Test that nonexistent file is rejected."""
+    is_valid, error = validate_executable_path("C:\\nonexistent\\fake.exe")
+    assert not is_valid
+    assert "not found" in error.lower()
+
+
+def test_valid_photoshop_path():
+    """Test validation of a valid Photoshop path."""
+    photoshop_path = r"C:\Program Files\Adobe\Adobe Photoshop 2026\Photoshop.exe"
+    
+    # Mock the path checks
+    with patch('faststack.io.executable_validator.Path') as mock_path:
+        mock_path_instance = MagicMock()
+        mock_path.return_value.resolve.return_value = mock_path_instance
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = True
+        mock_path_instance.suffix.lower.return_value = '.exe'
+        mock_path_instance.name = "Photoshop.exe"
+        mock_path_instance.__str__ = lambda self: photoshop_path
+        
+        with patch('faststack.io.executable_validator._is_subpath', return_value=True):
+            is_valid, error = validate_executable_path(
+                photoshop_path,
+                app_type="photoshop"
+            )
+            assert is_valid
+            assert error is None
+
+
+def test_suspicious_path_with_traversal():
+    """Test that paths with directory traversal are flagged."""
+    suspicious_path = r"C:\Program Files\..\Windows\System32\malware.exe"
+    
+    with patch('faststack.io.executable_validator.Path') as mock_path:
+        mock_path_instance = MagicMock()
+        mock_path.return_value.resolve.return_value = mock_path_instance
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = True
+        mock_path_instance.suffix.lower.return_value = '.exe'
+        mock_path_instance.name = "malware.exe"
+        mock_path_instance.__str__ = lambda self: r"C:\Windows\System32\malware.exe"
+        
+        # The normalized path will differ from input, triggering warning
+        is_valid, error = validate_executable_path(suspicious_path)
+        # Should still pass but with a warning logged
+        # (in production, you might want to make this fail)
+
+
+def test_non_exe_file():
+    """Test that non-executable files are rejected on Windows."""
+    txt_file = r"C:\Program Files\test.txt"
+    
+    with patch('faststack.io.executable_validator.Path') as mock_path:
+        mock_path_instance = MagicMock()
+        mock_path.return_value.resolve.return_value = mock_path_instance
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = True
+        mock_path_instance.suffix.lower.return_value = '.txt'
+        
+        is_valid, error = validate_executable_path(txt_file)
+        assert not is_valid
+        assert "not executable" in error.lower()
+
+
+def test_is_executable_windows():
+    """Test _is_executable on Windows."""
+    with patch('os.name', 'nt'):
+        exe_path = MagicMock()
+        exe_path.suffix.lower.return_value = '.exe'
+        assert _is_executable(exe_path)
+        
+        txt_path = MagicMock()
+        txt_path.suffix.lower.return_value = '.txt'
+        assert not _is_executable(txt_path)
+
+
+def test_is_subpath():
+    """Test _is_subpath logic."""
+    # This is hard to test without real paths, so we'll test the logic
+    parent = Path(r"C:\Program Files")
+    child = Path(r"C:\Program Files\Adobe\Photoshop.exe")
+    
+    # Mock the relative_to to simulate success
+    with patch.object(Path, 'resolve') as mock_resolve:
+        mock_resolve.return_value.relative_to = MagicMock()
+        result = _is_subpath(child, parent)
+        assert result
+
+
+def test_wrong_executable_name_for_type():
+    """Test that wrong executable names generate warnings but don't fail."""
+    wrong_exe = r"C:\Program Files\Adobe\NotPhotoshop.exe"
+    
+    with patch('faststack.io.executable_validator.Path') as mock_path:
+        mock_path_instance = MagicMock()
+        mock_path.return_value.resolve.return_value = mock_path_instance
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = True
+        mock_path_instance.suffix.lower.return_value = '.exe'
+        mock_path_instance.name = "NotPhotoshop.exe"
+        mock_path_instance.__str__ = lambda self: wrong_exe
+        
+        with patch('faststack.io.executable_validator._is_subpath', return_value=True):
+            # Should still pass, but with a warning logged
+            is_valid, error = validate_executable_path(
+                wrong_exe,
+                app_type="photoshop"
+            )
+            assert is_valid  # Name mismatch is warning, not failure
diff --git a/faststack/faststack/ui/keystrokes.py b/faststack/faststack/ui/keystrokes.py
index 2db830c..699f6ee 100644
--- a/faststack/faststack/ui/keystrokes.py
+++ b/faststack/faststack/ui/keystrokes.py
@@ -43,6 +43,7 @@ def __init__(self, controller):
 
         self.modifier_key_map = {
             (Qt.Key_C, Qt.ControlModifier): "copy_path_to_clipboard",
+            (Qt.Key_0, Qt.ControlModifier): "reset_zoom_pan",
         }
 
     def _call(self, method_name: str):
diff --git a/faststack/faststack/ui/keystrokes.py.bak b/faststack/faststack/ui/keystrokes.py.bak
new file mode 100644
index 0000000..812a764
--- /dev/null
+++ b/faststack/faststack/ui/keystrokes.py.bak
@@ -0,0 +1,45 @@
+"""Maps Qt Key events to application actions."""
+
+import logging
+from PySide6.QtCore import Qt
+
+log = logging.getLogger(__name__)
+
+class Keybinder:
+    def __init__(self, main_window):
+        self.main_window = main_window
+        self.key_map = {
+            # Navigation
+            Qt.Key.Key_J: self.main_window.next_image,
+            Qt.Key.Key_Right: self.main_window.next_image,
+            Qt.Key.Key_K: self.main_window.prev_image,
+            Qt.Key.Key_Left: self.main_window.prev_image,
+
+            # View Mode
+            Qt.Key.Key_G: self.main_window.toggle_grid_view,
+
+            # Metadata
+            Qt.Key.Key_Space: self.main_window.toggle_current_flag,
+            Qt.Key.Key_X: self.main_window.toggle_current_reject,
+
+            # Stacking
+            Qt.Key.Key_BracketLeft: self.main_window.begin_new_stack,
+            Qt.Key.Key_BracketRight: self.main_window.end_current_stack,
+
+            # Actions
+            Qt.Key.Key_S: self.main_window.toggle_selection,
+            Qt.Key.Key_Enter: self.main_window.launch_helicon,
+            Qt.Key.Key_Return: self.main_window.launch_helicon,
+
+            # Stack Management
+            Qt.Key.Key_C: self.main_window.clear_all_stacks,
+        }
+
+    def handle_key_press(self, event):
+        """Handles a key press event from the main window."""
+        log.info(f"Key pressed: {event.key()}")
+        action = self.key_map.get(event.key())
+        if action:
+            action()
+            return True
+        return False
diff --git a/faststack/faststack/ui/provider.py b/faststack/faststack/ui/provider.py
index d5fee0e..86b4609 100644
--- a/faststack/faststack/ui/provider.py
+++ b/faststack/faststack/ui/provider.py
@@ -58,6 +58,9 @@ class UIState(QObject):
     preloadProgressChanged = Signal()
     isZoomedChanged = Signal()
     statusMessageChanged = Signal() # New signal for status messages
+    resetZoomPanRequested = Signal() # Signal to tell QML to reset zoom/pan
+    stackSummaryChanged = Signal() # Signal for stack summary updates
+    filterStringChanged = Signal() # Signal for filter string updates
 
     def __init__(self, app_controller):
         super().__init__()
@@ -148,8 +151,8 @@ def stackedDate(self):
     def stackInfoText(self):
         return self.app_controller.get_current_metadata().get("stack_info_text", "")
 
-    @Property(str, notify=metadataChanged)
-    def get_stack_summary(self):
+    @Property(str, notify=stackSummaryChanged)
+    def stackSummary(self):
         if not self.app_controller.stacks:
             return "No stacks defined."
         summary = f"Found {len(self.app_controller.stacks)} stacks:\n\n"
@@ -168,6 +171,16 @@ def statusMessage(self, value: str):
             self._status_message = value
             self.statusMessageChanged.emit()
 
+    @Property(str, notify=filterStringChanged)
+    def filterString(self):
+        """Returns the current filter string (empty if no filter active)."""
+        return self.app_controller.get_filter_string()
+
+    @Property(str, constant=True)
+    def currentDirectory(self):
+        """Returns the path of the current working directory."""
+        return str(self.app_controller.image_dir)
+
     # --- Slots for QML to call ---
     @Slot()
     def nextImage(self):
@@ -259,3 +272,8 @@ def preloadAllImages(self):
     def onDisplaySizeChanged(self, width: int, height: int):
         self.app_controller.on_display_size_changed(width, height)
 
+    @Slot()
+    def resetZoomPan(self):
+        """Triggers a reset of zoom and pan in QML."""
+        self.resetZoomPanRequested.emit()
+
diff --git a/faststack/faststack/ui/provider.py.bak b/faststack/faststack/ui/provider.py.bak
new file mode 100644
index 0000000..fad115f
--- /dev/null
+++ b/faststack/faststack/ui/provider.py.bak
@@ -0,0 +1,247 @@
+"""QML Image Provider and application state bridge."""
+
+import logging
+from typing import Optional
+
+import numpy as np
+from PySide6.QtCore import QObject, Signal, Property, QUrl, Slot, Qt
+from PySide6.QtGui import QImage
+from PySide6.QtQuick import QQuickImageProvider
+
+from faststack.models import DecodedImage
+
+log = logging.getLogger(__name__)
+
+class ImageProvider(QQuickImageProvider):
+    def __init__(self, app_controller):
+        super().__init__(QQuickImageProvider.ImageType.Image)
+        self.app_controller = app_controller
+        self.placeholder = QImage(256, 256, QImage.Format.Format_RGB888)
+        self.placeholder.fill(Qt.GlobalColor.darkGray)
+
+    def requestImage(self, id: str, size: object, requestedSize: object) -> QImage:
+        """Handles image requests from QML."""
+        if not id:
+            return self.placeholder
+
+        # The ID is expected to be the image index
+        try:
+            image_index_str = id.split('/')[0]
+            index = int(image_index_str)
+            image_data = self.app_controller.get_decoded_image(index)
+
+            if image_data:
+                # Zero-copy QImage from numpy buffer
+                qimg = QImage(
+                    image_data.buffer,
+                    image_data.width,
+                    image_data.height,
+                    image_data.bytes_per_line,
+                    QImage.Format.Format_RGB888
+                )
+                # Keep a reference to the original buffer to prevent garbage collection
+                qimg.original_buffer = image_data.buffer
+                return qimg
+
+        except (ValueError, IndexError) as e:
+            log.error(f"Invalid image ID requested from QML: {id}. Error: {e}")
+        
+        return self.placeholder
+
+class UIState(QObject):
+    """Manages the state exposed to the QML user interface."""
+
+    # Signals
+    currentIndexChanged = Signal()
+    imageCountChanged = Signal()
+    currentImageSourceChanged = Signal()
+    metadataChanged = Signal()
+    themeChanged = Signal()
+    preloadingStateChanged = Signal()
+    preloadProgressChanged = Signal()
+    isZoomedChanged = Signal()
+
+    def __init__(self, app_controller):
+        super().__init__()
+        self.app_controller = app_controller
+        self._is_preloading = False
+        self._preload_progress = 0
+        self._theme = 1
+        @Property(int, notify=themeChanged)
+
+    def theme(self):
+        return self._theme
+
+    @theme.setter
+    def theme(self, value: int):
+        value = int(value)
+        if value == self._theme:
+            return
+        self._theme = value
+        self.themeChanged.emit()
+
+
+    @Property(bool, notify=isZoomedChanged)
+    def isZoomed(self):
+        return self.app_controller.is_zoomed
+
+    @Slot(bool)
+    def setZoomed(self, zoomed: bool):
+        self.app_controller.set_zoomed(zoomed)
+
+    @Property(bool, notify=preloadingStateChanged)
+    def isPreloading(self):
+        return self._is_preloading
+
+    @isPreloading.setter
+    def isPreloading(self, value):
+        if self._is_preloading != value:
+            self._is_preloading = value
+            self.preloadingStateChanged.emit()
+
+    @Property(int, notify=preloadProgressChanged)
+    def preloadProgress(self):
+        return self._preload_progress
+
+    @preloadProgress.setter
+    def preloadProgress(self, value):
+        if self._preload_progress != value:
+            self._preload_progress = value
+            self.preloadProgressChanged.emit()
+
+    @Property(int, notify=currentIndexChanged)
+    def currentIndex(self):
+        return self.app_controller.current_index
+
+    @Property(int, notify=imageCountChanged)
+    def imageCount(self):
+        return len(self.app_controller.image_files)
+
+    @Property(str, notify=currentImageSourceChanged)
+    def currentImageSource(self):
+        # The source is the provider ID, which we tie to the index and a generation counter
+        # to force QML to request a new image even if the index is the same.
+        return f"image://provider/{self.app_controller.current_index}/{self.app_controller.ui_refresh_generation}"
+
+    # --- Metadata Properties ---
+    @Property(str, notify=metadataChanged)
+    def currentFilename(self):
+        return self.app_controller.get_current_metadata().get("filename", "")
+
+    @Property(bool, notify=metadataChanged)
+    def isFlagged(self):
+        return self.app_controller.get_current_metadata().get("flag", False)
+
+    @Property(bool, notify=metadataChanged)
+    def isRejected(self):
+        return self.app_controller.get_current_metadata().get("reject", False)
+
+    @Property(bool, notify=metadataChanged)
+    def isStacked(self):
+        return self.app_controller.get_current_metadata().get("stacked", False)
+
+    @Property(str, notify=metadataChanged)
+    def stackedDate(self):
+        return self.app_controller.get_current_metadata().get("stacked_date", "")
+
+    @Property(str, notify=metadataChanged)
+    def stackInfoText(self):
+        return self.app_controller.get_current_metadata().get("stack_info_text", "")
+
+    @Property(str, notify=metadataChanged)
+    def get_stack_summary(self):
+        if not self.app_controller.stacks:
+            return "No stacks defined."
+
+        summary = f"Found {len(self.app_controller.stacks)} stacks:\n\n"
+        for i, (start, end) in enumerate(self.app_controller.stacks):
+            count = end - start + 1
+            summary += f"Stack {i+1}: {count} photos (indices {start}-{end})\n"
+        return summary
+
+    # --- Slots for QML to call ---
+    @Slot()
+    def nextImage(self):
+        self.app_controller.next_image()
+
+    @Slot()
+    def prevImage(self):
+        self.app_controller.prev_image()
+
+    @Slot()
+    def toggleFlag(self):
+        self.app_controller.toggle_current_flag()
+
+    @Slot()
+    def launch_helicon(self):
+        self.app_controller.launch_helicon()
+
+    @Slot()
+    def clear_all_stacks(self):
+        self.app_controller.clear_all_stacks()
+
+    @Slot(result=str)
+    def get_helicon_path(self):
+        return self.app_controller.get_helicon_path()
+
+    @Slot(str)
+    def set_helicon_path(self, path):
+        self.app_controller.set_helicon_path(path)
+
+    @Slot(result=str)
+    def open_file_dialog(self):
+        return self.app_controller.open_file_dialog()
+
+    @Slot(str, result=bool)
+    def check_path_exists(self, path):
+        return self.app_controller.check_path_exists(path)
+
+    @Slot(result=float)
+    def get_cache_size(self):
+        return self.app_controller.get_cache_size()
+
+    @Slot(float)
+    def set_cache_size(self, size):
+        self.app_controller.set_cache_size(size)
+
+    @Slot(result=int)
+    def get_prefetch_radius(self):
+        return self.app_controller.get_prefetch_radius()
+
+    @Slot(int)
+    def set_prefetch_radius(self, radius):
+        self.app_controller.set_prefetch_radius(radius)
+
+    @Slot(result=int)
+    def get_theme(self):
+        return self.app_controller.get_theme()
+
+    @Slot(int)
+    def set_theme(self, theme_index):
+        # update UI property
+        self.ui_state.theme = theme_index
+
+        # persist
+        theme = 'dark' if theme_index == 0 else 'light'
+        config.set('core', 'theme', theme)
+        config.save()
+
+    @Slot(result=str)
+    def get_default_directory(self):
+        return self.app_controller.get_default_directory()
+
+    @Slot(str)
+    def set_default_directory(self, path):
+        self.app_controller.set_default_directory(path)
+
+    @Slot(result=str)
+    def open_directory_dialog(self):
+        return self.app_controller.open_directory_dialog()
+
+    @Slot()
+    def preloadAllImages(self):
+        self.app_controller.preload_all_images()
+
+    @Slot(int, int)
+    def onDisplaySizeChanged(self, width: int, height: int):
+        self.app_controller.on_display_size_changed(width, height)
diff --git a/faststack/pyproject.toml b/faststack/pyproject.toml
index 435bca8..b059ff2 100644
--- a/faststack/pyproject.toml
+++ b/faststack/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "faststack"
-version = "0.6"
+version = "0.7"
 authors = [
     { name="Alan Rockefeller", email="alanrockefeller@gmail.com" },
 ]
diff --git a/run_app.py b/run_app.py
new file mode 100644
index 0000000..e1cd53c
--- /dev/null
+++ b/run_app.py
@@ -0,0 +1,10 @@
+import sys
+import os
+from pathlib import Path
+
+# Add the directory containing the 'faststack' package to the Python path
+sys.path.insert(0, str(Path(__file__).parent / "faststack"))
+
+# Now, try to run the module
+import runpy
+runpy.run_module('faststack.app', run_name='__main__', alter_sys=True)
\ No newline at end of file