Merge pull request 'Bugfixes from dev' (#68) from Dev into Stable

Reviewed-on: #68

.gitignore

@@ -30,6 +30,6 @@ Thumbs.db
 gui/__pycache__
 __pycache__
 
-Testfiles
-Testfiles/
+
+Testfiles/TestOutputs
 Testfiles_

.roo/mcp.json

@@ -0,0 +1,45 @@
+{
+  "mcpServers": {
+    "conport": {
+      "command": "C:\\Users\\theis\\context-portal\\.venv\\Scripts\\python.exe",
+      "args": [
+        "C:\\Users\\theis\\context-portal\\src\\context_portal_mcp\\main.py",
+        "--mode",
+        "stdio",
+        "--workspace_id",
+        "${workspaceFolder}"
+      ],
+      "alwaysAllow": [
+        "get_product_context",
+        "update_product_context",
+        "get_active_context",
+        "update_active_context",
+        "log_decision",
+        "get_decisions",
+        "search_decisions_fts",
+        "log_progress",
+        "get_progress",
+        "update_progress",
+        "delete_progress_by_id",
+        "log_system_pattern",
+        "get_system_patterns",
+        "log_custom_data",
+        "get_custom_data",
+        "delete_custom_data",
+        "search_project_glossary_fts",
+        "export_conport_to_markdown",
+        "import_markdown_to_conport",
+        "link_conport_items",
+        "search_custom_data_value_fts",
+        "get_linked_items",
+        "batch_log_items",
+        "get_item_history",
+        "delete_decision_by_id",
+        "delete_system_pattern_by_id",
+        "get_conport_schema",
+        "get_recent_activity_summary",
+        "semantic_search_conport"
+      ]
+    }
+  }
+}

.roomodes

@@ -0,0 +1,3 @@
+{
+  "customModes": []
+}

AUTOTEST_GUI_PLAN.md

@@ -0,0 +1,112 @@
+# Plan for Autotest GUI Mode Implementation
+
+**I. Objective:**
+Create an `autotest.py` script that can launch the Asset Processor GUI headlessly, load a predefined asset (`.zip`), select a predefined preset, verify the predicted rule structure against an expected JSON, trigger processing to a predefined output directory, check the output, and analyze logs for errors or specific messages. This serves as a sanity check for core GUI-driven workflows.
+
+**II. `TestFiles` Directory:**
+A new directory named `TestFiles` will be created in the project root (`c:/Users/Theis/Assetprocessor/Asset-Frameworker/TestFiles/`). This directory will house:
+*   Sample asset `.zip` files for testing (e.g., `TestFiles/SampleAsset1.zip`).
+*   Expected rule structure JSON files (e.g., `TestFiles/SampleAsset1_PresetX_expected_rules.json`).
+*   A subdirectory for test outputs (e.g., `TestFiles/TestOutputs/`).
+
+**III. `autotest.py` Script:**
+
+1.  **Location:** `c:/Users/Theis/Assetprocessor/Asset-Frameworker/autotest.py` (or `scripts/autotest.py`).
+2.  **Command-Line Arguments (with defaults pointing to `TestFiles/`):**
+    *   `--zipfile`: Path to the test asset. Default: `TestFiles/default_test_asset.zip`.
+    *   `--preset`: Name of the preset. Default: `DefaultTestPreset`.
+    *   `--expectedrules`: Path to expected rules JSON. Default: `TestFiles/default_test_asset_rules.json`.
+    *   `--outputdir`: Path for processing output. Default: `TestFiles/TestOutputs/DefaultTestOutput`.
+    *   `--search` (optional): Log search term. Default: `None`.
+    *   `--additional-lines` (optional): Context lines for log search. Default: `0`.
+3.  **Core Structure:**
+    *   Imports necessary modules from the main application and PySide6.
+    *   Adds project root to `sys.path` for imports.
+    *   `AutoTester` class:
+        *   **`__init__(self, app_instance: App)`:**
+            *   Stores `app_instance` and `main_window`.
+            *   Initializes `QEventLoop`.
+            *   Connects `app_instance.all_tasks_finished` to `self._on_all_tasks_finished`.
+            *   Loads expected rules from the `--expectedrules` file.
+        *   **`run_test(self)`:** Orchestrates the test steps sequentially:
+            1.  Load ZIP (`main_window.add_input_paths()`).
+            2.  Select Preset (`main_window.preset_editor_widget.editor_preset_list.setCurrentItem()`).
+            3.  Await Prediction (using `QTimer` to poll `main_window._pending_predictions`, manage with `QEventLoop`).
+            4.  Retrieve & Compare Rulelist:
+                *   Get actual rules: `main_window.unified_model.get_all_source_rules()`.
+                *   Convert actual rules to comparable dict (`_convert_rules_to_comparable()`).
+                *   Compare with loaded expected rules (`_compare_rules()`). If mismatch, log and fail.
+            5.  Start Processing (emit `main_window.start_backend_processing` with rules and output settings).
+            6.  Await Processing (use `QEventLoop` waiting for `_on_all_tasks_finished`).
+            7.  Check Output Path (verify existence of output dir, list contents, basic sanity checks like non-emptiness or presence of key asset folders).
+            8.  Retrieve & Analyze Logs (`main_window.log_console.log_console_output.toPlainText()`, filter by `--search`, check for tracebacks).
+            9.  Report result and call `cleanup_and_exit()`.
+        *   **`_check_prediction_status(self)`:** Slot for prediction polling timer.
+        *   **`_on_all_tasks_finished(self, processed_count, skipped_count, failed_count)`:** Slot for `App.all_tasks_finished` signal.
+        *   **`_convert_rules_to_comparable(self, source_rules_list: List[SourceRule]) -> dict`:** Converts `SourceRule` objects to the JSON structure defined below.
+        *   **`_compare_rules(self, actual_rules_data: dict, expected_rules_data: dict) -> bool`:** Implements Option 1 comparison logic:
+            *   Errors if an expected field is missing or its value mismatches.
+            *   Logs (but doesn't error on) fields present in actual but not in expected.
+        *   **`_process_and_display_logs(self, logs_text: str)`:** Handles log filtering/display.
+        *   **`cleanup_and_exit(self, success=True)`:** Quits `QCoreApplication` and `sys.exit()`.
+    *   `main()` function:
+        *   Parses CLI arguments.
+        *   Initializes `QApplication`.
+        *   Instantiates `main.App()` (does *not* show the GUI).
+        *   Instantiates `AutoTester(app_instance)`.
+        *   Uses `QTimer.singleShot(0, tester.run_test)` to start the test.
+        *   Runs `q_app.exec()`.
+
+**IV. `expected_rules.json` Structure (Revised):**
+Located in `TestFiles/`. Example: `TestFiles/SampleAsset1_PresetX_expected_rules.json`.
+```json
+{
+  "source_rules": [
+    {
+      "input_path": "SampleAsset1.zip",
+      "supplier_identifier": "ExpectedSupplier",
+      "preset_name": "PresetX",
+      "assets": [
+        {
+          "asset_name": "AssetNameFromPrediction",
+          "asset_type": "Prop",
+          "files": [
+            {
+              "file_path": "relative/path/to/file1.png",
+              "item_type": "MAP_COL",
+              "target_asset_name_override": null
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+**V. Mermaid Diagram of Autotest Flow:**
+```mermaid
+graph TD
+    A[Start autotest.py with CLI Args (defaults to TestFiles/)] --> B{Setup Args & Logging};
+    B --> C[Init QApplication & main.App (GUI Headless)];
+    C --> D[Instantiate AutoTester(app_instance)];
+    D --> E[QTimer.singleShot -> AutoTester.run_test()];
+
+    subgraph AutoTester.run_test()
+        E --> F[Load Expected Rules from --expectedrules JSON];
+        F --> G[Load ZIP (--zipfile) via main_window.add_input_paths()];
+        G --> H[Select Preset (--preset) via main_window.preset_editor_widget];
+        H --> I[Await Prediction (Poll main_window._pending_predictions via QTimer & QEventLoop)];
+        I -- Prediction Done --> J[Get Actual Rules from main_window.unified_model];
+        J --> K[Convert Actual Rules to Comparable JSON Structure];
+        K --> L{Compare Actual vs Expected Rules (Option 1 Logic)};
+        L -- Match --> M[Start Processing (Emit main_window.start_backend_processing with --outputdir)];
+        L -- Mismatch --> ZFAIL[Log Mismatch & Call cleanup_and_exit(False)];
+        M --> N[Await Processing (QEventLoop for App.all_tasks_finished signal)];
+        N -- Processing Done --> O[Check Output Dir (--outputdir): Exists? Not Empty? Key Asset Folders?];
+        O --> P[Retrieve & Analyze Logs (Search, Tracebacks)];
+        P --> Q[Log Test Success & Call cleanup_and_exit(True)];
+    end
+
+    ZFAIL --> ZEND[AutoTester.cleanup_and_exit() -> QCoreApplication.quit() & sys.exit()];
+    Q --> ZEND;

Documentation/01_User_Guide/02_Features.md

@@ -16,6 +16,7 @@ This document outlines the key features of the Asset Processor Tool.
     *   Saves maps in appropriate formats (JPG, PNG, EXR) based on complex rules involving map type (`FORCE_LOSSLESS_MAP_TYPES`), resolution (`RESOLUTION_THRESHOLD_FOR_JPG`), bit depth, and source format.
     *   Calculates basic image statistics (Min/Max/Mean) for a reference resolution.
     *   Calculates and stores the relative aspect ratio change string in metadata (e.g., `EVEN`, `X150`, `Y125`).
+    *   **Low-Resolution Fallback:** If enabled (`ENABLE_LOW_RESOLUTION_FALLBACK`), automatically saves an additional "LOWRES" variant of source images if their largest dimension is below a configurable threshold (`LOW_RESOLUTION_THRESHOLD`). This "LOWRES" variant uses the original image dimensions and is saved in addition to any standard resolution outputs.
 *   **Channel Merging:** Combines channels from different maps into packed textures (e.g., NRMRGH) based on preset rules (`MAP_MERGE_RULES` in `config.py`).
 *   **Metadata Generation:** Creates a `metadata.json` file for each asset containing details about maps, category, archetype, aspect ratio change, processing settings, etc.
 *   **Output Organization:** Creates a clean, structured output directory (`<output_base>/<supplier>/<asset_name>/`).

Documentation/01_User_Guide/04_Configuration_and_Presets.md

@@ -13,9 +13,21 @@ The `app_settings.json` file is structured into several key sections, including:
 *   `ASSET_TYPE_DEFINITIONS`: Defines known asset types (like Surface, Model, Decal) and their properties.
 *   `MAP_MERGE_RULES`: Defines how multiple input maps can be merged into a single output map (e.g., combining Normal and Roughness into one).
 
+### Low-Resolution Fallback Settings
+
+These settings control the generation of low-resolution "fallback" variants for source images:
+
+*   `ENABLE_LOW_RESOLUTION_FALLBACK` (boolean, default: `true`):
+    *   If `true`, the tool will generate an additional "LOWRES" variant for source images whose largest dimension is smaller than the `LOW_RESOLUTION_THRESHOLD`.
+    *   This "LOWRES" variant uses the original dimensions of the source image and is saved in addition to any other standard resolution outputs (e.g., 1K, PREVIEW).
+    *   If `false`, this feature is disabled.
+*   `LOW_RESOLUTION_THRESHOLD` (integer, default: `512`):
+    *   Defines the pixel dimension (for the largest side of an image) below which the "LOWRES" fallback variant will be generated (if enabled).
+    *   For example, if set to `512`, any source image smaller than 512x512 (e.g., 256x512, 128x128) will have a "LOWRES" variant created.
+
 ### LLM Predictor Settings
 
-For users who wish to utilize the experimental LLM Predictor feature, the following settings are available in `config/app_settings.json`:
+For users who wish to utilize the experimental LLM Predictor feature, the following settings are available in `config/llm_settings.json`:
 
 *   `llm_endpoint_url`: The URL of the LLM API endpoint. For local LLMs like LM Studio or Ollama, this will typically be `http://localhost:<port>/v1`. Consult your LLM server documentation for the exact endpoint.
 *   `llm_api_key`: The API key required to access the LLM endpoint. Some local LLM servers may not require a key, in which case this can be left empty.
@@ -23,15 +35,39 @@ For users who wish to utilize the experimental LLM Predictor feature, the follow
 *   `llm_temperature`: Controls the randomness of the LLM's output. Lower values (e.g., 0.1-0.5) make the output more deterministic and focused, while higher values (e.g., 0.6-1.0) make it more creative and varied. For prediction tasks, lower temperatures are generally recommended.
 *   `llm_request_timeout`: The maximum time (in seconds) to wait for a response from the LLM API. Adjust this based on the performance of your LLM server and the complexity of the requests.
 
-Note that the `llm_predictor_prompt` and `llm_predictor_examples` settings are also present in `app_settings.json`. These define the instructions and examples provided to the LLM for prediction. While they can be viewed here, they are primarily intended for developer reference and tuning the LLM's behavior, and most users will not need to modify them.
+Note that the `llm_predictor_prompt` and `llm_predictor_examples` settings are also present in `config/llm_settings.json`. These define the instructions and examples provided to the LLM for prediction. While they can be viewed here, they are primarily intended for developer reference and tuning the LLM's behavior, and most users will not need to modify them directly via the file. These settings are editable via the LLM Editor panel in the main GUI when the LLM interpretation mode is selected.
 
-## GUI Configuration Editor
+## Application Preferences (`config/app_settings.json` overrides)
 
-You can modify the `app_settings.json` file using the built-in GUI editor. Access it via the **Edit** -> **Preferences...** menu.
+You can modify user-overridable application settings using the built-in GUI editor. These settings are loaded from `config/app_settings.json` and saved as overrides in `config/user_settings.json`. Access it via the **Edit** -> **Preferences...** menu.
 
-This editor provides a tabbed interface (e.g., "General", "Output & Naming") to view and change the core application settings defined in `app_settings.json`. Settings in the editor directly correspond to the structure and values within the JSON file. Note that any changes made through the GUI editor require an application restart to take effect.
+This editor provides a tabbed interface to view and change various application behaviors. The tabs include:
+*   **General:** Basic settings like output base directory and temporary file prefix.
+*   **Output & Naming:** Settings controlling output directory and filename patterns, and how variants are handled.
+*   **Image Processing:** Settings related to image resolution definitions, compression levels, and format choices.
+*   **Map Merging:** Configuration for how multiple input maps are combined into single output maps.
+*   **Postprocess Scripts:** Paths to default Blender files for post-processing.
 
-*(Ideally, a screenshot of the GUI Configuration Editor would be included here.)*
+Note that this editor focuses on user-specific overrides of core application settings. **Asset Type Definitions, File Type Definitions, and Supplier Settings are managed in a separate Definitions Editor.**
+
+Any changes made through the Preferences editor require an application restart to take effect.
+
+*(Ideally, a screenshot of the Application Preferences editor would be included here.)*
+
+## Definitions Editor (`config/asset_type_definitions.json`, `config/file_type_definitions.json`, `config/suppliers.json`)
+
+Core application definitions that are separate from general user preferences are managed in the dedicated Definitions Editor. This includes defining known asset types, file types, and configuring settings specific to different suppliers. Access it via the **Edit** -> **Edit Definitions...** menu.
+
+The editor is organized into three tabs:
+*   **Asset Type Definitions:** Define the different categories of assets (e.g., Surface, Model, Decal). For each asset type, you can configure its description, a color for UI representation, and example usage strings.
+*   **File Type Definitions:** Define the specific types of files the tool recognizes (e.g., MAP_COL, MAP_NRM, MODEL). For each file type, you can configure its description, a color, example keywords/patterns, a standard type alias, bit depth handling rules, whether it's grayscale, and an optional keybind for quick assignment in the GUI.
+*   **Supplier Settings:** Configure settings that are specific to assets originating from different suppliers. Currently, this includes the "Normal Map Type" (OpenGL or DirectX) used for normal maps from that supplier.
+
+Each tab presents a list of the defined items on the left (Asset Types, File Types, or Suppliers). Selecting an item in the list displays its configurable details on the right. Buttons are provided to add new definitions or remove existing ones.
+
+Changes made in the Definitions Editor are saved directly to their respective configuration files (`config/asset_type_definitions.json`, `config/file_type_definitions.json`, and `config/suppliers.json`). Some changes may require an application restart to take full effect in processing logic.
+
+*(Ideally, screenshots of the Definitions Editor tabs would be included here.)*
 
 ## Preset Files (`presets/*.json`)
 

Documentation/01_User_Guide/05_Usage_GUI.md

@@ -12,7 +12,10 @@ python -m gui.main_window
 
 ## Interface Overview
 
-*   **Menu Bar:** The "Edit" menu contains the "Preferences..." option to open the GUI Configuration Editor. The "View" menu allows you to toggle the visibility of the Log Console and the Detailed File Preview.
+*   **Menu Bar:** The "Edit" menu contains options to configure application settings and definitions:
+    *   **Preferences...:** Opens the Application Preferences editor for user-overridable settings (saved to `config/user_settings.json`).
+    *   **Edit Definitions...:** Opens the Definitions Editor for managing Asset Type Definitions, File Type Definitions, and Supplier Settings (saved to their respective files).
+The "View" menu allows you to toggle the visibility of the Log Console and the Detailed File Preview.
 *   **Preset Editor Panel (Left):**
     *   **Optional Log Console:** Displays application logs (toggle via View menu).
     *   **Preset List:** Create, delete, load, edit, and save presets. On startup, the "-- Select a Preset --" item is explicitly selected. You must select a specific preset from this list to load it into the editor below, enable the detailed file preview, and enable the "Start Processing" button.

Documentation/01_User_Guide/09_Output_Structure.md

@@ -2,7 +2,7 @@
 
 This document describes the directory structure and contents of the processed assets generated by the Asset Processor Tool.
 
-Processed assets are saved to a location determined by two global settings defined in `config/app_settings.json`:
+Processed assets are saved to a location determined by two global settings, `OUTPUT_DIRECTORY_PATTERN` and `OUTPUT_FILENAME_PATTERN`, defined in `config/app_settings.json`. These settings can be overridden by the user via `config/user_settings.json`.
 
 *   `OUTPUT_DIRECTORY_PATTERN`: Defines the directory structure *within* the Base Output Directory.
 *   `OUTPUT_FILENAME_PATTERN`: Defines the naming convention for individual files *within* the directory created by `OUTPUT_DIRECTORY_PATTERN`.
@@ -23,7 +23,7 @@ The following tokens can be used in both `OUTPUT_DIRECTORY_PATTERN` and `OUTPUT_
 *   `[Time]`: Current time (`HHMMSS`).
 *   `[Sha5]`: The first 5 characters of the SHA-256 hash of the original input source file (e.g., the source zip archive).
 *   `[ApplicationPath]`: Absolute path to the application directory.
-*   `[maptype]`: The standardized map type identifier (e.g., `COL` for Color/Albedo, `NRM` for Normal, `RGH` for Roughness). This is derived from the `standard_type` defined in the application's `FILE_TYPE_DEFINITIONS` (see `config/app_settings.json`) and may include a variant suffix if applicable. (Primarily for filename pattern)
+*   `[maptype]`: The standardized map type identifier (e.g., `COL` for Color/Albedo, `NRM` for Normal, `RGH` for Roughness). This is derived from the `standard_type` defined in the application's `FILE_TYPE_DEFINITIONS` (managed in `config/file_type_definitions.json` via the Definitions Editor) and may include a variant suffix if applicable. (Primarily for filename pattern)
 *   `[dimensions]`: Pixel dimensions (e.g., `2048x2048`).
 *   `[bitdepth]`: Output bit depth (e.g., `8bit`, `16bit`).
 *   `[category]`: Asset category determined by preset rules.
@@ -51,13 +51,14 @@ The final output path is constructed by combining the Base Output Directory (set
 *   `OUTPUT_FILENAME_PATTERN`: `[maptype].[ext]`
 *   Resulting Path for a Normal map: `Output/Texture/Wood/WoodFloor001/Normal.exr`
 
-The `<output_base_directory>` (the root folder where processing output starts) is configured separately via the GUI (**Edit** -> **Preferences...** -> **Output & Naming** tab -> **Base Output Directory**) or the `--output` CLI argument. The `OUTPUT_DIRECTORY_PATTERN` defines the structure *within* this base directory, and `OUTPUT_FILENAME_PATTERN` defines the filenames within that structure.
+The `<output_base_directory>` (the root folder where processing output starts) is configured separately via the GUI (**Edit** -> **Preferences...** -> **General** tab -> **Output Base Directory**) or the `--output` CLI argument. The `OUTPUT_DIRECTORY_PATTERN` defines the structure *within* this base directory, and `OUTPUT_FILENAME_PATTERN` defines the filenames within that structure.
 
 ## Contents of Each Asset Directory
 
 Each asset directory contains the following:
 
 *   Processed texture maps (e.g., `WoodFloor_Albedo_4k.png`, `MetalPanel_Normal_2k.exr`). The exact filenames depend on the `OUTPUT_FILENAME_PATTERN`. These are the resized, format-converted, and bit-depth adjusted texture files.
+    *   **LOWRES Variants:** If the "Low-Resolution Fallback" feature is enabled and a source image's dimensions are below the configured threshold, an additional variant with "LOWRES" as its resolution token (e.g., `MyTexture_COL_LOWRES.png`) will be saved. This variant uses the original dimensions of the source image.
 *   Merged texture maps (e.g., `WoodFloor_Combined_4k.png`). The exact filenames depend on the `OUTPUT_FILENAME_PATTERN`. These are maps created by combining channels from different source maps based on the configured merge rules.
 *   Model files (if present in the source asset).
 *   `metadata.json`: A JSON file containing detailed information about the asset and the processing that was performed. This includes details about the maps (resolutions, formats, bit depths, and for roughness maps, a `derived_from_gloss_filename: true` flag if it was inverted from an original gloss map), merged map details, calculated image statistics, aspect ratio change information, asset category and archetype, the source preset used, and a list of ignored source files. This file is intended for use by downstream tools or scripts (like the Blender integration scripts).

Documentation/01_User_Guide/11_Usage_Autotest.md

@@ -0,0 +1,83 @@
+# User Guide: Usage - Automated GUI Testing (`autotest.py`)
+
+This document explains how to use the `autotest.py` script for automated sanity checks of the Asset Processor Tool's GUI-driven workflow.
+
+## Overview
+
+The `autotest.py` script provides a way to run predefined test scenarios headlessly (without displaying the GUI). It simulates the core user actions: loading an asset, selecting a preset, allowing rules to be predicted, processing the asset, and then checks the results against expectations. This is primarily intended as a developer tool for regression testing and ensuring core functionality remains stable.
+
+## Running the Autotest Script
+
+From the project root directory, you can run the script using Python:
+
+```bash
+python autotest.py [OPTIONS]
+```
+
+### Command-Line Options
+
+The script accepts several command-line arguments to configure the test run. If not provided, they use predefined default values.
+
+*   `--zipfile PATH_TO_ZIP`:
+    *   Specifies the path to the input asset `.zip` file to be used for the test.
+    *   Default: `TestFiles/BoucleChunky001.zip`
+*   `--preset PRESET_NAME`:
+    *   Specifies the name of the preset to be selected and used for rule prediction and processing.
+    *   Default: `Dinesen`
+*   `--expectedrules PATH_TO_JSON`:
+    *   Specifies the path to a JSON file containing the expected rule structure that should be generated after the preset is applied to the input asset.
+    *   Default: `TestFiles/test-BoucleChunky001.json`
+*   `--outputdir PATH_TO_DIR`:
+    *   Specifies the directory where the processed assets will be written.
+    *   Default: `TestFiles/TestOutputs/DefaultTestOutput`
+*   `--search "SEARCH_TERM"` (optional):
+    *   A string to search for within the application logs generated during the test run. If found, matching log lines (with context) will be highlighted.
+    *   Default: None
+*   `--additional-lines NUM_LINES` (optional):
+    *   When using `--search`, this specifies how many lines of context before and after each matching log line should be displayed.
+    *   Default: `0`
+
+**Example Usage:**
+
+```bash
+# Run with default test files and settings
+python autotest.py
+
+# Run with specific test files and search for a log message
+python autotest.py --zipfile TestFiles/MySpecificAsset.zip --preset MyPreset --expectedrules TestFiles/MySpecificAsset_rules.json --outputdir TestFiles/TestOutputs/MySpecificOutput --search "Processing complete for asset"
+```
+
+## `TestFiles` Directory
+
+The autotest script relies on a directory named `TestFiles` located in the project root. This directory should contain:
+
+*   **Test Asset `.zip` files:** The actual asset archives used as input for tests (e.g., `default_test_asset.zip`, `MySpecificAsset.zip`).
+*   **Expected Rules `.json` files:** JSON files defining the expected rule structure for a given asset and preset combination (e.g., `default_test_asset_rules.json`, `MySpecificAsset_rules.json`). The structure of this file is detailed in the main autotest plan (`AUTOTEST_GUI_PLAN.md`).
+*   **`TestOutputs/` subdirectory:** This is the default parent directory where the autotest script will create specific output folders for each test run (e.g., `TestFiles/TestOutputs/DefaultTestOutput/`).
+
+## Test Workflow
+
+When executed, `autotest.py` performs the following steps:
+
+1.  **Initialization:** Parses command-line arguments and initializes the main application components headlessly.
+2.  **Load Expected Rules:** Loads the `expected_rules.json` file.
+3.  **Load Asset:** Loads the specified `.zip` file into the application.
+4.  **Select Preset:** Selects the specified preset. This triggers the internal rule prediction process.
+5.  **Await Prediction:** Waits for the rule prediction to complete.
+6.  **Compare Rules:** Retrieves the predicted rules from the application and compares them against the loaded expected rules. If there's a mismatch, the test typically fails at this point.
+7.  **Start Processing:** If the rules match, it initiates the asset processing pipeline, directing output to the specified output directory.
+8.  **Await Processing:** Waits for all backend processing tasks to complete.
+9.  **Check Output:** Verifies the existence of the output directory and lists its contents. Basic checks ensure some output was generated.
+10. **Analyze Logs:** Retrieves logs from the application. If a search term was provided, it filters and displays relevant log portions. It also checks for Python tracebacks, which usually indicate a failure.
+11. **Report Result:** Prints a summary of the test outcome (success or failure) and exits with an appropriate status code (0 for success, 1 for failure).
+
+## Interpreting Results
+
+*   **Console Output:** The script will log its progress and the results of each step to the console.
+*   **Log Analysis:** Pay attention to the log output, especially if a `--search` term was used or if any tracebacks are reported.
+*   **Exit Code:**
+    *   `0`: Test completed successfully.
+    *   `1`: Test failed at some point (e.g., rule mismatch, processing error, traceback found).
+*   **Output Directory:** Inspect the contents of the specified output directory to manually verify the processed assets if needed.
+
+This automated test helps ensure the stability of the core processing logic when driven by GUI-equivalent actions.

Documentation/02_Developer_Guide/04_Configuration_System_and_Presets.md

@@ -2,43 +2,144 @@
 
 This document provides technical details about the configuration system and the structure of preset files for developers working on the Asset Processor Tool.
 
-## Configuration Flow
+## Configuration System Overview
 
-The tool utilizes a two-tiered configuration system managed by the `configuration.py` module:
+The tool's configuration is managed by the `configuration.py` module and loaded from several JSON files, providing a layered approach for defaults, user overrides, definitions, and source-specific presets.
 
-1.  **Application Settings (`config/app_settings.json`):** This JSON file defines the core global default settings, constants, and rules that apply generally across different asset sources (e.g., the global `OUTPUT_DIRECTORY_PATTERN` and `OUTPUT_FILENAME_PATTERN`, standard image resolutions, map merge rules, output format rules, Blender paths, `FILE_TYPE_DEFINITIONS`, `ASSET_TYPE_DEFINITIONS`). See the [User Guide: Output Structure](../01_User_Guide/09_Output_Structure.md#available-tokens) for a list of available tokens for these patterns.
-*   **`FILE_TYPE_DEFINITIONS` Enhancements:**
-        *   **`keybind` Property:** Each file type object within `FILE_TYPE_DEFINITIONS` can now optionally include a `keybind` property. This property accepts a single character string (e.g., `"C"`, `"R"`) representing the keyboard key. In the GUI, this key (typically combined with `Ctrl`, or standalone like `F2` for asset naming) is used as a shortcut to set or toggle the corresponding file type for selected items in the Preview Table.
-            *Example:*
-            ```json
-            "MAP_COL": {
-                "description": "Color/Albedo Map",
-                "color": [200, 200, 200],
-                "examples": ["albedo", "col", "basecolor"],
-                "standard_type": "COL",
-                "bit_depth_rule": "respect",
-                "is_grayscale": false,
-                "keybind": "C"
-            },
-            ```
-        *   **New File Type `MAP_GLOSS`:** A new standard file type, `MAP_GLOSS`, has been added. It is typically configured as follows:
-            *Example:*
-            ```json
-            "MAP_GLOSS": {
-                "description": "Glossiness Map",
-                "color": [180, 180, 220],
-                "examples": ["gloss", "gls"],
-                "standard_type": "GLOSS",
-                "bit_depth_rule": "respect",
-                "is_grayscale": true,
-                "keybind": "R"
-            }
-            ```
-            Note: The `keybind` "R" for `MAP_GLOSS` is often shared with `MAP_ROUGH` to allow toggling between them.
-2.  **LLM Settings (`config/llm_settings.json`):** This JSON file contains settings specifically related to the LLM predictor, such as the API endpoint, model name, prompt template, and examples. These settings can be edited through the GUI using the `LLMEditorWidget`.
-3.  **Preset Files (`Presets/*.json`):** These JSON files define supplier-specific rules and overrides. They contain patterns to interpret filenames, classify map types, handle variants, define naming conventions, and specify other source-specific behaviors.
+### Configuration Files
 
-The `configuration.py` module contains the `Configuration` class (for loading/merging settings for processing) and standalone functions like `load_base_config()` (for accessing `app_settings.json` directly) and `save_llm_config()` / `save_base_config()` (for writing settings back to files). Note that the old `config.py` file has been deleted.
+The tool's configuration is loaded from several JSON files, providing a layered approach for defaults, user overrides, definitions, and source-specific presets.
+
+1.  **Application Settings (`config/app_settings.json`):** This JSON file defines the core global default settings, constants, and rules that apply generally across different asset sources (e.g., the global `OUTPUT_DIRECTORY_PATTERN` and `OUTPUT_FILENAME_PATTERN`, standard image resolutions, map merge rules, output format rules, Blender paths, temporary directory prefix, initial scaling mode, merge dimension mismatch strategy). See the [User Guide: Output Structure](../01_User_Guide/09_Output_Structure.md#available-tokens) for a list of available tokens for these patterns.
+    *   *Note:* `ASSET_TYPE_DEFINITIONS` and `FILE_TYPE_DEFINITIONS` are no longer stored here; they have been moved to dedicated files.
+    *   It also includes settings for new features like the "Low-Resolution Fallback":
+        *   `ENABLE_LOW_RESOLUTION_FALLBACK` (boolean): Enables or disables the generation of "LOWRES" variants for small source images. Defaults to `true`.
+        *   `LOW_RESOLUTION_THRESHOLD` (integer): The pixel dimension threshold (largest side) below which a "LOWRES" variant is created if the feature is enabled. Defaults to `512`.
+
+2.  **User Settings (`config/user_settings.json`):** This optional JSON file allows users to override specific settings defined in `config/app_settings.json`. If this file exists, its values for corresponding keys will take precedence over the base application settings. This file is primarily managed through the GUI's Application Preferences Editor.
+
+3.  **Asset Type Definitions (`config/asset_type_definitions.json`):** This dedicated JSON file contains the definitions for different asset types (e.g., Surface, Model, Decal), including their descriptions, colors for UI representation, and example usage strings.
+
+4.  **File Type Definitions (`config/file_type_definitions.json`):** This dedicated JSON file contains the definitions for different file types (specifically texture maps and models), including descriptions, colors for UI representation, examples of keywords/patterns, a standard alias (`standard_type`), bit depth handling rules (`bit_depth_rule`), a grayscale flag (`is_grayscale`), and an optional GUI keybind (`keybind`).
+    *   **`keybind` Property:** Each file type object within `FILE_TYPE_DEFINITIONS` can optionally include a `keybind` property. This property accepts a single character string (e.g., `"C"`, `"R"`) representing the keyboard key. In the GUI, this key (typically combined with `Ctrl`) is used as a shortcut to set or toggle the corresponding file type for selected items in the Preview Table.
+        *Example:*
+        ```json
+        "MAP_COL": {
+            "description": "Color/Albedo Map",
+            "color": "#ffaa00",
+            "examples": ["_col.", "_basecolor.", "albedo", "diffuse"],
+            "standard_type": "COL",
+            "bit_depth_rule": "force_8bit",
+            "is_grayscale": false,
+            "keybind": "C"
+        },
+        ```
+        Note: The `bit_depth_rule` property in `FILE_TYPE_DEFINITIONS` is the primary source for determining bit depth handling for a given map type.
+
+5.  **Supplier Settings (`config/suppliers.json`):** This JSON file stores settings specific to different asset suppliers. It is now structured as a dictionary where keys are supplier names and values are objects containing supplier-specific configurations.
+    *   **Structure:**
+        ```json
+        {
+          "SupplierName1": {
+            "setting_key1": "value",
+            "setting_key2": "value"
+          },
+          "SupplierName2": {
+            "setting_key1": "value"
+          }
+        }
+        ```
+    *   **`normal_map_type` Property:** A key setting within each supplier's object is `normal_map_type`, specifying whether normal maps from this supplier use "OpenGL" or "DirectX" conventions.
+        *Example:*
+        ```json
+        {
+          "Poliigon": {
+            "normal_map_type": "DirectX"
+          },
+          "Dimensiva": {
+            "normal_map_type": "OpenGL"
+          }
+        }
+        ```
+
+6.  **LLM Settings (`config/llm_settings.json`):** This JSON file contains settings specifically related to the LLM predictor, such as the API endpoint, model name, prompt template, and examples. These settings are managed through the GUI using the `LLMEditorWidget`.
+
+7.  **Preset Files (`Presets/*.json`):** These JSON files define source-specific rules and overrides. They contain patterns to interpret filenames, classify map types, handle variants, define naming conventions, and specify other source-specific behaviors. Preset settings override values from `app_settings.json` and `user_settings.json` where applicable.
+
+
+### Configuration Loading and Access
+
+The `configuration.py` module contains the `Configuration` class and standalone functions for loading and saving settings.
+
+*   **`Configuration` Class:** This is the primary class used by the processing engine and other core components. When initialized with a `preset_name`, it loads settings in the following order, with later files overriding earlier ones for shared keys:
+    1.  `config/app_settings.json` (Base Defaults)
+    2.  `config/user_settings.json` (User Overrides - if exists)
+    3.  `config/asset_type_definitions.json` (Asset Type Definitions)
+    4.  `config/file_type_definitions.json` (File Type Definitions)
+    5.  `config/llm_settings.json` (LLM Settings)
+    6.  `Presets/{preset_name}.json` (Preset Overrides)
+
+    The loaded settings are merged into internal dictionaries, and most are accessible via instance properties (e.g., `config.output_base_dir`, `config.llm_endpoint_url`, `config.get_asset_type_definitions()`). Regex patterns defined in the merged configuration are pre-compiled for performance.
+
+*   **`load_base_config()` function:** This standalone function is primarily used by the GUI for initial setup and displaying default/user-overridden settings before a specific preset is selected. It loads and merges the following files:
+    1.  `config/app_settings.json`
+    2.  `config/user_settings.json` (if exists)
+    3.  `config/asset_type_definitions.json`
+    4.  `config/file_type_definitions.json`
+
+    It returns a single dictionary containing the combined settings and definitions.
+
+*   **Saving Functions:**
+    *   `save_base_config(settings_dict)`: Saves the provided dictionary to `config/app_settings.json`. (Used less frequently now for user-driven saves).
+    *   `save_user_config(settings_dict)`: Saves the provided dictionary to `config/user_settings.json`. Used by `ConfigEditorDialog`.
+    *   `save_llm_config(settings_dict)`: Saves the provided dictionary to `config/llm_settings.json`. Used by `LLMEditorWidget`.
+
+## Supplier Management (`config/suppliers.json`)
+
+A file, `config/suppliers.json`, is used to store a persistent list of known supplier names. This file is a simple JSON array of strings.
+
+*   **Purpose:** Provides a list of suggestions for the "Supplier" field in the GUI's Unified View, enabling auto-completion.
+*   **Management:** The GUI's `SupplierSearchDelegate` is responsible for loading this list on startup, adding new, unique supplier names entered by the user, and saving the updated list back to the file.
+
+## GUI Configuration Editors
+
+The GUI provides dedicated editors for modifying configuration files:
+
+*   **`ConfigEditorDialog` (`gui/config_editor_dialog.py`):** Edits user-configurable application settings.
+*   **`LLMEditorWidget` (`gui/llm_editor_widget.py`):** Edits the LLM-specific settings.
+
+### `ConfigEditorDialog` (`gui/config_editor_dialog.py`)
+
+The GUI includes a dedicated editor for modifying user-configurable settings. This is implemented in `gui/config_editor_dialog.py`.
+
+*   **Purpose:** Provides a user-friendly interface for viewing the effective application settings (defaults + user overrides + definitions) and editing the user-specific overrides.
+*   **Implementation:** The dialog loads the effective settings using `load_base_config()`. It presents relevant settings in a tabbed layout ("General", "Output & Naming", etc.). When saving, it now performs a **granular save**: it loads the current content of `config/user_settings.json`, identifies only the settings that were changed by the user during the current dialog session (by comparing against the initial state), updates only those specific values in the loaded `user_settings.json` content, and saves the modified content back to `config/user_settings.json` using `save_user_config()`. This preserves any other settings in `user_settings.json` that were not touched. The dialog displays definitions from `asset_type_definitions.json` and `file_type_definitions.json` but does not save changes to these files.
+*   **Limitations:** Currently, editing complex fields like `IMAGE_RESOLUTIONS` or the full details of `MAP_MERGE_RULES` via the UI is not fully supported for saving to `user_settings.json`.
+
+### `LLMEditorWidget` (`gui/llm_editor_widget.py`)
+
+*   **Purpose:** Provides a user-friendly interface for viewing and editing the LLM settings defined in `config/llm_settings.json`.
+*   **Implementation:** Uses tabs for "Prompt Settings" and "API Settings". Allows editing the prompt, managing examples, and configuring API details. When saving, it also performs a **granular save**: it loads the current content of `config/llm_settings.json`, identifies only the settings changed by the user in the current session, updates only those values, and saves the modified content back to `config/llm_settings.json` using `configuration.save_llm_config()`.
+
+## Preset File Structure (`Presets/*.json`)
+
+Preset files are the primary way to adapt the tool to new asset sources. Developers should use `Presets/_template.json` as a starting point. Key fields include:
+
+*   `supplier_name`: The name of the asset source (e.g., `"Poliigon"`). Used for output directory naming.
+*   `map_type_mapping`: A list of dictionaries, each mapping source filename patterns/keywords to a specific file type. The `target_type` for this mapping **must** be a key from the `FILE_TYPE_DEFINITIONS` now located in `config/file_type_definitions.json`.
+    *   `target_type`: The specific file type key from `FILE_TYPE_DEFINITIONS` (e.g., `"MAP_COL"`, `"MAP_NORM_GL"`, `"MAP_RGH"`). This replaces previous alias-based systems. The common aliases like "COL" or "NRM" are now derived from the `standard_type` property within `FILE_TYPE_DEFINITIONS` but are not used directly for `target_type`.
+    *   `keywords`: A list of filename patterns (regex or fnmatch-style wildcards) used to identify this map type. The order of keywords within this list, and the order of dictionaries in the `map_type_mapping` list, determines the priority for assigning variant suffixes (`-1`, `-2`, etc.) when multiple files match the same `target_type`.
+*   `bit_depth_variants`: A dictionary mapping standard map types (e.g., `"NRM"`) to a pattern identifying its high bit-depth variant (e.g., `"*_NRM16*.tif"`). Files matching these patterns are prioritized over their standard counterparts.
+*   `map_bit_depth_rules`: Defines how to handle the bit depth of source maps. Can specify a default behavior (`"respect"` or `"force_8bit"`) and overrides for specific map types.
+*   `model_patterns`: A list of regex patterns to identify model files (e.g., `".*\\.fbx"`, `".*\\.obj"`).
+*   `move_to_extra_patterns`: A list of regex patterns for files that should be moved directly to the `Extra/` output subdirectory without further processing.
+*   `source_naming_convention`: Rules for extracting the base asset name and potentially the archetype from source filenames or directory structures (e.g., using separators and indices).
+*   `asset_category_rules`: Keywords or patterns used to determine the asset category (e.g., identifying `"Decal"` based on keywords).
+*   `archetype_rules`: Keywords or patterns used to determine the asset archetype (e.g., identifying `"Wood"` or `"Metal"`).
+
+Careful definition of these patterns and rules, especially the regex in `map_type_mapping`, `bit_depth_variants`, `model_patterns`, and `move_to_extra_patterns`, is essential for correct asset processing.
+
+**Note on Data Passing:** As mentioned in the Architecture documentation, major changes to the data passing mechanisms between the GUI, Main (CLI orchestration), and `AssetProcessor` modules are currently being planned. The descriptions of how configuration data is handled and passed within this document reflect the current state and will require review and updates once the plan for these changes is finalized.
 
 ## Supplier Management (`config/suppliers.json`)
 

Documentation/02_Developer_Guide/05_Processing_Pipeline.md

@@ -50,27 +50,44 @@ These stages are executed sequentially once for each asset before the core item
 
 ### Core Item Processing Loop
 
-The [`PipelineOrchestrator`](processing/pipeline/orchestrator.py:36) iterates through the `context.processing_items` list (populated by the [`PrepareProcessingItemsStage`](processing/pipeline/stages/prepare_processing_items.py:10)). For each item (either a [`FileRule`](rule_structure.py:5) for a regular map or a [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16) for a merged map), the following stages are executed sequentially:
+The [`PipelineOrchestrator`](processing/pipeline/orchestrator.py:36) iterates through the `context.processing_items` list (populated by the [`PrepareProcessingItemsStage`](processing/pipeline/stages/prepare_processing_items.py:10)). Each `item` in this list is now either a [`ProcessingItem`](rule_structure.py:0) (representing a specific variant of a source map, e.g., Color at 1K, or Color at LOWRES) or a [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16).
 
 1.  **[`PrepareProcessingItemsStage`](processing/pipeline/stages/prepare_processing_items.py:10)** (`processing/pipeline/stages/prepare_processing_items.py`):
-    *   **Responsibility**: (Executed once before the loop) Creates the `context.processing_items` list by combining [`FileRule`](rule_structure.py:5)s from `context.files_to_process` and [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16)s derived from the global `map_merge_rules` configuration. It correctly accesses `map_merge_rules` from `context.config_obj` and validates each merge rule for the presence of `output_map_type` and a dictionary for `inputs`. Initializes `context.intermediate_results`.
-    *   **Context Interaction**: Reads from `context.files_to_process` and `context.config_obj` (accessing `map_merge_rules`). Populates `context.processing_items` and initializes `context.intermediate_results`.
+    *   **Responsibility**: (Executed once before the loop) This stage is now responsible for "exploding" each relevant [`FileRule`](rule_structure.py:5) into one or more [`ProcessingItem`](rule_structure.py:0) objects.
+        *   For each [`FileRule`](rule_structure.py:5) that represents an image map:
+            *   It loads the source image data and determines its original dimensions and bit depth.
+            *   It creates standard [`ProcessingItem`](rule_structure.py:0)s for each required output resolution (e.g., "1K", "PREVIEW"), populating them with a copy of the source image data and the respective `resolution_key`.
+            *   If the "Low-Resolution Fallback" feature is enabled (`ENABLE_LOW_RESOLUTION_FALLBACK` in config) and the source image's largest dimension is below `LOW_RESOLUTION_THRESHOLD`, it creates an additional [`ProcessingItem`](rule_structure.py:0) with `resolution_key="LOWRES"`, using the original image data and dimensions.
+        *   It also adds [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16)s derived from global `map_merge_rules`.
+    *   **Context Interaction**: Reads `context.files_to_process` and `context.config_obj`. Populates `context.processing_items` with a list of [`ProcessingItem`](rule_structure.py:0) and [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16) objects. Initializes `context.intermediate_results`.
 
-2.  **[`RegularMapProcessorStage`](processing/pipeline/stages/regular_map_processor.py:18)** (`processing/pipeline/stages/regular_map_processor.py`):
-    *   **Responsibility**: (Executed per [`FileRule`](rule_structure.py:5) item) Checks if the `FileRule.item_type` starts with "MAP_". If not, the item is skipped. Otherwise, it loads the image data for the file, determines its potentially suffixed internal map type (e.g., "MAP_COL-1"), applies in-memory transformations (Gloss-to-Rough, Normal Green Invert) using the shared utility function [`apply_common_map_transformations`](processing/utils/image_processing_utils.py), and returns the processed image data and details in a [`ProcessedRegularMapData`](processing/pipeline/asset_context.py:23) object. The `internal_map_type` in the output reflects any transformations (e.g., "MAP_GLOSS" becomes "MAP_ROUGH").
-    *   **Context Interaction**: Reads from the input [`FileRule`](rule_structure.py:5) (checking `item_type`) and [`Configuration`](configuration.py:68). Returns a [`ProcessedRegularMapData`](processing/pipeline/asset_context.py:23) object which is stored in `context.intermediate_results`.
+For each `item` in `context.processing_items`:
+
+2.  **Transformations (Implicit or via a dedicated stage - formerly `RegularMapProcessorStage` logic):**
+    *   **Responsibility**: If the `item` is a [`ProcessingItem`](rule_structure.py:0), its `image_data` (loaded by `PrepareProcessingItemsStage`) may need transformations (Gloss-to-Rough, Normal Green Invert). This logic, previously in `RegularMapProcessorStage`, might be integrated into `PrepareProcessingItemsStage` before `ProcessingItem` creation, or handled by a new dedicated transformation stage that operates on `ProcessingItem.image_data`. The `item.map_type_identifier` would be updated if a transformation like Gloss-to-Rough occurs.
+    *   **Context Interaction**: Modifies `item.image_data` and `item.map_type_identifier` within the [`ProcessingItem`](rule_structure.py:0) object.
 
 3.  **[`MergedTaskProcessorStage`](processing/pipeline/stages/merged_task_processor.py:68)** (`processing/pipeline/stages/merged_task_processor.py`):
-    *   **Responsibility**: (Executed per [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16) item) Validates that all input map types specified in the merge rule start with "MAP_". If not, the task is failed. It dynamically loads input images by looking up the required input map types (e.g., "MAP_NRM") in `context.processed_maps_details` and using the temporary file paths from their `saved_files_info`. It applies in-memory transformations to inputs using [`apply_common_map_transformations`](processing/utils/image_processing_utils.py), handles dimension mismatches (with fallback creation if configured and `source_dimensions` are available), performs the channel merging operation, and returns the merged image data and details in a [`ProcessedMergedMapData`](processing/pipeline/asset_context.py:35) object. The `output_map_type` of the merged map must also be "MAP_" prefixed in the configuration.
-    *   **Context Interaction**: Reads from the input [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16) (checking input map types), `context.workspace_path`, `context.processed_maps_details` (for input image data), and [`Configuration`](configuration.py:68). Returns a [`ProcessedMergedMapData`](processing/pipeline/asset_context.py:35) object which is stored in `context.intermediate_results`.
+    *   **Responsibility**: (Executed if `item` is a [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16)) Same as before: validates inputs, loads source map data (likely from `ProcessingItem`s in `context.processing_items` or a cache populated from them), applies transformations, merges channels, and returns [`ProcessedMergedMapData`](processing/pipeline/asset_context.py:35).
+    *   **Context Interaction**: Reads [`MergeTaskDefinition`](processing/pipeline/asset_context.py:16), potentially `context.processing_items` (or a cache derived from it) for input image data. Returns [`ProcessedMergedMapData`](processing/pipeline/asset_context.py:35).
 
 4.  **[`InitialScalingStage`](processing/pipeline/stages/initial_scaling.py:14)** (`processing/pipeline/stages/initial_scaling.py`):
-    *   **Responsibility**: (Executed per item) Applies initial scaling (e.g., Power-of-Two downscaling) to the image data from the previous processing stage based on the `initial_scaling_mode` configuration.
-    *   **Context Interaction**: Takes a [`InitialScalingInput`](processing/pipeline/asset_context.py:46) (containing image data and config) and returns an [`InitialScalingOutput`](processing/pipeline/asset_context.py:54) object, which updates the item's entry in `context.intermediate_results`.
+    *   **Responsibility**: (Executed per item)
+        *   If `item` is a [`ProcessingItem`](rule_structure.py:0): Takes `item.image_data`, `item.current_dimensions`, and `item.resolution_key` as input. If `item.resolution_key` is "LOWRES", POT scaling is skipped. Otherwise, applies POT scaling if configured.
+        *   If `item` is from a `MergeTaskDefinition` (i.e., `processed_data` from `MergedTaskProcessorStage`): Applies POT scaling as before.
+    *   **Context Interaction**: Takes [`InitialScalingInput`](processing/pipeline/asset_context.py:46) (now including `resolution_key`). Returns [`InitialScalingOutput`](processing/pipeline/asset_context.py:54) (also including `resolution_key`), which updates `context.intermediate_results`. The `current_image_data` and `current_dimensions` for saving are taken from this output.
 
 5.  **[`SaveVariantsStage`](processing/pipeline/stages/save_variants.py:15)** (`processing/pipeline/stages/save_variants.py`):
-    *   **Responsibility**: (Executed per item) Takes the final processed image data (potentially scaled) and configuration, and calls a utility to save the image to temporary files in various resolutions and formats as defined by the configuration.
-    *   **Context Interaction**: Takes a [`SaveVariantsInput`](processing/pipeline/asset_context.py:61) object (which includes the "MAP_" prefixed `internal_map_type`). It uses the `get_filename_friendly_map_type` utility to convert this to a "standard type" (e.g., "COL") for output naming. Returns a [`SaveVariantsOutput`](processing/pipeline/asset_context.py:79) object containing details about the saved temporary files. The orchestrator stores these details, including the original "MAP_" prefixed `internal_map_type`, in `context.processed_maps_details` for the item.
+    *   **Responsibility**: (Executed per item) Saves the (potentially scaled) `current_image_data`.
+    *   **Context Interaction**:
+        *   Takes [`SaveVariantsInput`](processing/pipeline/asset_context.py:61).
+        *   `internal_map_type` is set from `item.map_type_identifier` (for `ProcessingItem`) or `processed_data.output_map_type` (for merged).
+        *   `output_filename_pattern_tokens['resolution']` is set to the `resolution_key` obtained from `scaled_data_output.resolution_key` (which originates from `item.resolution_key` for `ProcessingItem`s, or is `None` for merged items that get all standard resolutions).
+        *   `image_resolutions` argument for `SaveVariantsInput`:
+            *   If `resolution_key == "LOWRES"`: Set to `{"LOWRES": width_of_lowres_data}`.
+            *   If `resolution_key` is a standard key (e.g., "1K"): Set to `{resolution_key: configured_dimension}`.
+            *   For merged items (where `resolution_key` from scaling is likely `None`): Set to the full `config.image_resolutions` map to generate all applicable standard sizes.
+        *   Returns [`SaveVariantsOutput`](processing/pipeline/asset_context.py:79). Orchestrator stores details in `context.processed_maps_details`.
 
 ### Post-Item Stages
 

Documentation/02_Developer_Guide/06_GUI_Internals.md

@@ -10,13 +10,13 @@ The GUI is built using `PySide6`, which provides Python bindings for the Qt fram
 
 The `MainWindow` class acts as the central **coordinator** for the GUI application. It is responsible for:
 
-*   Setting up the main application window structure and menu bar.
+*   Setting up the main application window structure and menu bar, including actions to launch configuration and definition editors.
 *   **Layout:** Arranging the main GUI components using a `QSplitter`.
     *   **Left Pane:** Contains the preset selection controls (from `PresetEditorWidget`) permanently displayed at the top. Below this, a `QStackedWidget` switches between the preset JSON editor (also from `PresetEditorWidget`) and the `LLMEditorWidget`.
     *   **Right Pane:** Contains the `MainPanelWidget`.
 *   Instantiating and managing the major GUI widgets:
     *   `PresetEditorWidget` (`gui/preset_editor_widget.py`): Provides the preset selector and the JSON editor parts.
-    *   `LLMEditorWidget` (`gui/llm_editor_widget.py`): Provides the editor for LLM settings.
+    *   `LLMEditorWidget` (`gui/llm_editor_widget.py`): Provides the editor for LLM settings (from `config/llm_settings.json`).
     *   `MainPanelWidget` (`gui/main_panel_widget.py`): Contains the rule hierarchy view and processing controls.
     *   `LogConsoleWidget` (`gui/log_console_widget.py`): Displays application logs.
 *   Instantiating key models and handlers:
@@ -198,13 +198,24 @@ The `LogConsoleWidget` displays logs captured by a custom `QtLogHandler` from Py
 
 The GUI provides a "Cancel" button. Cancellation logic for the actual processing is now likely handled within the `main.ProcessingTask` or the code that manages it, as the `ProcessingHandler` has been removed. The GUI button would signal this external task manager.
 
-## GUI Configuration Editor (`gui/config_editor_dialog.py`)
+## Application Preferences Editor (`gui/config_editor_dialog.py`)
 
-A dedicated dialog for editing `config/app_settings.json`.
+A dedicated dialog for editing user-overridable application settings. It loads base settings from `config/app_settings.json` and saves user overrides to `config/user_settings.json`.
 
-*   **Functionality:** Loads `config/app_settings.json`, presents in tabs, allows editing basic fields, definitions tables (with color editing), and merge rules list/detail.
-*   **Limitations:** Editing complex fields like `IMAGE_RESOLUTIONS` or full `MAP_MERGE_RULES` details might still be limited.
-*   **Integration:** Launched by `MainWindow` ("Edit" -> "Preferences...").
-*   **Persistence:** Saves changes to `config/app_settings.json`. Requires application restart for changes to affect processing logic loaded by the `Configuration` class.
+*   **Functionality:** Provides a tabbed interface to edit various application settings, including general paths, output/naming patterns, image processing options (like resolutions and compression), and map merging rules. It no longer includes editors for Asset Type or File Type Definitions.
+*   **Integration:** Launched by `MainWindow` via the "Edit" -> "Preferences..." menu.
+*   **Persistence:** Saves changes to `config/user_settings.json`. Changes require an application restart to take effect in processing logic.
 
 The refactored GUI separates concerns into distinct widgets and handlers, coordinated by the `MainWindow`. Background tasks use `QThreadPool` and `QRunnable`. The `UnifiedViewModel` focuses on data presentation and simple edits, delegating complex restructuring to the `AssetRestructureHandler`.
+
+## Definitions Editor (`gui/definitions_editor_dialog.py`)
+
+A new dedicated dialog for managing core application definitions that are separate from general user preferences.
+
+*   **Purpose:** Provides a structured UI for editing Asset Type Definitions, File Type Definitions, and Supplier Settings.
+*   **Structure:** Uses a `QTabWidget` with three tabs:
+    *   **Asset Type Definitions:** Manages definitions from `config/asset_type_definitions.json`. Presents a list of asset types and allows editing their description, color, and examples.
+    *   **File Type Definitions:** Manages definitions from `config/file_type_definitions.json`. Presents a list of file types and allows editing their description, color, examples, standard type, bit depth rule, grayscale status, and keybind.
+    *   **Supplier Settings:** Manages settings from `config/suppliers.json`. Presents a list of suppliers and allows editing supplier-specific settings (e.g., Normal Map Type).
+*   **Integration:** Launched by `MainWindow` via the "Edit" -> "Edit Definitions..." menu.
+*   **Persistence:** Saves changes directly to the respective configuration files (`config/asset_type_definitions.json`, `config/file_type_definitions.json`, `config/suppliers.json`). Some changes may require an application restart.

Presets/Poliigon.json

@@ -25,102 +25,10 @@
         "*.pdf",
         "*.url",
         "*.htm*",
-        "*_Fabric.*"
-    ],
-    "map_type_mapping": [
-        {
-            "target_type": "MAP_COL",
-            "keywords": [
-                "COLOR*",
-                "COL",
-                "DIFFUSE",
-                "DIF",
-                "ALBEDO"
-            ]
-        },
-        {
-            "target_type": "MAP_NRM",
-            "keywords": [
-                "NORMAL*",
-                "NORM*",
-                "NRM*"
-            ]
-        },
-        {
-            "target_type": "MAP_ROUGH",
-            "keywords": [
-                "ROUGHNESS",
-                "ROUGH"
-            ]
-        },
-        {
-            "target_type": "MAP_GLOSS",
-            "keywords": [
-                "GLOSS"
-            ],
-            "is_gloss_source": true
-        },
-        {
-            "target_type": "MAP_AO",
-            "keywords": [
-                "AMBIENTOCCLUSION",
-                "AO"
-            ]
-        },
-        {
-            "target_type": "MAP_DISP",
-            "keywords": [
-                "DISPLACEMENT",
-                "DISP",
-                "HEIGHT",
-                "BUMP"
-            ]
-        },
-        {
-            "target_type": "MAP_REFL",
-            "keywords": [
-                "REFLECTION",
-                "REFL",
-                "SPECULAR",
-                "SPEC"
-            ]
-        },
-        {
-            "target_type": "MAP_SSS",
-            "keywords": [
-                "SSS",
-                "SUBSURFACE*"
-            ]
-        },
-        {
-            "target_type": "MAP_FUZZ",
-            "keywords": [
-                "FUZZ"
-            ]
-        },
-        {
-            "target_type": "MAP_IDMAP",
-            "keywords": [
-                "IDMAP"
-            ]
-        },
-        {
-            "target_type": "MAP_MASK",
-            "keywords": [
-                "OPAC*",
-                "TRANSP*",
-                "MASK*",
-                "ALPHA*"
-            ]
-        },
-        {
-            "target_type": "MAP_METAL",
-            "keywords": [
-                "METAL*",
-                "METALLIC"
-            ]
-        }
+        "*_Fabric.*",
+        "*_Albedo*"
     ],
+    "map_type_mapping": [],
     "asset_category_rules": {
         "model_patterns": [
             "*.fbx",

ProjectNotes/ConfigurationRefactoringPlan.md

@@ -0,0 +1,107 @@
+# Configuration System Refactoring Plan
+
+This document outlines the plan for refactoring the configuration system of the Asset Processor Tool.
+
+## Overall Goals
+
+1.  **Decouple Definitions:** Separate `ASSET_TYPE_DEFINITIONS` and `FILE_TYPE_DEFINITIONS` from the main `config/app_settings.json` into dedicated files.
+2.  **Introduce User Overrides:** Allow users to override base settings via a new `config/user_settings.json` file.
+3.  **Improve GUI Saving:** (Lower Priority) Make GUI configuration saving more targeted to avoid overwriting unrelated settings when saving changes from `ConfigEditorDialog` or `LLMEditorWidget`.
+
+## Proposed Plan Phases
+
+**Phase 1: Decouple Definitions**
+
+1.  **Create New Definition Files:**
+    *   Create `config/asset_type_definitions.json`.
+    *   Create `config/file_type_definitions.json`.
+2.  **Migrate Content:**
+    *   Move `ASSET_TYPE_DEFINITIONS` object from `config/app_settings.json` to `config/asset_type_definitions.json`.
+    *   Move `FILE_TYPE_DEFINITIONS` object from `config/app_settings.json` to `config/file_type_definitions.json`.
+3.  **Update `configuration.py`:**
+    *   Add constants for new definition file paths.
+    *   Modify `Configuration` class to load these new files.
+    *   Update property methods (e.g., `get_asset_type_definitions`, `get_file_type_definitions_with_examples`) to use data from the new definition dictionaries.
+    *   Adjust validation (`_validate_configs`) as needed.
+4.  **Update GUI & `load_base_config()`:**
+    *   Modify `load_base_config()` to load and return a combined dictionary including `app_settings.json` and the two new definition files.
+    *   Update GUI components relying on `load_base_config()` to ensure they receive the necessary definition data.
+
+**Phase 2: Implement User Overrides**
+
+1.  **Define `user_settings.json`:**
+    *   Establish `config/user_settings.json` for user-specific overrides, mirroring parts of `app_settings.json`.
+2.  **Update `configuration.py` Loading:**
+    *   In `Configuration.__init__`, load `app_settings.json`, then definition files, then attempt to load and deep merge `user_settings.json` (user settings override base).
+    *   Load presets *after* the base+user merge (presets override combined base+user).
+    *   Modify `load_base_config()` to also load and merge `user_settings.json` after `app_settings.json`.
+3.  **Update GUI Editors:**
+    *   Modify `ConfigEditorDialog` to load the effective settings (base+user) but save changes *only* to `config/user_settings.json`.
+    *   `LLMEditorWidget` continues targeting `llm_settings.json`.
+
+**Phase 3: Granular GUI Saving (Lower Priority)**
+
+1.  **Refactor Saving Logic:**
+    *   In `ConfigEditorDialog` and `LLMEditorWidget`:
+        *   Load the current target file (`user_settings.json` or `llm_settings.json`).
+        *   Identify specific setting(s) changed by the user in the GUI session.
+        *   Update only those specific key(s) in the loaded dictionary.
+        *   Write the entire modified dictionary back to the target file, preserving untouched settings.
+
+## Proposed File Structure & Loading Flow
+
+```mermaid
+graph LR
+    subgraph Config Files
+        A[config/asset_type_definitions.json]
+        B[config/file_type_definitions.json]
+        C[config/app_settings.json (Base Defaults)]
+        D[config/user_settings.json (User Overrides)]
+        E[config/llm_settings.json]
+        F[config/suppliers.json]
+        G[Presets/*.json]
+    end
+
+    subgraph Code
+        H[configuration.py]
+        I[GUI]
+        J[Processing Engine / Pipeline]
+        K[LLM Handlers]
+    end
+
+    subgraph Loading Flow (Configuration Class)
+        L(Load Asset Types) --> H
+        M(Load File Types) --> H
+        N(Load Base Settings) --> P(Merge Base + User)
+        O(Load User Settings) --> P
+        P --> R(Merge Preset Overrides)
+        Q(Load LLM Settings) --> H
+        R --> T(Final Config Object)
+        G -- Load Preset --> R
+        H -- Contains --> T
+    end
+
+    subgraph Loading Flow (GUI - load_base_config)
+        L2(Load Asset Types) --> U(Return Merged Defaults + Defs)
+        M2(Load File Types) --> U
+        N2(Load Base Settings) --> V(Merge Base + User)
+        O2(Load User Settings) --> V
+        V --> U
+        I -- Calls --> U
+    end
+
+
+    T -- Used by --> J
+    T -- Used by --> K
+
+    I -- Edits --> D
+    I -- Edits --> E
+    I -- Manages --> F
+
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style B fill:#f9f,stroke:#333,stroke-width:2px
+    style C fill:#ccf,stroke:#333,stroke-width:2px
+    style D fill:#9cf,stroke:#333,stroke-width:2px
+    style E fill:#ccf,stroke:#333,stroke-width:2px
+    style F fill:#9cf,stroke:#333,stroke-width:2px
+    style G fill:#ffc,stroke:#333,stroke-width:2px

ProjectNotes/MAP_Prefix_Enforcement_Plan.md

@@ -1,96 +0,0 @@
-# Plan: Enforcing "MAP_" Prefix for Internal Processing and Standard Type for Output Naming
-
-**Date:** 2025-05-13
-
-**I. Goal:**
-The primary goal is to ensure that for all internal processing, the system *exclusively* uses `FileRule.item_type` values that start with the "MAP_" prefix (e.g., "MAP_COL", "MAP_NRM"). The "standard type" (e.g., "COL", "NRM") associated with these "MAP_" types (as defined in `config/app_settings.json`) should *only* be used during the file saving stages for output naming. Any `FileRule` whose `item_type` does not start with "MAP_" (and isn't a special type like "EXTRA" or "MODEL") should be skipped by the relevant map processing stages.
-
-**II. Current State Analysis Summary:**
-
-*   **Output Naming:** The use of "standard type" for output filenames via the `get_filename_friendly_map_type` utility in `SaveVariantsStage` and `OutputOrganizationStage` is **correct** and already meets the requirement.
-*   **Internal "MAP_" Prefix Usage:**
-    *   Some stages like `GlossToRoughConversionStage` correctly check for "MAP_" prefixes (e.g., `processing_map_type.startswith("MAP_GLOSS")`).
-    *   Other stages like `RegularMapProcessorStage` and `MergedTaskProcessorStage` (and its helpers) implicitly expect "MAP_" prefixed types for their internal regex-based logic but lack explicit checks to skip items if the prefix is missing.
-    *   Stages like `AlphaExtractionToMaskStage` and `NormalMapGreenChannelStage` currently use non-"MAP_" prefixed "standard types" (e.g., "NORMAL", "ALBEDO") when reading from `context.processed_maps_details` for their decision-making logic.
-    *   The `PrepareProcessingItemsStage` adds `FileRule`s to the processing queue without filtering based on the "MAP_" prefix in `item_type`.
-*   **Data Consistency in `AssetProcessingContext`:**
-    *   `FileRule.item_type` is the field that should hold the "MAP_" prefixed type from the initial rule generation.
-    *   `context.processed_maps_details` entries can contain various map type representations:
-        *   `map_type`: Often stores the "standard type" (e.g., "Roughness", "MASK", "NORMAL").
-        *   `processing_map_type` / `internal_map_type`: Generally seem to store the "MAP_" prefixed type. This needs to be consistent.
-*   **Configuration (`config/app_settings.json`):**
-    *   `FILE_TYPE_DEFINITIONS` correctly use "MAP_" prefixed keys.
-    *   `MAP_MERGE_RULES` need to be reviewed to ensure their `output_map_type` and input map types are "MAP_" prefixed.
-
-**III. Proposed Changes (Code Identification & Recommendations):**
-
-**A. Enforce "MAP_" Prefix for Processing Items (Skipping Logic):**
-The core requirement is that processing stages should skip `FileRule` items if their `item_type` doesn't start with "MAP_".
-
-1.  **`RegularMapProcessorStage` (`processing/pipeline/stages/regular_map_processor.py`):**
-    *   **Identify:** In the `execute` method, `initial_internal_map_type` is derived from `file_rule.item_type_override` or `file_rule.item_type`.
-    *   **Recommend:** Add an explicit check after determining `initial_internal_map_type`. If `initial_internal_map_type` does not start with `"MAP_"`, the stage should log a warning, set the `result.status` to "Skipped (Invalid Type)" or similar, and return `result` early, effectively skipping processing for this item.
-
-2.  **`MergedTaskProcessorStage` (`processing/pipeline/stages/merged_task_processor.py`):**
-    *   **Identify:** This stage processes `MergeTaskDefinition`s. The definitions for these tasks (input types, output type) come from `MAP_MERGE_RULES` in `config/app_settings.json`. The stage uses `required_map_type_from_rule` for its inputs.
-    *   **Recommend:**
-        *   **Configuration First:** Review all entries in `MAP_MERGE_RULES` in `config/app_settings.json`.
-            *   Ensure the `output_map_type` for each rule (e.g., "MAP_NRMRGH") starts with "MAP_".
-            *   Ensure all map type values within the `inputs` dictionary (e.g., `"R": "MAP_NRM"`) start with "MAP_".
-        *   **Stage Logic:** In the `execute` method, when iterating through `merge_inputs_config.items()`, check if `required_map_type_from_rule` starts with `"MAP_"`. If not, log a warning and either:
-            *   Skip loading/processing this specific input channel (potentially using its fallback if the overall merge can still proceed).
-            *   Or, if a non-"MAP_" input is critical, fail the entire merge task for this asset.
-        *   The helper `_apply_in_memory_transformations` already uses regex expecting "MAP_" prefixes; this will naturally fail or misbehave if inputs are not "MAP_" prefixed, reinforcing the need for the check above.
-
-**B. Standardize Map Type Fields and Usage in `context.processed_maps_details`:**
-Ensure consistency in how "MAP_" prefixed types are stored and accessed within `context.processed_maps_details` for internal logic (not naming).
-
-1.  **Recommendation:** Establish a single, consistent field name within `context.processed_maps_details` to store the definitive "MAP_" prefixed internal map type (e.g., `internal_map_type` or `processing_map_type`). All stages that perform logic based on the specific *kind* of map (e.g., transformations, source selection) should read from this standardized field. The `map_type` field can continue to store the "standard type" (e.g., "Roughness") primarily for informational/metadata purposes if needed, but not for core processing logic.
-
-2.  **`AlphaExtractionToMaskStage` (`processing/pipeline/stages/alpha_extraction_to_mask.py`):**
-    *   **Identify:**
-        *   Checks for existing MASK map using `file_rule.map_type == "MASK"`. (Discrepancy: `FileRule` uses `item_type`).
-        *   Searches for suitable source maps using `details.get('map_type') in self.SUITABLE_SOURCE_MAP_TYPES` where `SUITABLE_SOURCE_MAP_TYPES` are standard types like "ALBEDO".
-        *   When adding new details, it sets `map_type: "MASK"` and the new `FileRule` gets `item_type="MAP_MASK"`.
-    *   **Recommend:**
-        *   Change the check for an existing MASK map to `file_rule.item_type == "MAP_MASK"`.
-        *   Modify the source map search to use the standardized "MAP_" prefixed field from `details` (e.g., `details.get('internal_map_type')`) and update `SUITABLE_SOURCE_MAP_TYPES` to be "MAP_" prefixed (e.g., "MAP_COL", "MAP_ALBEDO").
-        *   When adding new details for the created MASK map to `context.processed_maps_details`, ensure the standardized "MAP_" prefixed field is set to "MAP_MASK", and `map_type` (if kept) is "MASK".
-
-3.  **`NormalMapGreenChannelStage` (`processing/pipeline/stages/normal_map_green_channel.py`):**
-    *   **Identify:** Checks `map_details.get('map_type') == "NORMAL"`.
-    *   **Recommend:** Change this check to use the standardized "MAP_" prefixed field from `map_details` (e.g., `map_details.get('internal_map_type')`) and verify if it `startswith("MAP_NRM")`.
-
-4.  **`GlossToRoughConversionStage` (`processing/pipeline/stages/gloss_to_rough_conversion.py`):**
-    *   **Identify:** This stage already uses `processing_map_type.startswith("MAP_GLOSS")` and updates `processing_map_type` to "MAP_ROUGH" in `map_details`. It also updates the `FileRule.item_type` correctly.
-    *   **Recommend:** This stage is largely consistent. Ensure the field it reads/writes (`processing_map_type`) aligns with the chosen standardized "MAP_" prefixed field for `processed_maps_details`.
-
-**C. Review Orchestration Logic (Conceptual):**
-*   When the orchestrator populates `context.processed_maps_details` after stages like `SaveVariantsStage`, ensure it stores the "MAP_" prefixed `internal_map_type` (from `SaveVariantsInput`) into the chosen standardized field in `processed_maps_details`.
-
-**IV. Testing Recommendations:**
-
-*   Create test cases with `AssetRule`s containing `FileRule`s where `item_type` is intentionally set to a non-"MAP_" prefixed value (e.g., "COLOR_MAP", "TEXTURE_ROUGH"). Verify that `RegularMapProcessorStage` skips these.
-*   Modify `MAP_MERGE_RULES` in a test configuration:
-    *   Set an `output_map_type` to a non-"MAP_" value.
-    *   Set an input map type (e.g., for channel "R") to a non-"MAP_" value.
-    *   Verify that `MergedTaskProcessorStage` correctly handles these (e.g., fails the task, skips the input, logs warnings).
-*   Test `AlphaExtractionToMaskStage`:
-    *   With an existing `FileRule` having `item_type="MAP_MASK"` to ensure extraction is skipped.
-    *   With source maps having "MAP_COL" (with alpha) as their `internal_map_type` in `processed_maps_details` to ensure they are correctly identified as sources.
-*   Test `NormalMapGreenChannelStage` with a normal map having "MAP_NRM" as its `internal_map_type` in `processed_maps_details` to ensure it's processed.
-*   Verify that output filenames continue to use the "standard type" (e.g., "COL", "ROUGH", "NRM") correctly.
-
-**V. Mermaid Diagram (Illustrative Flow for `FileRule` Processing):**
-
-```mermaid
-graph TD
-    A[AssetRule with FileRules] --> B{FileRuleFilterStage};
-    B -- files_to_process --> C{PrepareProcessingItemsStage};
-    C -- processing_items (FileRule) --> D{PipelineOrchestrator};
-    D -- FileRule --> E(RegularMapProcessorStage);
-    E --> F{Check FileRule.item_type};
-    F -- Starts with "MAP_"? --> G[Process Map];
-    F -- No --> H[Skip Map / Log Warning];
-    G --> I[...subsequent stages...];
-    H --> I;

ProjectNotes/PipelineRefactoringPlan.md

@@ -1,72 +0,0 @@
-# Processing Pipeline Refactoring Plan
-
-## 1. Problem Summary
-
-The current processing pipeline, particularly the `IndividualMapProcessingStage`, exhibits maintainability challenges:
-
-*   **High Complexity:** The stage handles too many responsibilities (loading, merging, transformations, scaling, saving).
-*   **Duplicated Logic:** Image transformations (Gloss-to-Rough, Normal Green Invert) are duplicated within the stage instead of relying solely on dedicated stages or being handled consistently.
-*   **Tight Coupling:** Heavy reliance on the large, mutable `AssetProcessingContext` object creates implicit dependencies and makes isolated testing difficult.
-
-## 2. Refactoring Goals
-
-*   Improve code readability and understanding.
-*   Enhance maintainability by localizing changes and removing duplication.
-*   Increase testability through smaller, focused components with clear interfaces.
-*   Clarify data dependencies between pipeline stages.
-*   Adhere more closely to the Single Responsibility Principle (SRP).
-
-## 3. Proposed New Pipeline Stages
-
-Replace the existing `IndividualMapProcessingStage` with the following sequence of smaller, focused stages, executed by the `PipelineOrchestrator` for each processing item:
-
-1.  **`PrepareProcessingItemsStage`:**
-    *   **Responsibility:** Identifies and lists all items (`FileRule`, `MergeTaskDefinition`) to be processed from the main context.
-    *   **Output:** Updates `context.processing_items`.
-
-2.  **`RegularMapProcessorStage`:** (Handles `FileRule` items)
-    *   **Responsibility:** Loads source image, determines internal map type (with suffix), applies relevant transformations (Gloss-to-Rough, Normal Green Invert), determines original metadata.
-    *   **Output:** `ProcessedRegularMapData` object containing transformed image data and metadata.
-
-3.  **`MergedTaskProcessorStage`:** (Handles `MergeTaskDefinition` items)
-    *   **Responsibility:** Loads input images, applies transformations to inputs, handles fallbacks/resizing, performs merge operation.
-    *   **Output:** `ProcessedMergedMapData` object containing merged image data and metadata.
-
-4.  **`InitialScalingStage`:** (Optional)
-    *   **Responsibility:** Applies configured scaling (e.g., POT downscale) to the processed image data received from the previous stage.
-    *   **Output:** Scaled image data.
-
-5.  **`SaveVariantsStage`:**
-    *   **Responsibility:** Takes the final processed (and potentially scaled) image data and orchestrates saving variants using the `save_image_variants` utility.
-    *   **Output:** List of saved file details (`saved_files_details`).
-
-## 4. Proposed Data Flow
-
-*   **Input/Output Objects:** Key stages (`RegularMapProcessor`, `MergedTaskProcessor`, `InitialScaling`, `SaveVariants`) will use specific Input and Output dataclasses for clearer interfaces.
-*   **Orchestrator Role:** The `PipelineOrchestrator` manages the overall flow. It calls stages, passes necessary data (extracting image data references and metadata from previous stage outputs to create inputs for the next), receives output objects, and integrates final results (like saved file details) back into the main `AssetProcessingContext`.
-*   **Image Data Handling:** Large image arrays (`np.ndarray`) are passed primarily via stage return values (Output objects) and used as inputs to subsequent stages, managed by the Orchestrator. They are not stored long-term in the main `AssetProcessingContext`.
-*   **Main Context:** The `AssetProcessingContext` remains for overall state (rules, paths, configuration access, final status tracking) and potentially for simpler stages with minimal side effects.
-
-## 5. Visualization (Conceptual)
-
-```mermaid
-graph TD
-    subgraph Proposed Pipeline Stages
-        Start --> Prep[PrepareProcessingItemsStage]
-        Prep --> ItemLoop{Loop per Item}
-        ItemLoop -- FileRule --> RegProc[RegularMapProcessorStage]
-        ItemLoop -- MergeTask --> MergeProc[MergedTaskProcessorStage]
-        RegProc --> Scale(InitialScalingStage)
-        MergeProc --> Scale
-        Scale --> Save[SaveVariantsStage]
-        Save --> UpdateContext[Update Main Context w/ Results]
-        UpdateContext --> ItemLoop
-    end
-```
-
-## 6. Benefits
-
-*   Improved Readability & Understanding.
-*   Enhanced Maintainability & Reduced Risk.
-*   Better Testability.
-*   Clearer Dependencies.

ProjectNotes/issue_definitions_editor_list_selection.md

@@ -0,0 +1,62 @@
+# Issue: List item selection not working in Definitions Editor
+
+**Date:** 2025-05-13
+
+**Affected File:** [`gui/definitions_editor_dialog.py`](gui/definitions_editor_dialog.py)
+
+**Problem Description:**
+User mouse clicks on items within the `QListWidget` instances (for Asset Types, File Types, and Suppliers) in the Definitions Editor dialog do not trigger item selection or the `currentItemChanged` signal. The first item is selected by default and its details are displayed correctly. Programmatic selection of items (e.g., via a diagnostic button) *does* correctly trigger the `currentItemChanged` signal and updates the UI detail views. The issue is specific to user-initiated mouse clicks for selection after the initial load.
+
+**Debugging Steps Taken & Findings:**
+
+1.  **Initial Analysis:**
+    *   Reviewed GUI internals documentation ([`Documentation/02_Developer_Guide/06_GUI_Internals.md`](Documentation/02_Developer_Guide/06_GUI_Internals.md)) and [`gui/definitions_editor_dialog.py`](gui/definitions_editor_dialog.py) source code.
+    *   Confirmed signal connections (`currentItemChanged` to display slots) are made.
+
+2.  **Logging in Display Slots (`_display_*_details`):**
+    *   Added logging to display slots. Confirmed they are called for the initial (default) item selection.
+    *   No further calls to these slots occur on user clicks, indicating `currentItemChanged` is not firing.
+
+3.  **Color Swatch Palette Role:**
+    *   Investigated and corrected `QPalette.ColorRole` for color swatches (reverted from `Background` to `Window`). This fixed an `AttributeError` but did not resolve the selection issue.
+
+4.  **Robust Error Handling in Display Slots:**
+    *   Wrapped display slot logic in `try...finally` blocks with detailed logging. Confirmed slots complete without error for initial selection and signals for detail widgets are reconnected.
+
+5.  **Diagnostic Lambda for `currentItemChanged`:**
+    *   Added a lambda logger to `currentItemChanged` alongside the main display slot.
+    *   Confirmed both lambda and display slot fire for initial programmatic selection.
+    *   Neither fires for subsequent user clicks. This proved the `QListWidget` itself was not emitting the signal.
+
+6.  **Explicit `setEnabled` and `setSelectionMode` on `QListWidget`:**
+    *   Explicitly set these properties. No change in behavior.
+
+7.  **Explicit `setEnabled` and `setFocusPolicy(Qt.ClickFocus)` on `tab_page` (parent of `QListWidget` layout):**
+    *   This change **allowed programmatic selection via a diagnostic button to correctly fire `currentItemChanged` and update the UI**.
+    *   However, user mouse clicks still did not work and did not fire the signal.
+
+8.  **Event Filter Investigation:**
+    *   **Filter on `QListWidget`:** Did NOT receive mouse press/release events from user clicks.
+    *   **Filter on `tab_page` (parent of `QListWidget`'s layout):** Did NOT receive mouse press/release events.
+    *   **Filter on `self.tab_widget` (QTabWidget):** DID receive mouse press/release events.
+    *   Modified `self.tab_widget`'s event filter to return `False` for events over the current page, attempting to ensure propagation.
+    *   **Result:** With the modified `tab_widget` filter, an event filter re-added to `asset_type_list_widget` *did* start receiving mouse press/release events. **However, `asset_type_list_widget` still did not emit `currentItemChanged` from these user clicks.**
+
+9.  **`DebugListWidget` (Subclassing `QListWidget`):**
+    *   Created `DebugListWidget` overriding `mousePressEvent` with logging.
+    *   Used `DebugListWidget` for `asset_type_list_widget`.
+    *   **Initial user report indicated that `DebugListWidget.mousePressEvent` logs were NOT appearing for user clicks.** This means that even with the `QTabWidget` event filter attempting to propagate events, and the `asset_type_list_widget`'s filter (from step 8) confirming it received them, the `mousePressEvent` of the `QListWidget` itself was not being triggered by those propagated events. This is the current mystery.
+
+**Current Status:**
+- Programmatic selection works and fires signals.
+- User clicks are received by an event filter on `asset_type_list_widget` (after `QTabWidget` filter modification) but do not result in `mousePressEvent` being called on the `QListWidget` (or `DebugListWidget`) itself, and thus no `currentItemChanged` signal is emitted.
+- The issue seems to be a very low-level event processing problem specifically for user mouse clicks within the `QListWidget` instances when they are children of the `QTabWidget` pages, even when events appear to reach the list widget via an event filter.
+
+**Next Steps (When Resuming):**
+1.  Re-verify the logs from the `DebugListWidget.mousePressEvent` test. If it's truly not being called despite its event filter seeing events, this is extremely unusual.
+2.  Simplify the `_create_tab_pane` method drastically for one tab:
+    *   Remove the right-hand pane.
+    *   Add the `DebugListWidget` directly to the `tab_page`'s layout without the intermediate `left_pane_layout`.
+3.  Consider if any styles applied to `QListWidget` or its parents via stylesheets could be interfering with hit testing or event processing (unlikely for this specific symptom, but possible).
+4.  Explore alternative ways to populate/manage the `QListWidget` or its items if a subtle corruption is occurring.
+5.  If all else fails, consider replacing the `QListWidget` with a `QListView` and a `QStringListModel` as a more fundamental change to see if the issue is specific to `QListWidget` in this context.

TestFiles/Test-BoucleChunky001.json

@@ -0,0 +1,57 @@
+{
+  "source_rules": [
+    {
+      "input_path": "BoucleChunky001.zip",
+      "supplier_identifier": "Dinesen",
+      "preset_name": null,
+      "assets": [
+        {
+          "asset_name": "BoucleChunky001",
+          "asset_type": "Surface",
+          "files": [
+            {
+              "file_path": "BoucleChunky001_AO_1K_METALNESS.png",
+              "item_type": "MAP_AO",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_COL_1K_METALNESS.png",
+              "item_type": "MAP_COL",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_DISP16_1K_METALNESS.png",
+              "item_type": "MAP_DISP",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_DISP_1K_METALNESS.png",
+              "item_type": "EXTRA", 
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_Fabric.png",
+              "item_type": "EXTRA",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_METALNESS_1K_METALNESS.png",
+              "item_type": "MAP_METAL",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_NRM_1K_METALNESS.png",
+              "item_type": "MAP_NRM",
+              "target_asset_name_override": "BoucleChunky001"
+            },
+            {
+              "file_path": "BoucleChunky001_ROUGHNESS_1K_METALNESS.png",
+              "item_type": "MAP_ROUGH",
+              "target_asset_name_override": "BoucleChunky001"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

autotest.py

@@ -0,0 +1,855 @@
+import argparse
+import sys
+import logging
+import logging.handlers
+import time
+import json
+import shutil # Import shutil for directory operations
+from pathlib import Path
+from typing import List, Dict, Any
+
+from PySide6.QtCore import QCoreApplication, QTimer, Slot, QEventLoop, QObject, Signal
+from PySide6.QtWidgets import QApplication, QListWidgetItem
+
+# Add project root to sys.path
+project_root = Path(__file__).resolve().parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+try:
+    from main import App
+    from gui.main_window import MainWindow
+    from rule_structure import SourceRule # Assuming SourceRule is in rule_structure.py
+except ImportError as e:
+    print(f"Error importing project modules: {e}")
+    print(f"Ensure that the script is run from the project root or that the project root is in PYTHONPATH.")
+    print(f"Current sys.path: {sys.path}")
+    sys.exit(1)
+
+# Global variable for the memory log handler
+autotest_memory_handler = None
+
+# Custom Log Filter for Concise Output
+class InfoSummaryFilter(logging.Filter):
+    # Keywords that identify INFO messages to *allow* for concise output
+    SUMMARY_KEYWORDS_PRECISE = [
+        "Test run completed",
+        "Test succeeded",
+        "Test failed",
+        "Rule comparison successful",
+        "Rule comparison failed",
+        "ProcessingEngine finished. Summary:",
+        "Autotest Context:",
+        "Parsed CLI arguments:",
+        "Prediction completed successfully.",
+        "Processing completed.",
+        "Signal 'all_tasks_finished' received",
+        "final status:",  # To catch "Asset '...' final status:"
+        "User settings file not found:",
+        "MainPanelWidget: Default output directory set to:",
+        # Search related (as per original filter)
+        "Searching logs for term",
+        "Search term ",
+        "Found ",
+        "No tracebacks found in the logs.",
+        "--- End Log Analysis ---",
+        "Log analysis completed.",
+    ]
+    # Patterns for case-insensitive rejection
+    REJECT_PATTERNS_LOWER = [
+        # Original debug prefixes (ensure these are still relevant or merge if needed)
+        "debug:", "orchestrator_trace:", "configuration_debug:", "app_debug:", "output_org_debug:",
+        # Iterative / Per-item / Per-file details / Intermediate steps
+        ": item ",  # Catches "Asset '...', Item X/Y"
+        "item successfully processed and saved",
+        ", file '", # Catches "Asset '...', File '...'"
+        ": processing regular map",
+        ": found source file:",
+        ": determined source bit depth:",
+        "successfully processed regular map",
+        "successfully created mergetaskdefinition",
+        ": preparing processing items",
+        ": finished preparing items. found",
+        ": starting core item processing loop",
+        ", task '",
+        ": processing merge task",
+        "loaded from context:",
+        "using dimensions from first loaded input",
+        "successfully merged inputs into image",
+        "successfully processed merge task",
+        "mergedtaskprocessorstage result",
+        "calling savevariantsstage",
+        "savevariantsstage result",
+        "adding final details to context",
+        ": finished core item processing loop",
+        ": copied variant",
+        ": copied extra file",
+        ": successfully organized",
+        ": output organization complete.",
+        ": metadata saved to",
+        "worker thread: starting processing for rule:",
+        "preparing workspace for input:",
+        "input is a supported archive",
+        "calling processingengine.process with rule",
+        "calculated sha5 for",
+        "calculated next incrementing value for",
+        "verify: processingengine.process called",
+        ": effective supplier set to",
+        ": metadata initialized.",
+        "path",
+        "\\asset_processor",
+        ": file rules queued for processing",
+        "successfully loaded base application settings",
+        "successfully loaded and merged asset_type_definitions",
+        "successfully loaded and merged file_type_definitions",
+        "starting rule-based prediction for:",
+        "rule-based prediction finished successfully for",
+        "finished rule-based prediction run for",
+        "updating model with rule-based results for source:",
+        "debug task ",
+        "worker thread: finished processing for rule:",
+        "task finished signal received for",
+        # Autotest step markers (not global summaries)
+    ]
+
+    def filter(self, record):
+        # Allow CRITICAL, ERROR, WARNING unconditionally
+        if record.levelno >= logging.WARNING:
+            return True
+
+        if record.levelno == logging.INFO:
+            msg = record.getMessage()
+            msg_lower = msg.lower() # For case-insensitive pattern rejection
+
+            # 1. Explicitly REJECT if message contains verbose patterns (case-insensitive)
+            for pattern in self.REJECT_PATTERNS_LOWER: # Use the new list
+                if pattern in msg_lower:
+                    return False # Reject
+
+            # 2. Then, if not rejected, ALLOW only if message contains precise summary keywords
+            for keyword in self.SUMMARY_KEYWORDS_PRECISE: # Use the new list
+                if keyword in msg: # Original message for case-sensitive summary keywords if needed
+                    return True # Allow
+
+            # 3. Reject all other INFO messages that don't match precise summary keywords
+            return False
+
+        # Reject levels below INFO (e.g., DEBUG) by default for this handler
+        return False
+
+# --- Root Logger Configuration for Concise Console Output ---
+def setup_autotest_logging():
+    """
+    Configures the root logger for concise console output for autotest.py.
+    This ensures that only essential summary information, warnings, and errors
+    are displayed on the console by default.
+    """
+    root_logger = logging.getLogger()
+
+    # 1. Remove all existing handlers from the root logger.
+    # This prevents interference from other logging configurations.
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+        handler.close() # Close handler before removing
+
+    # 2. Set the root logger's level to DEBUG to capture everything for the memory handler.
+    # The console handler will still filter down to INFO/selected.
+    root_logger.setLevel(logging.DEBUG) # Changed from INFO to DEBUG
+
+    # 3. Create a new StreamHandler for sys.stdout (for concise console output).
+    console_handler = logging.StreamHandler(sys.stdout)
+
+    # 4. Set this console handler's level to INFO.
+    # The filter will then decide which INFO messages to display on console.
+    console_handler.setLevel(logging.INFO)
+
+    # 5. Apply the enhanced InfoSummaryFilter to the console handler.
+    info_filter = InfoSummaryFilter()
+    console_handler.addFilter(info_filter)
+
+    # 6. Set a concise formatter for the console handler.
+    formatter = logging.Formatter('[%(levelname)s] %(message)s')
+    console_handler.setFormatter(formatter)
+
+    # 7. Add this newly configured console handler to the root_logger.
+    root_logger.addHandler(console_handler)
+
+    # 8. Setup the MemoryHandler
+    global autotest_memory_handler # Declare usage of global
+    autotest_memory_handler = logging.handlers.MemoryHandler(
+        capacity=20000,  # Increased capacity
+        flushLevel=logging.CRITICAL + 1, # Prevent automatic flushing
+        target=None # Does not flush to another handler
+    )
+    autotest_memory_handler.setLevel(logging.DEBUG) # Capture all logs from DEBUG up
+    # Not adding a formatter here, will format in _process_and_display_logs
+
+    # 9. Add the memory handler to the root logger.
+    root_logger.addHandler(autotest_memory_handler)
+
+# Call the setup function early in the script's execution.
+setup_autotest_logging()
+
+# Logger for autotest.py's own messages.
+# Messages from this logger will propagate to the root logger and be filtered
+# by the console_handler configured above.
+# Setting its level to DEBUG allows autotest.py to generate DEBUG messages,
+# which won't appear on the concise console (due to handler's INFO level)
+# but can be captured by other handlers (e.g., the GUI's log console).
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG) # Ensure autotest.py can generate DEBUGs for other handlers
+
+# Note: The GUI's log console (e.g., self.main_window.log_console.log_console_output)
+# is assumed to capture all logs (including DEBUG) from various modules.
+# The _process_and_display_logs function then uses these comprehensive logs for the --search feature.
+# This root logger setup primarily makes autotest.py's direct console output concise,
+# ensuring that only filtered, high-level information appears on stdout by default.
+# --- End of Root Logger Configuration ---
+
+# --- Argument Parsing ---
+def parse_arguments():
+    """Parses command-line arguments for the autotest script."""
+    parser = argparse.ArgumentParser(description="Automated test script for Asset Processor GUI.")
+    parser.add_argument(
+        "--zipfile",
+        type=Path,
+        default=project_root / "TestFiles" / "BoucleChunky001.zip",
+        help="Path to the test asset ZIP file. Default: TestFiles/BoucleChunky001.zip"
+    )
+    parser.add_argument(
+        "--preset",
+        type=str,
+        default="Dinesen", # This should match a preset name in the application
+        help="Name of the preset to use. Default: Dinesen"
+    )
+    parser.add_argument(
+        "--expectedrules",
+        type=Path,
+        default=project_root / "TestFiles" / "Test-BoucleChunky001.json",
+        help="Path to the JSON file with expected rules. Default: TestFiles/Test-BoucleChunky001.json"
+    )
+    parser.add_argument(
+        "--outputdir",
+        type=Path,
+        default=project_root / "TestFiles" / "TestOutputs" / "BoucleChunkyOutput",
+        help="Path for processing output. Default: TestFiles/TestOutputs/BoucleChunkyOutput"
+    )
+    parser.add_argument(
+        "--search",
+        type=str,
+        default=None,
+        help="Optional log search term. Default: None"
+    )
+    parser.add_argument(
+        "--additional-lines",
+        type=int,
+        default=0,
+        help="Context lines for log search. Default: 0"
+    )
+    return parser.parse_args()
+
+class AutoTester(QObject):
+    """
+    Handles the automated testing process for the Asset Processor GUI.
+    """
+    # Define signals if needed, e.g., for specific test events
+    # test_step_completed = Signal(str)
+
+    def __init__(self, app_instance: App, cli_args: argparse.Namespace):
+        super().__init__()
+        self.app_instance: App = app_instance
+        self.main_window: MainWindow = app_instance.main_window
+        self.cli_args: argparse.Namespace = cli_args
+        self.event_loop = QEventLoop(self)
+        self.prediction_poll_timer = QTimer(self)
+        self.expected_rules_data: Dict[str, Any] = {}
+        self.test_step: str = "INIT"  # Possible values: INIT, LOADING_ZIP, SELECTING_PRESET, AWAITING_PREDICTION, PREDICTION_COMPLETE, COMPARING_RULES, STARTING_PROCESSING, AWAITING_PROCESSING, PROCESSING_COMPLETE, CHECKING_OUTPUT, ANALYZING_LOGS, DONE
+
+        if not self.main_window:
+            logger.error("MainWindow instance not found in App. Cannot proceed.")
+            self.cleanup_and_exit(success=False)
+            return
+
+        # Connect signals
+        if hasattr(self.app_instance, 'all_tasks_finished') and isinstance(self.app_instance.all_tasks_finished, Signal):
+            self.app_instance.all_tasks_finished.connect(self._on_all_tasks_finished)
+        else:
+            logger.warning("App instance does not have 'all_tasks_finished' signal or it's not a Signal. Processing completion might not be detected.")
+
+        self._load_expected_rules()
+
+    def _load_expected_rules(self) -> None:
+        """Loads the expected rules from the JSON file specified by cli_args."""
+        self.test_step = "LOADING_EXPECTED_RULES"
+        logger.debug(f"Loading expected rules from: {self.cli_args.expectedrules}")
+        try:
+            with open(self.cli_args.expectedrules, 'r') as f:
+                self.expected_rules_data = json.load(f)
+            logger.debug("Expected rules loaded successfully.")
+        except FileNotFoundError:
+            logger.error(f"Expected rules file not found: {self.cli_args.expectedrules}")
+            self.cleanup_and_exit(success=False)
+        except json.JSONDecodeError as e:
+            logger.error(f"Error decoding expected rules JSON: {e}")
+            self.cleanup_and_exit(success=False)
+        except Exception as e:
+            logger.error(f"An unexpected error occurred while loading expected rules: {e}")
+            self.cleanup_and_exit(success=False)
+
+    def run_test(self) -> None:
+        """Orchestrates the test steps."""
+        logger.info("Starting test run...")
+
+        if not self.expected_rules_data: # Ensure rules were loaded
+            logger.error("Expected rules not loaded. Aborting test.")
+            self.cleanup_and_exit(success=False)
+            return
+
+        # Add a specific summary log for essential context
+        logger.info(f"Autotest Context: Input='{self.cli_args.zipfile.name}', Preset='{self.cli_args.preset}', Output='{self.cli_args.outputdir}'")
+
+        # Step 1: Load ZIP
+        self.test_step = "LOADING_ZIP"
+        logger.info(f"Step 1: Loading ZIP file: {self.cli_args.zipfile}") # KEEP INFO - Passes filter
+        if not self.cli_args.zipfile.exists():
+            logger.error(f"ZIP file not found: {self.cli_args.zipfile}")
+            self.cleanup_and_exit(success=False)
+            return
+        try:
+            # Assuming add_input_paths can take a list of strings or Path objects
+            self.main_window.add_input_paths([str(self.cli_args.zipfile)])
+            logger.debug("ZIP file loading initiated.")
+        except Exception as e:
+            logger.error(f"Error during ZIP file loading: {e}")
+            self.cleanup_and_exit(success=False)
+            return
+
+        # Step 2: Select Preset
+        self.test_step = "SELECTING_PRESET"
+        logger.info(f"Step 2: Selecting preset: {self.cli_args.preset}") # KEEP INFO - Passes filter
+        preset_found = False
+        preset_list_widget = self.main_window.preset_editor_widget.editor_preset_list
+        for i in range(preset_list_widget.count()):
+            item = preset_list_widget.item(i)
+            if item and item.text() == self.cli_args.preset:
+                preset_list_widget.setCurrentItem(item)
+                logger.debug(f"Preset '{self.cli_args.preset}' selected.")
+                preset_found = True
+                break
+        if not preset_found:
+            logger.error(f"Preset '{self.cli_args.preset}' not found in the list.")
+            available_presets = [preset_list_widget.item(i).text() for i in range(preset_list_widget.count())]
+            logger.debug(f"Available presets: {available_presets}")
+            self.cleanup_and_exit(success=False)
+            return
+
+        # Step 3: Await Prediction Completion
+        self.test_step = "AWAITING_PREDICTION"
+        logger.debug("Step 3: Awaiting prediction completion...")
+        self.prediction_poll_timer.timeout.connect(self._check_prediction_status)
+        self.prediction_poll_timer.start(500) # Poll every 500ms
+
+        # Use a QTimer to allow event loop to process while waiting for this step
+        # This ensures that the _check_prediction_status can be called.
+        # We will exit this event_loop from _check_prediction_status when prediction is done.
+        logger.debug("Starting event loop for prediction...")
+        self.event_loop.exec() # This loop is quit by _check_prediction_status
+        self.prediction_poll_timer.stop()
+        logger.debug("Event loop for prediction finished.")
+
+
+        if self.test_step != "PREDICTION_COMPLETE":
+            logger.error(f"Prediction did not complete as expected. Current step: {self.test_step}")
+            # Check if there were any pending predictions that never cleared
+            if hasattr(self.main_window, '_pending_predictions'):
+                 logger.error(f"Pending predictions at timeout: {self.main_window._pending_predictions}")
+            self.cleanup_and_exit(success=False)
+            return
+        logger.info("Prediction completed successfully.") # KEEP INFO - Passes filter
+
+        # Step 4: Retrieve & Compare Rulelist
+        self.test_step = "COMPARING_RULES"
+        logger.info("Step 4: Retrieving and Comparing Rules...") # KEEP INFO - Passes filter
+        actual_source_rules_list: List[SourceRule] = self.main_window.unified_model.get_all_source_rules()
+        actual_rules_obj = actual_source_rules_list # Keep the SourceRule list for processing
+        
+        comparable_actual_rules = self._convert_rules_to_comparable(actual_source_rules_list)
+
+        if not self._compare_rules(comparable_actual_rules, self.expected_rules_data):
+            logger.error("Rule comparison failed. See logs for details.")
+            self.cleanup_and_exit(success=False)
+            return
+        logger.info("Rule comparison successful.") # KEEP INFO - Passes filter
+
+        # Step 5: Start Processing
+        self.test_step = "START_PROCESSING"
+        logger.info("Step 5: Starting Processing...") # KEEP INFO - Passes filter
+        processing_settings = {
+            "output_dir": str(self.cli_args.outputdir), # Ensure it's a string for JSON/config
+            "overwrite": True,
+            "workers": 1,
+            "blender_enabled": False # Basic test, no Blender
+        }
+        try:
+            Path(self.cli_args.outputdir).mkdir(parents=True, exist_ok=True)
+            logger.debug(f"Ensured output directory exists: {self.cli_args.outputdir}")
+        except Exception as e:
+            logger.error(f"Could not create output directory {self.cli_args.outputdir}: {e}")
+            self.cleanup_and_exit(success=False)
+            return
+
+        if hasattr(self.main_window, 'start_backend_processing') and isinstance(self.main_window.start_backend_processing, Signal):
+            logger.debug(f"Emitting start_backend_processing with rules count: {len(actual_rules_obj)} and settings: {processing_settings}")
+            self.main_window.start_backend_processing.emit(actual_rules_obj, processing_settings)
+        else:
+            logger.error("'start_backend_processing' signal not found on MainWindow. Cannot start processing.")
+            self.cleanup_and_exit(success=False)
+            return
+        
+        # Step 6: Await Processing Completion
+        self.test_step = "AWAIT_PROCESSING"
+        logger.debug("Step 6: Awaiting processing completion...")
+        self.event_loop.exec() # This loop is quit by _on_all_tasks_finished
+
+        if self.test_step != "PROCESSING_COMPLETE":
+            logger.error(f"Processing did not complete as expected. Current step: {self.test_step}")
+            self.cleanup_and_exit(success=False)
+            return
+        logger.info("Processing completed.") # KEEP INFO - Passes filter
+
+        # Step 7: Check Output Path
+        self.test_step = "CHECK_OUTPUT"
+        logger.info(f"Step 7: Checking output path: {self.cli_args.outputdir}") # KEEP INFO - Passes filter
+        output_path = Path(self.cli_args.outputdir)
+        if not output_path.exists() or not output_path.is_dir():
+            logger.error(f"Output directory {output_path} does not exist or is not a directory.")
+            self.cleanup_and_exit(success=False)
+            return
+
+        output_items = list(output_path.iterdir())
+        if not output_items:
+            logger.warning(f"Output directory {output_path} is empty. This might be a test failure depending on the case.")
+            # For a more specific check, one might iterate through actual_rules_obj
+            # and verify if subdirectories matching asset_name exist.
+            # e.g. for asset_rule in source_rule.assets:
+            #   expected_asset_dir = output_path / asset_rule.asset_name
+            #   if not expected_asset_dir.is_dir(): logger.error(...)
+        else:
+            logger.debug(f"Found {len(output_items)} item(s) in output directory:")
+            for item in output_items:
+                logger.debug(f"  - {item.name} ({'dir' if item.is_dir() else 'file'})")
+        logger.info("Output path check completed.") # KEEP INFO - Passes filter
+
+        # Step 8: Retrieve & Analyze Logs
+        self.test_step = "CHECK_LOGS"
+        logger.debug("Step 8: Retrieving and Analyzing Logs...")
+        all_logs_text = ""
+        if self.main_window.log_console and self.main_window.log_console.log_console_output:
+            all_logs_text = self.main_window.log_console.log_console_output.toPlainText()
+        else:
+            logger.warning("Log console or output widget not found. Cannot retrieve logs.")
+        
+        self._process_and_display_logs(all_logs_text)
+        logger.info("Log analysis completed.")
+
+        # Final Step
+        logger.info("Test run completed successfully.") # KEEP INFO - Passes filter
+        self.cleanup_and_exit(success=True)
+
+    @Slot()
+    def _check_prediction_status(self) -> None:
+        """Polls the main window for pending predictions."""
+        # logger.debug(f"Checking prediction status. Pending: {self.main_window._pending_predictions if hasattr(self.main_window, '_pending_predictions') else 'N/A'}")
+        if hasattr(self.main_window, '_pending_predictions'):
+            if not self.main_window._pending_predictions: # Assuming _pending_predictions is a list/dict that's empty when done
+                logger.debug("No pending predictions. Prediction assumed complete.")
+                self.test_step = "PREDICTION_COMPLETE"
+                if self.event_loop.isRunning():
+                    self.event_loop.quit()
+            # else:
+                # logger.debug(f"Still awaiting predictions: {len(self.main_window._pending_predictions)} remaining.")
+        else:
+            logger.warning("'_pending_predictions' attribute not found on MainWindow. Cannot check prediction status automatically.")
+            # As a fallback, if the attribute is missing, we might assume prediction is instant or needs manual check.
+            # For now, let's assume it means it's done if the attribute is missing, but this is risky.
+            # A better approach would be to have a clear signal from MainWindow when predictions are done.
+            self.test_step = "PREDICTION_COMPLETE" # Risky assumption
+            if self.event_loop.isRunning():
+                self.event_loop.quit()
+
+
+    @Slot(int, int, int)
+    def _on_all_tasks_finished(self, processed_count: int, skipped_count: int, failed_count: int) -> None:
+        """Slot for App.all_tasks_finished signal."""
+        logger.info(f"Signal 'all_tasks_finished' received: Processed={processed_count}, Skipped={skipped_count}, Failed={failed_count}") # KEEP INFO - Passes filter
+        
+        if self.test_step == "AWAIT_PROCESSING":
+            logger.debug("Processing completion signal received.") # Covered by the summary log above
+            if failed_count > 0:
+                logger.error(f"Processing finished with {failed_count} failed task(s).")
+            # Even if tasks failed, the test might pass based on output checks.
+            # The error is logged for information.
+            self.test_step = "PROCESSING_COMPLETE"
+            if self.event_loop.isRunning():
+                self.event_loop.quit()
+        else:
+            logger.warning(f"Signal 'all_tasks_finished' received at an unexpected test step: '{self.test_step}'. Counts: P={processed_count}, S={skipped_count}, F={failed_count}")
+
+
+    def _convert_rules_to_comparable(self, source_rules_list: List[SourceRule]) -> Dict[str, Any]:
+        """
+        Converts a list of SourceRule objects to a dictionary structure
+        suitable for comparison with the expected_rules.json.
+        """
+        logger.debug(f"Converting {len(source_rules_list)} SourceRule objects to comparable dictionary...")
+        comparable_sources_list = []
+        for source_rule_obj in source_rules_list:
+            comparable_asset_list = []
+            # source_rule_obj.assets is List[AssetRule]
+            for asset_rule_obj in source_rule_obj.assets:
+                comparable_file_list = []
+                # asset_rule_obj.files is List[FileRule]
+                for file_rule_obj in asset_rule_obj.files:
+                    comparable_file_list.append({
+                        "file_path": file_rule_obj.file_path,
+                        "item_type": file_rule_obj.item_type,
+                        "target_asset_name_override": file_rule_obj.target_asset_name_override
+                    })
+                comparable_asset_list.append({
+                    "asset_name": asset_rule_obj.asset_name,
+                    "asset_type": asset_rule_obj.asset_type,
+                    "files": comparable_file_list
+                })
+            comparable_sources_list.append({
+                "input_path": Path(source_rule_obj.input_path).name, # Use only the filename
+                "supplier_identifier": source_rule_obj.supplier_identifier,
+                "preset_name": source_rule_obj.preset_name,
+                "assets": comparable_asset_list
+            })
+        logger.debug("Conversion to comparable dictionary finished.")
+        return {"source_rules": comparable_sources_list}
+
+    def _compare_rule_item(self, actual_item: Dict[str, Any], expected_item: Dict[str, Any], item_type_name: str, parent_context: str = "") -> bool:
+        """
+        Recursively compares an individual actual rule item dictionary with an expected rule item dictionary.
+        Logs differences and returns True if they match, False otherwise.
+        """
+        item_match = True
+        
+        identifier = ""
+        if item_type_name == "SourceRule":
+            identifier = expected_item.get('input_path', f'UnknownSource_at_{parent_context}')
+        elif item_type_name == "AssetRule":
+            identifier = expected_item.get('asset_name', f'UnknownAsset_at_{parent_context}')
+        elif item_type_name == "FileRule":
+            identifier = expected_item.get('file_path', f'UnknownFile_at_{parent_context}')
+        
+        current_context = f"{parent_context}/{identifier}" if parent_context else identifier
+
+        # Log Extra Fields: Iterate through keys in actual_item.
+        # If a key is in actual_item but not in expected_item (and is not a list container like "assets" or "files"),
+        # log this as an informational message.
+        for key in actual_item.keys():
+            if key not in expected_item and key not in ["assets", "files"]:
+                logger.debug(f"Field '{key}' present in actual {item_type_name} ({current_context}) but not specified in expected. Value: '{actual_item[key]}'")
+
+        # Check Expected Fields: Iterate through keys in expected_item.
+        for key, expected_value in expected_item.items():
+            if key not in actual_item:
+                logger.error(f"Missing expected field '{key}' in actual {item_type_name} ({current_context}).")
+                item_match = False
+                continue # Continue to check other fields in the expected_item
+
+            actual_value = actual_item[key]
+
+            if key == "assets": # List of AssetRule dictionaries
+                if not self._compare_list_of_rules(actual_value, expected_value, "AssetRule", current_context, "asset_name"):
+                    item_match = False
+            elif key == "files": # List of FileRule dictionaries
+                if not self._compare_list_of_rules(actual_value, expected_value, "FileRule", current_context, "file_path"):
+                    item_match = False
+            else: # Regular field comparison
+                if actual_value != expected_value:
+                    # Handle None vs "None" string for preset_name specifically if it's a common issue
+                    if key == "preset_name" and actual_value is None and expected_value == "None":
+                        logger.debug(f"Field '{key}' in {item_type_name} ({current_context}): Actual is None, Expected is string \"None\". Treating as match for now.")
+                    elif key == "target_asset_name_override" and actual_value is not None and expected_value is None:
+                         # If actual has a value (e.g. parent asset name) and expected is null/None,
+                         # this is a mismatch according to strict comparison.
+                         # For a more lenient check, this logic could be adjusted here.
+                         # Current strict comparison will flag this as error, which is what the logs show.
+                         logger.error(f"Value mismatch for field '{key}' in {item_type_name} ({current_context}): Actual='{actual_value}', Expected='{expected_value}'.")
+                         item_match = False
+                    else:
+                        logger.error(f"Value mismatch for field '{key}' in {item_type_name} ({current_context}): Actual='{actual_value}', Expected='{expected_value}'.")
+                        item_match = False
+            
+        return item_match
+    
+    def _compare_list_of_rules(self, actual_list: List[Dict[str, Any]], expected_list: List[Dict[str, Any]], item_type_name: str, parent_context: str, item_key_field: str) -> bool:
+        """
+        Compares a list of actual rule items against a list of expected rule items.
+        Items are matched by a key field (e.g., 'asset_name' or 'file_path').
+        Order independent for matching, but logs count mismatches.
+        """
+        list_match = True
+        if not isinstance(actual_list, list) or not isinstance(expected_list, list):
+            logger.error(f"Type mismatch for list of {item_type_name}s in {parent_context}. Expected lists.")
+            return False
+
+        if len(actual_list) != len(expected_list):
+            logger.error(f"Mismatch in number of {item_type_name}s for {parent_context}. Actual: {len(actual_list)}, Expected: {len(expected_list)}.")
+            list_match = False # Count mismatch is an error
+            # If counts differ, we still try to match what we can to provide more detailed feedback,
+            # but the overall list_match will remain False.
+
+        actual_items_map = {item.get(item_key_field): item for item in actual_list if item.get(item_key_field) is not None}
+        
+        # Keep track of expected items that found a match to identify missing ones more easily
+        matched_expected_keys = set()
+
+        for expected_item in expected_list:
+            expected_key_value = expected_item.get(item_key_field)
+            if expected_key_value is None:
+                logger.error(f"Expected {item_type_name} in {parent_context} is missing key field '{item_key_field}'. Cannot compare this item: {expected_item}")
+                list_match = False # This specific expected item cannot be processed
+                continue
+
+            actual_item = actual_items_map.get(expected_key_value)
+            if actual_item:
+                matched_expected_keys.add(expected_key_value)
+                if not self._compare_rule_item(actual_item, expected_item, item_type_name, parent_context):
+                    list_match = False # Individual item comparison failed
+            else:
+                logger.error(f"Expected {item_type_name} with {item_key_field} '{expected_key_value}' not found in actual items for {parent_context}.")
+                list_match = False
+        
+        # Identify actual items that were not matched by any expected item
+        # This is useful if len(actual_list) >= len(expected_list) but some actual items are "extra"
+        for actual_key_value, actual_item_data in actual_items_map.items():
+            if actual_key_value not in matched_expected_keys:
+                logger.debug(f"Extra actual {item_type_name} with {item_key_field} '{actual_key_value}' found in {parent_context} (not in expected list or already matched).")
+                if len(actual_list) != len(expected_list): # If counts already flagged a mismatch, this is just detail
+                    pass
+                else: # Counts matched, but content didn't align perfectly by key
+                    list_match = False
+
+
+        return list_match
+    
+
+    def _compare_rules(self, actual_rules_data: Dict[str, Any], expected_rules_data: Dict[str, Any]) -> bool:
+        """
+        Compares the actual rule data (converted from live SourceRule objects)
+        with the expected rule data (loaded from JSON).
+        """
+        logger.debug("Comparing actual rules with expected rules...")
+
+        actual_source_rules = actual_rules_data.get("source_rules", []) if actual_rules_data else []
+        expected_source_rules = expected_rules_data.get("source_rules", []) if expected_rules_data else []
+
+        if not isinstance(actual_source_rules, list):
+            logger.error(f"Actual 'source_rules' is not a list. Found type: {type(actual_source_rules)}. Comparison aborted.")
+            return False # Cannot compare if actual data is malformed
+        if not isinstance(expected_source_rules, list):
+            logger.error(f"Expected 'source_rules' is not a list. Found type: {type(expected_source_rules)}. Test configuration error. Comparison aborted.")
+            return False # Test setup error
+
+        if not expected_source_rules and not actual_source_rules:
+            logger.debug("Both expected and actual source rules lists are empty. Considered a match.")
+            return True
+        
+        if len(actual_source_rules) != len(expected_source_rules):
+            logger.error(f"Mismatch in the number of source rules. Actual: {len(actual_source_rules)}, Expected: {len(expected_source_rules)}.")
+            # Optionally, log more details about which list is longer/shorter or identifiers if available
+            return False
+
+        overall_match_status = True
+        for i in range(len(expected_source_rules)):
+            actual_sr = actual_source_rules[i]
+            expected_sr = expected_source_rules[i]
+            
+            # For context, use input_path or an index
+            source_rule_context = expected_sr.get('input_path', f"SourceRule_index_{i}")
+
+            if not self._compare_rule_item(actual_sr, expected_sr, "SourceRule", parent_context=source_rule_context):
+                overall_match_status = False
+                # Continue checking other source rules to log all discrepancies
+
+        if overall_match_status:
+            logger.debug("All rules match the expected criteria.") # Covered by "Rule comparison successful" summary
+        else:
+            logger.warning("One or more rules did not match the expected criteria. See logs above for details.")
+            
+        return overall_match_status
+
+    def _process_and_display_logs(self, logs_text: str) -> None: # logs_text is no longer the primary source for search
+        """
+        Processes and displays logs, potentially filtering them if --search is used.
+        Also checks for tracebacks.
+        Sources logs from the in-memory handler for search and detailed analysis.
+        """
+        logger.debug("--- Log Analysis ---")
+        global autotest_memory_handler # Access the global handler
+        log_records = []
+        if autotest_memory_handler and autotest_memory_handler.buffer:
+            log_records = autotest_memory_handler.buffer
+
+        formatted_log_lines = []
+        # Define a consistent formatter, similar to what might be expected or useful for search
+        record_formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s')
+        # Default asctime format includes milliseconds.
+
+
+        for record in log_records:
+            formatted_log_lines.append(record_formatter.format(record))
+        
+        lines_for_search_and_traceback = formatted_log_lines
+        
+        if not lines_for_search_and_traceback:
+            logger.warning("No log records found in memory handler. No analysis to perform.")
+            # Still check the console logs_text for tracebacks if it exists, as a fallback
+            # or if some critical errors didn't make it to the memory handler (unlikely with DEBUG level)
+            if logs_text:
+                logger.debug("Checking provided logs_text (from console) for tracebacks as a fallback.")
+                console_lines = logs_text.splitlines()
+                traceback_found_console = False
+                for i, line in enumerate(console_lines):
+                    if line.strip().startswith("Traceback (most recent call last):"):
+                        logger.error(f"!!! TRACEBACK DETECTED in console logs_text around line {i+1} !!!")
+                        traceback_found_console = True
+                if traceback_found_console:
+                     logger.warning("A traceback was found in the console logs_text.")
+                else:
+                    logger.info("No tracebacks found in the console logs_text either.")
+            logger.info("--- End Log Analysis ---")
+            return
+
+        traceback_found = False
+
+        if self.cli_args.search:
+            logger.info(f"Searching {len(lines_for_search_and_traceback)} in-memory log lines for term '{self.cli_args.search}' with {self.cli_args.additional_lines} context lines.")
+            matched_line_indices = [i for i, line in enumerate(lines_for_search_and_traceback) if self.cli_args.search in line]
+            
+            if not matched_line_indices:
+                logger.info(f"Search term '{self.cli_args.search}' not found in in-memory logs.")
+            else:
+                logger.info(f"Found {len(matched_line_indices)} match(es) for '{self.cli_args.search}' in in-memory logs:")
+                collected_lines_to_print = set()
+                for match_idx in matched_line_indices:
+                    start_idx = max(0, match_idx - self.cli_args.additional_lines)
+                    end_idx = min(len(lines_for_search_and_traceback), match_idx + self.cli_args.additional_lines + 1)
+                    for i in range(start_idx, end_idx):
+                        # Use i directly as index for lines_for_search_and_traceback, line number is for display
+                        collected_lines_to_print.add(f"L{i+1:05d}: {lines_for_search_and_traceback[i]}")
+                
+                print("--- Filtered Log Output (from Memory Handler) ---")
+                for line_to_print in sorted(list(collected_lines_to_print)):
+                    print(line_to_print)
+                print("--- End Filtered Log Output ---")
+        # Removed: else block that showed last N lines by default (as per original instruction for this section)
+
+        # Traceback Check (on lines_for_search_and_traceback)
+        for i, line in enumerate(lines_for_search_and_traceback):
+            if line.strip().startswith("Traceback (most recent call last):") or "Traceback (most recent call last):" in line : # More robust check
+                logger.error(f"!!! TRACEBACK DETECTED in in-memory logs around line index {i} !!!")
+                logger.error(f"Line content: {line}")
+                traceback_found = True
+        
+        if traceback_found:
+            logger.warning("A traceback was found in the in-memory logs. This usually indicates a significant issue.")
+        else:
+            logger.info("No tracebacks found in the in-memory logs.") # This refers to the comprehensive memory logs
+            
+        logger.info("--- End Log Analysis ---")
+
+    def cleanup_and_exit(self, success: bool = True) -> None:
+        """Cleans up and exits the application."""
+        global autotest_memory_handler
+        if autotest_memory_handler:
+            logger.debug("Clearing memory log handler buffer and removing handler.")
+            autotest_memory_handler.buffer = [] # Clear buffer
+            logging.getLogger().removeHandler(autotest_memory_handler) # Remove handler
+            autotest_memory_handler.close() # MemoryHandler close is a no-op but good practice
+            autotest_memory_handler = None
+
+        logger.info(f"Test {'succeeded' if success else 'failed'}. Cleaning up and exiting...") # KEEP INFO - Passes filter
+        q_app = QCoreApplication.instance()
+        if q_app:
+            q_app.quit()
+        sys.exit(0 if success else 1)
+
+# --- Main Execution ---
+def main():
+    """Main function to run the autotest script."""
+    cli_args = parse_arguments()
+    # Logger is configured above, this will now use the new filtered setup
+    logger.info(f"Parsed CLI arguments: {cli_args}") # KEEP INFO - Passes filter
+
+    # Clean and ensure output directory exists
+    output_dir_path = Path(cli_args.outputdir)
+    logger.debug(f"Preparing output directory: {output_dir_path}")
+    try:
+        if output_dir_path.exists():
+            logger.debug(f"Output directory {output_dir_path} exists. Cleaning its contents...")
+            for item in output_dir_path.iterdir():
+                if item.is_dir():
+                    shutil.rmtree(item)
+                    logger.debug(f"Removed directory: {item}")
+                else:
+                    item.unlink()
+                    logger.debug(f"Removed file: {item}")
+            logger.debug(f"Contents of {output_dir_path} cleaned.")
+        else:
+            logger.debug(f"Output directory {output_dir_path} does not exist. Creating it.")
+        
+        output_dir_path.mkdir(parents=True, exist_ok=True) # Ensure it exists after cleaning/if it didn't exist
+        logger.debug(f"Output directory {output_dir_path} is ready.")
+
+    except Exception as e:
+        logger.error(f"Could not prepare output directory {output_dir_path}: {e}", exc_info=True)
+        sys.exit(1)
+
+    # Initialize QApplication
+    # Use QCoreApplication if no GUI elements are directly interacted with by the test logic itself,
+    # but QApplication is needed if MainWindow or its widgets are constructed and used.
+    # Since MainWindow is instantiated by App, QApplication is appropriate.
+    q_app = QApplication.instance()
+    if not q_app:
+        q_app = QApplication(sys.argv)
+    if not q_app: # Still no app
+        logger.error("Failed to initialize QApplication.")
+        sys.exit(1)
+
+    logger.debug("Initializing main.App()...")
+    try:
+        # Instantiate main.App() - this should create MainWindow but not show it by default
+        # if App is designed to not show GUI unless app.main_window.show() is called.
+        app_instance = App()
+    except Exception as e:
+        logger.error(f"Failed to initialize main.App: {e}", exc_info=True)
+        sys.exit(1)
+    
+    if not app_instance.main_window:
+        logger.error("main.App initialized, but main_window is None. Cannot proceed with test.")
+        sys.exit(1)
+    
+    logger.debug("Initializing AutoTester...")
+    try:
+        tester = AutoTester(app_instance, cli_args)
+    except Exception as e:
+        logger.error(f"Failed to initialize AutoTester: {e}", exc_info=True)
+        sys.exit(1)
+
+    # Use QTimer.singleShot to start the test after the Qt event loop has started.
+    # This ensures that the Qt environment is fully set up.
+    logger.debug("Scheduling test run...")
+    QTimer.singleShot(0, tester.run_test)
+
+    logger.debug("Starting Qt application event loop...")
+    exit_code = q_app.exec()
+    logger.debug(f"Qt application event loop finished with exit code: {exit_code}")
+    sys.exit(exit_code)
+
+if __name__ == "__main__":
+    main()

config/app_settings.json

@@ -1,245 +1,4 @@
 {
-    "ASSET_TYPE_DEFINITIONS": {
-        "Surface": {
-            "description": "A single Standard PBR material set for a surface.",
-            "color": "#1f3e5d",
-            "examples": [
-                "Set: Wood01_COL + Wood01_NRM + WOOD01_ROUGH",
-                "Set: Dif_Concrete + Normal_Concrete + Refl_Concrete"
-            ]
-        },
-        "Model": {
-            "description": "A set that contains models, can include PBR textureset",
-            "color": "#b67300",
-            "examples": [
-                "Single = Chair.fbx",
-                "Set = Plant02.fbx + Plant02_col + Plant02_SSS"
-            ]
-        },
-        "Decal": {
-            "description": "A alphamasked textureset",
-            "color": "#68ac68",
-            "examples": [
-                "Set = DecalGraffiti01_Col + DecalGraffiti01_Alpha",
-                "Single = DecalLeakStain03"
-            ]
-        },
-        "Atlas": {
-            "description": "A texture, name usually hints that it's an atlas",
-            "color": "#955b8b",
-            "examples": [
-                "Set = FoliageAtlas01_col + FoliageAtlas01_nrm"
-            ]
-        },
-        "UtilityMap": {
-            "description": "A useful image-asset consisting of only a single texture. Therefor each Utilitymap can only contain a single item.",
-            "color": "#706b87",
-            "examples": [
-                "Single = imperfection.png",
-                "Single = smudges.png",
-                "Single = scratches.tif"
-            ]
-        }
-    },
-    "FILE_TYPE_DEFINITIONS": {
-        "MAP_COL": {
-            "description": "Color/Albedo Map",
-            "color": "#ffaa00",
-            "examples": [
-                "_col.",
-                "_basecolor.",
-                "albedo",
-                "diffuse"
-            ],
-            "standard_type": "COL",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": false,
-            "keybind": "C"
-        },
-        "MAP_NRM": {
-            "description": "Normal Map",
-            "color": "#cca2f1",
-            "examples": [
-                "_nrm.",
-                "_normal."
-            ],
-            "standard_type": "NRM",
-            "bit_depth_rule": "respect",
-            "is_grayscale": false,
-            "keybind": "N"
-        },
-        "MAP_METAL": {
-            "description": "Metalness Map",
-            "color": "#dcf4f2",
-            "examples": [
-                "_metal.",
-                "_met."
-            ],
-            "standard_type": "METAL",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true,
-            "keybind": "M"
-        },
-        "MAP_ROUGH": {
-            "description": "Roughness Map",
-            "color": "#bfd6bf",
-            "examples": [
-                "_rough.",
-                "_rgh.",
-                "_gloss"
-            ],
-            "standard_type": "ROUGH",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true,
-            "keybind": "R"
-        },
-        "MAP_GLOSS": {
-            "description": "Glossiness Map",
-            "color": "#d6bfd6",
-            "examples": [
-                "_gloss.",
-                "_gls."
-            ],
-            "standard_type": "GLOSS",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true,
-            "keybind": "R"
-        },
-        "MAP_AO": {
-            "description": "Ambient Occlusion Map",
-            "color": "#e3c7c7",
-            "examples": [
-                "_ao.",
-                "_ambientocclusion."
-            ],
-            "standard_type": "AO",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true
-        },
-        "MAP_DISP": {
-            "description": "Displacement/Height Map",
-            "color": "#c6ddd5",
-            "examples": [
-                "_disp.",
-                "_height."
-            ],
-            "standard_type": "DISP",
-            "bit_depth_rule": "respect",
-            "is_grayscale": true,
-            "keybind": "D"
-        },
-        "MAP_REFL": {
-            "description": "Reflection/Specular Map",
-            "color": "#c2c2b9",
-            "examples": [
-                "_refl.",
-                "_specular."
-            ],
-            "standard_type": "REFL",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true,
-            "keybind": "M"
-        },
-        "MAP_SSS": {
-            "description": "Subsurface Scattering Map",
-            "color": "#a0d394",
-            "examples": [
-                "_sss.",
-                "_subsurface."
-            ],
-            "standard_type": "SSS",
-            "bit_depth_rule": "respect",
-            "is_grayscale": true
-        },
-        "MAP_FUZZ": {
-            "description": "Fuzz/Sheen Map",
-            "color": "#a2d1da",
-            "examples": [
-                "_fuzz.",
-                "_sheen."
-            ],
-            "standard_type": "FUZZ",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true
-        },
-        "MAP_IDMAP": {
-            "description": "ID Map (for masking)",
-            "color": "#ca8fb4",
-            "examples": [
-                "_id.",
-                "_matid."
-            ],
-            "standard_type": "IDMAP",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": false
-        },
-        "MAP_MASK": {
-            "description": "Generic Mask Map",
-            "color": "#c6e2bf",
-            "examples": [
-                "_mask."
-            ],
-            "standard_type": "MASK",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true
-        },
-        "MAP_IMPERFECTION": {
-            "description": "Imperfection Map (scratches, dust)",
-            "color": "#e6d1a6",
-            "examples": [
-                "_imp.",
-                "_imperfection.",
-                "splatter",
-                "scratches",
-                "smudges",
-                "hairs",
-                "fingerprints"
-            ],
-            "standard_type": "IMPERFECTION",
-            "bit_depth_rule": "force_8bit",
-            "is_grayscale": true
-        },
-        "MODEL": {
-            "description": "3D Model File",
-            "color": "#3db2bd",
-            "examples": [
-                ".fbx",
-                ".obj"
-            ],
-            "standard_type": "",
-            "bit_depth_rule": "",
-            "is_grayscale": false
-        },
-        "EXTRA": {
-            "description": "asset previews or metadata",
-            "color": "#8c8c8c",
-            "examples": [
-                ".txt",
-                ".zip",
-                "preview.",
-                "_flat.",
-                "_sphere.",
-                "_Cube.",
-                "thumb"
-            ],
-            "standard_type": "",
-            "bit_depth_rule": "",
-            "is_grayscale": false,
-            "keybind": "E"
-        },
-        "FILE_IGNORE": {
-            "description": "File to be ignored",
-            "color": "#673d35",
-            "examples": [
-                "Thumbs.db",
-                ".DS_Store"
-            ],
-            "standard_type": "",
-            "bit_depth_rule": "",
-            "is_grayscale": false,
-            "keybind": "X"
-        }
-    },
     "TARGET_FILENAME_PATTERN": "{base_name}_{map_type}_{resolution}.{ext}",
     "RESPECT_VARIANT_MAP_TYPES": [
         "COL"
@@ -287,7 +46,10 @@
     "TEMP_DIR_PREFIX": "_PROCESS_ASSET_",
     "INITIAL_SCALING_MODE": "POT_DOWNSCALE",
     "MERGE_DIMENSION_MISMATCH_STRATEGY": "USE_LARGEST",
+    "ENABLE_LOW_RESOLUTION_FALLBACK": true,
+    "LOW_RESOLUTION_THRESHOLD": 512,
     "general_settings": {
-        "invert_normal_map_green_channel_globally": false
+        "invert_normal_map_green_channel_globally": false,
+        "app_version": "Pre-Alpha"
     }
 }

config/asset_type_definitions.json

@@ -0,0 +1,44 @@
+{
+    "ASSET_TYPE_DEFINITIONS": {
+        "Surface": {
+            "color": "#1f3e5d",
+            "description": "A single Standard PBR material set for a surface.",
+            "examples": [
+                "Set: Wood01_COL + Wood01_NRM + WOOD01_ROUGH",
+                "Set: Dif_Concrete + Normal_Concrete + Refl_Concrete"
+            ]
+        },
+        "Model": {
+            "color": "#b67300",
+            "description": "A set that contains models, can include PBR textureset",
+            "examples": [
+                "Single = Chair.fbx",
+                "Set = Plant02.fbx + Plant02_col + Plant02_SSS"
+            ]
+        },
+        "Decal": {
+            "color": "#68ac68",
+            "description": "A alphamasked textureset",
+            "examples": [
+                "Set = DecalGraffiti01_Col + DecalGraffiti01_Alpha",
+                "Single = DecalLeakStain03"
+            ]
+        },
+        "Atlas": {
+            "color": "#955b8b",
+            "description": "A texture, name usually hints that it's an atlas",
+            "examples": [
+                "Set = FoliageAtlas01_col + FoliageAtlas01_nrm"
+            ]
+        },
+        "UtilityMap": {
+            "color": "#706b87",
+            "description": "A useful image-asset consisting of only a single texture. Therefor each Utilitymap can only contain a single item.",
+            "examples": [
+                "Single = imperfection.png",
+                "Single = smudges.png",
+                "Single = scratches.tif"
+            ]
+        }
+    }
+}

config/file_type_definitions.json

@@ -0,0 +1,208 @@
+{
+    "FILE_TYPE_DEFINITIONS": {
+        "MAP_COL": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#ffaa00",
+            "description": "Color/Albedo Map",
+            "examples": [
+                "_col.",
+                "_basecolor.",
+                "albedo",
+                "diffuse"
+            ],
+            "is_grayscale": false,
+            "keybind": "C",
+            "standard_type": "COL"
+        },
+        "MAP_NRM": {
+            "bit_depth_rule": "respect",
+            "color": "#cca2f1",
+            "description": "Normal Map",
+            "examples": [
+                "_nrm.",
+                "_normal."
+            ],
+            "is_grayscale": false,
+            "keybind": "N",
+            "standard_type": "NRM"
+        },
+        "MAP_METAL": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#dcf4f2",
+            "description": "Metalness Map",
+            "examples": [
+                "_metal.",
+                "_met."
+            ],
+            "is_grayscale": true,
+            "keybind": "M",
+            "standard_type": "METAL"
+        },
+        "MAP_ROUGH": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#bfd6bf",
+            "description": "Roughness Map",
+            "examples": [
+                "_rough.",
+                "_rgh.",
+                "_gloss"
+            ],
+            "is_grayscale": true,
+            "keybind": "R",
+            "standard_type": "ROUGH"
+        },
+        "MAP_GLOSS": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#d6bfd6",
+            "description": "Glossiness Map",
+            "examples": [
+                "_gloss.",
+                "_gls."
+            ],
+            "is_grayscale": true,
+            "keybind": "R",
+            "standard_type": "GLOSS"
+        },
+        "MAP_AO": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#e3c7c7",
+            "description": "Ambient Occlusion Map",
+            "examples": [
+                "_ao.",
+                "_ambientocclusion."
+            ],
+            "is_grayscale": true,
+            "keybind": "",
+            "standard_type": "AO"
+        },
+        "MAP_DISP": {
+            "bit_depth_rule": "respect",
+            "color": "#c6ddd5",
+            "description": "Displacement/Height Map",
+            "examples": [
+                "_disp.",
+                "_height."
+            ],
+            "is_grayscale": true,
+            "keybind": "D",
+            "standard_type": "DISP"
+        },
+        "MAP_REFL": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#c2c2b9",
+            "description": "Reflection/Specular Map",
+            "examples": [
+                "_refl.",
+                "_specular."
+            ],
+            "is_grayscale": true,
+            "keybind": "M",
+            "standard_type": "REFL"
+        },
+        "MAP_SSS": {
+            "bit_depth_rule": "respect",
+            "color": "#a0d394",
+            "description": "Subsurface Scattering Map",
+            "examples": [
+                "_sss.",
+                "_subsurface."
+            ],
+            "is_grayscale": true,
+            "keybind": "",
+            "standard_type": "SSS"
+        },
+        "MAP_FUZZ": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#a2d1da",
+            "description": "Fuzz/Sheen Map",
+            "examples": [
+                "_fuzz.",
+                "_sheen."
+            ],
+            "is_grayscale": true,
+            "keybind": "",
+            "standard_type": "FUZZ"
+        },
+        "MAP_IDMAP": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#ca8fb4",
+            "description": "ID Map (for masking)",
+            "examples": [
+                "_id.",
+                "_matid."
+            ],
+            "is_grayscale": false,
+            "keybind": "",
+            "standard_type": "IDMAP"
+        },
+        "MAP_MASK": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#c6e2bf",
+            "description": "Generic Mask Map",
+            "examples": [
+                "_mask."
+            ],
+            "is_grayscale": true,
+            "keybind": "",
+            "standard_type": "MASK"
+        },
+        "MAP_IMPERFECTION": {
+            "bit_depth_rule": "force_8bit",
+            "color": "#e6d1a6",
+            "description": "Imperfection Map (scratches, dust)",
+            "examples": [
+                "_imp.",
+                "_imperfection.",
+                "splatter",
+                "scratches",
+                "smudges",
+                "hairs",
+                "fingerprints"
+            ],
+            "is_grayscale": true,
+            "keybind": "",
+            "standard_type": "IMPERFECTION"
+        },
+        "MODEL": {
+            "bit_depth_rule": "",
+            "color": "#3db2bd",
+            "description": "3D Model File",
+            "examples": [
+                ".fbx",
+                ".obj"
+            ],
+            "is_grayscale": false,
+            "keybind": "",
+            "standard_type": ""
+        },
+        "EXTRA": {
+            "bit_depth_rule": "",
+            "color": "#8c8c8c",
+            "description": "asset previews or metadata",
+            "examples": [
+                ".txt",
+                ".zip",
+                "preview.",
+                "_flat.",
+                "_sphere.",
+                "_Cube.",
+                "thumb"
+            ],
+            "is_grayscale": false,
+            "keybind": "E",
+            "standard_type": "EXTRA"
+        },
+        "FILE_IGNORE": {
+            "bit_depth_rule": "",
+            "color": "#673d35",
+            "description": "File to be ignored",
+            "examples": [
+                "Thumbs.db",
+                ".DS_Store"
+            ],
+            "is_grayscale": false,
+            "keybind": "X",
+            "standard_type": ""
+        }
+    }
+}

config/llm_settings.json

@@ -3,256 +3,256 @@
         {
             "input": "MessyTextures/Concrete_Damage_Set/concrete_col.png\nMessyTextures/Concrete_Damage_Set/concrete_N.png\nMessyTextures/Concrete_Damage_Set/concrete_rough.jpg\nMessyTextures/Concrete_Damage_Set/height_map_concrete.tif\nMessyTextures/Concrete_Damage_Set/Thumbs.db\nMessyTextures/Fabric_Pattern/pattern_01_diffuse.tga\nMessyTextures/Fabric_Pattern/pattern_01_ao.png\nMessyTextures/Fabric_Pattern/pattern_01_normal.png\nMessyTextures/Fabric_Pattern/notes.txt\nMessyTextures/Fabric_Pattern/variant_blue_diffuse.tga\nMessyTextures/Fabric_Pattern/fabric_flat.jpg",
             "output": {
-              "individual_file_analysis": [
-                {
-                  "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_col.png",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Concrete_Damage_Set"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_N.png",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Concrete_Damage_Set"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_rough.jpg",
-                  "classified_file_type": "MAP_ROUGH",
-                  "proposed_asset_group_name": "Concrete_Damage_Set"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Concrete_Damage_Set/height_map_concrete.tif",
-                  "classified_file_type": "MAP_DISP",
-                  "proposed_asset_group_name": "Concrete_Damage_Set"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Concrete_Damage_Set/Thumbs.db",
-                  "classified_file_type": "FILE_IGNORE",
-                  "proposed_asset_group_name": null
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_diffuse.tga",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_ao.png",
-                  "classified_file_type": "MAP_AO",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_normal.png",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/notes.txt",
-                  "classified_file_type": "EXTRA",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/variant_blue_diffuse.tga",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
-                },
-                {
-                  "relative_file_path": "MessyTextures/Fabric_Pattern/fabric_flat.jpg",
-                  "classified_file_type": "EXTRA",
-                  "proposed_asset_group_name": "Fabric_Pattern_01"
+                "individual_file_analysis": [
+                    {
+                        "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_col.png",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Concrete_Damage_Set"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_N.png",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Concrete_Damage_Set"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Concrete_Damage_Set/concrete_rough.jpg",
+                        "classified_file_type": "MAP_ROUGH",
+                        "proposed_asset_group_name": "Concrete_Damage_Set"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Concrete_Damage_Set/height_map_concrete.tif",
+                        "classified_file_type": "MAP_DISP",
+                        "proposed_asset_group_name": "Concrete_Damage_Set"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Concrete_Damage_Set/Thumbs.db",
+                        "classified_file_type": "FILE_IGNORE",
+                        "proposed_asset_group_name": null
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_diffuse.tga",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_ao.png",
+                        "classified_file_type": "MAP_AO",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/pattern_01_normal.png",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/notes.txt",
+                        "classified_file_type": "EXTRA",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/variant_blue_diffuse.tga",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    },
+                    {
+                        "relative_file_path": "MessyTextures/Fabric_Pattern/fabric_flat.jpg",
+                        "classified_file_type": "EXTRA",
+                        "proposed_asset_group_name": "Fabric_Pattern_01"
+                    }
+                ],
+                "asset_group_classifications": {
+                    "Concrete_Damage_Set": "Surface",
+                    "Fabric_Pattern_01": "Surface"
                 }
-              ],
-              "asset_group_classifications": {
-                "Concrete_Damage_Set": "Surface",
-                "Fabric_Pattern_01": "Surface"
-              }
             }
         },
         {
             "input": "SciFi_Drone/Drone_Model.fbx\nSciFi_Drone/Textures/Drone_BaseColor.png\nSciFi_Drone/Textures/Drone_Metallic.png\nSciFi_Drone/Textures/Drone_Roughness.png\nSciFi_Drone/Textures/Drone_Normal.png\nSciFi_Drone/Textures/Drone_Emissive.jpg\nSciFi_Drone/ReferenceImages/concept.jpg",
             "output": {
-              "individual_file_analysis": [
-                {
-                  "relative_file_path": "SciFi_Drone/Drone_Model.fbx",
-                  "classified_file_type": "MODEL",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/Textures/Drone_BaseColor.png",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/Textures/Drone_Metallic.png",
-                  "classified_file_type": "MAP_METAL",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/Textures/Drone_Roughness.png",
-                  "classified_file_type": "MAP_ROUGH",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/Textures/Drone_Normal.png",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/Textures/Drone_Emissive.jpg",
-                  "classified_file_type": "EXTRA",
-                  "proposed_asset_group_name": "SciFi_Drone"
-                },
-                {
-                  "relative_file_path": "SciFi_Drone/ReferenceImages/concept.jpg",
-                  "classified_file_type": "EXTRA",
-                  "proposed_asset_group_name": "SciFi_Drone"
+                "individual_file_analysis": [
+                    {
+                        "relative_file_path": "SciFi_Drone/Drone_Model.fbx",
+                        "classified_file_type": "MODEL",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/Textures/Drone_BaseColor.png",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/Textures/Drone_Metallic.png",
+                        "classified_file_type": "MAP_METAL",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/Textures/Drone_Roughness.png",
+                        "classified_file_type": "MAP_ROUGH",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/Textures/Drone_Normal.png",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/Textures/Drone_Emissive.jpg",
+                        "classified_file_type": "EXTRA",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    },
+                    {
+                        "relative_file_path": "SciFi_Drone/ReferenceImages/concept.jpg",
+                        "classified_file_type": "EXTRA",
+                        "proposed_asset_group_name": "SciFi_Drone"
+                    }
+                ],
+                "asset_group_classifications": {
+                    "SciFi_Drone": "Model"
                 }
-              ],
-              "asset_group_classifications": {
-                "SciFi_Drone": "Model"
-              }
             }
         },
         {
             "input": "21_hairs_deposits.tif\n22_hairs_fabric.tif\n23_hairs_fibres.tif\n24_hairs_fibres.tif\n25_bonus_isolatedFingerprints.tif\n26_bonus_isolatedPalmprint.tif\n27_metal_aluminum.tif\n28_metal_castIron.tif\n29_scratcehes_deposits_shapes.tif\n30_scratches_deposits.tif",
             "output": {
-              "individual_file_analysis": [
-                {
-                  "relative_file_path": "21_hairs_deposits.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Hairs_Deposits_21"
-                },
-                {
-                  "relative_file_path": "22_hairs_fabric.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Hairs_Fabric_22"
-                },
-                {
-                  "relative_file_path": "23_hairs_fibres.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Hairs_Fibres_23"
-                },
-                {
-                  "relative_file_path": "24_hairs_fibres.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Hairs_Fibres_24"
-                },
-                {
-                  "relative_file_path": "25_bonus_isolatedFingerprints.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Bonus_IsolatedFingerprints_25"
-                },
-                {
-                  "relative_file_path": "26_bonus_isolatedPalmprint.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Bonus_IsolatedPalmprint_26"
-                },
-                {
-                  "relative_file_path": "27_metal_aluminum.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Metal_Aluminum_27"
-                },
-                {
-                  "relative_file_path": "28_metal_castIron.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Metal_CastIron_28"
-                },
-                {
-                  "relative_file_path": "29_scratcehes_deposits_shapes.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Scratches_Deposits_Shapes_29"
-                },
-                {
-                  "relative_file_path": "30_scratches_deposits.tif",
-                  "classified_file_type": "MAP_IMPERFECTION",
-                  "proposed_asset_group_name": "Scratches_Deposits_30"
+                "individual_file_analysis": [
+                    {
+                        "relative_file_path": "21_hairs_deposits.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Hairs_Deposits_21"
+                    },
+                    {
+                        "relative_file_path": "22_hairs_fabric.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Hairs_Fabric_22"
+                    },
+                    {
+                        "relative_file_path": "23_hairs_fibres.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Hairs_Fibres_23"
+                    },
+                    {
+                        "relative_file_path": "24_hairs_fibres.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Hairs_Fibres_24"
+                    },
+                    {
+                        "relative_file_path": "25_bonus_isolatedFingerprints.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Bonus_IsolatedFingerprints_25"
+                    },
+                    {
+                        "relative_file_path": "26_bonus_isolatedPalmprint.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Bonus_IsolatedPalmprint_26"
+                    },
+                    {
+                        "relative_file_path": "27_metal_aluminum.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Metal_Aluminum_27"
+                    },
+                    {
+                        "relative_file_path": "28_metal_castIron.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Metal_CastIron_28"
+                    },
+                    {
+                        "relative_file_path": "29_scratcehes_deposits_shapes.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Scratches_Deposits_Shapes_29"
+                    },
+                    {
+                        "relative_file_path": "30_scratches_deposits.tif",
+                        "classified_file_type": "MAP_IMPERFECTION",
+                        "proposed_asset_group_name": "Scratches_Deposits_30"
+                    }
+                ],
+                "asset_group_classifications": {
+                    "Hairs_Deposits_21": "UtilityMap",
+                    "Hairs_Fabric_22": "UtilityMap",
+                    "Hairs_Fibres_23": "UtilityMap",
+                    "Hairs_Fibres_24": "UtilityMap",
+                    "Bonus_IsolatedFingerprints_25": "UtilityMap",
+                    "Bonus_IsolatedPalmprint_26": "UtilityMap",
+                    "Metal_Aluminum_27": "UtilityMap",
+                    "Metal_CastIron_28": "UtilityMap",
+                    "Scratches_Deposits_Shapes_29": "UtilityMap",
+                    "Scratches_Deposits_30": "UtilityMap"
                 }
-              ],
-              "asset_group_classifications": {
-                "Hairs_Deposits_21": "UtilityMap",
-                "Hairs_Fabric_22": "UtilityMap",
-                "Hairs_Fibres_23": "UtilityMap",
-                "Hairs_Fibres_24": "UtilityMap",
-                "Bonus_IsolatedFingerprints_25": "UtilityMap",
-                "Bonus_IsolatedPalmprint_26": "UtilityMap",
-                "Metal_Aluminum_27": "UtilityMap",
-                "Metal_CastIron_28": "UtilityMap",
-                "Scratches_Deposits_Shapes_29": "UtilityMap",
-                "Scratches_Deposits_30": "UtilityMap"
-              }
             }
         },
         {
             "input": "Part1/TextureSupply_Boards001_A_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_A_28x300cm-Normal.jpg\nPart1/TextureSupply_Boards001_B_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_B_28x300cm-Normal.jpg\nPart1/TextureSupply_Boards001_C_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_C_28x300cm-Normal.jpg\nPart1/TextureSupply_Boards001_D_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_D_28x300cm-Normal.jpg\nPart1/TextureSupply_Boards001_E_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_E_28x300cm-Normal.jpg\nPart1/TextureSupply_Boards001_F_28x300cm-Albedo.jpg\nPart1/TextureSupply_Boards001_F_28x300cm-Normal.jpg",
             "output": {
-              "individual_file_analysis": [
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_A_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_A"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_A_28x300cm-Normal.jpg",
-                    "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_A"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_B_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_B"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_B_28x300cm-Normal.jpg",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_B"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_C_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_C"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_C_28x300cm-Normal.jpg",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_C"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_D_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_D"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_D_28x300cm-Normal.jpg",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_D"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_E_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_E"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_E_28x300cm-Normal.jpg",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_E"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_F_28x300cm-Albedo.jpg",
-                  "classified_file_type": "MAP_COL",
-                  "proposed_asset_group_name": "Boards001_F"
-                },
-                {
-                  "relative_file_path": "Part1/TextureSupply_Boards001_F_28x300cm-Normal.jpg",
-                  "classified_file_type": "MAP_NRM",
-                  "proposed_asset_group_name": "Boards001_F"
+                "individual_file_analysis": [
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_A_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_A"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_A_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_A"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_B_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_B"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_B_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_B"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_C_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_C"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_C_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_C"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_D_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_D"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_D_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_D"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_E_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_E"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_E_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_E"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_F_28x300cm-Albedo.jpg",
+                        "classified_file_type": "MAP_COL",
+                        "proposed_asset_group_name": "Boards001_F"
+                    },
+                    {
+                        "relative_file_path": "Part1/TextureSupply_Boards001_F_28x300cm-Normal.jpg",
+                        "classified_file_type": "MAP_NRM",
+                        "proposed_asset_group_name": "Boards001_F"
+                    }
+                ],
+                "asset_group_classifications": {
+                    "Boards001_A": "Surface",
+                    "Boards001_B": "Surface",
+                    "Boards001_C": "Surface",
+                    "Boards001_D": "Surface",
+                    "Boards001_E": "Surface",
+                    "Boards001_F": "Surface"
                 }
-              ],
-              "asset_group_classifications": {
-                "Boards001_A": "Surface",
-                "Boards001_B": "Surface",
-                "Boards001_C": "Surface",
-                "Boards001_D": "Surface",
-                "Boards001_E": "Surface",
-                "Boards001_F": "Surface"
-              }
             }
         }
     ],

config/suppliers.json

@@ -1,5 +1,11 @@
-[
-    "Dimensiva",
-    "Dinesen",
-    "Poliigon"
-]
+{
+  "Dimensiva": {
+    "normal_map_type": "OpenGL"
+  },
+  "Dinesen": {
+    "normal_map_type": "OpenGL"
+  },
+  "Poliigon": {
+    "normal_map_type": "OpenGL"
+  }
+}

configuration.py

@@ -3,12 +3,18 @@ import os
 from pathlib import Path
 import logging
 import re
+import collections.abc
+from typing import Optional
 
 log = logging.getLogger(__name__)
 
 BASE_DIR = Path(__file__).parent
 APP_SETTINGS_PATH = BASE_DIR / "config" / "app_settings.json"
 LLM_SETTINGS_PATH = BASE_DIR / "config" / "llm_settings.json"
+ASSET_TYPE_DEFINITIONS_PATH = BASE_DIR / "config" / "asset_type_definitions.json"
+FILE_TYPE_DEFINITIONS_PATH = BASE_DIR / "config" / "file_type_definitions.json"
+USER_SETTINGS_PATH = BASE_DIR / "config" / "user_settings.json"
+SUPPLIERS_CONFIG_PATH = BASE_DIR / "config" / "suppliers.json"
 PRESETS_DIR = BASE_DIR / "Presets"
 
 class ConfigurationError(Exception):
@@ -64,6 +70,25 @@ def _fnmatch_to_regex(pattern: str) -> str:
     # For filename matching, we usually want to find the pattern, not match the whole string.
     return res
 
+def _deep_merge_dicts(base_dict: dict, override_dict: dict) -> dict:
+    """
+    Recursively merges override_dict into base_dict.
+    If a key exists in both and both values are dicts, it recursively merges them.
+    Otherwise, the value from override_dict takes precedence.
+    Modifies base_dict in place and returns it.
+    """
+    for key, value in override_dict.items():
+        if isinstance(value, collections.abc.Mapping):
+            node = base_dict.get(key) # Use .get() to avoid creating empty dicts if not needed for override
+            if isinstance(node, collections.abc.Mapping):
+                _deep_merge_dicts(node, value) # node is base_dict[key], modified in place
+            else:
+                # If base_dict[key] is not a dict or doesn't exist, override it
+                base_dict[key] = value
+        else:
+            base_dict[key] = value
+    return base_dict
+
 
 class Configuration:
     """
@@ -71,7 +96,7 @@ class Configuration:
     """
     def __init__(self, preset_name: str):
         """
-        Loads core config and the specified preset file.
+        Loads core config, user overrides, and the specified preset file.
 
         Args:
             preset_name: The name of the preset (without .json extension).
@@ -81,9 +106,32 @@ class Configuration:
         """
         log.debug(f"Initializing Configuration with preset: '{preset_name}'")
         self.preset_name = preset_name
+
+        # 1. Load core settings
         self._core_settings: dict = self._load_core_config()
+
+        # 2. Load asset type definitions
+        self._asset_type_definitions: dict = self._load_asset_type_definitions()
+
+        # 3. Load file type definitions
+        self._file_type_definitions: dict = self._load_file_type_definitions()
+
+        # 4. Load user settings
+        user_settings_overrides: dict = self._load_user_settings()
+
+        # 5. Deep merge user settings onto core settings
+        if user_settings_overrides:
+            log.info("Applying user setting overrides to core settings.")
+            # _deep_merge_dicts modifies self._core_settings in place
+            _deep_merge_dicts(self._core_settings, user_settings_overrides)
+        
+        # 6. Load LLM settings
         self._llm_settings: dict = self._load_llm_config()
+
+        # 7. Load preset settings (conceptually overrides combined base + user for shared keys)
         self._preset_settings: dict = self._load_preset(preset_name)
+        
+        # 8. Validate and compile (after all base/user/preset settings are established)
         self._validate_configs()
         self._compile_regex_patterns()
         log.info(f"Configuration loaded successfully using preset: '{self.preset_name}'")
@@ -215,9 +263,79 @@ class Configuration:
         except Exception as e:
             raise ConfigurationError(f"Failed to read preset file {preset_file}: {e}")
 
+    def _load_asset_type_definitions(self) -> dict:
+        """Loads asset type definitions from the asset_type_definitions.json file."""
+        log.debug(f"Loading asset type definitions from: {ASSET_TYPE_DEFINITIONS_PATH}")
+        if not ASSET_TYPE_DEFINITIONS_PATH.is_file():
+            raise ConfigurationError(f"Asset type definitions file not found: {ASSET_TYPE_DEFINITIONS_PATH}")
+        try:
+            with open(ASSET_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            if "ASSET_TYPE_DEFINITIONS" not in data:
+                raise ConfigurationError(f"Key 'ASSET_TYPE_DEFINITIONS' not found in {ASSET_TYPE_DEFINITIONS_PATH}")
+            settings = data["ASSET_TYPE_DEFINITIONS"]
+            if not isinstance(settings, dict):
+                raise ConfigurationError(f"'ASSET_TYPE_DEFINITIONS' in {ASSET_TYPE_DEFINITIONS_PATH} must be a dictionary.")
+            log.debug(f"Asset type definitions loaded successfully.")
+            return settings
+        except json.JSONDecodeError as e:
+            raise ConfigurationError(f"Failed to parse asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}")
+        except Exception as e:
+            raise ConfigurationError(f"Failed to read asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: {e}")
+
+    def _load_file_type_definitions(self) -> dict:
+        """Loads file type definitions from the file_type_definitions.json file."""
+        log.debug(f"Loading file type definitions from: {FILE_TYPE_DEFINITIONS_PATH}")
+        if not FILE_TYPE_DEFINITIONS_PATH.is_file():
+            raise ConfigurationError(f"File type definitions file not found: {FILE_TYPE_DEFINITIONS_PATH}")
+        try:
+            with open(FILE_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            if "FILE_TYPE_DEFINITIONS" not in data:
+                raise ConfigurationError(f"Key 'FILE_TYPE_DEFINITIONS' not found in {FILE_TYPE_DEFINITIONS_PATH}")
+            settings = data["FILE_TYPE_DEFINITIONS"]
+            if not isinstance(settings, dict):
+                raise ConfigurationError(f"'FILE_TYPE_DEFINITIONS' in {FILE_TYPE_DEFINITIONS_PATH} must be a dictionary.")
+            log.debug(f"File type definitions loaded successfully.")
+            return settings
+        except json.JSONDecodeError as e:
+            raise ConfigurationError(f"Failed to parse file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}")
+        except Exception as e:
+            raise ConfigurationError(f"Failed to read file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: {e}")
+
+    def _load_user_settings(self) -> dict:
+        """Loads user override settings from config/user_settings.json."""
+        log.debug(f"Attempting to load user settings from: {USER_SETTINGS_PATH}")
+        if not USER_SETTINGS_PATH.is_file():
+            log.info(f"User settings file not found: {USER_SETTINGS_PATH}. Proceeding without user overrides.")
+            return {}
+        try:
+            with open(USER_SETTINGS_PATH, 'r', encoding='utf-8') as f:
+                settings = json.load(f)
+            log.info(f"User settings loaded successfully from {USER_SETTINGS_PATH}.")
+            return settings
+        except json.JSONDecodeError as e:
+            log.warning(f"Failed to parse user settings file {USER_SETTINGS_PATH}: Invalid JSON - {e}. Using empty user settings.")
+            return {}
+        except Exception as e:
+            log.warning(f"Failed to read user settings file {USER_SETTINGS_PATH}: {e}. Using empty user settings.")
+            return {}
+
     def _validate_configs(self):
         """Performs basic validation checks on loaded settings."""
         log.debug("Validating loaded configurations...")
+
+        # Validate new definition files first
+        if not isinstance(self._asset_type_definitions, dict):
+            raise ConfigurationError("Asset type definitions were not loaded correctly or are not a dictionary.")
+        if not self._asset_type_definitions: # Check if empty
+             raise ConfigurationError("Asset type definitions are empty.")
+
+        if not isinstance(self._file_type_definitions, dict):
+            raise ConfigurationError("File type definitions were not loaded correctly or are not a dictionary.")
+        if not self._file_type_definitions: # Check if empty
+            raise ConfigurationError("File type definitions are empty.")
+
         # Preset validation
         required_preset_keys = [
             "preset_name", "supplier_name", "source_naming", "map_type_mapping",
@@ -236,7 +354,7 @@ class Configuration:
              if 'target_type' not in rule or not isinstance(rule['target_type'], str):
                   raise ConfigurationError(f"Preset '{self.preset_name}': Rule at index {index} in 'map_type_mapping' is missing 'target_type' string.")
  
-             valid_file_type_keys = self._core_settings.get('FILE_TYPE_DEFINITIONS', {}).keys()
+             valid_file_type_keys = self._file_type_definitions.keys()
              if rule['target_type'] not in valid_file_type_keys:
                  raise ConfigurationError(
                      f"Preset '{self.preset_name}': Rule at index {index} in 'map_type_mapping' "
@@ -261,7 +379,7 @@ class Configuration:
              raise ConfigurationError("Core config 'IMAGE_RESOLUTIONS' must be a dictionary.")
 
         # Validate DEFAULT_ASSET_CATEGORY
-        valid_asset_type_keys = self._core_settings.get('ASSET_TYPE_DEFINITIONS', {}).keys()
+        valid_asset_type_keys = self._asset_type_definitions.keys()
         default_asset_category_value = self._core_settings.get('DEFAULT_ASSET_CATEGORY')
         if not default_asset_category_value:
             raise ConfigurationError("Core config 'DEFAULT_ASSET_CATEGORY' is missing.")
@@ -423,11 +541,11 @@ class Configuration:
         Gets the bit depth rule ('respect', 'force_8bit', 'force_16bit') for a given map type identifier.
         The map_type_input can be an FTD key (e.g., "MAP_COL") or a suffixed FTD key (e.g., "MAP_COL-1").
         """
-        if not self._core_settings or 'FILE_TYPE_DEFINITIONS' not in self._core_settings:
-            log.warning("FILE_TYPE_DEFINITIONS not found in core settings. Cannot determine bit depth rule.")
+        if not self._file_type_definitions: # Check if the attribute exists and is not empty
+            log.warning("File type definitions not loaded. Cannot determine bit depth rule.")
             return "respect"
 
-        file_type_definitions = self._core_settings['FILE_TYPE_DEFINITIONS']
+        file_type_definitions = self._file_type_definitions
         
         # 1. Try direct match with map_type_input as FTD key
         definition = file_type_definitions.get(map_type_input)
@@ -473,8 +591,8 @@ class Configuration:
         from FILE_TYPE_DEFINITIONS.
         """
         aliases = set()
-        file_type_definitions = self._core_settings.get('FILE_TYPE_DEFINITIONS', {})
-        for _key, definition in file_type_definitions.items():
+        # _file_type_definitions is guaranteed to be a dict by the loader
+        for _key, definition in self._file_type_definitions.items():
             if isinstance(definition, dict):
                 standard_type = definition.get('standard_type')
                 if standard_type and isinstance(standard_type, str) and standard_type.strip():
@@ -482,16 +600,16 @@ class Configuration:
         return sorted(list(aliases))
  
     def get_asset_type_definitions(self) -> dict:
-        """Returns the ASSET_TYPE_DEFINITIONS dictionary from core settings."""
-        return self._core_settings.get('ASSET_TYPE_DEFINITIONS', {})
+        """Returns the _asset_type_definitions dictionary."""
+        return self._asset_type_definitions
 
     def get_asset_type_keys(self) -> list:
         """Returns a list of valid asset type keys from core settings."""
         return list(self.get_asset_type_definitions().keys())
 
     def get_file_type_definitions_with_examples(self) -> dict:
-        """Returns the FILE_TYPE_DEFINITIONS dictionary (including descriptions and examples) from core settings."""
-        return self._core_settings.get('FILE_TYPE_DEFINITIONS', {})
+        """Returns the _file_type_definitions dictionary (including descriptions and examples)."""
+        return self._file_type_definitions
 
     def get_file_type_keys(self) -> list:
         """Returns a list of valid file type keys from core settings."""
@@ -532,9 +650,27 @@ class Configuration:
         """Returns the LLM request timeout in seconds from LLM settings."""
         return self._llm_settings.get('llm_request_timeout', 120)
 
+    @property
+    def app_version(self) -> Optional[str]:
+        """Returns the application version from general_settings."""
+        gs = self._core_settings.get('general_settings')
+        if isinstance(gs, dict):
+            return gs.get('app_version')
+        return None
+
+    @property
+    def enable_low_resolution_fallback(self) -> bool:
+        """Gets the setting for enabling low-resolution fallback."""
+        return self._core_settings.get('ENABLE_LOW_RESOLUTION_FALLBACK', True)
+
+    @property
+    def low_resolution_threshold(self) -> int:
+        """Gets the pixel dimension threshold for low-resolution fallback."""
+        return self._core_settings.get('LOW_RESOLUTION_THRESHOLD', 512)
+
     @property
     def FILE_TYPE_DEFINITIONS(self) -> dict:
-        return self._core_settings.get('FILE_TYPE_DEFINITIONS', {})
+        return self._file_type_definitions
 
     @property
     def keybind_config(self) -> dict[str, list[str]]:
@@ -544,8 +680,8 @@ class Configuration:
         Example: {'C': ['MAP_COL'], 'R': ['MAP_ROUGH', 'MAP_GLOSS']}
         """
         keybinds = {}
-        file_type_defs = self._core_settings.get('FILE_TYPE_DEFINITIONS', {})
-        for ftd_key, ftd_value in file_type_defs.items():
+        # _file_type_definitions is guaranteed to be a dict by the loader
+        for ftd_key, ftd_value in self._file_type_definitions.items():
             if isinstance(ftd_value, dict) and 'keybind' in ftd_value:
                 key = ftd_value['keybind']
                 if key not in keybinds:
@@ -561,25 +697,92 @@ class Configuration:
 
 def load_base_config() -> dict:
     """
-    Loads only the base configuration from app_settings.json.
-    Does not load presets or perform merging/validation.
+    Loads base configuration by merging app_settings.json, user_settings.json (if exists),
+    asset_type_definitions.json, and file_type_definitions.json.
+    Does not load presets or perform full validation beyond basic file loading.
+    Returns a dictionary containing the merged settings. If app_settings.json
+    fails to load, an empty dictionary is returned. If other files
+    fail, errors are logged, and the function proceeds with what has been loaded.
     """
+    base_settings = {}
+
+    # 1. Load app_settings.json (critical)
     if not APP_SETTINGS_PATH.is_file():
-        log.error(f"Base configuration file not found: {APP_SETTINGS_PATH}")
-        # Return empty dict or raise a specific error if preferred
-        # For now, return empty dict to allow GUI to potentially start with defaults
+        log.error(f"Critical: Base application settings file not found: {APP_SETTINGS_PATH}. Returning empty configuration.")
         return {}
     try:
         with open(APP_SETTINGS_PATH, 'r', encoding='utf-8') as f:
-            settings = json.load(f)
-        return settings
+            base_settings = json.load(f)
+        log.info(f"Successfully loaded base application settings from: {APP_SETTINGS_PATH}")
     except json.JSONDecodeError as e:
-        log.error(f"Failed to parse base configuration file {APP_SETTINGS_PATH}: Invalid JSON - {e}")
+        log.error(f"Critical: Failed to parse base application settings file {APP_SETTINGS_PATH}: Invalid JSON - {e}. Returning empty configuration.")
         return {}
     except Exception as e:
-        log.error(f"Failed to read base configuration file {APP_SETTINGS_PATH}: {e}")
+        log.error(f"Critical: Failed to read base application settings file {APP_SETTINGS_PATH}: {e}. Returning empty configuration.")
         return {}
 
+    # 2. Attempt to load user_settings.json
+    user_settings_overrides = {}
+    if USER_SETTINGS_PATH.is_file():
+        try:
+            with open(USER_SETTINGS_PATH, 'r', encoding='utf-8') as f:
+                user_settings_overrides = json.load(f)
+            log.info(f"User settings loaded successfully for base_config from {USER_SETTINGS_PATH}.")
+        except json.JSONDecodeError as e:
+            log.warning(f"Failed to parse user settings file {USER_SETTINGS_PATH} for base_config: Invalid JSON - {e}. Proceeding without these user overrides.")
+        except Exception as e:
+            log.warning(f"Failed to read user settings file {USER_SETTINGS_PATH} for base_config: {e}. Proceeding without these user overrides.")
+    
+    # 3. Deep merge user settings onto base_settings
+    if user_settings_overrides:
+        log.info("Applying user setting overrides to base_settings in load_base_config.")
+        # _deep_merge_dicts modifies base_settings in place
+        _deep_merge_dicts(base_settings, user_settings_overrides)
+
+    # 4. Load asset_type_definitions.json (non-critical, merge if successful)
+    if not ASSET_TYPE_DEFINITIONS_PATH.is_file():
+        log.error(f"Asset type definitions file not found: {ASSET_TYPE_DEFINITIONS_PATH}. Proceeding without it.")
+    else:
+        try:
+            with open(ASSET_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+                asset_defs_data = json.load(f)
+            if "ASSET_TYPE_DEFINITIONS" in asset_defs_data:
+                if isinstance(asset_defs_data["ASSET_TYPE_DEFINITIONS"], dict):
+                    # Merge into base_settings, which might already contain user overrides
+                    base_settings['ASSET_TYPE_DEFINITIONS'] = asset_defs_data["ASSET_TYPE_DEFINITIONS"]
+                    log.info(f"Successfully loaded and merged ASSET_TYPE_DEFINITIONS from: {ASSET_TYPE_DEFINITIONS_PATH}")
+                else:
+                    log.error(f"Value under 'ASSET_TYPE_DEFINITIONS' in {ASSET_TYPE_DEFINITIONS_PATH} is not a dictionary. Skipping merge.")
+            else:
+                log.error(f"Key 'ASSET_TYPE_DEFINITIONS' not found in {ASSET_TYPE_DEFINITIONS_PATH}. Skipping merge.")
+        except json.JSONDecodeError as e:
+            log.error(f"Failed to parse asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}. Skipping merge.")
+        except Exception as e:
+            log.error(f"Failed to read asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: {e}. Skipping merge.")
+
+    # 5. Load file_type_definitions.json (non-critical, merge if successful)
+    if not FILE_TYPE_DEFINITIONS_PATH.is_file():
+        log.error(f"File type definitions file not found: {FILE_TYPE_DEFINITIONS_PATH}. Proceeding without it.")
+    else:
+        try:
+            with open(FILE_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+                file_defs_data = json.load(f)
+            if "FILE_TYPE_DEFINITIONS" in file_defs_data:
+                if isinstance(file_defs_data["FILE_TYPE_DEFINITIONS"], dict):
+                     # Merge into base_settings
+                    base_settings['FILE_TYPE_DEFINITIONS'] = file_defs_data["FILE_TYPE_DEFINITIONS"]
+                    log.info(f"Successfully loaded and merged FILE_TYPE_DEFINITIONS from: {FILE_TYPE_DEFINITIONS_PATH}")
+                else:
+                    log.error(f"Value under 'FILE_TYPE_DEFINITIONS' in {FILE_TYPE_DEFINITIONS_PATH} is not a dictionary. Skipping merge.")
+            else:
+                log.error(f"Key 'FILE_TYPE_DEFINITIONS' not found in {FILE_TYPE_DEFINITIONS_PATH}. Skipping merge.")
+        except json.JSONDecodeError as e:
+            log.error(f"Failed to parse file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}. Skipping merge.")
+        except Exception as e:
+            log.error(f"Failed to read file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: {e}. Skipping merge.")
+
+    return base_settings
+
 def save_llm_config(settings_dict: dict):
     """
     Saves the provided LLM settings dictionary to llm_settings.json.
@@ -594,6 +797,18 @@ def save_llm_config(settings_dict: dict):
         log.error(f"Failed to save LLM configuration file {LLM_SETTINGS_PATH}: {e}")
         # Re-raise as ConfigurationError to signal failure upstream
         raise ConfigurationError(f"Failed to save LLM configuration: {e}")
+def save_user_config(settings_dict: dict):
+    """Saves the provided settings dictionary to user_settings.json."""
+    log.debug(f"Saving user config to: {USER_SETTINGS_PATH}")
+    try:
+        # Ensure parent directory exists (though 'config/' should always exist)
+        USER_SETTINGS_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with open(USER_SETTINGS_PATH, 'w', encoding='utf-8') as f:
+            json.dump(settings_dict, f, indent=4)
+        log.info(f"User config saved successfully to {USER_SETTINGS_PATH}")
+    except Exception as e:
+        log.error(f"Failed to save user configuration file {USER_SETTINGS_PATH}: {e}")
+        raise ConfigurationError(f"Failed to save user configuration: {e}")
 def save_base_config(settings_dict: dict):
     """
     Saves the provided settings dictionary to app_settings.json.
@@ -606,3 +821,149 @@ def save_base_config(settings_dict: dict):
     except Exception as e:
         log.error(f"Failed to save base configuration file {APP_SETTINGS_PATH}: {e}")
         raise ConfigurationError(f"Failed to save configuration: {e}")
+
+def load_asset_definitions() -> dict:
+    """
+    Reads config/asset_type_definitions.json.
+    Returns the dictionary under the "ASSET_TYPE_DEFINITIONS" key.
+    Handles file not found or JSON errors gracefully (e.g., return empty dict, log error).
+    """
+    log.debug(f"Loading asset type definitions from: {ASSET_TYPE_DEFINITIONS_PATH}")
+    if not ASSET_TYPE_DEFINITIONS_PATH.is_file():
+        log.error(f"Asset type definitions file not found: {ASSET_TYPE_DEFINITIONS_PATH}")
+        return {}
+    try:
+        with open(ASSET_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        if "ASSET_TYPE_DEFINITIONS" not in data:
+            log.error(f"Key 'ASSET_TYPE_DEFINITIONS' not found in {ASSET_TYPE_DEFINITIONS_PATH}")
+            return {}
+        settings = data["ASSET_TYPE_DEFINITIONS"]
+        if not isinstance(settings, dict):
+            log.error(f"'ASSET_TYPE_DEFINITIONS' in {ASSET_TYPE_DEFINITIONS_PATH} must be a dictionary.")
+            return {}
+        log.debug(f"Asset type definitions loaded successfully.")
+        return settings
+    except json.JSONDecodeError as e:
+        log.error(f"Failed to parse asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}")
+        return {}
+    except Exception as e:
+        log.error(f"Failed to read asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: {e}")
+        return {}
+
+def save_asset_definitions(data: dict):
+    """
+    Takes a dictionary (representing the content for the "ASSET_TYPE_DEFINITIONS" key).
+    Writes it to config/asset_type_definitions.json under the root key "ASSET_TYPE_DEFINITIONS".
+    Handles potential I/O errors.
+    """
+    log.debug(f"Saving asset type definitions to: {ASSET_TYPE_DEFINITIONS_PATH}")
+    try:
+        with open(ASSET_TYPE_DEFINITIONS_PATH, 'w', encoding='utf-8') as f:
+            json.dump({"ASSET_TYPE_DEFINITIONS": data}, f, indent=4)
+        log.info(f"Asset type definitions saved successfully to {ASSET_TYPE_DEFINITIONS_PATH}")
+    except Exception as e:
+        log.error(f"Failed to save asset type definitions file {ASSET_TYPE_DEFINITIONS_PATH}: {e}")
+        raise ConfigurationError(f"Failed to save asset type definitions: {e}")
+
+def load_file_type_definitions() -> dict:
+    """
+    Reads config/file_type_definitions.json.
+    Returns the dictionary under the "FILE_TYPE_DEFINITIONS" key.
+    Handles errors gracefully.
+    """
+    log.debug(f"Loading file type definitions from: {FILE_TYPE_DEFINITIONS_PATH}")
+    if not FILE_TYPE_DEFINITIONS_PATH.is_file():
+        log.error(f"File type definitions file not found: {FILE_TYPE_DEFINITIONS_PATH}")
+        return {}
+    try:
+        with open(FILE_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        if "FILE_TYPE_DEFINITIONS" not in data:
+            log.error(f"Key 'FILE_TYPE_DEFINITIONS' not found in {FILE_TYPE_DEFINITIONS_PATH}")
+            return {}
+        settings = data["FILE_TYPE_DEFINITIONS"]
+        if not isinstance(settings, dict):
+            log.error(f"'FILE_TYPE_DEFINITIONS' in {FILE_TYPE_DEFINITIONS_PATH} must be a dictionary.")
+            return {}
+        log.debug(f"File type definitions loaded successfully.")
+        return settings
+    except json.JSONDecodeError as e:
+        log.error(f"Failed to parse file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: Invalid JSON - {e}")
+        return {}
+    except Exception as e:
+        log.error(f"Failed to read file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: {e}")
+        return {}
+
+def save_file_type_definitions(data: dict):
+    """
+    Takes a dictionary (representing content for "FILE_TYPE_DEFINITIONS" key).
+    Writes it to config/file_type_definitions.json under the root key "FILE_TYPE_DEFINITIONS".
+    Handles errors.
+    """
+    log.debug(f"Saving file type definitions to: {FILE_TYPE_DEFINITIONS_PATH}")
+    try:
+        with open(FILE_TYPE_DEFINITIONS_PATH, 'w', encoding='utf-8') as f:
+            json.dump({"FILE_TYPE_DEFINITIONS": data}, f, indent=4)
+        log.info(f"File type definitions saved successfully to {FILE_TYPE_DEFINITIONS_PATH}")
+    except Exception as e:
+        log.error(f"Failed to save file type definitions file {FILE_TYPE_DEFINITIONS_PATH}: {e}")
+        raise ConfigurationError(f"Failed to save file type definitions: {e}")
+
+def load_supplier_settings() -> dict:
+    """
+    Reads config/suppliers.json.
+    Returns the entire dictionary.
+    Handles file not found (return empty dict) or JSON errors.
+    If the loaded data is a list (old format), convert it in memory to the new
+    dictionary format, defaulting normal_map_type to "OpenGL" for each supplier.
+    """
+    log.debug(f"Loading supplier settings from: {SUPPLIERS_CONFIG_PATH}")
+    if not SUPPLIERS_CONFIG_PATH.is_file():
+        log.warning(f"Supplier settings file not found: {SUPPLIERS_CONFIG_PATH}. Returning empty dict.")
+        return {}
+    try:
+        with open(SUPPLIERS_CONFIG_PATH, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        if isinstance(data, list):
+            log.warning(f"Supplier settings in {SUPPLIERS_CONFIG_PATH} is in the old list format. Converting to new dictionary format.")
+            new_data = {}
+            for supplier_name in data:
+                if isinstance(supplier_name, str):
+                    new_data[supplier_name] = {"normal_map_type": "OpenGL"}
+                else:
+                    log.warning(f"Skipping non-string item '{supplier_name}' during old format conversion of supplier settings.")
+            log.info(f"Supplier settings converted to new format: {new_data}")
+            return new_data
+        
+        if not isinstance(data, dict):
+            log.error(f"Supplier settings in {SUPPLIERS_CONFIG_PATH} must be a dictionary. Found {type(data)}. Returning empty dict.")
+            return {}
+            
+        log.debug(f"Supplier settings loaded successfully.")
+        return data
+    except json.JSONDecodeError as e:
+        log.error(f"Failed to parse supplier settings file {SUPPLIERS_CONFIG_PATH}: Invalid JSON - {e}. Returning empty dict.")
+        return {}
+    except Exception as e:
+        log.error(f"Failed to read supplier settings file {SUPPLIERS_CONFIG_PATH}: {e}. Returning empty dict.")
+        return {}
+
+def save_supplier_settings(data: dict):
+    """
+    Takes a dictionary (in the new format).
+    Writes it directly to config/suppliers.json.
+    Handles errors.
+    """
+    log.debug(f"Saving supplier settings to: {SUPPLIERS_CONFIG_PATH}")
+    if not isinstance(data, dict):
+        log.error(f"Data for save_supplier_settings must be a dictionary. Got {type(data)}.")
+        raise ConfigurationError(f"Invalid data type for saving supplier settings: {type(data)}")
+    try:
+        with open(SUPPLIERS_CONFIG_PATH, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2) # Using indent=2 as per the example for suppliers.json
+        log.info(f"Supplier settings saved successfully to {SUPPLIERS_CONFIG_PATH}")
+    except Exception as e:
+        log.error(f"Failed to save supplier settings file {SUPPLIERS_CONFIG_PATH}: {e}")
+        raise ConfigurationError(f"Failed to save supplier settings: {e}")

documentation/definitions_editor_plan.md

@@ -0,0 +1,137 @@
+# Plan for New Definitions Editor UI
+
+## 1. Overview
+
+This document outlines the plan to create a new, dedicated UI for managing "Asset Type Definitions", "File Type Definitions", and "Supplier Settings". This editor will provide a more structured and user-friendly way to manage these core application configurations, which are currently stored in separate JSON files.
+
+## 2. General Design Principles
+
+*   **Dedicated Dialog:** The editor will be a new `QDialog` (e.g., `DefinitionsEditorDialog`).
+*   **Access Point:** Launched from the `MainWindow` menu bar (e.g., under a "Definitions" menu or "Edit" -> "Edit Definitions...").
+*   **Tabbed Interface:** The dialog will use a `QTabWidget` to separate the management of different definition types.
+*   **List/Details View:** Each tab will generally follow a two-pane layout:
+    *   **Left Pane:** A `QListWidget` displaying the primary keys or names of the definitions (e.g., asset type names, file type IDs, supplier names). Includes "Add" and "Remove" buttons for managing these primary entries.
+    *   **Right Pane:** A details area (e.g., `QGroupBox` with a `QFormLayout`) that shows the specific settings for the item selected in the left-pane list.
+*   **Data Persistence:** The dialog will load from and save to the respective JSON configuration files:
+    *   Asset Types: `config/asset_type_definitions.json`
+    *   File Types: `config/file_type_definitions.json`
+    *   Supplier Settings: `config/suppliers.json` (This file will be refactored from a simple list to a dictionary of supplier objects).
+*   **User Experience:** Standard "Save" and "Cancel" buttons, with a check for unsaved changes.
+
+## 3. Tab-Specific Plans
+
+### 3.1. Asset Type Definitions Tab
+
+*   **Manages:** `config/asset_type_definitions.json`
+*   **UI Sketch:**
+    ```mermaid
+    graph LR
+        subgraph AssetTypeTab [Asset Type Definitions Tab]
+            direction LR
+            AssetList[QListWidget (Asset Type Keys e.g., "Surface")] --> AssetDetailsGroup{Details for Selected Asset Type};
+        end
+
+        subgraph AssetDetailsGroup
+            direction TB
+            Desc[Description: QTextEdit]
+            Color[Color: QPushButton ("Choose Color...") + Color Swatch Display]
+            Examples[Examples: QListWidget + Add/Remove Example Buttons]
+        end
+        AssetActions["Add Asset Type (Prompt for Name)\nRemove Selected Asset Type"] --> AssetList
+    ```
+*   **Details:**
+    *   **Left Pane:** `QListWidget` for asset type names. "Add Asset Type" (prompts for new key) and "Remove Selected Asset Type" buttons.
+    *   **Right Pane (Details):**
+        *   `description`: `QTextEdit`.
+        *   `color`: `QPushButton` opening `QColorDialog`, with an adjacent `QLabel` to display the color swatch.
+        *   `examples`: `QListWidget` with "Add Example" (`QInputDialog.getText`) and "Remove Selected Example" buttons.
+
+### 3.2. File Type Definitions Tab
+
+*   **Manages:** `config/file_type_definitions.json`
+*   **UI Sketch:**
+    ```mermaid
+    graph LR
+        subgraph FileTypeTab [File Type Definitions Tab]
+            direction LR
+            FileList[QListWidget (File Type Keys e.g., "MAP_COL")] --> FileDetailsGroup{Details for Selected File Type};
+        end
+
+        subgraph FileDetailsGroup
+            direction TB
+            DescF[Description: QTextEdit]
+            ColorF[Color: QPushButton ("Choose Color...") + Color Swatch Display]
+            ExamplesF[Examples: QListWidget + Add/Remove Example Buttons]
+            StdType[Standard Type: QLineEdit]
+            BitDepth[Bit Depth Rule: QComboBox ("respect", "force_8bit", "force_16bit")]
+            IsGrayscale[Is Grayscale: QCheckBox]
+            Keybind[Keybind: QLineEdit (1 char)]
+        end
+        FileActions["Add File Type (Prompt for ID)\nRemove Selected File Type"] --> FileList
+    ```
+*   **Details:**
+    *   **Left Pane:** `QListWidget` for file type IDs. "Add File Type" (prompts for new key) and "Remove Selected File Type" buttons.
+    *   **Right Pane (Details):**
+        *   `description`: `QTextEdit`.
+        *   `color`: `QPushButton` opening `QColorDialog`, with an adjacent `QLabel` for color swatch.
+        *   `examples`: `QListWidget` with "Add Example" and "Remove Selected Example" buttons.
+        *   `standard_type`: `QLineEdit`.
+        *   `bit_depth_rule`: `QComboBox` (options: "respect", "force_8bit", "force_16bit").
+        *   `is_grayscale`: `QCheckBox`.
+        *   `keybind`: `QLineEdit` (validation for single character recommended).
+
+### 3.3. Supplier Settings Tab
+
+*   **Manages:** `config/suppliers.json` (This file will be refactored to a dictionary structure, e.g., `{"SupplierName": {"normal_map_type": "OpenGL", ...}}`).
+*   **UI Sketch:**
+    ```mermaid
+    graph LR
+        subgraph SupplierTab [Supplier Settings Tab]
+            direction LR
+            SupplierList[QListWidget (Supplier Names)] --> SupplierDetailsGroup{Details for Selected Supplier};
+        end
+
+        subgraph SupplierDetailsGroup
+            direction TB
+            NormalMapType[Normal Map Type: QComboBox ("OpenGL", "DirectX")]
+            %% Future supplier-specific settings can be added here
+        end
+        SupplierActions["Add Supplier (Prompt for Name)\nRemove Selected Supplier"] --> SupplierList
+    ```
+*   **Details:**
+    *   **Left Pane:** `QListWidget` for supplier names. "Add Supplier" (prompts for new name) and "Remove Selected Supplier" buttons.
+    *   **Right Pane (Details):**
+        *   `normal_map_type`: `QComboBox` (options: "OpenGL", "DirectX"). Default for new suppliers: "OpenGL".
+        *   *(Space for future supplier-specific settings).*
+*   **Data Handling Note for `config/suppliers.json`:**
+    *   The editor will load from and save to `config/suppliers.json` using the new dictionary format (supplier name as key, object of settings as value).
+    *   Initial implementation might require `config/suppliers.json` to be manually updated to this new format if it currently exists as a simple list. Alternatively, the editor could attempt an automatic conversion on first load if the old list format is detected, or prompt the user. For the first pass, assuming the editor works with the new format is simpler.
+
+## 4. Implementation Steps (High-Level)
+
+1.  **(Potentially Manual First Step) Refactor `config/suppliers.json`:** If `config/suppliers.json` exists as a list, manually convert it to the new dictionary structure (e.g., `{"SupplierName": {"normal_map_type": "OpenGL"}}`) before starting UI development for this tab, or plan for the editor to handle this conversion.
+2.  **Create `DefinitionsEditorDialog` Class:** Inherit from `QDialog`.
+3.  **Implement UI Structure:** Main `QTabWidget`, and for each tab, the two-pane layout with `QListWidget`, `QGroupBox` for details, and relevant input widgets (`QLineEdit`, `QTextEdit`, `QComboBox`, `QCheckBox`, `QPushButton`).
+4.  **Implement Loading Logic:**
+    *   For each tab, read data from its corresponding JSON file.
+    *   Populate the left-pane `QListWidget` with the primary keys/names.
+    *   Store the full data structure internally (e.g., in dictionaries within the dialog instance).
+5.  **Implement Display Logic:**
+    *   When an item is selected in a `QListWidget`, populate the right-pane detail fields with the data for that item.
+6.  **Implement Editing Logic:**
+    *   Ensure that changes made in the detail fields (text edits, combobox selections, checkbox states, color choices, list example modifications) update the corresponding internal data structure for the currently selected item.
+7.  **Implement Add/Remove Functionality:**
+    *   For each definition type (Asset Type, File Type, Supplier), implement the "Add" and "Remove" buttons.
+        *   "Add": Prompt for a unique key/name, create a new default entry in the internal data, and add it to the `QListWidget`.
+        *   "Remove": Remove the selected item from the `QListWidget` and the internal data.
+    *   For "examples" lists within Asset and File types, implement their "Add Example" and "Remove Selected Example" buttons.
+8.  **Implement Saving Logic:**
+    *   When the main "Save" button is clicked:
+        *   Write the (potentially modified) Asset Type definitions data structure to `config/asset_type_definitions.json`.
+        *   Write File Type definitions to `config/file_type_definitions.json`.
+        *   Write Supplier settings (in the new dictionary format) to `config/suppliers.json`.
+    *   Consider creating new dedicated save functions in `configuration.py` for each of these files if they don't already exist or if existing ones are not suitable.
+9.  **Implement Unsaved Changes Check & Cancel Logic.**
+10. **Integrate Dialog Launch:** Add a menu action in `MainWindow.py` to open the `DefinitionsEditorDialog`.
+
+This plan provides a comprehensive approach to creating a dedicated editor for these crucial application definitions.

documentation/preferences_refactor_plan.md

@@ -0,0 +1,113 @@
+# Refactoring Plan for Preferences Window (ConfigEditorDialog)
+
+## 1. Overview
+
+This document outlines the plan to refactor the preferences window (`gui/config_editor_dialog.py`). The primary goal is to address issues related to misaligned scope, poor user experience for certain data types, and incomplete interactivity. The refactoring will focus on making the `ConfigEditorDialog` a robust editor for settings in `config/app_settings.json` that are intended to be overridden by the user via `config/user_settings.json`.
+
+## 2. Assessment Summary
+
+*   **Misaligned Scope:** The dialog currently includes UI for "Asset Type Definitions" and "File Type Definitions". However, these are managed in separate dedicated JSON files ([`config/asset_type_definitions.json`](config/asset_type_definitions.json) and [`config/file_type_definitions.json`](config/file_type_definitions.json)) and are not saved by this dialog (which targets `config/user_settings.json`).
+*   **Poor UX for Data Types:**
+    *   Lists (e.g., `RESPECT_VARIANT_MAP_TYPES`) are edited as comma-separated strings.
+    *   Dictionary-like structures (e.g., `IMAGE_RESOLUTIONS`) are handled inconsistently (JSON defines as dict, UI attempts list-of-pairs).
+    *   Editing complex list-of-objects (e.g., `MAP_MERGE_RULES`) is functionally incomplete.
+*   **Incomplete Interactivity:** Many table-based editors lack "Add/Remove Row" functionality and proper cell delegates for intuitive editing.
+*   **LLM Settings:** Confirmed to be correctly managed by the separate `LLMEditorWidget` and `config/llm_settings.json`, so they are out of scope for this specific dialog refactor.
+
+## 3. Refactoring Phases and Plan Details
+
+```mermaid
+graph TD
+    A[Start: Current State] --> B{Phase 1: Correct Scope & Critical UX/Data Fixes};
+    B --> C{Phase 2: Enhance MAP_MERGE_RULES Editor};
+    C --> D{Phase 3: General UX & Table Interactivity};
+    D --> E[End: Refactored Preferences Window];
+
+    subgraph "Phase 1: Correct Scope & Critical UX/Data Fixes"
+        B1[Remove Definitions Editing from ConfigEditorDialog]
+        B2[Improve List Editing for RESPECT_VARIANT_MAP_TYPES]
+        B3[Fix IMAGE_RESOLUTIONS Handling (Dictionary)]
+        B4[Handle Simple Nested Settings (e.g., general_settings)]
+    end
+
+    subgraph "Phase 2: Enhance MAP_MERGE_RULES Editor"
+        C1[Implement Add/Remove for Merge Rules]
+        C2[Improve Rule Detail Editing (ComboBoxes, SpinBoxes)]
+    end
+
+    subgraph "Phase 3: General UX & Table Interactivity"
+        D1[Implement IMAGE_RESOLUTIONS Table Add/Remove Buttons]
+        D2[Implement Necessary Table Cell Delegates (e.g., for IMAGE_RESOLUTIONS values)]
+        D3[Review/Refine Tab Layout & Widget Grouping]
+    end
+
+    B --> B1; B --> B2; B --> B3; B --> B4;
+    C --> C1; C --> C2;
+    D --> D1; D --> D2; D --> D3;
+```
+
+### Phase 1: Correct Scope & Critical UX/Data Fixes (in `gui/config_editor_dialog.py`)
+
+1.  **Remove Definitions Editing:**
+    *   **Action:** In `populate_definitions_tab`, remove the inner `QTabWidget` and the code that creates/populates the "Asset Types" and "File Types" tables.
+    *   The `DEFAULT_ASSET_CATEGORY` `QComboBox` (for the setting from `app_settings.json`) should remain. Its items should be populated using keys obtained from the `Configuration` class (which loads the actual `ASSET_TYPE_DEFINITIONS` from its dedicated file).
+    *   **Rationale:** Simplifies the dialog to settings managed via `user_settings.json`. Editing of the full definition files requires dedicated UI (see Future Enhancements note).
+
+2.  **Improve `RESPECT_VARIANT_MAP_TYPES` Editing:**
+    *   **Action:** In `populate_output_naming_tab`, replace the `QLineEdit` for `RESPECT_VARIANT_MAP_TYPES` with a `QListWidget` and "Add"/"Remove" buttons.
+    *   "Add" button: Use `QInputDialog.getItem` with items populated from `Configuration.get_file_type_keys()` (or similar method accessing loaded `FILE_TYPE_DEFINITIONS`) to allow users to select a valid file type key.
+    *   "Remove" button: Remove the selected item from the `QListWidget`.
+    *   Update `save_settings` to read the list of strings from this `QListWidget`.
+    *   Update `populate_widgets_from_settings` to populate this `QListWidget`.
+
+3.  **Fix `IMAGE_RESOLUTIONS` Handling:**
+    *   **Action:** In `populate_image_processing_tab`:
+        *   The `QTableWidget` for `IMAGE_RESOLUTIONS` should have two columns: "Name" (string, for the dictionary key) and "Resolution (px)" (integer, for the dictionary value).
+        *   In `populate_image_resolutions_table`, ensure it correctly populates from the dictionary structure in `self.settings['IMAGE_RESOLUTIONS']` (from `app_settings.json`).
+        *   In `save_settings`, ensure it correctly reads data from the table and reconstructs the `IMAGE_RESOLUTIONS` dictionary (e.g., `{"4K": 4096, "2K": 2048}`) when saving to `user_settings.json`.
+    *   ComboBoxes `CALCULATE_STATS_RESOLUTION` and `RESOLUTION_THRESHOLD_FOR_JPG` should be populated with the *keys* (names like "4K", "2K") from the `IMAGE_RESOLUTIONS` dictionary. `RESOLUTION_THRESHOLD_FOR_JPG` should also include "Never" and "Always" options. The `save_settings` method needs to correctly map these special ComboBox values back to appropriate storable values if necessary (e.g., sentinel numbers or specific strings if the backend configuration expects them for "Never"/"Always").
+
+4.  **Handle Simple Nested Settings (e.g., `general_settings`):**
+    *   **Action:** For `general_settings.invert_normal_map_green_channel_globally` (from `config/app_settings.json`):
+        *   Add a `QCheckBox` labeled "Invert Normal Map Green Channel Globally" to an appropriate tab (e.g., "Image Processing" or a "General" tab after layout review).
+        *   Update `populate_widgets_from_settings` to read `self.settings.get('general_settings', {}).get('invert_normal_map_green_channel_globally', False)`.
+        *   Update `save_settings` to write this value back to `target_file_content.setdefault('general_settings', {})['invert_normal_map_green_channel_globally'] = widget.isChecked()`.
+
+### Phase 2: Enhance `MAP_MERGE_RULES` Editor (in `gui/config_editor_dialog.py`)
+
+1.  **Rule Management:**
+    *   **Action:** In `populate_map_merging_tab`:
+        *   Connect the "Add Rule" button:
+            *   Create a default new rule dictionary (e.g., `{"output_map_type": "NEW_RULE", "inputs": {}, "defaults": {}, "output_bit_depth": "respect_inputs"}`).
+            *   Add it to the internal list of rules that will be saved (e.g., a copy of `self.settings['MAP_MERGE_RULES']` that gets modified).
+            *   Add a new `QListWidgetItem` for it and select it to display its details.
+        *   Connect the "Remove Rule" button:
+            *   Remove the selected rule from the internal list and the `QListWidget`.
+            *   Clear the details panel.
+
+2.  **Rule Details Panel Improvements (`display_merge_rule_details`):**
+    *   **`output_map_type`:** Change the `QLineEdit` to a `QComboBox`. Populate its items from `Configuration.get_file_type_keys()`.
+    *   **`inputs` Table:** The "Input Map Type" column cells should use a `QComboBox` delegate, populated with `Configuration.get_file_type_keys()` plus an empty/None option.
+    *   **`defaults` Table:** The "Default Value" column cells should use a `QDoubleSpinBox` delegate (e.g., range 0.0 to 1.0, or 0-255 if appropriate for specific channel types).
+    *   Ensure changes in these detail editors update the underlying rule data associated with the selected `QListWidgetItem` and the internal list of rules.
+
+### Phase 3: General UX & Table Interactivity (in `gui/config_editor_dialog.py`)
+
+1.  **Implement `IMAGE_RESOLUTIONS` Table Add/Remove Buttons:**
+    *   **Action:** In `populate_image_processing_tab`, connect the "Add Row" and "Remove Row" buttons for the `IMAGE_RESOLUTIONS` table.
+        *   "Add Row": Prompt for "Name" (string) and "Resolution (px)" (integer).
+        *   "Remove Row": Remove the selected row from the table and the underlying data.
+2.  **Implement Necessary Table Cell Delegates:**
+    *   **Action:** For the `IMAGE_RESOLUTIONS` table, the "Resolution (px)" column should use a `QSpinBox` delegate or a `QLineEdit` with integer validation to ensure correct data input.
+3.  **Review/Refine Tab Layout & Widget Grouping:**
+    *   **Action:** After the functional changes, review the overall layout of tabs and the grouping of settings within `gui/config_editor_dialog.py`.
+        *   Ensure settings from `config/app_settings.json` are logically placed and clearly labeled.
+        *   Verify widget labels are descriptive and tooltips are helpful where needed.
+        *   Confirm correct mapping between UI widgets and the keys in `app_settings.json` (e.g., `OUTPUT_FILENAME_PATTERN` vs. `TARGET_FILENAME_PATTERN`).
+
+## 4. Future Enhancements (Out of Scope for this Refactor)
+
+*   **Dedicated Editors for Definitions:** As per user feedback, if `ASSET_TYPE_DEFINITIONS` and `FILE_TYPE_DEFINITIONS` require UI-based editing, dedicated dialogs/widgets should be created. These would read from and save to their respective files ([`config/asset_type_definitions.json`](config/asset_type_definitions.json) and [`config/file_type_definitions.json`](config/file_type_definitions.json)) and could adopt a list/details UI similar to the `MAP_MERGE_RULES` editor.
+*   **Live Updates:** Consider mechanisms for applying some settings without requiring an application restart, if feasible for specific settings.
+
+This plan aims to create a more focused, usable, and correct preferences window.

gui/delegates.py

@@ -126,12 +126,15 @@ class SupplierSearchDelegate(QStyledItemDelegate):
         """Loads the list of known suppliers from the JSON config file."""
         try:
             with open(SUPPLIERS_CONFIG_PATH, 'r') as f:
-                suppliers = json.load(f)
-                if isinstance(suppliers, list):
+                suppliers_data = json.load(f) # Renamed variable for clarity
+                if isinstance(suppliers_data, list):
                     # Ensure all items are strings
-                    return sorted([str(s) for s in suppliers if isinstance(s, str)])
-                else:
-                    log.warning(f"'{SUPPLIERS_CONFIG_PATH}' does not contain a valid list. Starting fresh.")
+                    return sorted([str(s) for s in suppliers_data if isinstance(s, str)])
+                elif isinstance(suppliers_data, dict): # ADDED: Handle dictionary case
+                    # If it's a dictionary, extract keys as supplier names
+                    return sorted([str(key) for key in suppliers_data.keys() if isinstance(key, str)])
+                else: # MODIFIED: Updated warning message
+                    log.warning(f"'{SUPPLIERS_CONFIG_PATH}' does not contain a valid list or dictionary of suppliers. Starting fresh.")
                     return []
         except FileNotFoundError:
             log.info(f"'{SUPPLIERS_CONFIG_PATH}' not found. Starting with an empty supplier list.")

gui/llm_editor_widget.py

@@ -1,6 +1,7 @@
 # gui/llm_editor_widget.py
 import json
 import logging
+import copy # Added for deepcopy
 from PySide6.QtWidgets import (
     QWidget, QVBoxLayout, QTabWidget, QPlainTextEdit, QGroupBox,
     QHBoxLayout, QPushButton, QFormLayout, QLineEdit, QDoubleSpinBox,
@@ -24,6 +25,7 @@ class LLMEditorWidget(QWidget):
     def __init__(self, parent=None):
         super().__init__(parent)
         self._unsaved_changes = False
+        self.original_llm_settings = {} # Initialize original_llm_settings
         self._init_ui()
         self._connect_signals()
         self.save_button.setEnabled(False) # Initially disabled
@@ -131,6 +133,7 @@ class LLMEditorWidget(QWidget):
         try:
             with open(LLM_CONFIG_PATH, 'r', encoding='utf-8') as f:
                 settings = json.load(f)
+            self.original_llm_settings = copy.deepcopy(settings) # Store a deep copy
 
             # Populate Prompt Settings
             self.prompt_editor.setPlainText(settings.get("llm_predictor_prompt", ""))
@@ -159,9 +162,9 @@ class LLMEditorWidget(QWidget):
             logger.info("LLM settings loaded successfully.")
 
         except FileNotFoundError:
-            logger.warning(f"LLM settings file not found: {LLM_CONFIG_PATH}. Using defaults and disabling editor.")
+            logger.warning(f"LLM settings file not found: {LLM_CONFIG_PATH}. Using defaults.")
             QMessageBox.warning(self, "Load Error",
-                                f"LLM settings file not found:\n{LLM_CONFIG_PATH}\n\nPlease ensure the file exists. Using default values.")
+                                f"LLM settings file not found:\n{LLM_CONFIG_PATH}\n\nNew settings will be created if you save.")
             # Reset to defaults (optional, or leave fields empty)
             self.prompt_editor.clear()
             self.endpoint_url_edit.clear()
@@ -169,19 +172,21 @@ class LLMEditorWidget(QWidget):
             self.model_name_edit.clear()
             self.temperature_spinbox.setValue(0.7)
             self.timeout_spinbox.setValue(120)
-            # self.setEnabled(False) # Disabling might be too harsh if user wants to create settings
+            self.original_llm_settings = {} # Start with empty original settings if file not found
 
         except json.JSONDecodeError as e:
             logger.error(f"Error decoding JSON from {LLM_CONFIG_PATH}: {e}")
             QMessageBox.critical(self, "Load Error",
                                  f"Failed to parse LLM settings file:\n{LLM_CONFIG_PATH}\n\nError: {e}\n\nPlease check the file for syntax errors. Editor will be disabled.")
             self.setEnabled(False) # Disable editor on critical load error
+            self.original_llm_settings = {} # Reset original settings on JSON error
 
         except Exception as e: # Catch other potential errors during loading/populating
              logger.error(f"An unexpected error occurred loading LLM settings: {e}", exc_info=True)
              QMessageBox.critical(self, "Load Error",
                                   f"An unexpected error occurred while loading settings:\n{e}\n\nEditor will be disabled.")
              self.setEnabled(False)
+             self.original_llm_settings = {} # Reset original settings on other errors
 
 
         # Reset unsaved changes flag and disable save button after loading
@@ -201,26 +206,38 @@ class LLMEditorWidget(QWidget):
         """Gather data from UI, save to JSON file, and handle errors."""
         logger.info("Attempting to save LLM settings...")
 
-        settings_dict = {}
+        # 1.a. Load Current Target File
+        target_file_content = {}
+        try:
+            with open(LLM_CONFIG_PATH, 'r', encoding='utf-8') as f:
+                target_file_content = json.load(f)
+        except FileNotFoundError:
+            logger.info(f"{LLM_CONFIG_PATH} not found. Will create a new one.")
+            target_file_content = {} # Start with an empty dict if file doesn't exist
+        except json.JSONDecodeError as e:
+            logger.error(f"Error decoding existing {LLM_CONFIG_PATH}: {e}. Starting with an empty config for save.")
+            QMessageBox.warning(self, "Warning",
+                                f"Could not parse existing LLM settings file ({LLM_CONFIG_PATH}).\n"
+                                f"Any pre-existing settings in that file might be overwritten if you save now.\nError: {e}")
+            target_file_content = {} # Start fresh if current file is corrupt
+
+        # 1.b. Gather current UI settings into current_llm_settings
+        current_llm_settings = {}
         parsed_examples = []
-        has_errors = False
+        has_errors = False # For example parsing
 
-        # Gather API Settings
-        settings_dict["llm_endpoint_url"] = self.endpoint_url_edit.text().strip()
-        settings_dict["llm_api_key"] = self.api_key_edit.text() # Keep as is, don't strip
-        settings_dict["llm_model_name"] = self.model_name_edit.text().strip()
-        settings_dict["llm_temperature"] = self.temperature_spinbox.value()
-        settings_dict["llm_request_timeout"] = self.timeout_spinbox.value()
+        current_llm_settings["llm_endpoint_url"] = self.endpoint_url_edit.text().strip()
+        current_llm_settings["llm_api_key"] = self.api_key_edit.text() # Keep as is
+        current_llm_settings["llm_model_name"] = self.model_name_edit.text().strip()
+        current_llm_settings["llm_temperature"] = self.temperature_spinbox.value()
+        current_llm_settings["llm_request_timeout"] = self.timeout_spinbox.value()
+        current_llm_settings["llm_predictor_prompt"] = self.prompt_editor.toPlainText().strip()
 
-        # Gather Prompt Settings
-        settings_dict["llm_predictor_prompt"] = self.prompt_editor.toPlainText().strip()
-
-        # Gather and Parse Examples
         for i in range(self.examples_tab_widget.count()):
             example_editor = self.examples_tab_widget.widget(i)
             if isinstance(example_editor, QTextEdit):
                 example_text = example_editor.toPlainText().strip()
-                if not example_text: # Skip empty examples silently
+                if not example_text:
                     continue
                 try:
                     parsed_example = json.loads(example_text)
@@ -231,40 +248,58 @@ class LLMEditorWidget(QWidget):
                     logger.warning(f"Invalid JSON in '{tab_name}': {e}. Skipping example.")
                     QMessageBox.warning(self, "Invalid Example",
                                         f"The content in '{tab_name}' is not valid JSON and will not be saved.\n\nError: {e}\n\nPlease correct it or remove the tab.")
-                    # Optionally switch to the tab with the error:
-                    # self.examples_tab_widget.setCurrentIndex(i)
             else:
-                 logger.warning(f"Widget at index {i} in examples tab is not a QTextEdit. Skipping.")
-
+                logger.warning(f"Widget at index {i} in examples tab is not a QTextEdit. Skipping.")
 
         if has_errors:
             logger.warning("LLM settings not saved due to invalid JSON in examples.")
-            # Keep save button enabled if there were errors, allowing user to fix and retry
-            # self.save_button.setEnabled(True)
-            # self._unsaved_changes = True
-            return # Stop saving process
+            return
 
-        settings_dict["llm_predictor_examples"] = parsed_examples
+        current_llm_settings["llm_predictor_examples"] = parsed_examples
 
-        # Save the dictionary to file
+        # 1.c. Identify Changes and Update Target File Content
+        changed_settings_count = 0
+        for key, current_value in current_llm_settings.items():
+            original_value = self.original_llm_settings.get(key)
+
+            # Special handling for lists (e.g., examples) - direct comparison works
+            # For other types, direct comparison also works.
+            # This includes new keys present in current_llm_settings but not in original_llm_settings
+            if key not in self.original_llm_settings or current_value != original_value:
+                target_file_content[key] = current_value
+                logger.debug(f"Setting '{key}' changed or added. Old: '{original_value}', New: '{current_value}'")
+                changed_settings_count +=1
+
+        if changed_settings_count == 0 and self._unsaved_changes:
+             logger.info("Save called, but no actual changes detected compared to original loaded settings.")
+             # If _unsaved_changes was true, it means UI interaction happened,
+             # but values might have been reverted to original.
+             # We still proceed to save target_file_content as it might contain
+             # values from a file that was modified externally since last load.
+             # Or, if the file didn't exist, it will now be created with current UI values.
+
+        # 1.d. Save Updated Content
         try:
-            save_llm_config(settings_dict)
+            save_llm_config(target_file_content) # Save the potentially modified target_file_content
             QMessageBox.information(self, "Save Successful", f"LLM settings saved to:\n{LLM_CONFIG_PATH}")
+            
+            # Update original_llm_settings to reflect the newly saved state
+            self.original_llm_settings = copy.deepcopy(target_file_content)
+            
             self.save_button.setEnabled(False)
             self._unsaved_changes = False
-            self.settings_saved.emit() # Notify MainWindow or others
+            self.settings_saved.emit()
             logger.info("LLM settings saved successfully.")
 
         except ConfigurationError as e:
             logger.error(f"Failed to save LLM settings: {e}")
             QMessageBox.critical(self, "Save Error", f"Could not save LLM settings.\n\nError: {e}")
-            # Keep save button enabled as save failed
-            self.save_button.setEnabled(True)
+            self.save_button.setEnabled(True) # Keep save enabled
             self._unsaved_changes = True
-        except Exception as e: # Catch unexpected errors during save
+        except Exception as e:
             logger.error(f"An unexpected error occurred during LLM settings save: {e}", exc_info=True)
             QMessageBox.critical(self, "Save Error", f"An unexpected error occurred while saving settings:\n{e}")
-            self.save_button.setEnabled(True)
+            self.save_button.setEnabled(True) # Keep save enabled
             self._unsaved_changes = True
 
     # --- Example Management Slots ---

gui/main_window.py

@@ -27,6 +27,7 @@ from .llm_editor_widget import LLMEditorWidget
 from .log_console_widget import LogConsoleWidget
 from .main_panel_widget import MainPanelWidget
 
+from .definitions_editor_dialog import DefinitionsEditorDialog
 # --- Backend Imports for Data Structures ---
 from rule_structure import SourceRule, AssetRule, FileRule
 
@@ -861,6 +862,11 @@ class MainWindow(QMainWindow):
         self.preferences_action = QAction("&Preferences...", self)
         self.preferences_action.triggered.connect(self._open_config_editor)
         edit_menu.addAction(self.preferences_action)
+        edit_menu.addSeparator()
+
+        self.definitions_editor_action = QAction("Edit Definitions...", self)
+        self.definitions_editor_action.triggered.connect(self._open_definitions_editor)
+        edit_menu.addAction(self.definitions_editor_action)
 
         view_menu = self.menu_bar.addMenu("&View")
 
@@ -904,6 +910,17 @@ class MainWindow(QMainWindow):
             log.exception(f"Error opening configuration editor dialog: {e}")
             QMessageBox.critical(self, "Error", f"An error occurred while opening the configuration editor:\n{e}")
 
+    @Slot() # PySide6.QtCore.Slot
+    def _open_definitions_editor(self):
+        log.debug("Opening Definitions Editor dialog.")
+        try:
+            # DefinitionsEditorDialog is imported at the top of the file
+            dialog = DefinitionsEditorDialog(self)
+            dialog.exec_() # Use exec_() for modal dialog
+            log.debug("Definitions Editor dialog closed.")
+        except Exception as e:
+            log.exception(f"Error opening Definitions Editor dialog: {e}")
+            QMessageBox.critical(self, "Error", f"An error occurred while opening the Definitions Editor:\n{e}")
 
     @Slot(bool)
     def _toggle_log_console_visibility(self, checked):

gui/preset_editor_widget.py

@@ -20,7 +20,8 @@ script_dir = Path(__file__).parent
 project_root = script_dir.parent
 PRESETS_DIR = project_root / "Presets"
 TEMPLATE_PATH = PRESETS_DIR / "_template.json"
-APP_SETTINGS_PATH_LOCAL = project_root / "config" / "app_settings.json"
+APP_SETTINGS_PATH_LOCAL = project_root / "config" / "app_settings.json" # Retain for other settings if used elsewhere
+FILE_TYPE_DEFINITIONS_PATH = project_root / "config" / "file_type_definitions.json"
 
 
 log = logging.getLogger(__name__)
@@ -63,18 +64,19 @@ class PresetEditorWidget(QWidget):
         """Loads FILE_TYPE_DEFINITIONS keys from app_settings.json."""
         keys = []
         try:
-            if APP_SETTINGS_PATH_LOCAL.is_file():
-                with open(APP_SETTINGS_PATH_LOCAL, 'r', encoding='utf-8') as f:
+            if FILE_TYPE_DEFINITIONS_PATH.is_file():
+                with open(FILE_TYPE_DEFINITIONS_PATH, 'r', encoding='utf-8') as f:
                     settings = json.load(f)
+                # The FILE_TYPE_DEFINITIONS key is at the root of file_type_definitions.json
                 ftd = settings.get("FILE_TYPE_DEFINITIONS", {})
                 keys = list(ftd.keys())
-                log.debug(f"Successfully loaded {len(keys)} FILE_TYPE_DEFINITIONS keys.")
+                log.debug(f"Successfully loaded {len(keys)} FILE_TYPE_DEFINITIONS keys from {FILE_TYPE_DEFINITIONS_PATH}.")
             else:
-                log.error(f"app_settings.json not found at {APP_SETTINGS_PATH_LOCAL} for PresetEditorWidget.")
+                log.error(f"file_type_definitions.json not found at {FILE_TYPE_DEFINITIONS_PATH} for PresetEditorWidget.")
         except json.JSONDecodeError as e:
-            log.error(f"Failed to parse app_settings.json in PresetEditorWidget: {e}")
+            log.error(f"Failed to parse file_type_definitions.json in PresetEditorWidget: {e}")
         except Exception as e:
-            log.error(f"Error loading FILE_TYPE_DEFINITIONS keys in PresetEditorWidget: {e}")
+            log.error(f"Error loading FILE_TYPE_DEFINITIONS keys from {FILE_TYPE_DEFINITIONS_PATH} in PresetEditorWidget: {e}")
         return keys
 
     def _init_ui(self):

gui/unified_view_model.py

@@ -552,6 +552,13 @@ class UnifiedViewModel(QAbstractItemModel):
                      supplier_col_index = self.createIndex(existing_source_row, self.COL_SUPPLIER, existing_source_rule)
                      self.dataChanged.emit(supplier_col_index, supplier_col_index, [Qt.DisplayRole, Qt.EditRole])
 
+            # Always update the preset_name from the new_source_rule, as this reflects the latest prediction context
+            if existing_source_rule.preset_name != new_source_rule.preset_name:
+                log.debug(f"  Updating preset_name for SourceRule '{source_path}' from '{existing_source_rule.preset_name}' to '{new_source_rule.preset_name}'")
+                existing_source_rule.preset_name = new_source_rule.preset_name
+                # Note: preset_name is not directly displayed in the view, so no dataChanged needed for a specific column,
+                # but if it influenced other display elements, dataChanged would be emitted for those.
+
 
             # --- Merge AssetRules ---
             existing_assets_dict = {asset.asset_name: asset for asset in existing_source_rule.assets}

main.py

@@ -4,6 +4,7 @@ import time
 import os
 import logging
 from pathlib import Path
+import re # Added for checking incrementing token
 from concurrent.futures import ProcessPoolExecutor, as_completed
 import subprocess
 import shutil
@@ -238,9 +239,14 @@ class ProcessingTask(QRunnable):
                 # output_dir should already be a Path object
                 pattern = getattr(config, 'output_directory_pattern', None)
                 if pattern:
-                    log.debug(f"Calculating next incrementing value for dir: {output_dir} using pattern: {pattern}")
-                    next_increment_str = get_next_incrementing_value(output_dir, pattern)
-                    log.info(f"Calculated next incrementing value for {output_dir}: {next_increment_str}")
+                    # Only call get_next_incrementing_value if the pattern contains an incrementing token
+                    if re.search(r"\[IncrementingValue\]|#+", pattern):
+                        log.debug(f"Incrementing token found in pattern '{pattern}'. Calculating next value for dir: {output_dir}")
+                        next_increment_str = get_next_incrementing_value(output_dir, pattern)
+                        log.info(f"Calculated next incrementing value for {output_dir}: {next_increment_str}")
+                    else:
+                        log.debug(f"No incrementing token found in pattern '{pattern}'. Skipping increment calculation.")
+                        next_increment_str = None # Or a default like "00" if downstream expects a string, but None is cleaner if handled.
                 else:
                     log.warning(f"Cannot calculate incrementing value: 'output_directory_pattern' not found in configuration for preset {config.preset_name}")
             except Exception as e:
@@ -401,11 +407,13 @@ class App(QObject):
 
         # --- Get paths needed for ProcessingTask ---
         try:
-            # Access output path via MainPanelWidget
-            output_base_path_str = self.main_window.main_panel_widget.output_path_edit.text().strip()
+            # Get output_dir from processing_settings passed from autotest.py
+            output_base_path_str = processing_settings.get("output_dir")
+            log.info(f"APP_DEBUG: Received output_dir in processing_settings: {output_base_path_str}")
+
             if not output_base_path_str:
-                log.error("Cannot queue tasks: Output directory path is empty in the GUI.")
-                self.main_window.statusBar().showMessage("Error: Output directory cannot be empty.", 5000)
+                log.error("Cannot queue tasks: Output directory path is empty in processing_settings.")
+                # self.main_window.statusBar().showMessage("Error: Output directory cannot be empty.", 5000) # GUI specific
                 return
             output_base_path = Path(output_base_path_str)
             # Basic validation - check if it's likely a valid path structure (doesn't guarantee existence/writability here)
@@ -477,8 +485,9 @@ class App(QObject):
                     engine=task_engine,
                     rule=rule,
                     workspace_path=workspace_path,
-                    output_base_path=output_base_path
+                    output_base_path=output_base_path # This is Path(output_base_path_str)
                 )
+                log.info(f"APP_DEBUG: Passing to ProcessingTask: output_base_path = {output_base_path}")
                 task.signals.finished.connect(self._on_task_finished)
                 log.debug(f"DEBUG: Calling thread_pool.start() for task {i+1}")
                 self.thread_pool.start(task)

monitor.py

@@ -195,17 +195,25 @@ def _process_archive_task(archive_path: Path, output_dir: Path, processed_dir: P
             # Assuming config object has 'output_directory_pattern' attribute/key
             pattern = getattr(config, 'output_directory_pattern', None) # Use getattr for safety
             if pattern:
-                log.debug(f"[Task:{archive_path.name}] Calculating next incrementing value for dir: {output_dir} using pattern: {pattern}")
-                next_increment_str = get_next_incrementing_value(output_dir, pattern)
-                log.info(f"[Task:{archive_path.name}] Calculated next incrementing value: {next_increment_str}")
+                if re.search(r"\[IncrementingValue\]|#+", pattern):
+                    log.debug(f"[Task:{archive_path.name}] Incrementing token found in pattern '{pattern}'. Calculating next value for dir: {output_dir}")
+                    next_increment_str = get_next_incrementing_value(output_dir, pattern)
+                    log.info(f"[Task:{archive_path.name}] Calculated next incrementing value: {next_increment_str}")
+                else:
+                    log.debug(f"[Task:{archive_path.name}] No incrementing token found in pattern '{pattern}'. Skipping increment calculation.")
+                    next_increment_str = None
             else:
                 # Check if config is a dict as fallback (depends on load_config implementation)
                 if isinstance(config, dict):
                     pattern = config.get('output_directory_pattern')
                     if pattern:
-                        log.debug(f"[Task:{archive_path.name}] Calculating next incrementing value for dir: {output_dir} using pattern (from dict): {pattern}")
-                        next_increment_str = get_next_incrementing_value(output_dir, pattern)
-                        log.info(f"[Task:{archive_path.name}] Calculated next incrementing value (from dict): {next_increment_str}")
+                        if re.search(r"\[IncrementingValue\]|#+", pattern):
+                            log.debug(f"[Task:{archive_path.name}] Incrementing token found in pattern '{pattern}' (from dict). Calculating next value for dir: {output_dir}")
+                            next_increment_str = get_next_incrementing_value(output_dir, pattern)
+                            log.info(f"[Task:{archive_path.name}] Calculated next incrementing value (from dict): {next_increment_str}")
+                        else:
+                            log.debug(f"[Task:{archive_path.name}] No incrementing token found in pattern '{pattern}' (from dict). Skipping increment calculation.")
+                            next_increment_str = None
                     else:
                         log.warning(f"[Task:{archive_path.name}] Cannot calculate incrementing value: 'output_directory_pattern' not found in configuration dictionary.")
                 else:

processing/pipeline/asset_context.py

@@ -1,3 +1,4 @@
+import dataclasses # Added import
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, List, Optional
@@ -27,6 +28,7 @@ class ProcessedRegularMapData:
     original_bit_depth: Optional[int]
     original_dimensions: Optional[Tuple[int, int]] # (width, height)
     transformations_applied: List[str]
+    resolution_key: Optional[str] = None # Added field
     status: str = "Processed"
     error_message: Optional[str] = None
 
@@ -45,9 +47,10 @@ class ProcessedMergedMapData:
 @dataclass
 class InitialScalingInput:
     image_data: np.ndarray
+    initial_scaling_mode: str # Moved before fields with defaults
     original_dimensions: Optional[Tuple[int, int]] # (width, height)
+    resolution_key: Optional[str] = None # Added field
     # Configuration needed
-    initial_scaling_mode: str
 
 # Output for InitialScalingStage
 @dataclass
@@ -55,6 +58,7 @@ class InitialScalingOutput:
     scaled_image_data: np.ndarray
     scaling_applied: bool
     final_dimensions: Tuple[int, int] # (width, height)
+    resolution_key: Optional[str] = None # Added field
 
 # Input for SaveVariantsStage
 @dataclass

processing/pipeline/orchestrator.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Optional, Any, Union # Added Any, Union
 import numpy as np # Added numpy
 
 from configuration import Configuration
-from rule_structure import SourceRule, AssetRule, FileRule # Added FileRule
+from rule_structure import SourceRule, AssetRule, FileRule, ProcessingItem # Added ProcessingItem
 
 # Import new context classes and stages
 from .asset_context import (
@@ -200,145 +200,224 @@ class PipelineOrchestrator:
                     current_image_data: Optional[np.ndarray] = None # Track current image data ref
 
                     try:
-                        # 1. Process (Load/Merge + Transform)
-                        if isinstance(item, FileRule):
-                            if item.item_type == 'EXTRA':
-                                log.debug(f"{item_log_prefix}: Skipping image processing for EXTRA FileRule '{item.file_path}'.")
-                                # Add a basic entry to processed_maps_details to acknowledge it was seen
-                                context.processed_maps_details[item.file_path] = {
-                                    "status": "Skipped (EXTRA file)",
-                                    "internal_map_type": "EXTRA",
-                                    "source_file": str(item.file_path)
-                                }
-                                continue # Skip to the next item
-                            item_key = item.file_path # Use file_path string as key
-                            log.debug(f"{item_log_prefix}: Processing FileRule '{item.file_path}'...")
-                            processed_data = self._regular_processor_stage.execute(context, item)
-                        elif isinstance(item, MergeTaskDefinition):
-                            item_key = item.task_key # Use task_key string as key
-                            log.info(f"{item_log_prefix}: Executing MergedTaskProcessorStage for MergeTask '{item_key}'...") # Log call
-                            processed_data = self._merged_processor_stage.execute(context, item)
-                            # Log status/error from merge processor
-                            if processed_data:
-                                log.info(f"{item_log_prefix}: MergedTaskProcessorStage result - Status: {processed_data.status}, Error: {processed_data.error_message}")
-                            else:
-                                log.warning(f"{item_log_prefix}: MergedTaskProcessorStage returned None for MergeTask '{item_key}'.")
-                        else:
-                            log.warning(f"{item_log_prefix}: Unknown item type '{type(item)}'. Skipping.")
-                            item_key = f"unknown_item_{item_index}"
-                            context.processed_maps_details[item_key] = {"status": "Skipped", "notes": f"Unknown item type {type(item)}"}
-                            asset_had_item_errors = True
-                            continue # Next item
+                        # The 'item' is now expected to be a ProcessingItem or MergeTaskDefinition
                         
-                        # Check for processing failure
-                        if not processed_data or processed_data.status != "Processed":
-                            error_msg = processed_data.error_message if processed_data else "Processor returned None"
-                            log.error(f"{item_log_prefix}: Failed during processing stage. Error: {error_msg}")
-                            context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Processing Error: {error_msg}", "stage": processed_data.__class__.__name__ if processed_data else "UnknownProcessor"}
-                            asset_had_item_errors = True
-                            continue # Next item
+                        if isinstance(item, ProcessingItem):
+                            item_key = f"{item.source_file_info_ref}_{item.map_type_identifier}_{item.resolution_key}"
+                            item_log_prefix = f"Asset '{asset_name}', ProcItem '{item_key}'"
+                            log.info(f"{item_log_prefix}: Starting processing.")
 
-                        # Store intermediate result & get current image data
-                        context.intermediate_results[item_key] = processed_data
-                        current_image_data = processed_data.processed_image_data if isinstance(processed_data, ProcessedRegularMapData) else processed_data.merged_image_data
-                        current_dimensions = processed_data.original_dimensions if isinstance(processed_data, ProcessedRegularMapData) else processed_data.final_dimensions
+                            # Data for ProcessingItem is already loaded by PrepareProcessingItemsStage
+                            current_image_data = item.image_data
+                            current_dimensions = item.current_dimensions
+                            item_resolution_key = item.resolution_key
                             
-                        # 2. Scale (Optional)
-                        scaling_mode = getattr(context.config_obj, "INITIAL_SCALING_MODE", "NONE")
-                        if scaling_mode != "NONE" and current_image_data is not None and current_image_data.size > 0:
-                            if isinstance(item, MergeTaskDefinition): # Log scaling call for merge tasks
-                                log.info(f"{item_log_prefix}: Calling InitialScalingStage for MergeTask '{item_key}' (Mode: {scaling_mode})...")
-                            log.debug(f"{item_log_prefix}: Applying initial scaling (Mode: {scaling_mode})...")
+                            # Transformations (like gloss to rough, normal invert) are assumed to be applied
+                            # by RegularMapProcessorStage if it's still used, or directly in PrepareProcessingItemsStage
+                            # before creating the ProcessingItem, or a new dedicated transformation stage.
+                            # For now, assume item.image_data is ready for scaling/saving.
+                            
+                            # Store initial ProcessingItem data as "processed_data" for consistency if RegularMapProcessor is bypassed
+                            # This is a simplification; a dedicated transformation stage would be cleaner.
+                            # For now, we assume transformations happened before or within PrepareProcessingItemsStage.
+                            # The 'processed_data' variable here is more of a placeholder for what would feed into scaling.
+                            
+                            # Create a simple ProcessedRegularMapData-like structure for logging/details if needed,
+                            # or adapt the final_details population later.
+                            # For now, we'll directly use 'item' fields.
+
+                            # 2. Scale (Optional)
+                            scaling_mode = getattr(context.config_obj, "INITIAL_SCALING_MODE", "NONE")
+                            # Pass the item's resolution_key to InitialScalingInput
                             scale_input = InitialScalingInput(
                                 image_data=current_image_data,
-                                original_dimensions=current_dimensions, # Pass original/merged dims
-                                initial_scaling_mode=scaling_mode
+                                original_dimensions=current_dimensions,
+                                initial_scaling_mode=scaling_mode,
+                                resolution_key=item_resolution_key # Pass the key
                             )
+                            # Add _source_file_path for logging within InitialScalingStage if available
+                            setattr(scale_input, '_source_file_path', item.source_file_info_ref)
+
+                            log.debug(f"{item_log_prefix}: Calling InitialScalingStage. Input res_key: {scale_input.resolution_key}")
                             scaled_data_output = self._scaling_stage.execute(scale_input)
-                            # Update intermediate result and current image data reference
-                            context.intermediate_results[item_key] = scaled_data_output # Overwrite previous intermediate
-                            current_image_data = scaled_data_output.scaled_image_data # Use scaled data for saving
-                            log.debug(f"{item_log_prefix}: Scaling applied: {scaled_data_output.scaling_applied}. New Dims: {scaled_data_output.final_dimensions}")
-                        else:
-                            log.debug(f"{item_log_prefix}: Initial scaling skipped (Mode: NONE or empty image).")
-                            # Create dummy output if scaling skipped, using current dims
-                            final_dims = current_dimensions if current_dimensions else (current_image_data.shape[1], current_image_data.shape[0]) if current_image_data is not None else (0,0)
-                            scaled_data_output = InitialScalingOutput(scaled_image_data=current_image_data, scaling_applied=False, final_dimensions=final_dims)
+                            current_image_data = scaled_data_output.scaled_image_data
+                            current_dimensions = scaled_data_output.final_dimensions # Dimensions after scaling
+                            # The resolution_key from item is passed through by InitialScalingOutput
+                            output_resolution_key = scaled_data_output.resolution_key
+                            log.debug(f"{item_log_prefix}: InitialScalingStage output. Scaled: {scaled_data_output.scaling_applied}, New Dims: {current_dimensions}, Output ResKey: {output_resolution_key}")
+                            context.intermediate_results[item_key] = scaled_data_output
 
 
-                        # 3. Save Variants
-                        if current_image_data is None or current_image_data.size == 0:
-                             log.warning(f"{item_log_prefix}: Skipping save stage because image data is empty.")
-                             context.processed_maps_details[item_key] = {"status": "Skipped", "notes": "No image data to save", "stage": "SaveVariantsStage"}
-                             # Don't mark as asset error, just skip this item's saving
-                             continue # Next item
+                            # 3. Save Variants
+                            if current_image_data is None or current_image_data.size == 0:
+                                log.warning(f"{item_log_prefix}: Skipping save stage because image data is empty.")
+                                context.processed_maps_details[item_key] = {"status": "Skipped", "notes": "No image data to save", "stage": "SaveVariantsStage"}
+                                continue
 
-                        if isinstance(item, MergeTaskDefinition): # Log save call for merge tasks
-                             log.info(f"{item_log_prefix}: Calling SaveVariantsStage for MergeTask '{item_key}'...")
-                        log.debug(f"{item_log_prefix}: Saving variants...")
-                        # Prepare input for save stage
-                        internal_map_type = processed_data.final_internal_map_type if isinstance(processed_data, ProcessedRegularMapData) else processed_data.output_map_type
-                        source_bit_depth = [processed_data.original_bit_depth] if isinstance(processed_data, ProcessedRegularMapData) and processed_data.original_bit_depth is not None else processed_data.source_bit_depths if isinstance(processed_data, ProcessedMergedMapData) else [8] # Default bit depth if unknown
+                            log.debug(f"{item_log_prefix}: Preparing to save variant with resolution key '{output_resolution_key}'...")
                             
-                        # Construct filename tokens (ensure temp dir is used)
-                        output_filename_tokens = {
-                            'asset_name': asset_name,
-                            'output_base_directory': context.engine_temp_dir, # Save variants to temp dir
-                            # Add other tokens from context/config as needed by the pattern
-                            'supplier': context.effective_supplier or 'UnknownSupplier',
-                        }
-
-                        # Log the value being read for the threshold before creating the input object
-                        log.info(f"ORCHESTRATOR_DEBUG: Reading RESOLUTION_THRESHOLD_FOR_JPG from config for SaveVariantsInput: {getattr(context.config_obj, 'RESOLUTION_THRESHOLD_FOR_JPG', None)}")
-                        save_input = SaveVariantsInput(
-                            image_data=current_image_data, # Use potentially scaled data
-                            internal_map_type=internal_map_type,
-                            source_bit_depth_info=source_bit_depth,
-                            output_filename_pattern_tokens=output_filename_tokens,
-                            # Pass config values needed by save stage
-                            image_resolutions=context.config_obj.image_resolutions,
-                            file_type_defs=getattr(context.config_obj, "FILE_TYPE_DEFINITIONS", {}),
-                            output_format_8bit=context.config_obj.get_8bit_output_format(),
-                            output_format_16bit_primary=context.config_obj.get_16bit_output_formats()[0],
-                            output_format_16bit_fallback=context.config_obj.get_16bit_output_formats()[1],
-                            png_compression_level=context.config_obj.png_compression_level,
-                            jpg_quality=context.config_obj.jpg_quality,
-                            output_filename_pattern=context.config_obj.output_filename_pattern,
-                            resolution_threshold_for_jpg=getattr(context.config_obj, "resolution_threshold_for_jpg", None) # Corrected case
-                        )
-                        saved_data = self._save_stage.execute(save_input)
-                        # Log saved_data for merge tasks
-                        if isinstance(item, MergeTaskDefinition):
-                            log.info(f"{item_log_prefix}: SaveVariantsStage result for MergeTask '{item_key}' - Status: {saved_data.status if saved_data else 'N/A'}, Saved Files: {len(saved_data.saved_files_details) if saved_data else 0}")
-
-                        # Check save status and finalize item result
-                        if saved_data and saved_data.status.startswith("Processed"):
-                            item_status = saved_data.status # e.g., "Processed" or "Processed (No Output)"
-                            log.info(f"{item_log_prefix}: Item successfully processed and saved. Status: {item_status}")
-                            # Populate final details for this item
-                            final_details = {
-                                "status": item_status,
-                                "saved_files_info": saved_data.saved_files_details, # List of dicts from save util
-                                "internal_map_type": internal_map_type,
-                                "original_dimensions": processed_data.original_dimensions if isinstance(processed_data, ProcessedRegularMapData) else None,
-                                "final_dimensions": scaled_data_output.final_dimensions if scaled_data_output else current_dimensions,
-                                "transformations": processed_data.transformations_applied if isinstance(processed_data, ProcessedRegularMapData) else processed_data.transformations_applied_to_inputs,
-                                # Add source file if regular map
-                                "source_file": str(processed_data.source_file_path) if isinstance(processed_data, ProcessedRegularMapData) else None,
+                            output_filename_tokens = {
+                                'asset_name': asset_name,
+                                'output_base_directory': context.engine_temp_dir,
+                                'supplier': context.effective_supplier or 'UnknownSupplier',
+                                'resolution': output_resolution_key # Use the key from the item/scaling stage
                             }
-                            # Log final details addition for merge tasks
-                            if isinstance(item, MergeTaskDefinition):
-                                log.info(f"{item_log_prefix}: Adding final details to context.processed_maps_details for MergeTask '{item_key}'. Details: {final_details}")
-                            context.processed_maps_details[item_key] = final_details
+                            
+                            # Determine image_resolutions argument for save_image_variants
+                            save_specific_resolutions = {}
+                            if output_resolution_key == "LOWRES":
+                                # For LOWRES, the "resolution value" is its actual dimension.
+                                # image_saving_utils needs a dict like {"LOWRES": 64} if current_dim is 64x64
+                                # Assuming current_dimensions[0] is width.
+                                save_specific_resolutions = {"LOWRES": current_dimensions[0] if current_dimensions else 0}
+                                log.debug(f"{item_log_prefix}: Preparing to save LOWRES variant. Dimensions: {current_dimensions}. Save resolutions arg: {save_specific_resolutions}")
+                            elif output_resolution_key in context.config_obj.image_resolutions:
+                                save_specific_resolutions = {output_resolution_key: context.config_obj.image_resolutions[output_resolution_key]}
+                            else:
+                                log.warning(f"{item_log_prefix}: Resolution key '{output_resolution_key}' not found in config.image_resolutions and not LOWRES. Saving might fail or use full res.")
+                                # Fallback: pass all configured resolutions, image_saving_utils will try to match by size.
+                                # This might not be ideal if the key is truly unknown.
+                                # Or, more strictly, fail here if key is unknown and not LOWRES.
+                                # For now, let image_saving_utils handle it by passing all.
+                                save_specific_resolutions = context.config_obj.image_resolutions
+
+
+                            save_input = SaveVariantsInput(
+                                image_data=current_image_data,
+                                internal_map_type=item.map_type_identifier,
+                                source_bit_depth_info=[item.bit_depth] if item.bit_depth is not None else [8], # Default to 8 if not set
+                                output_filename_pattern_tokens=output_filename_tokens,
+                                image_resolutions=save_specific_resolutions, # Pass the specific resolution(s)
+                                file_type_defs=getattr(context.config_obj, "FILE_TYPE_DEFINITIONS", {}),
+                                output_format_8bit=context.config_obj.get_8bit_output_format(),
+                                output_format_16bit_primary=context.config_obj.get_16bit_output_formats()[0],
+                                output_format_16bit_fallback=context.config_obj.get_16bit_output_formats()[1],
+                                png_compression_level=context.config_obj.png_compression_level,
+                                jpg_quality=context.config_obj.jpg_quality,
+                                output_filename_pattern=context.config_obj.output_filename_pattern,
+                                resolution_threshold_for_jpg=getattr(context.config_obj, "resolution_threshold_for_jpg", None)
+                            )
+                            saved_data = self._save_stage.execute(save_input)
+                            
+                            if saved_data and saved_data.status.startswith("Processed"):
+                                item_status = saved_data.status
+                                log.info(f"{item_log_prefix}: Item successfully processed and saved. Status: {item_status}")
+                                context.processed_maps_details[item_key] = {
+                                    "status": item_status,
+                                    "saved_files_info": saved_data.saved_files_details,
+                                    "internal_map_type": item.map_type_identifier,
+                                    "resolution_key": output_resolution_key,
+                                    "original_dimensions": item.original_dimensions,
+                                    "final_dimensions": current_dimensions, # Dimensions after scaling
+                                    "source_file": item.source_file_info_ref,
+                                }
+                            else:
+                                error_msg = saved_data.error_message if saved_data else "Save stage returned None"
+                                log.error(f"{item_log_prefix}: Failed during save stage. Error: {error_msg}")
+                                context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Save Error: {error_msg}", "stage": "SaveVariantsStage"}
+                                asset_had_item_errors = True
+                                item_status = "Failed"
+
+                        elif isinstance(item, MergeTaskDefinition):
+                            # --- This part needs similar refactoring for resolution_key if merged outputs can be LOWRES ---
+                            # --- For now, assume merged tasks always produce standard resolutions ---
+                            item_key = item.task_key
+                            item_log_prefix = f"Asset '{asset_name}', MergeTask '{item_key}'"
+                            log.info(f"{item_log_prefix}: Processing MergeTask.")
+
+                            # 1. Process Merge Task
+                            processed_data = self._merged_processor_stage.execute(context, item)
+                            if not processed_data or processed_data.status != "Processed":
+                                error_msg = processed_data.error_message if processed_data else "Merge processor returned None"
+                                log.error(f"{item_log_prefix}: Failed during merge processing. Error: {error_msg}")
+                                context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Merge Error: {error_msg}", "stage": "MergedTaskProcessorStage"}
+                                asset_had_item_errors = True
+                                continue
+                            
+                            context.intermediate_results[item_key] = processed_data
+                            current_image_data = processed_data.merged_image_data
+                            current_dimensions = processed_data.final_dimensions
+
+                            # 2. Scale Merged Output (Optional)
+                            # Merged tasks typically don't have a single "resolution_key" like LOWRES from source.
+                            # They produce an image that then gets downscaled to 1K, PREVIEW etc.
+                            # So, resolution_key for InitialScalingInput here would be None or a default.
+                            scaling_mode = getattr(context.config_obj, "INITIAL_SCALING_MODE", "NONE")
+                            scale_input = InitialScalingInput(
+                                image_data=current_image_data,
+                                original_dimensions=current_dimensions,
+                                initial_scaling_mode=scaling_mode,
+                                resolution_key=None # Merged outputs are not "LOWRES" themselves before this scaling
+                            )
+                            setattr(scale_input, '_source_file_path', f"MergeTask_{item_key}") # For logging
+                            
+                            log.debug(f"{item_log_prefix}: Calling InitialScalingStage for merged data.")
+                            scaled_data_output = self._scaling_stage.execute(scale_input)
+                            current_image_data = scaled_data_output.scaled_image_data
+                            current_dimensions = scaled_data_output.final_dimensions
+                            # Merged items don't have a specific output_resolution_key from source,
+                            # they will be saved to all applicable resolutions from config.
+                            # So scaled_data_output.resolution_key will be None here.
+                            context.intermediate_results[item_key] = scaled_data_output
+
+                            # 3. Save Merged Variants
+                            if current_image_data is None or current_image_data.size == 0:
+                                log.warning(f"{item_log_prefix}: Skipping save for merged task, image data is empty.")
+                                context.processed_maps_details[item_key] = {"status": "Skipped", "notes": "No merged image data to save", "stage": "SaveVariantsStage"}
+                                continue
+
+                            output_filename_tokens = {
+                                'asset_name': asset_name,
+                                'output_base_directory': context.engine_temp_dir,
+                                'supplier': context.effective_supplier or 'UnknownSupplier',
+                                # 'resolution' token will be filled by image_saving_utils for each variant
+                            }
+                            
+                            # For merged tasks, we usually want to generate all standard resolutions.
+                            # The `resolution_key` from the item itself is not applicable here for the `resolution` token.
+                            # The `image_saving_utils.save_image_variants` will iterate through `context.config_obj.image_resolutions`.
+                            save_input = SaveVariantsInput(
+                                image_data=current_image_data,
+                                internal_map_type=processed_data.output_map_type,
+                                source_bit_depth_info=processed_data.source_bit_depths,
+                                output_filename_pattern_tokens=output_filename_tokens,
+                                image_resolutions=context.config_obj.image_resolutions, # Pass all configured resolutions
+                                file_type_defs=getattr(context.config_obj, "FILE_TYPE_DEFINITIONS", {}),
+                                output_format_8bit=context.config_obj.get_8bit_output_format(),
+                                output_format_16bit_primary=context.config_obj.get_16bit_output_formats()[0],
+                                output_format_16bit_fallback=context.config_obj.get_16bit_output_formats()[1],
+                                png_compression_level=context.config_obj.png_compression_level,
+                                jpg_quality=context.config_obj.jpg_quality,
+                                output_filename_pattern=context.config_obj.output_filename_pattern,
+                                resolution_threshold_for_jpg=getattr(context.config_obj, "resolution_threshold_for_jpg", None)
+                            )
+                            saved_data = self._save_stage.execute(save_input)
+
+                            if saved_data and saved_data.status.startswith("Processed"):
+                                item_status = saved_data.status
+                                log.info(f"{item_log_prefix}: Merged task successfully processed and saved. Status: {item_status}")
+                                context.processed_maps_details[item_key] = {
+                                    "status": item_status,
+                                    "saved_files_info": saved_data.saved_files_details,
+                                    "internal_map_type": processed_data.output_map_type,
+                                    "final_dimensions": current_dimensions,
+                                }
+                            else:
+                                error_msg = saved_data.error_message if saved_data else "Save stage for merged task returned None"
+                                log.error(f"{item_log_prefix}: Failed during save stage for merged task. Error: {error_msg}")
+                                context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Save Error (Merged): {error_msg}", "stage": "SaveVariantsStage"}
+                                asset_had_item_errors = True
+                                item_status = "Failed"
                         else:
-                            error_msg = saved_data.error_message if saved_data else "Save stage returned None"
-                            log.error(f"{item_log_prefix}: Failed during save stage. Error: {error_msg}")
-                            context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Save Error: {error_msg}", "stage": "SaveVariantsStage"}
+                            log.warning(f"{item_log_prefix}: Unknown item type in loop: {type(item)}. Skipping.")
+                            # Ensure some key exists to prevent KeyError if item_key was not set
+                            unknown_item_key = f"unknown_item_at_index_{item_index}"
+                            context.processed_maps_details[unknown_item_key] = {"status": "Skipped", "notes": f"Unknown item type {type(item)}"}
                             asset_had_item_errors = True
-                            item_status = "Failed" # Ensure item status reflects failure
+                            continue
 
                     except Exception as e:
-                        log.exception(f"{item_log_prefix}: Unhandled exception during item processing loop: {e}")
+                        log.exception(f"Asset '{asset_name}', Item Loop Index {item_index}: Unhandled exception: {e}")
                         # Ensure details are recorded even on unhandled exception
                         if item_key is not None:
                              context.processed_maps_details[item_key] = {"status": "Failed", "notes": f"Unhandled Loop Error: {e}", "stage": "OrchestratorLoop"}

processing/pipeline/stages/initial_scaling.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Tuple
+from typing import Tuple, Optional # Added Optional
 
 import cv2 # Assuming cv2 is available for interpolation flags
 import numpy as np
@@ -7,77 +7,93 @@ import numpy as np
 from .base_stage import ProcessingStage
 # Import necessary context classes and utils
 from ..asset_context import InitialScalingInput, InitialScalingOutput
+# ProcessingItem is no longer created here, so its import can be removed if not used otherwise.
+# For now, keep rule_structure import if other elements from it might be needed,
+# but ProcessingItem itself is not directly instantiated by this stage anymore.
+# from rule_structure import ProcessingItem
 from ...utils import image_processing_utils as ipu
+import numpy as np
+import cv2 # Added cv2 for interpolation flags (already used implicitly by ipu.resize_image)
 
 log = logging.getLogger(__name__)
 
 class InitialScalingStage(ProcessingStage):
     """
-    Applies initial scaling (e.g., Power-of-Two downscaling) to image data
-    if configured via the InitialScalingInput.
+    Applies initial Power-of-Two (POT) downscaling to image data if configured
+    and if the item is not already a 'LOWRES' variant.
     """
 
     def execute(self, input_data: InitialScalingInput) -> InitialScalingOutput:
         """
-        Applies scaling based on input_data.initial_scaling_mode.
+        Applies POT scaling based on input_data.initial_scaling_mode,
+        unless input_data.resolution_key is 'LOWRES'.
+        Passes through the resolution_key.
         """
-        log.debug(f"Initial Scaling Stage: Mode '{input_data.initial_scaling_mode}'.")
+        # Safely access source_file_path for logging, if provided by orchestrator via underscore attribute
+        source_file_path = getattr(input_data, '_source_file_path', "UnknownSourcePath")
+        log_prefix = f"InitialScalingStage (Source: {source_file_path}, ResKey: {input_data.resolution_key})"
+
+        log.debug(f"{log_prefix}: Mode '{input_data.initial_scaling_mode}'. Received resolution_key: '{input_data.resolution_key}'")
 
         image_to_scale = input_data.image_data
-        original_dims_wh = input_data.original_dimensions
+        current_dimensions_wh = input_data.original_dimensions # Dimensions of the image_to_scale
         scaling_mode = input_data.initial_scaling_mode
-        scaling_applied = False
-        final_image_data = image_to_scale # Default to original if no scaling happens
+        
+        output_resolution_key = input_data.resolution_key # Pass through the resolution key
 
         if image_to_scale is None or image_to_scale.size == 0:
-            log.warning("Initial Scaling Stage: Input image data is None or empty. Skipping.")
-            # Return original (empty) data and indicate no scaling
+            log.warning(f"{log_prefix}: Input image data is None or empty. Skipping POT scaling.")
             return InitialScalingOutput(
                 scaled_image_data=np.array([]),
                 scaling_applied=False,
-                final_dimensions=(0, 0)
+                final_dimensions=(0, 0),
+                resolution_key=output_resolution_key
             )
 
-        if original_dims_wh is None:
-            log.warning("Initial Scaling Stage: Original dimensions not provided. Using current image shape.")
-            h_pre_scale, w_pre_scale = image_to_scale.shape[:2]
-            original_dims_wh = (w_pre_scale, h_pre_scale)
+        if not current_dimensions_wh:
+            log.warning(f"{log_prefix}: Original dimensions not provided for POT scaling. Using current image shape.")
+            h_pre_pot_scale, w_pre_pot_scale = image_to_scale.shape[:2]
         else:
-            w_pre_scale, h_pre_scale = original_dims_wh
+            w_pre_pot_scale, h_pre_pot_scale = current_dimensions_wh
         
+        final_image_data = image_to_scale # Default to original if no scaling happens
+        scaling_applied = False
 
-        if scaling_mode == "POT_DOWNSCALE":
-            pot_w = ipu.get_nearest_power_of_two_downscale(w_pre_scale)
-            pot_h = ipu.get_nearest_power_of_two_downscale(h_pre_scale)
+        # Skip POT scaling if the item is already a LOWRES variant or scaling mode is NONE
+        if output_resolution_key == "LOWRES":
+            log.info(f"{log_prefix}: Item is a 'LOWRES' variant. Skipping POT downscaling.")
+        elif scaling_mode == "NONE":
+            log.info(f"{log_prefix}: Mode is NONE. No POT scaling applied.")
+        elif scaling_mode == "POT_DOWNSCALE":
+            pot_w = ipu.get_nearest_power_of_two_downscale(w_pre_pot_scale)
+            pot_h = ipu.get_nearest_power_of_two_downscale(h_pre_pot_scale)
 
-            if (pot_w, pot_h) != (w_pre_scale, h_pre_scale):
-                log.info(f"Initial Scaling: Applying POT Downscale from ({w_pre_scale},{h_pre_scale}) to ({pot_w},{pot_h}).")
-                # Use INTER_AREA for downscaling generally
+            if (pot_w, pot_h) != (w_pre_pot_scale, h_pre_pot_scale):
+                log.info(f"{log_prefix}: Applying POT Downscale from ({w_pre_pot_scale},{h_pre_pot_scale}) to ({pot_w},{pot_h}).")
                 resized_img = ipu.resize_image(image_to_scale, pot_w, pot_h, interpolation=cv2.INTER_AREA)
                 if resized_img is not None:
                     final_image_data = resized_img
                     scaling_applied = True
-                    log.debug("Initial Scaling: POT Downscale applied successfully.")
+                    log.debug(f"{log_prefix}: POT Downscale applied successfully.")
                 else:
-                    log.warning("Initial Scaling: POT Downscale resize failed. Using original data.")
-                    # final_image_data remains image_to_scale
+                    log.warning(f"{log_prefix}: POT Downscale resize failed. Using pre-POT-scaled data.")
             else:
-                log.info("Initial Scaling: POT Downscale - Image already POT or smaller. No scaling needed.")
-                # final_image_data remains image_to_scale
-
-        elif scaling_mode == "NONE":
-            log.info("Initial Scaling: Mode is NONE. No scaling applied.")
-            # final_image_data remains image_to_scale
+                log.info(f"{log_prefix}: Image already POT or smaller. No POT scaling needed.")
         else:
-            log.warning(f"Initial Scaling: Unknown INITIAL_SCALING_MODE '{scaling_mode}'. Defaulting to NONE.")
-            # final_image_data remains image_to_scale
+            log.warning(f"{log_prefix}: Unknown INITIAL_SCALING_MODE '{scaling_mode}'. Defaulting to NONE (no scaling).")
 
         # Determine final dimensions
-        final_h, final_w = final_image_data.shape[:2]
-        final_dims_wh = (final_w, final_h)
+        if final_image_data is not None and final_image_data.size > 0:
+            final_h, final_w = final_image_data.shape[:2]
+            final_dims_wh = (final_w, final_h)
+        else:
+            final_dims_wh = (0,0)
+            if final_image_data is None: # Ensure it's an empty array for consistency if None
+                 final_image_data = np.array([])
 
         return InitialScalingOutput(
             scaled_image_data=final_image_data,
             scaling_applied=scaling_applied,
-            final_dimensions=final_dims_wh
+            final_dimensions=final_dims_wh,
+            resolution_key=output_resolution_key # Pass through the resolution key
         )

processing/pipeline/stages/metadata_initialization.py

@@ -85,6 +85,7 @@ class MetadataInitializationStage(ProcessingStage):
     merged_maps_details.
     """
     def execute(self, context: AssetProcessingContext) -> AssetProcessingContext:
+        logger.debug(f"METADATA_INIT_DEBUG: Entry - context.output_base_path = {context.output_base_path}") # Added
         """
         Executes the metadata initialization logic.
 
@@ -147,12 +148,15 @@ class MetadataInitializationStage(ProcessingStage):
         context.asset_metadata['processing_start_time'] = datetime.datetime.now().isoformat()
         context.asset_metadata['status'] = "Pending"
 
-        if context.config_obj and hasattr(context.config_obj, 'general_settings') and \
-           hasattr(context.config_obj.general_settings, 'app_version'):
-            context.asset_metadata['version'] = context.config_obj.general_settings.app_version
+        app_version_value = None
+        if context.config_obj and hasattr(context.config_obj, 'app_version'):
+            app_version_value = context.config_obj.app_version
+
+        if app_version_value:
+            context.asset_metadata['version'] = app_version_value
         else:
-            logger.warning("App version not found in config_obj.general_settings. Setting version to 'N/A'.")
-            context.asset_metadata['version'] = "N/A" # Default or placeholder
+            logger.warning("App version not found using config_obj.app_version. Setting version to 'N/A'.")
+            context.asset_metadata['version'] = "N/A"
 
         if context.incrementing_value is not None:
             context.asset_metadata['incrementing_value'] = context.incrementing_value
@@ -170,4 +174,5 @@ class MetadataInitializationStage(ProcessingStage):
         # Example of how you might log the full metadata for debugging:
         # logger.debug(f"Initialized metadata: {context.asset_metadata}")
 
+        logger.debug(f"METADATA_INIT_DEBUG: Exit - context.output_base_path = {context.output_base_path}") # Added
         return context

processing/pipeline/stages/output_organization.py

@@ -17,8 +17,16 @@ class OutputOrganizationStage(ProcessingStage):
     """
 
     def execute(self, context: AssetProcessingContext) -> AssetProcessingContext:
-        log.info("OUTPUT_ORG: Stage execution started for asset '%s'", context.asset_rule.asset_name)
-        log.info(f"OUTPUT_ORG: context.processed_maps_details at start: {context.processed_maps_details}")
+        asset_name_for_log_early = context.asset_rule.asset_name if hasattr(context, 'asset_rule') and context.asset_rule else "Unknown Asset (early)"
+        log.info(f"OUTPUT_ORG_DEBUG: Stage execution started for asset '{asset_name_for_log_early}'.")
+        logger.debug(f"OUTPUT_ORG_DEBUG: Entry - context.output_base_path = {context.output_base_path}") # Modified
+        log.info(f"OUTPUT_ORG_DEBUG: Received context.config_obj.output_directory_base (raw from config) = {getattr(context.config_obj, 'output_directory_base', 'N/A')}")
+        # resolved_base = "N/A"
+        # if hasattr(context.config_obj, '_settings') and context.config_obj._settings.get('OUTPUT_BASE_DIR'):
+        #     base_dir_from_settings = context.config_obj._settings.get('OUTPUT_BASE_DIR')
+            # Path resolution logic might be complex
+        # log.info(f"OUTPUT_ORG_DEBUG: Received context.config_obj._settings.OUTPUT_BASE_DIR (resolved guess) = {resolved_base}")
+        log.info(f"OUTPUT_ORG_DEBUG: context.processed_maps_details at start: {context.processed_maps_details}")
         """
         Copies temporary processed and merged files to their final output locations
         based on path patterns and updates AssetProcessingContext.
@@ -103,7 +111,9 @@ class OutputOrganizationStage(ProcessingStage):
                                 pattern_string=output_dir_pattern,
                                 token_data=token_data_variant_cleaned
                             )
+                            logger.debug(f"OUTPUT_ORG_DEBUG: Variants - Using context.output_base_path = {context.output_base_path} for final_variant_path construction.") # Added
                             final_variant_path = Path(context.output_base_path) / Path(relative_dir_path_str_variant) / Path(output_filename_variant)
+                            logger.debug(f"OUTPUT_ORG_DEBUG: Variants - Constructed final_variant_path = {final_variant_path}") # Added
                             final_variant_path.parent.mkdir(parents=True, exist_ok=True)
 
                             if final_variant_path.exists() and not overwrite_existing:
@@ -169,7 +179,9 @@ class OutputOrganizationStage(ProcessingStage):
                             pattern_string=output_dir_pattern,
                             token_data=token_data_cleaned
                         )
+                        logger.debug(f"OUTPUT_ORG_DEBUG: SingleFile - Using context.output_base_path = {context.output_base_path} for final_path construction.") # Added
                         final_path = Path(context.output_base_path) / Path(relative_dir_path_str) / Path(output_filename)
+                        logger.debug(f"OUTPUT_ORG_DEBUG: SingleFile - Constructed final_path = {final_path}") # Added
                         final_path.parent.mkdir(parents=True, exist_ok=True)
 
                         if final_path.exists() and not overwrite_existing:
@@ -245,10 +257,12 @@ class OutputOrganizationStage(ProcessingStage):
                             token_data=base_token_data_cleaned
                         )
                         # Destination: <output_base_path>/<asset_base_output_dir_str>/<extra_subdir_name>/<original_filename>
+                        logger.debug(f"OUTPUT_ORG_DEBUG: ExtraFiles - Using context.output_base_path = {context.output_base_path} for final_dest_path construction.") # Added
                         final_dest_path = (Path(context.output_base_path) /
                                            Path(asset_base_output_dir_str) /
                                            Path(extra_subdir_name) /
                                            source_file_path.name) # Use original filename
+                        logger.debug(f"OUTPUT_ORG_DEBUG: ExtraFiles - Constructed final_dest_path = {final_dest_path}") # Added
 
                         final_dest_path.parent.mkdir(parents=True, exist_ok=True)
 

processing/pipeline/stages/prepare_processing_items.py

@@ -1,21 +1,69 @@
 import logging
-from typing import List, Union, Optional
+from typing import List, Union, Optional, Tuple, Dict # Added Dict
+from pathlib import Path # Added Path
 
 from .base_stage import ProcessingStage
 from ..asset_context import AssetProcessingContext, MergeTaskDefinition
-from rule_structure import FileRule # Assuming FileRule is imported correctly
+from rule_structure import FileRule, ProcessingItem # Added ProcessingItem
+from processing.utils import image_processing_utils as ipu # Added ipu
 
 log = logging.getLogger(__name__)
 
 class PrepareProcessingItemsStage(ProcessingStage):
     """
-    Identifies and prepares a unified list of items (FileRule, MergeTaskDefinition)
-    to be processed in subsequent stages. Performs initial validation.
+    Identifies and prepares a unified list of ProcessingItem and MergeTaskDefinition objects
+    to be processed in subsequent stages. Performs initial validation and explodes
+    FileRules into specific ProcessingItems for each required output variant.
     """
 
+    def _get_target_resolutions(self, source_w: int, source_h: int, config_resolutions: dict, file_rule: FileRule) -> Dict[str, int]:
+        """
+        Determines the target output resolutions for a given source image.
+        Placeholder logic: Uses all config resolutions smaller than or equal to source, plus PREVIEW if smaller.
+        Needs to be refined to consider FileRule.resolution_override and actual project requirements.
+        """
+        # For now, very basic logic:
+        # If FileRule has a resolution_override (e.g., (1024,1024)), that might be the *only* target.
+        # This needs to be clarified. Assuming override means *only* that size.
+        if file_rule.resolution_override and isinstance(file_rule.resolution_override, tuple) and len(file_rule.resolution_override) == 2:
+            # How to get a "key" for an arbitrary override? For now, skip if overridden.
+            # This part of the design (how overrides interact with standard resolutions) is unclear.
+            # Let's assume for now that if resolution_override is set, we don't generate standard named resolutions.
+            # This is likely incorrect for a full implementation.
+            log.warning(f"FileRule '{file_rule.file_path}' has resolution_override. Standard resolution key generation skipped (needs design refinement).")
+            return {}
+
+
+        target_res = {}
+        max_source_dim = max(source_w, source_h)
+
+        for key, res_val in config_resolutions.items():
+            if key == "PREVIEW": # Always consider PREVIEW if its value is smaller
+                if res_val < max_source_dim : # Or just always include PREVIEW? For now, if smaller.
+                     target_res[key] = res_val
+            elif res_val <= max_source_dim:
+                target_res[key] = res_val
+        
+        # Ensure PREVIEW is included if it's defined and smaller than the smallest other target, or if no other targets.
+        # This logic is still a bit naive.
+        if "PREVIEW" in config_resolutions and config_resolutions["PREVIEW"] < max_source_dim:
+            if not target_res or config_resolutions["PREVIEW"] < min(v for k,v in target_res.items() if k != "PREVIEW" and isinstance(v,int)):
+                 target_res["PREVIEW"] = config_resolutions["PREVIEW"]
+        elif "PREVIEW" in config_resolutions and not target_res : # if only preview is applicable
+             if config_resolutions["PREVIEW"] <= max_source_dim:
+                  target_res["PREVIEW"] = config_resolutions["PREVIEW"]
+
+
+        if not target_res and max_source_dim > 0 : # If no standard res is smaller, but image exists
+             log.debug(f"No standard resolutions from config are <= source dimension {max_source_dim}. Only LOWRES (if applicable) or PREVIEW (if smaller) might be generated.")
+        
+        log.debug(f"Determined target resolutions for source {source_w}x{source_h}: {target_res}")
+        return target_res
+
+
     def execute(self, context: AssetProcessingContext) -> AssetProcessingContext:
         """
-        Populates context.processing_items with FileRule and MergeTaskDefinition objects.
+        Populates context.processing_items with ProcessingItem and MergeTaskDefinition objects.
         """
         asset_name_for_log = context.asset_rule.asset_name if context.asset_rule else "Unknown Asset"
         log.info(f"Asset '{asset_name_for_log}': Preparing processing items...")
@@ -25,72 +73,135 @@ class PrepareProcessingItemsStage(ProcessingStage):
             context.processing_items = []
             return context
 
-        items_to_process: List[Union[FileRule, MergeTaskDefinition]] = []
+        # Output list will now be List[Union[ProcessingItem, MergeTaskDefinition]]
+        items_to_process: List[Union[ProcessingItem, MergeTaskDefinition]] = []
         preparation_failed = False
+        config = context.config_obj
 
-        # --- Add regular files ---
+        # --- Process FileRules into ProcessingItems ---
         if context.files_to_process:
-            # Validate source path early for regular files
             source_path_valid = True
             if not context.source_rule or not context.source_rule.input_path:
-                log.error(f"Asset '{asset_name_for_log}': SourceRule or SourceRule.input_path is not set. Cannot process regular files.")
+                log.error(f"Asset '{asset_name_for_log}': SourceRule or SourceRule.input_path is not set.")
                 source_path_valid = False
-                preparation_failed = True # Mark as failed if source path is missing
+                preparation_failed = True
                 context.status_flags['prepare_items_failed_reason'] = "SourceRule.input_path missing"
             elif not context.workspace_path or not context.workspace_path.is_dir():
-                 log.error(f"Asset '{asset_name_for_log}': Workspace path '{context.workspace_path}' is not a valid directory. Cannot process regular files.")
+                 log.error(f"Asset '{asset_name_for_log}': Workspace path '{context.workspace_path}' is invalid.")
                  source_path_valid = False
-                 preparation_failed = True # Mark as failed if workspace path is bad
+                 preparation_failed = True
                  context.status_flags['prepare_items_failed_reason'] = "Workspace path invalid"
 
             if source_path_valid:
                 for file_rule in context.files_to_process:
-                    # Basic validation for FileRule itself
+                    log_prefix_fr = f"Asset '{asset_name_for_log}', FileRule '{file_rule.file_path}'"
                     if not file_rule.file_path:
-                         log.warning(f"Asset '{asset_name_for_log}': Skipping FileRule with empty file_path.")
-                         continue # Skip this specific rule, but don't fail the whole stage
-                    items_to_process.append(file_rule)
-                log.debug(f"Asset '{asset_name_for_log}': Added {len(context.files_to_process)} potential FileRule items.")
-            else:
-                 log.warning(f"Asset '{asset_name_for_log}': Skipping addition of all FileRule items due to invalid source/workspace path.")
+                         log.warning(f"{log_prefix_fr}: Skipping FileRule with empty file_path.")
+                         continue
+                    
+                    item_type = file_rule.item_type_override or file_rule.item_type
+                    if not item_type or item_type == "EXTRA" or not item_type.startswith("MAP_"):
+                        log.debug(f"{log_prefix_fr}: Item type is '{item_type}'. Not creating map ProcessingItems.")
+                        # Optionally, create a different kind of ProcessingItem for EXTRAs if they need pipeline processing
+                        continue
+
+                    source_image_path = context.workspace_path / file_rule.file_path
+                    if not source_image_path.is_file():
+                        log.error(f"{log_prefix_fr}: Source image file not found at '{source_image_path}'. Skipping this FileRule.")
+                        preparation_failed = True # Individual file error can contribute to overall stage failure
+                        context.status_flags.setdefault('prepare_items_file_errors', []).append(str(source_image_path))
+                        continue
+                    
+                    # Load image data to get dimensions and for LOWRES variant
+                    # This data will be passed to subsequent stages via ProcessingItem.
+                    # Consider caching this load if RegularMapProcessorStage also loads.
+                    # For now, load here as dimensions are needed for LOWRES decision.
+                    log.debug(f"{log_prefix_fr}: Loading image from '{source_image_path}' to determine dimensions and prepare items.")
+                    source_image_data = ipu.load_image(str(source_image_path))
+                    if source_image_data is None:
+                        log.error(f"{log_prefix_fr}: Failed to load image from '{source_image_path}'. Skipping this FileRule.")
+                        preparation_failed = True
+                        context.status_flags.setdefault('prepare_items_file_errors', []).append(f"Failed to load {source_image_path}")
+                        continue
+                    
+                    orig_h, orig_w = source_image_data.shape[:2]
+                    original_dimensions_wh = (orig_w, orig_h)
+                    source_bit_depth = ipu.get_image_bit_depth(str(source_image_path)) # Get bit depth from file
+                    source_channels = ipu.get_image_channels(source_image_data)
 
 
-        # --- Add merged tasks ---
-        # --- Add merged tasks from global configuration ---
-        # merged_image_tasks are expected to be loaded into context.config_obj
-        # by the Configuration class from app_settings.json.
+                    # Determine standard resolutions to generate
+                    # This logic needs to be robust and consider file_rule.resolution_override, etc.
+                    # Using a placeholder _get_target_resolutions for now.
+                    target_resolutions = self._get_target_resolutions(orig_w, orig_h, config.image_resolutions, file_rule)
 
-        merged_tasks_list = getattr(context.config_obj, 'map_merge_rules', None)
+                    for res_key, _res_val in target_resolutions.items():
+                        pi = ProcessingItem(
+                            source_file_info_ref=str(source_image_path), # Using full path as ref
+                            map_type_identifier=item_type,
+                            resolution_key=res_key,
+                            image_data=source_image_data.copy(), # Give each PI its own copy
+                            original_dimensions=original_dimensions_wh,
+                            current_dimensions=original_dimensions_wh,
+                            bit_depth=source_bit_depth,
+                            channels=source_channels,
+                            status="Pending"
+                        )
+                        items_to_process.append(pi)
+                        log.debug(f"{log_prefix_fr}: Created standard ProcessingItem: {pi.map_type_identifier}_{pi.resolution_key}")
 
+                    # Create LOWRES variant if applicable
+                    if config.enable_low_resolution_fallback and max(orig_w, orig_h) < config.low_resolution_threshold:
+                        # Check if a LOWRES item for this source_file_info_ref already exists (e.g. if target_resolutions was empty)
+                        # This check is important if _get_target_resolutions might return empty for small images.
+                        # A more robust way is to ensure LOWRES is distinct from standard resolutions.
+                        
+                        # Avoid duplicate LOWRES if _get_target_resolutions somehow already made one (unlikely with current placeholder)
+                        is_lowres_already_added = any(p.resolution_key == "LOWRES" and p.source_file_info_ref == str(source_image_path) for p in items_to_process if isinstance(p, ProcessingItem))
+
+                        if not is_lowres_already_added:
+                            pi_lowres = ProcessingItem(
+                                source_file_info_ref=str(source_image_path),
+                                map_type_identifier=item_type,
+                                resolution_key="LOWRES",
+                                image_data=source_image_data.copy(), # Fresh copy for LOWRES
+                                original_dimensions=original_dimensions_wh,
+                                current_dimensions=original_dimensions_wh,
+                                bit_depth=source_bit_depth,
+                                channels=source_channels,
+                                status="Pending"
+                            )
+                            items_to_process.append(pi_lowres)
+                            log.info(f"{log_prefix_fr}: Created LOWRES ProcessingItem because {orig_w}x{orig_h} < {config.low_resolution_threshold}px threshold.")
+                        else:
+                            log.debug(f"{log_prefix_fr}: LOWRES item for this source already added by target resolution logic. Skipping duplicate LOWRES creation.")
+                    elif config.enable_low_resolution_fallback:
+                         log.debug(f"{log_prefix_fr}: Image {orig_w}x{orig_h} not below LOWRES threshold {config.low_resolution_threshold}px.")
+
+
+            else: # Source path not valid
+                 log.warning(f"Asset '{asset_name_for_log}': Skipping creation of ProcessingItems from FileRules due to invalid source/workspace path.")
+
+        # --- Add MergeTaskDefinitions --- (This part remains largely the same)
+        merged_tasks_list = getattr(config, 'map_merge_rules', None)
         if merged_tasks_list and isinstance(merged_tasks_list, list):
             log.debug(f"Asset '{asset_name_for_log}': Found {len(merged_tasks_list)} merge tasks in global config.")
             for task_idx, task_data in enumerate(merged_tasks_list):
                 if isinstance(task_data, dict):
                     task_key = f"merged_task_{task_idx}"
-                    # Basic validation for merge task data: requires output_map_type and an inputs dictionary
                     if not task_data.get('output_map_type') or not isinstance(task_data.get('inputs'), dict):
-                        log.warning(f"Asset '{asset_name_for_log}', Task Index {task_idx}: Skipping merge task due to missing 'output_map_type' or valid 'inputs' dictionary. Task data: {task_data}")
-                        continue # Skip this specific task
-                    log.debug(f"Asset '{asset_name_for_log}', Preparing Merge Task Index {task_idx}: Raw task_data: {task_data}")
+                        log.warning(f"Asset '{asset_name_for_log}', Task Index {task_idx}: Skipping merge task due to missing 'output_map_type' or valid 'inputs'. Task data: {task_data}")
+                        continue
                     merge_def = MergeTaskDefinition(task_data=task_data, task_key=task_key)
-                    log.debug(f"Asset '{asset_name_for_log}': Created MergeTaskDefinition object: {merge_def}")
-                    log.info(f"Asset '{asset_name_for_log}': Successfully CREATED MergeTaskDefinition: Key='{merge_def.task_key}', OutputType='{merge_def.task_data.get('output_map_type', 'N/A')}'")
                     items_to_process.append(merge_def)
+                    log.info(f"Asset '{asset_name_for_log}': Added MergeTaskDefinition: Key='{merge_def.task_key}', OutputType='{merge_def.task_data.get('output_map_type', 'N/A')}'")
                 else:
-                    log.warning(f"Asset '{asset_name_for_log}': Item at index {task_idx} in config_obj.merged_image_tasks is not a dictionary. Skipping. Item: {task_data}")
-            # The log for "Added X potential MergeTaskDefinition items" will be covered by the final log.
-        elif merged_tasks_list is None:
-            log.debug(f"Asset '{asset_name_for_log}': 'merged_image_tasks' not found in config_obj. No global merge tasks to add.")
-        elif not isinstance(merged_tasks_list, list):
-            log.warning(f"Asset '{asset_name_for_log}': 'merged_image_tasks' in config_obj is not a list. Skipping global merge tasks. Type: {type(merged_tasks_list)}")
-        else: # Empty list
-            log.debug(f"Asset '{asset_name_for_log}': 'merged_image_tasks' in config_obj is empty. No global merge tasks to add.")
+                    log.warning(f"Asset '{asset_name_for_log}': Item at index {task_idx} in config.map_merge_rules is not a dict. Skipping. Item: {task_data}")
+        # ... (rest of merge task handling) ...
 
+        if not items_to_process and not preparation_failed: # Check preparation_failed too
+             log.info(f"Asset '{asset_name_for_log}': No valid items (ProcessingItem or MergeTaskDefinition) found to process.")
 
-        if not items_to_process:
-             log.info(f"Asset '{asset_name_for_log}': No valid items found to process after preparation.")
-
-        log.debug(f"Asset '{asset_name_for_log}': Final items_to_process before assigning to context: {items_to_process}")
         context.processing_items = items_to_process
         context.intermediate_results = {} # Initialize intermediate results storage
 

processing/pipeline/stages/regular_map_processor.py

@@ -37,7 +37,7 @@ class RegularMapProcessorStage(ProcessingStage):
         """
         final_internal_map_type = initial_internal_map_type # Default
 
-        base_map_type_match = re.match(r"(MAP_[A-Z]{3})", initial_internal_map_type)
+        base_map_type_match = re.match(r"(MAP_[A-Z]+)", initial_internal_map_type)
         if not base_map_type_match or not asset_rule or not asset_rule.files:
             return final_internal_map_type # Cannot determine suffix without base type or asset rule files
 
@@ -47,7 +47,7 @@ class RegularMapProcessorStage(ProcessingStage):
         peers_of_same_base_type = []
         for fr_asset in asset_rule.files:
             fr_asset_item_type = fr_asset.item_type_override or fr_asset.item_type or "UnknownMapType"
-            fr_asset_base_match = re.match(r"(MAP_[A-Z]{3})", fr_asset_item_type)
+            fr_asset_base_match = re.match(r"(MAP_[A-Z]+)", fr_asset_item_type)
             if fr_asset_base_match and fr_asset_base_match.group(1) == true_base_map_type:
                 peers_of_same_base_type.append(fr_asset)
 
@@ -197,10 +197,17 @@ class RegularMapProcessorStage(ProcessingStage):
             result.final_internal_map_type = final_map_type # Update if Gloss->Rough changed it
             result.transformations_applied = transform_notes
 
+            # --- Determine Resolution Key for LOWRES ---
+            if config.enable_low_resolution_fallback and result.original_dimensions:
+                w, h = result.original_dimensions
+                if max(w, h) < config.low_resolution_threshold:
+                    result.resolution_key = "LOWRES"
+                    log.info(f"{log_prefix}: Image dimensions ({w}x{h}) are below threshold ({config.low_resolution_threshold}px). Flagging as LOWRES.")
+
             # --- Success ---
             result.status = "Processed"
             result.error_message = None
-            log.info(f"{log_prefix}: Successfully processed regular map. Final type: '{result.final_internal_map_type}'.")
+            log.info(f"{log_prefix}: Successfully processed regular map. Final type: '{result.final_internal_map_type}', ResolutionKey: {result.resolution_key}.")
 
         except Exception as e:
             log.exception(f"{log_prefix}: Unhandled exception during processing: {e}")

processing/pipeline/stages/save_variants.py

@@ -23,8 +23,17 @@ class SaveVariantsStage(ProcessingStage):
         Calls isu.save_image_variants with data from input_data.
         """
         internal_map_type = input_data.internal_map_type
-        log_prefix = f"Save Variants Stage (Type: {internal_map_type})"
+        # The input_data for SaveVariantsStage doesn't directly contain the ProcessingItem.
+        # It receives data *derived* from a ProcessingItem by previous stages.
+        # For debugging, we'd need to pass more context or rely on what's in output_filename_pattern_tokens.
+        resolution_key_from_tokens = input_data.output_filename_pattern_tokens.get('resolution', 'UnknownResKey')
+        log_prefix = f"Save Variants Stage (Type: {internal_map_type}, ResKey: {resolution_key_from_tokens})"
+        
         log.info(f"{log_prefix}: Starting.")
+        log.debug(f"{log_prefix}: Input image_data shape: {input_data.image_data.shape if input_data.image_data is not None else 'None'}")
+        log.debug(f"{log_prefix}: Input source_bit_depth_info: {input_data.source_bit_depth_info}")
+        log.debug(f"{log_prefix}: Configured image_resolutions for saving: {input_data.image_resolutions}")
+        log.debug(f"{log_prefix}: Output filename pattern tokens: {input_data.output_filename_pattern_tokens}")
 
         # Initialize output object with default failure state
         result = SaveVariantsOutput(
@@ -64,11 +73,11 @@ class SaveVariantsStage(ProcessingStage):
                 "resolution_threshold_for_jpg": input_data.resolution_threshold_for_jpg, # Added
             }
 
-            log.debug(f"{log_prefix}: Calling save_image_variants utility.")
+            log.debug(f"{log_prefix}: Calling save_image_variants utility with args: {save_args}")
             saved_files_details: List[Dict] = isu.save_image_variants(**save_args)
 
             if saved_files_details:
-                log.info(f"{log_prefix}: Save utility completed successfully. Saved {len(saved_files_details)} variants.")
+                log.info(f"{log_prefix}: Save utility completed successfully. Saved {len(saved_files_details)} variants: {[details.get('filepath') for details in saved_files_details]}")
                 result.saved_files_details = saved_files_details
                 result.status = "Processed"
                 result.error_message = None

processing/utils/image_processing_utils.py

@@ -194,6 +194,16 @@ def get_image_bit_depth(image_path_str: str) -> Optional[int]:
         print(f"Error getting bit depth for {image_path_str}: {e}")
         return None
 
+def get_image_channels(image_data: np.ndarray) -> Optional[int]:
+    """Determines the number of channels in an image."""
+    if image_data is None:
+        return None
+    if len(image_data.shape) == 2: # Grayscale
+        return 1
+    elif len(image_data.shape) == 3: # Color
+        return image_data.shape[2]
+    return None # Unknown shape
+
 def calculate_image_stats(image_data: np.ndarray) -> Optional[Dict]:
     """
     Calculates min, max, mean for a given numpy image array.

projectBrief.md

@@ -0,0 +1,44 @@
+# Project Brief: Asset Processor Tool
+
+## 1. Main Goal & Purpose
+
+The primary goal of the Asset Processor Tool is to provide **CG artists and 3D content teams with a friendly, fast, and flexible interface to process and organize 3D asset source files into a standardized library format.** It automates repetitive and complex tasks involved in preparing assets from various suppliers for use in production pipelines.
+
+## 2. Key Features & Components
+
+*   **Automated Asset Processing:** Ingests 3D asset source files (texture sets, models, etc.) from `.zip`, `.rar`, `.7z` archives, or folders.
+*   **Preset-Driven Workflow:** Utilizes configurable JSON presets to interpret different asset sources (e.g., from various online vendors or internal standards), defining rules for file classification and processing.
+*   **Comprehensive File Operations:**
+    *   **Classification:** Automatically identifies map types (Color, Normal, Roughness, etc.), models, and other file categories based on preset rules.
+    *   **Image Processing:** Performs tasks like image resizing (to standard resolutions like 1K, 2K, 4K, avoiding upscaling), glossiness-to-roughness conversion, normal map green channel inversion (OpenGL/DirectX handling), alpha channel extraction, bit-depth adjustments, and low-resolution fallback generation for small source images.
+    *   **Channel Merging:** Combines channels from different source maps into packed textures (e.g., Normal + Roughness + Metallic into a single NRMRGH map).
+*   **Metadata Generation:** Creates a detailed `metadata.json` file for each processed asset, containing information about maps, categories, processing settings, and more, for downstream tool integration.
+*   **Flexible Output Organization:** Generates a clean, structured output directory based on user-configurable naming patterns and tokens.
+*   **Multiple User Interfaces:**
+    *   **Graphical User Interface (GUI):** The primary interface, designed to be user-friendly, offering drag-and-drop functionality, an integrated preset editor, a live preview table for rule validation and overrides, and clear processing controls.
+    *   **Directory Monitor:** An automated script that watches a specified folder for new asset archives and processes them based on preset names embedded in the archive filename.
+    *   **Command-Line Interface (CLI):** Intended for batch processing and scripting (currently with limited core functionality).
+*   **Optional Blender Integration:** Can automatically run Blender scripts post-processing to create PBR node groups and materials in specified `.blend` files, linking to the newly processed textures.
+*   **Hierarchical Rule System:** Allows for dynamic, granular overrides of preset configurations at the source, asset, or individual file level via the GUI.
+*   **Experimental LLM Prediction:** Includes an option to use a Large Language Model for file interpretation and rule prediction.
+
+## 3. Target Audience
+
+*   **CG Artists:** Individual artists looking for an efficient way to manage and prepare their personal or downloaded asset libraries.
+*   **3D Content Creation Teams:** Studios or groups needing a standardized pipeline for processing and organizing assets from multiple sources.
+*   **Technical Artists/Pipeline Developers:** Who may extend or integrate the tool into broader production workflows.
+
+## 4. Overall Architectural Style & Key Technologies
+
+*   **Core Language:** Python
+*   **GUI Framework:** PySide6
+*   **Configuration:** Primarily JSON-based (application settings, user overrides, type definitions, supplier settings, presets, LLM settings).
+*   **Processing Architecture:** A modular, staged processing pipeline orchestrated by a central engine. Each stage performs a discrete task on an `AssetProcessingContext` object.
+*   **Key Libraries:** OpenCV (image processing), NumPy (numerical operations), py7zr/rarfile (archive handling), watchdog (directory monitoring).
+*   **Design Principles:** Modularity, configurability, and user-friendliness (especially for the GUI).
+
+## 5. Foundational Information
+
+*   The tool aims to significantly reduce manual effort and ensure consistency in asset preparation.
+*   It is designed to be adaptable to various asset sources and pipeline requirements through its extensive configuration options and preset system.
+*   The output `metadata.json` is key for enabling further automation and integration with other tools or digital content creation (DCC) applications.

rule_structure.py

@@ -1,6 +1,7 @@
 import dataclasses
 import json
 from typing import List, Dict, Any, Tuple, Optional
+import numpy as np # Added for ProcessingItem
 @dataclasses.dataclass
 class FileRule:
     file_path: str = None
@@ -10,8 +11,12 @@ class FileRule:
     resolution_override: Tuple[int, int] = None
     channel_merge_instructions: Dict[str, Any] = dataclasses.field(default_factory=dict)
     output_format_override: str = None
+    processing_items: List['ProcessingItem'] = dataclasses.field(default_factory=list) # Added field
 
     def to_json(self) -> str:
+        # Need to handle ProcessingItem serialization if it contains non-serializable types like np.ndarray
+        # For now, assume asdict handles it or it's handled before calling to_json for persistence.
+        # A custom asdict_factory might be needed for robust serialization.
         return json.dumps(dataclasses.asdict(self), indent=4)
 
     @classmethod
@@ -54,4 +59,43 @@ class SourceRule:
         data = json.loads(json_string)
         # Manually deserialize nested AssetRule objects
         data['assets'] = [AssetRule.from_json(json.dumps(asset_data)) for asset_data in data.get('assets', [])]
+        # Need to handle ProcessingItem deserialization if it was serialized
+        # For now, from_json for FileRule doesn't explicitly handle processing_items from JSON.
         return cls(**data)
+
+@dataclasses.dataclass
+class ProcessingItem:
+    """
+    Represents a specific version of an image map to be processed and saved.
+    This could be a standard resolution (1K, 2K), a preview, or a special
+    variant like 'LOWRES'.
+    """
+    source_file_info_ref: str  # Reference to the original SourceFileInfo or unique ID of the source image
+    map_type_identifier: str   # The internal map type (e.g., "MAP_COL", "MAP_ROUGH")
+    resolution_key: str        # The resolution identifier (e.g., "1K", "PREVIEW", "LOWRES")
+    image_data: np.ndarray     # The actual image data for this item
+    original_dimensions: Tuple[int, int] # (width, height) of the source image for this item
+    current_dimensions: Tuple[int, int]  # (width, height) of the image_data in this item
+    target_filename: str = ""  # Will be populated by SaveVariantsStage
+    is_extra: bool = False     # If this item should be treated as an 'extra' file
+    bit_depth: Optional[int] = None
+    channels: Optional[int] = None
+    file_extension: Optional[str] = None # Determined during saving based on format
+    processing_applied_log: List[str] = dataclasses.field(default_factory=list)
+    status: str = "Pending" # e.g., Pending, Processed, Failed
+    error_message: Optional[str] = None
+
+    # __getstate__ and __setstate__ might be needed if we pickle these objects
+    # and np.ndarray causes issues. For JSON, image_data would typically not be serialized.
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Don't pickle image_data if it's large or not needed for state
+        if 'image_data' in state: # Or a more sophisticated check
+            del state['image_data'] # Example: remove it
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Potentially re-initialize or handle missing 'image_data'
+        if 'image_data' not in self.__dict__:
+             self.image_data = None # Or load it if a path was stored instead