Add release package v0.5.0

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Bump version to 0.5.0
2026-01-25 18:35:26 +01:00 · 2026-01-25 18:32:24 +01:00 · 2026-01-25 18:31:36 +01:00 · 2026-01-24 17:01:50 +01:00 · 2026-01-24 16:45:33 +01:00 · 2026-01-24 16:42:39 +01:00
41 changed files with 5385 additions and 2637 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,141 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.5.0] - 2026-01-25
+
+### Added
+
+- Multi-domain licensing support: Customers can now purchase multiple licenses for different domains in a single order
+- Each cart item quantity requires a unique domain at checkout
+- New "Enable Multi-Domain Licensing" setting in WooCommerce > Settings > Licensed Products
+- Multi-domain checkout UI for WooCommerce Blocks checkout
+- DOM injection fallback for checkout domain fields when React component fails to render
+- Grouped license display in customer account page by product/order
+- "Older versions" collapsible section in customer download area
+- Updated email templates to show licenses grouped by product
+
+### Changed
+
+- Customer account licenses page now shows licenses grouped by product package
+- Order meta now stores `_licensed_product_domains` array for multi-domain orders
+- Updated translations with 19 new strings for multi-domain functionality (de_CH)
+- Refactored checkout blocks JavaScript to use ExperimentalOrderMeta slot pattern
+
+### Technical Details
+
+- `CheckoutBlocksIntegration` now uses `registerPlugin` with `woocommerce-checkout` scope
+- `StoreApiExtension` handles both single-domain and multi-domain data formats
+- `CheckoutController` validates unique domains per product in multi-domain mode
+- `AccountController` groups licenses by product for package-style display
+- Backward compatible: existing single-domain orders continue to work
+
+## [0.4.0] - 2026-01-24
+
+### Added
+
+- Self-licensing prevention: Plugin automatically bypasses license validation when the configured license server URL points to the same WordPress installation
+- New `isSelfLicensing()` method in `PluginLicenseChecker` to detect circular licensing scenarios
+- New `normalizeDomain()` helper method for domain comparison (strips www prefix, lowercases)
+
+### Changed
+
+- `isLicenseValid()` and `validateLicense()` now check for self-licensing before attempting validation
+- Cache clearing now also clears the self-licensing check cache
+
+### Technical Details
+
+- Self-licensing detection compares normalized domains of license server URL and current site URL
+- Prevents circular dependency where plugin would try to validate against itself
+- Plugins can only be validated against the original store from which they were obtained
+
+## [0.3.9] - 2026-01-24
+
+### Added
+
+- "Generate Licenses" button in order meta box for admin-created orders
+- "Generate Missing Licenses" button when some products in an order are missing licenses
+- AJAX handler `ajaxGenerateOrderLicenses()` for manual license generation from admin
+- Warning message when order domain is not set before generating licenses
+
+### Fixed
+
+- **Critical:** Licenses are now generated for orders created manually in admin area
+- Previously, licenses were only generated via checkout hooks, leaving admin-created orders without licenses
+
+### Technical Details
+
+- Added `wclp_generate_order_licenses` AJAX action to `OrderLicenseController`
+- Updated `order-licenses.js` with generate button handler and page reload on success
+- Added CSS styles for generate status messages
+- Updated translations (365 strings)
+
+## [0.3.8] - 2026-01-24
+
+### Fixed
+
+- Fixed duplicate German translation string causing `ArgumentCountError` in settings page
+- The notification settings description had duplicated text with two `%s` placeholders
+
+### Changed
+
+- Updated `magdev/wc-licensed-product-client` to latest version (64d215c)
+
+## [0.3.7] - 2026-01-24
+
+### Added
+
+- Download counter for licensed product versions (tracked per version)
+- Download Statistics admin dashboard widget showing total downloads, top products, and top versions
+- New `DownloadWidgetController` class for download statistics widget
+- New `incrementDownloadCount()`, `getTotalDownloadCount()`, and `getDownloadStatistics()` methods in `VersionManager`
+- New `download_count` column in product versions database table
+
+### Fixed
+
+- Dashboard widget "View All Licenses" link now uses correct page slug (`wc-licenses`)
+- Download links in customer account page no longer result in 404 errors (added query var registration)
+- Added `license-download` endpoint registration during plugin activation
+
+### Changed
+
+- Removed redundant "Status Breakdown" section from dashboard widget (info already shown in stat cards)
+- License Types section in dashboard widget now uses card style matching the stats row above
+- Improved dashboard widget visual consistency
+
+### Technical Details
+
+- Added `addDownloadQueryVar()` method to `DownloadController` for proper endpoint registration
+- Updated `Installer::activate()` to register `license-download` endpoint before flushing rewrite rules
+- Updated translations (356 strings)
+
+## [0.3.6] - 2026-01-23
+
+### Security
+
+- Added CSRF protection (nonce verification) to CSV export functionality
+- Fixed IP header spoofing vulnerability in rate limiting - now requires explicit trusted proxy configuration
+- Enabled explicit Twig autoescape for XSS protection
+- Fixed unescaped status values in CSS classes in Twig templates
+
+### Fixed
+
+- Fixed response signing to use recursive key sorting for client compatibility
+- ResponseSigner now recursively sorts nested array keys alphabetically as required by client implementation
+
+### Changed
+
+- Rate limiting now only trusts proxy headers when `WC_LICENSE_TRUSTED_PROXIES` constant is defined
+- Added Cloudflare IP range support via `WC_LICENSE_TRUSTED_PROXIES = 'CLOUDFLARE'` configuration
+- Improved IP detection with CIDR notation support for trusted proxy ranges
+
+### Technical Details
+
+- Added `recursiveKeySort()` method to `ResponseSigner` for proper response signing
+- Added `isTrustedProxy()`, `isCloudflareIp()`, and `ipMatchesCidr()` methods to `RestApiController`
+- Twig environment now explicitly sets `autoescape => 'html'`
+- Export CSV link now includes nonce via `wp_nonce_url()`
+- Added `export_csv_url()` Twig function for generating export URL with nonce
+
 ## [0.3.5] - 2026-01-23

 ### Added
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -36,9 +36,9 @@ This project is proudly **"vibe-coded"** using Claude.AI - the entire codebase w

 No known bugs at the moment.

-### Version 0.4.0
+### Version 0.5.0

- On first plugin activation, get the checksums of all security related files (at least in `src/`) as hashes, store them encrypted on the server and add a mechanism to check the integrity of the files and the license validity periodically, control via wp-cron.
+No changes at the moment.

 ## Technical Stack

@@ -974,3 +974,219 @@ Added admin dashboard widget for license statistics and automatic license expira
 - `autoExpireLicense()` updates status to expired and returns true if changed
 - LicenseExpiredEmail follows same pattern as LicenseExpirationEmail (warning vs expired)
 - Expired notification tracked via user meta to prevent duplicate emails
+
+### 2026-01-23 - Version 0.3.6 - Security Hardening
+
+**Overview:**
+
+Security audit and implementation alignment with client/server documentation. Fixed response signing compatibility, rate limiting security, and XSS prevention.
+
+**Security Fixes:**
+
+- Added CSRF protection (nonce verification) to CSV export functionality
+- Fixed IP header spoofing vulnerability in rate limiting - now requires explicit trusted proxy configuration
+- Enabled explicit Twig autoescape (`'html'`) for XSS protection
+- Fixed unescaped status values in CSS class names in Twig templates
+
+**Implementation Fixes:**
+
+- Fixed response signing to use recursive key sorting for client library compatibility
+- ResponseSigner now recursively sorts nested array keys alphabetically as required by `magdev/wc-licensed-product-client`
+
+**Modified files:**
+
+- `src/Api/ResponseSigner.php` - Added `recursiveKeySort()` method for proper signature generation
+- `src/Api/RestApiController.php` - Added trusted proxy support with `isTrustedProxy()`, `isCloudflareIp()`, `ipMatchesCidr()` methods
+- `src/Plugin.php` - Added explicit `autoescape => 'html'` to Twig environment
+- `src/Admin/AdminController.php` - Added nonce verification to `handleCsvExport()`, added `export_csv_url()` Twig function
+- `templates/frontend/licenses.html.twig` - Added `esc_attr()` for CSS class status
+- `templates/admin/licenses.html.twig` - Added `esc_attr()` for CSS class status, updated export link to use `export_csv_url()`
+
+**Configuration:**
+
+To enable trusted proxy support for rate limiting, add to `wp-config.php`:
+
+```php
+// For Cloudflare
+define('WC_LICENSE_TRUSTED_PROXIES', 'CLOUDFLARE');
+
+// Or for specific IPs/CIDR ranges
+define('WC_LICENSE_TRUSTED_PROXIES', '10.0.0.1,192.168.1.0/24');
+```
+
+**Technical notes:**
+
+- Rate limiting now only trusts proxy headers (`HTTP_CF_CONNECTING_IP`, `HTTP_X_FORWARDED_FOR`, `HTTP_X_REAL_IP`) when `WC_LICENSE_TRUSTED_PROXIES` constant is defined
+- Without trusted proxy configuration, rate limiting uses `REMOTE_ADDR` only (prevents IP spoofing)
+- Cloudflare IP ranges are hardcoded for convenience (as of 2024)
+- CIDR notation supported for custom proxy ranges
+- Recursive key sorting ensures signature compatibility with SecureLicenseClient
+- References: <https://src.bundespruefstelle.ch/magdev/wc-licensed-product-client/raw/branch/main/docs/server-implementation.md>
+
+**Release v0.3.6:**
+
+- Created release package: `releases/wc-licensed-product-0.3.6.zip` (818 KB)
+- SHA256: `b0063f0312759f090e12faba83de730baf4114139d763e46fad2b781d4b38270`
+- Tagged as `v0.3.6` and pushed to `main` branch
+
+### 2026-01-24 - Version 0.3.7 - Dashboard Improvements & Download Counter
+
+**Overview:**
+
+Fixed dashboard widget bugs, improved UI consistency, and added download tracking functionality with a new statistics widget.
+
+**Bug Fixes:**
+
+- Fixed: Dashboard widget "View All Licenses" link used wrong page slug (`wc-licensed-product-licenses` instead of `wc-licenses`)
+- Fixed: Download links in customer account resulted in 404 errors due to missing query var registration
+- Added `license-download` endpoint registration during plugin activation in `Installer::activate()`
+- Added `addDownloadQueryVar()` method to `DownloadController` for proper WordPress endpoint recognition
+
+**UI Improvements:**
+
+- Removed redundant "Status Breakdown" section from license statistics widget (info already shown in stat cards above)
+- Changed License Types section to use card-style layout matching the stats row above
+- Cleaned up unused CSS for status badges
+
+**New Features:**
+
+- Download counter for licensed product versions (tracked per version in database)
+- New Download Statistics admin dashboard widget showing:
+  - Total downloads count
+  - Top 5 products by downloads
+  - Top 5 versions by downloads
+
+**New files:**
+
+- `src/Admin/DownloadWidgetController.php` - Dashboard widget for download statistics
+
+**New methods in VersionManager:**
+
+- `incrementDownloadCount()` - Atomically increment download count for a version
+- `getTotalDownloadCount()` - Get total downloads across all versions
+- `getDownloadStatistics()` - Get download stats grouped by product and version
+
+**Modified files:**
+
+- `src/Installer.php` - Added `download_count` column to versions table, added `license-download` endpoint registration
+- `src/Product/ProductVersion.php` - Added `downloadCount` property and `getDownloadCount()` method
+- `src/Product/VersionManager.php` - Added download counting methods
+- `src/Frontend/DownloadController.php` - Added query var registration, increment download count on file serve
+- `src/Admin/DashboardWidgetController.php` - Fixed URL, removed Status Breakdown, changed License Types to cards
+- `src/Plugin.php` - Added DownloadWidgetController instantiation
+
+**Technical notes:**
+
+- Download count is incremented atomically using SQL `download_count = download_count + 1`
+- Statistics queries use SQL aggregation with product name enrichment via `wc_get_product()`
+- WordPress endpoints require both `add_rewrite_endpoint()` AND `query_vars` filter registration
+- Existing installations need to flush rewrite rules (Settings > Permalinks > Save) or reactivate plugin
+
+**Release v0.3.7:**
+
+- Created release package: `releases/wc-licensed-product-0.3.7.zip` (827 KB)
+- SHA256: `e93b2ab06f6d43c2179167090e07eda5db6809df6e391baece4ceba321cf33f6`
+- Tagged as `v0.3.7` and pushed to `main` branch
+
+### 2026-01-24 - Version 0.3.8 - Translation Bug Fix
+
+**Overview:**
+
+Fixed a critical translation bug that caused the settings page to crash with an `ArgumentCountError`.
+
+**Bug Fix:**
+
+- Fixed: Duplicate German translation string in `wc-licensed-product-de_CH.po` causing `ArgumentCountError` in settings page
+- Root cause: The notification settings description was duplicated in the translation, resulting in two `%s` placeholders when only one argument was passed to `sprintf()`
+- Location: [wc-licensed-product-de_CH.po:322-328](languages/wc-licensed-product-de_CH.po#L322-L328)
+
+**Modified files:**
+
+- `languages/wc-licensed-product-de_CH.po` - Removed duplicated translation string
+- `languages/wc-licensed-product-de_CH.mo` - Recompiled binary translation
+
+**Technical notes:**
+
+- Error was logged to `tmp/fatal-errors-2026-01-24.log`
+- The German `msgstr` contained the same text twice, each with a `%s` placeholder
+- `sprintf()` at `SettingsController.php:221` only provided one argument for the single `%s` in the English source
+- Translation strings with `%s` placeholders must have exactly matching placeholder counts between source and translation
+
+**Dependency Updates:**
+
+- Updated `magdev/wc-licensed-product-client` from `9f513a8` to `64d215c`
+
+**Release v0.3.8:**
+
+- Created release package: `releases/wc-licensed-product-0.3.8.zip` (829 KB)
+- SHA256: `50ad6966c5ab8db2257572084d2d8a820448df62615678e1576696f2c0cb383d`
+- Tagged as `v0.3.8` and pushed to `main` branch
+
+### 2026-01-24 - Version 0.3.9 - Admin Order License Generation Fix
+
+**Overview:**
+
+Fixed a critical bug where licenses were not generated for orders created manually in the WordPress admin area.
+
+**Bug Fix:**
+
+- **Critical:** Licenses are now generated for orders created manually in admin area
+- Previously, licenses were only generated via checkout hooks (`woocommerce_order_status_completed`, `woocommerce_order_status_processing`, `woocommerce_payment_complete`)
+- Admin-created orders bypassed checkout, so the `_licensed_product_domain` meta was never set and licenses were never generated
+
+**Implemented:**
+
+- "Generate Licenses" button in order meta box for admin-created orders
+- "Generate Missing Licenses" button when some products in an order already have licenses
+- Warning message when order domain is not set before generating licenses
+- AJAX handler `ajaxGenerateOrderLicenses()` for manual license generation
+
+**Modified files:**
+
+- `src/Admin/OrderLicenseController.php` - Added Generate button, AJAX handler, CSS styles
+- `assets/js/order-licenses.js` - Added `generateLicenses()` function with page reload on success
+
+**Technical notes:**
+
+- Button only appears when order is paid and domain is set
+- Uses existing `LicenseManager::generateLicense()` which handles duplicate prevention
+- Page reloads after successful generation to show new licenses in table
+- Tracks generated vs skipped licenses for accurate feedback messages
+- Updated translations (365 strings)
+
+**Release v0.3.9:**
+
+- Created release package: `releases/wc-licensed-product-0.3.9.zip` (851 KB)
+- SHA256: `fdb65200c368da380df0cabb3c6ac6419d5b4731cd528f630f9b432a3ba5c586`
+- Tagged as `v0.3.9` and pushed to `main` branch
+
+### 2026-01-24 - Version 0.4.0 - Self-Licensing Prevention
+
+**Overview:**
+
+Added self-licensing prevention to avoid circular dependency when the plugin tries to validate its license against itself.
+
+**Implemented:**
+
+- Self-licensing detection: Plugin automatically bypasses license validation when the configured license server URL points to the same WordPress installation
+- New `isSelfLicensing()` method in `PluginLicenseChecker` to detect circular licensing scenarios
+- New `normalizeDomain()` helper method for domain comparison (strips www prefix, lowercases)
+- Cache property `$isSelfLicensingCached` for efficient repeated checks
+
+**Modified files:**
+
+- `src/License/PluginLicenseChecker.php` - Added self-licensing detection methods and bypass logic
+
+**Technical notes:**
+
+- Self-licensing detection compares normalized domains of license server URL and current site URL
+- Prevents circular dependency where plugin would try to validate against itself
+- Plugins can only be validated against the original store from which they were obtained
+- Bypass check added to both `isLicenseValid()` and `validateLicense()` methods
+- Cache clearing via `clearCache()` also clears the self-licensing check cache
+
+**Release v0.4.0:**
+
+- Created release package: `releases/wc-licensed-product-0.4.0.zip` (852 KB)
+- SHA256: `cf8769c861d77c327f178049d5fac0d4e47679cc1a1d35c5b613e4cd3fb8674f`
+- Tagged as `v0.4.0` and pushed to `main` branch
--- a/README.md
+++ b/README.md
@@ -14,10 +14,13 @@ WC Licensed Product adds a new product type "Licensed Product" to WooCommerce, e
 - **Automatic License Generation**: License keys generated on order completion (format: XXXX-XXXX-XXXX-XXXX)
 - **Domain Binding**: Licenses are bound to customer-specified domains
 - **REST API**: Public endpoints for license validation and management
+- **Response Signing**: Optional HMAC-SHA256 cryptographic signatures for API responses
 - **Version Binding**: Optional binding to major software versions
 - **Expiration Support**: Set license validity periods or lifetime licenses
 - **Rate Limiting**: API endpoints protected with rate limiting (30 requests/minute)
+- **Trusted Proxy Support**: Configurable trusted proxies for accurate rate limiting behind CDNs
 - **Checkout Blocks**: Full support for WooCommerce Checkout Blocks (default since WC 8.3+)
+- **Self-Licensing**: The plugin can validate its own license (for commercial distribution)

 ### Customer Features

@@ -30,6 +33,7 @@ WC Licensed Product adds a new product type "Licensed Product" to WooCommerce, e

 - **License Management**: Full CRUD interface for license management
 - **License Dashboard**: Statistics and analytics (WooCommerce > Reports > Licenses)
+- **Dashboard Widget**: License statistics on WordPress admin dashboard
 - **Search & Filtering**: Search by license key, domain, status, or product
 - **Live Search**: AJAX-powered instant search results
 - **Inline Editing**: Edit license status, expiry, and domain directly in the list
@@ -38,7 +42,10 @@ WC Licensed Product adds a new product type "Licensed Product" to WooCommerce, e
 - **CSV Export/Import**: Export and import licenses via CSV
 - **Order Integration**: View and manage licenses directly from order pages
 - **Expiration Warnings**: Automatic email notifications before license expiration
+- **Auto-Expire**: Daily cron job automatically expires licenses past their expiration date
+- **License Testing**: Test licenses against the API directly from admin interface
 - **Version Management**: Manage multiple versions per product with file attachments
+- **SHA256 Checksums**: File integrity verification with SHA256 hash display
 - **Global Settings**: Default license settings via WooCommerce settings tab
 - **WooCommerce HPOS**: Compatible with High-Performance Order Storage

@@ -103,6 +110,40 @@ When a customer purchases a licensed product, they must enter the domain where t
 3. Upload a CSV file (supports exported format or simplified format)
 4. Choose options: skip header row, update existing licenses

+## Security
+
+The plugin implements several security best practices:
+
+- **Input Sanitization**: All user inputs are sanitized using WordPress functions
+- **Output Escaping**: All output is escaped to prevent XSS attacks
+- **CSRF Protection**: Nonce verification on all forms and AJAX requests
+- **SQL Injection Prevention**: All database queries use prepared statements
+- **Capability Checks**: Admin functions require `manage_woocommerce` capability
+- **Secure Downloads**: File downloads use hash-verified URLs with user authentication
+- **Response Signing**: Optional HMAC-SHA256 signatures for API tamper protection
+
+### Trusted Proxy Configuration
+
+If your server is behind a load balancer, reverse proxy, or CDN (like Cloudflare), you need to configure trusted proxies for accurate rate limiting. Without this, the rate limiter uses the direct connection IP which may be your proxy's IP.
+
+**Configuration (wp-config.php):**
+
+```php
+// For Cloudflare (includes all Cloudflare IP ranges)
+define('WC_LICENSE_TRUSTED_PROXIES', 'CLOUDFLARE');
+
+// For specific proxy IPs
+define('WC_LICENSE_TRUSTED_PROXIES', '10.0.0.1,10.0.0.2');
+
+// For CIDR ranges
+define('WC_LICENSE_TRUSTED_PROXIES', '10.0.0.0/8,192.168.1.0/24');
+
+// Combine multiple methods
+define('WC_LICENSE_TRUSTED_PROXIES', 'CLOUDFLARE,10.0.0.1');
+```
+
+**Note**: Only configure trusted proxies if you actually use them. Without this configuration, rate limiting is more secure against IP spoofing attacks.
+
 ## REST API

 Full API documentation available in `openapi.json` (OpenAPI 3.1 specification).
@@ -117,6 +158,12 @@ When the server is configured with a shared secret, all API responses include cr
 define('WC_LICENSE_SERVER_SECRET', 'your-secure-random-string-min-32-chars');
 ```

+Generate a secure secret using:
+
+```bash
+openssl rand -hex 32
+```
+
 **Response Headers:**

 | Header | Description |
@@ -256,11 +303,12 @@ Content-Type: application/json

 ## Email Notifications

-The plugin sends automatic email notifications:
+The plugin sends automatic email notifications (configurable via WooCommerce > Settings > Emails):

 - **Order Completion**: License keys included in order confirmation emails
 - **Expiration Warning (7 days)**: Reminder sent 7 days before expiration
 - **Expiration Warning (1 day)**: Urgent reminder sent 1 day before expiration
+- **License Expired**: Notification when a license auto-expires

 ## Changelog

--- a/assets/css/frontend.css
+++ b/assets/css/frontend.css
@@ -37,13 +37,196 @@
    color: #383d41;
 }

-/* License Cards */
+/* License Packages */
 .woocommerce-licenses {
    display: flex;
    flex-direction: column;
    gap: 1.5em;
 }

+.license-package {
+    border: 1px solid #e5e5e5;
+    border-radius: 8px;
+    overflow: hidden;
+    background: #fff;
+}
+
+.package-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1em 1.5em;
+    background: #f8f9fa;
+    border-bottom: 1px solid #e5e5e5;
+}
+
+.package-title {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25em;
+}
+
+.package-title h3 {
+    margin: 0;
+    font-size: 1.1em;
+}
+
+.package-title h3 a {
+    color: inherit;
+    text-decoration: none;
+}
+
+.package-title h3 a:hover {
+    text-decoration: underline;
+}
+
+.package-order {
+    font-size: 0.85em;
+    color: #666;
+}
+
+.package-order a {
+    color: #2271b1;
+    text-decoration: none;
+}
+
+.package-order a:hover {
+    text-decoration: underline;
+}
+
+.package-license-count {
+    font-size: 0.9em;
+    color: #666;
+    background: #e9ecef;
+    padding: 0.3em 0.8em;
+    border-radius: 12px;
+}
+
+/* Package Licenses - Two Row Layout */
+.package-licenses {
+    padding: 0;
+}
+
+.license-entry {
+    padding: 1em 1.5em;
+    border-bottom: 1px solid #e5e5e5;
+}
+
+.license-entry:last-child {
+    border-bottom: none;
+}
+
+.license-entry:hover {
+    background-color: #fafafa;
+}
+
+.license-row-primary {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1em;
+    margin-bottom: 0.5em;
+}
+
+.license-key-group {
+    display: flex;
+    align-items: center;
+    gap: 0.75em;
+    flex-shrink: 1;
+    min-width: 0;
+}
+
+.license-entry code.license-key {
+    font-family: 'SF Mono', Monaco, Consolas, monospace;
+    background-color: #f5f5f5;
+    padding: 0.4em 0.75em;
+    border-radius: 4px;
+    font-size: 0.95em;
+    letter-spacing: 0.03em;
+    flex-shrink: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.license-key-group .license-status {
+    flex-shrink: 0;
+}
+
+.license-actions {
+    display: flex;
+    align-items: center;
+    gap: 0.5em;
+    flex-shrink: 0;
+}
+
+.license-row-secondary {
+    display: flex;
+    align-items: center;
+    gap: 1.5em;
+    font-size: 0.9em;
+    color: #666;
+    flex-wrap: wrap;
+}
+
+.license-meta-item {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35em;
+}
+
+.license-meta-item .dashicons {
+    font-size: 14px;
+    width: 14px;
+    height: 14px;
+    color: #999;
+}
+
+.license-domain {
+    color: #333;
+}
+
+.license-expiry .lifetime {
+    color: #28a745;
+    font-weight: 500;
+}
+
+/* Legacy table styles (kept for backwards compatibility) */
+.licenses-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.95em;
+}
+
+.licenses-table th,
+.licenses-table td {
+    padding: 0.75em 1em;
+    text-align: left;
+    border-bottom: 1px solid #e5e5e5;
+}
+
+.licenses-table th {
+    font-weight: 600;
+    background-color: #fafafa;
+    font-size: 0.9em;
+    color: #555;
+}
+
+.licenses-table code.license-key {
+    font-family: 'SF Mono', Monaco, Consolas, monospace;
+    background-color: #f5f5f5;
+    padding: 0.3em 0.6em;
+    border-radius: 4px;
+    font-size: 0.9em;
+    letter-spacing: 0.03em;
+}
+
+.licenses-table .lifetime {
+    color: #28a745;
+    font-weight: 500;
+}
+
+/* Legacy single card styles (kept for backwards compatibility) */
 .license-card {
    border: 1px solid #e5e5e5;
    border-radius: 8px;
@@ -184,12 +367,14 @@
 }

 /* Download Section */
+.package-downloads,
 .license-downloads {
    padding: 1em 1.5em;
    background: #f8f9fa;
    border-top: 1px solid #e5e5e5;
 }

+.package-downloads h4,
 .license-downloads h4 {
    margin: 0 0 0.75em 0;
    font-size: 0.95em;
@@ -282,6 +467,71 @@
    color: #666;
 }

+/* Latest version badge */
+.download-version-badge {
+    display: inline-block;
+    padding: 0.15em 0.5em;
+    margin-left: 0.5em;
+    font-size: 0.75em;
+    font-weight: 600;
+    text-transform: uppercase;
+    background: #d4edda;
+    color: #155724;
+    border-radius: 3px;
+    vertical-align: middle;
+}
+
+/* Older versions collapsible */
+.older-versions-section {
+    margin-top: 0.75em;
+    padding-top: 0.75em;
+    border-top: 1px dashed #ddd;
+}
+
+.older-versions-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35em;
+    padding: 0.4em 0.75em;
+    background: transparent;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 0.85em;
+    color: #666;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.older-versions-toggle:hover {
+    background: #f5f5f5;
+    border-color: #ccc;
+    color: #333;
+}
+
+.older-versions-toggle .dashicons {
+    font-size: 16px;
+    width: 16px;
+    height: 16px;
+    transition: transform 0.2s ease;
+}
+
+.older-versions-toggle[aria-expanded="true"] .dashicons {
+    transform: rotate(180deg);
+}
+
+.older-versions-list {
+    margin-top: 0.75em;
+    padding-left: 0;
+}
+
+.older-versions-list .download-item {
+    opacity: 0.85;
+}
+
+.older-versions-list .download-item:hover {
+    opacity: 1;
+}
+
 /* Domain Field */
 #licensed-product-domain-field {
    margin-top: 2em;
@@ -333,6 +583,52 @@

 /* Responsive */
@media screen and (max-width: 768px) {
+    /* Package header responsive */
+    .package-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.75em;
+    }
+
+    .package-license-count {
+        align-self: flex-start;
+    }
+
+    /* License entry responsive */
+    .license-entry {
+        padding: 1em;
+    }
+
+    .license-row-primary {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.75em;
+    }
+
+    .license-key-group {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5em;
+        width: 100%;
+    }
+
+    .license-entry code.license-key {
+        font-size: 0.85em;
+        word-break: break-all;
+        white-space: normal;
+    }
+
+    .license-actions {
+        align-self: flex-start;
+    }
+
+    .license-row-secondary {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5em;
+    }
+
+    /* Legacy card layout responsive */
    .license-header {
        flex-direction: column;
        align-items: flex-start;
@@ -354,33 +650,44 @@
        flex-wrap: wrap;
    }

+    /* Legacy table responsive */
    .woocommerce-licenses-table,
    .woocommerce-licenses-table thead,
    .woocommerce-licenses-table tbody,
    .woocommerce-licenses-table th,
    .woocommerce-licenses-table td,
-    .woocommerce-licenses-table tr {
+    .woocommerce-licenses-table tr,
+    .licenses-table,
+    .licenses-table thead,
+    .licenses-table tbody,
+    .licenses-table th,
+    .licenses-table td,
+    .licenses-table tr {
        display: block;
    }

-    .woocommerce-licenses-table thead tr {
+    .woocommerce-licenses-table thead tr,
+    .licenses-table thead tr {
        position: absolute;
        top: -9999px;
        left: -9999px;
    }

-    .woocommerce-licenses-table tr {
+    .woocommerce-licenses-table tr,
+    .licenses-table tr {
        border: 1px solid #e5e5e5;
        margin-bottom: 1em;
    }

-    .woocommerce-licenses-table td {
+    .woocommerce-licenses-table td,
+    .licenses-table td {
        border: none;
        position: relative;
        padding-left: 50%;
    }

-    .woocommerce-licenses-table td:before {
+    .woocommerce-licenses-table td:before,
+    .licenses-table td:before {
        content: attr(data-title);
        position: absolute;
        left: 0.75em;
--- a/assets/js/checkout-blocks.js
+++ b/assets/js/checkout-blocks.js
@@ -1,7 +1,8 @@
 /**
 * WooCommerce Checkout Blocks Integration
 *
- * Adds a domain field to the checkout block for licensed products.
+ * Adds domain fields to the checkout block for licensed products.
+ * Supports single domain mode (legacy) and multi-domain mode (per quantity).
 *
 * @package WcLicensedProduct
 */
@@ -9,92 +10,333 @@
 (function () {
    'use strict';

-    const { registerCheckoutBlock } = wc.blocksCheckout;
-    const { createElement, useState, useEffect } = wp.element;
+    // Check dependencies
+    if (typeof wc === 'undefined' ||
+        typeof wc.blocksCheckout === 'undefined' ||
+        typeof wc.wcSettings === 'undefined') {
+        return;
+    }
+
+    const { getSetting } = wc.wcSettings;
+    const { createElement, useState } = wp.element;
    const { TextControl } = wp.components;
    const { __ } = wp.i18n;
-    const { extensionCartUpdate } = wc.blocksCheckout;
-    const { getSetting } = wc.wcSettings;

-    // Get settings passed from PHP
+    // Get available exports from blocksCheckout
+    const { ExperimentalOrderMeta } = wc.blocksCheckout;
+
+    // Get settings from PHP
    const settings = getSetting('wc-licensed-product_data', {});

+    // Check if we have licensed products
+    if (!settings.hasLicensedProducts) {
+        return;
+    }
+
    /**
     * Validate domain format
     */
    function isValidDomain(domain) {
-        if (!domain || domain.length > 255) {
-            return false;
-        }
+        if (!domain || domain.length > 255) return false;
        const pattern = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
        return pattern.test(domain);
    }

    /**
-     * Normalize domain (remove protocol and www)
+     * Normalize domain
     */
    function normalizeDomain(domain) {
-        let normalized = domain.toLowerCase().trim();
-        normalized = normalized.replace(/^https?:\/\//, '');
-        normalized = normalized.replace(/^www\./, '');
-        normalized = normalized.replace(/\/.*$/, '');
-        return normalized;
+        return domain.toLowerCase().trim()
+            .replace(/^https?:\/\//, '')
+            .replace(/^www\./, '')
+            .replace(/\/.*$/, '');
    }

    /**
-     * License Domain Block Component
+     * Single Domain Component
     */
-    const LicenseDomainBlock = ({ checkoutExtensionData, extensions }) => {
+    const SingleDomainField = () => {
        const [domain, setDomain] = useState('');
        const [error, setError] = useState('');
-        const { setExtensionData } = checkoutExtensionData;
-
-        // Only show if cart has licensed products
-        if (!settings.hasLicensedProducts) {
-            return null;
-        }

        const handleChange = (value) => {
            const normalized = normalizeDomain(value);
            setDomain(normalized);

-            // Validate
            if (normalized && !isValidDomain(normalized)) {
                setError(settings.validationError || __('Please enter a valid domain.', 'wc-licensed-product'));
            } else {
                setError('');
            }

-            // Update extension data for server-side processing
-            setExtensionData('wc-licensed-product', 'licensed_product_domain', normalized);
+            // Store in hidden input for form submission
+            const hiddenInput = document.getElementById('wclp-domain-hidden');
+            if (hiddenInput) {
+                hiddenInput.value = normalized;
+            }
        };

        return createElement(
            'div',
-            { className: 'wc-block-components-licensed-product-domain' },
-            createElement(
-                'h3',
-                { className: 'wc-block-components-title' },
+            {
+                className: 'wc-block-components-licensed-product-domain',
+                style: {
+                    padding: '16px',
+                    backgroundColor: '#f0f0f0',
+                    borderRadius: '4px',
+                    marginBottom: '16px',
+                }
+            },
+            createElement('h4', { style: { marginTop: 0, marginBottom: '8px' } },
                settings.sectionTitle || __('License Domain', 'wc-licensed-product')
            ),
+            createElement('p', { style: { marginBottom: '12px', color: '#666', fontSize: '0.9em' } },
+                settings.fieldDescription || __('Enter the domain where you will use the license.', 'wc-licensed-product')
+            ),
            createElement(TextControl, {
-                label: settings.fieldLabel || __('Domain for License Activation', 'wc-licensed-product'),
+                label: settings.singleDomainLabel || __('Domain', 'wc-licensed-product'),
                value: domain,
                onChange: handleChange,
                placeholder: settings.fieldPlaceholder || 'example.com',
-                help: error || settings.fieldDescription || __('Enter the domain where you will use this license.', 'wc-licensed-product'),
+                help: error || '',
                className: error ? 'has-error' : '',
-                required: true,
+            }),
+            createElement('input', {
+                type: 'hidden',
+                id: 'wclp-domain-hidden',
+                name: 'wclp_license_domain',
+                value: domain,
            })
        );
    };

-    // Register the checkout block
-    registerCheckoutBlock({
-        metadata: {
-            name: 'wc-licensed-product/domain-field',
-            parent: ['woocommerce/checkout-contact-information-block'],
-        },
-        component: LicenseDomainBlock,
-    });
+    /**
+     * Multi-Domain Component
+     */
+    const MultiDomainFields = () => {
+        const products = settings.licensedProducts || [];
+        const [domains, setDomains] = useState(() => {
+            const init = {};
+            products.forEach(p => {
+                init[p.product_id] = Array(p.quantity).fill('');
+            });
+            return init;
+        });
+        const [errors, setErrors] = useState({});
+
+        if (!products.length) {
+            return null;
+        }
+
+        const handleChange = (productId, index, value) => {
+            const normalized = normalizeDomain(value);
+            const newDomains = { ...domains };
+            if (!newDomains[productId]) newDomains[productId] = [];
+            newDomains[productId] = [...newDomains[productId]];
+            newDomains[productId][index] = normalized;
+            setDomains(newDomains);
+
+            // Validate
+            const key = `${productId}_${index}`;
+            const newErrors = { ...errors };
+            if (normalized && !isValidDomain(normalized)) {
+                newErrors[key] = settings.validationError || __('Please enter a valid domain.', 'wc-licensed-product');
+            } else {
+                delete newErrors[key];
+            }
+
+            // Check for duplicates within same product
+            const productDomains = newDomains[productId].filter(d => d);
+            const uniqueDomains = new Set(productDomains.map(d => normalizeDomain(d)));
+            if (productDomains.length !== uniqueDomains.size) {
+                const seen = new Set();
+                newDomains[productId].forEach((d, idx) => {
+                    const normalizedD = normalizeDomain(d);
+                    const dupKey = `${productId}_${idx}`;
+                    if (normalizedD && seen.has(normalizedD)) {
+                        newErrors[dupKey] = settings.duplicateError || __('Each license requires a unique domain.', 'wc-licensed-product');
+                    } else if (normalizedD) {
+                        seen.add(normalizedD);
+                    }
+                });
+            }
+
+            setErrors(newErrors);
+
+            // Update hidden field
+            const data = Object.entries(newDomains).map(([pid, doms]) => ({
+                product_id: parseInt(pid, 10),
+                domains: doms.filter(d => d),
+            })).filter(item => item.domains.length > 0);
+
+            const hiddenInput = document.getElementById('wclp-domains-hidden');
+            if (hiddenInput) {
+                hiddenInput.value = JSON.stringify(data);
+            }
+        };
+
+        return createElement(
+            'div',
+            {
+                className: 'wc-block-components-licensed-product-domains',
+                style: {
+                    padding: '16px',
+                    backgroundColor: '#f0f0f0',
+                    borderRadius: '4px',
+                    marginBottom: '16px',
+                }
+            },
+            createElement('h4', { style: { marginTop: 0, marginBottom: '8px' } },
+                settings.sectionTitle || __('License Domains', 'wc-licensed-product')
+            ),
+            createElement('p', { style: { marginBottom: '12px', color: '#666', fontSize: '0.9em' } },
+                settings.fieldDescription || __('Enter a unique domain for each license.', 'wc-licensed-product')
+            ),
+            products.map(product => createElement(
+                'div',
+                {
+                    key: product.product_id,
+                    style: {
+                        marginBottom: '16px',
+                        padding: '12px',
+                        backgroundColor: '#fff',
+                        borderRadius: '4px',
+                    }
+                },
+                createElement('strong', { style: { display: 'block', marginBottom: '8px' } },
+                    product.name + (product.quantity > 1 ? ` (×${product.quantity})` : '')
+                ),
+                Array.from({ length: product.quantity }, (_, i) => {
+                    const key = `${product.product_id}_${i}`;
+                    return createElement(
+                        'div',
+                        { key: i, style: { marginBottom: '8px' } },
+                        createElement(TextControl, {
+                            label: (settings.licenseLabel || __('License %d:', 'wc-licensed-product')).replace('%d', i + 1),
+                            value: domains[product.product_id]?.[i] || '',
+                            onChange: (val) => handleChange(product.product_id, i, val),
+                            placeholder: settings.fieldPlaceholder || 'example.com',
+                            help: errors[key] || '',
+                        })
+                    );
+                })
+            )),
+            createElement('input', {
+                type: 'hidden',
+                id: 'wclp-domains-hidden',
+                name: 'wclp_license_domains',
+                value: '',
+            })
+        );
+    };
+
+    /**
+     * Main License Domains Block
+     */
+    const LicenseDomainsBlock = () => {
+        if (settings.isMultiDomainEnabled) {
+            return createElement(MultiDomainFields);
+        }
+        return createElement(SingleDomainField);
+    };
+
+    // Register using ExperimentalOrderMeta slot
+    if (ExperimentalOrderMeta) {
+        const { registerPlugin } = wp.plugins || {};
+
+        if (registerPlugin) {
+            registerPlugin('wc-licensed-product-domain-fields', {
+                render: () => createElement(
+                    ExperimentalOrderMeta,
+                    {},
+                    createElement(LicenseDomainsBlock)
+                ),
+                scope: 'woocommerce-checkout',
+            });
+        }
+    }
+
+    // Fallback: inject into DOM directly if React approach fails
+    setTimeout(function() {
+        const existingComponent = document.querySelector('.wc-block-components-licensed-product-domain, .wc-block-components-licensed-product-domains');
+        if (existingComponent) {
+            return;
+        }
+
+        const checkoutForm = document.querySelector('.wc-block-checkout, .wc-block-checkout__form, form.checkout');
+        if (!checkoutForm) {
+            return;
+        }
+
+        const contactInfo = document.querySelector('.wc-block-checkout__contact-fields, .wp-block-woocommerce-checkout-contact-information-block');
+        const paymentMethods = document.querySelector('.wc-block-checkout__payment-method, .wp-block-woocommerce-checkout-payment-block');
+
+        let insertionPoint = contactInfo || paymentMethods;
+        if (!insertionPoint) {
+            insertionPoint = checkoutForm.querySelector('.wc-block-components-form');
+        }
+
+        if (!insertionPoint) {
+            return;
+        }
+
+        const container = document.createElement('div');
+        container.id = 'wclp-domain-fields-container';
+        container.className = 'wc-block-components-licensed-product-wrapper';
+        container.style.cssText = 'margin: 20px 0; padding: 16px; background: #f0f0f0; border-radius: 4px;';
+
+        if (settings.isMultiDomainEnabled && settings.licensedProducts) {
+            container.innerHTML = `
+                <h4 style="margin: 0 0 8px 0;">${settings.sectionTitle || 'License Domains'}</h4>
+                <p style="margin-bottom: 12px; color: #666; font-size: 0.9em;">
+                    ${settings.fieldDescription || 'Enter a unique domain for each license.'}
+                </p>
+                ${settings.licensedProducts.map(product => `
+                    <div style="margin-bottom: 16px; padding: 12px; background: #fff; border-radius: 4px;">
+                        <strong style="display: block; margin-bottom: 8px;">
+                            ${product.name}${product.quantity > 1 ? ` (×${product.quantity})` : ''}
+                        </strong>
+                        ${Array.from({ length: product.quantity }, (_, i) => `
+                            <div style="margin-bottom: 8px;">
+                                <label style="display: block; margin-bottom: 4px;">
+                                    ${(settings.licenseLabel || 'License %d:').replace('%d', i + 1)}
+                                </label>
+                                <input type="text"
+                                    name="licensed_domains[${product.product_id}][${i}]"
+                                    placeholder="${settings.fieldPlaceholder || 'example.com'}"
+                                    style="width: 100%; padding: 8px; border: 1px solid #ccc; border-radius: 4px;"
+                                />
+                            </div>
+                        `).join('')}
+                    </div>
+                `).join('')}
+            `;
+        } else {
+            container.innerHTML = `
+                <h4 style="margin: 0 0 8px 0;">${settings.sectionTitle || 'License Domain'}</h4>
+                <p style="margin-bottom: 12px; color: #666; font-size: 0.9em;">
+                    ${settings.fieldDescription || 'Enter the domain where you will use the license.'}
+                </p>
+                <div style="margin-bottom: 8px;">
+                    <label style="display: block; margin-bottom: 4px;">
+                        ${settings.singleDomainLabel || 'Domain'}
+                    </label>
+                    <input type="text"
+                        name="licensed_product_domain"
+                        placeholder="${settings.fieldPlaceholder || 'example.com'}"
+                        style="width: 100%; padding: 8px; border: 1px solid #ccc; border-radius: 4px;"
+                    />
+                </div>
+            `;
+        }
+
+        if (contactInfo) {
+            contactInfo.parentNode.insertBefore(container, contactInfo.nextSibling);
+        } else if (paymentMethods) {
+            paymentMethods.parentNode.insertBefore(container, paymentMethods);
+        } else {
+            insertionPoint.appendChild(container);
+        }
+    }, 2000);
+
 })();
--- a/assets/js/frontend.js
+++ b/assets/js/frontend.js
@@ -25,6 +25,9 @@
            $(document).on('click', '.wclp-modal-close, .wclp-modal-cancel, .wclp-modal-overlay', this.closeTransferModal.bind(this));
            $(document).on('submit', '#wclp-transfer-form', this.submitTransfer.bind(this));

+            // Older versions toggle
+            $(document).on('click', '.older-versions-toggle', this.toggleOlderVersions);
+
            // Close modal on escape key
            $(document).on('keyup', function(e) {
                if (e.key === 'Escape') {
@@ -33,6 +36,20 @@
            });
        },

+        /**
+         * Toggle older versions visibility
+         */
+        toggleOlderVersions: function(e) {
+            e.preventDefault();
+
+            var $btn = $(this);
+            var $list = $btn.siblings('.older-versions-list');
+            var isExpanded = $btn.attr('aria-expanded') === 'true';
+
+            $btn.attr('aria-expanded', !isExpanded);
+            $list.slideToggle(200);
+        },
+
        /**
         * Copy license key to clipboard
         */
--- a/assets/js/order-licenses.js
+++ b/assets/js/order-licenses.js
@@ -16,6 +16,9 @@
            // Order domain save
            $('#wclp-save-order-domain').on('click', this.saveOrderDomain.bind(this));

+            // Generate licenses button
+            $(document).on('click', '#wclp-generate-licenses', this.generateLicenses.bind(this));
+
            // License domain edit/save/cancel
            $(document).on('click', '.wclp-edit-domain-btn', this.startEditDomain);
            $(document).on('click', '.wclp-save-domain-btn', this.saveLicenseDomain.bind(this));
@@ -135,6 +138,54 @@
            $editBtn.show();
        },

+        /**
+         * Generate licenses for order
+         */
+        generateLicenses: function(e) {
+            e.preventDefault();
+
+            var $btn = $(e.currentTarget);
+            var $spinner = $btn.siblings('.spinner');
+            var $status = $btn.siblings('.wclp-generate-status');
+
+            var orderId = $btn.data('order-id');
+
+            $btn.prop('disabled', true);
+            $spinner.addClass('is-active');
+            $status.text('').removeClass('success error');
+
+            $.ajax({
+                url: wclpOrderLicenses.ajaxUrl,
+                type: 'POST',
+                data: {
+                    action: 'wclp_generate_order_licenses',
+                    nonce: wclpOrderLicenses.nonce,
+                    order_id: orderId
+                },
+                success: function(response) {
+                    if (response.success) {
+                        $status.text(response.data.message).addClass('success');
+                        if (response.data.reload) {
+                            // Reload the page after a short delay to show the new licenses
+                            setTimeout(function() {
+                                window.location.reload();
+                            }, 1500);
+                        }
+                    } else {
+                        $status.text(response.data.message || wclpOrderLicenses.strings.error).addClass('error');
+                        $btn.prop('disabled', false);
+                    }
+                },
+                error: function() {
+                    $status.text(wclpOrderLicenses.strings.error).addClass('error');
+                    $btn.prop('disabled', false);
+                },
+                complete: function() {
+                    $spinner.removeClass('is-active');
+                }
+            });
+        },
+
        /**
         * Save license domain
         */
--- a/composer.lock
+++ b/composer.lock
@@ -12,7 +12,7 @@
            "source": {
                "type": "git",
                "url": "https://src.bundespruefstelle.ch/magdev/wc-licensed-product-client.git",
-                "reference": "a3a957914fd6ef74cb479e213d1d3bc0606f496b"
+                "reference": "64d215cb265a64ff318cfbb954dd128b0076dc1d"
            },
            "require": {
                "php": "^8.3",
@@ -52,7 +52,7 @@
                "issues": "https://src.bundespruefstelle.ch/magdev/wc-licensed-product-client/issues",
                "source": "https://src.bundespruefstelle.ch/magdev/wc-licensed-product-client"
            },
-            "time": "2026-01-22T20:05:48+00:00"
+            "time": "2026-01-24T13:32:11+00:00"
        },
        {
            "name": "psr/cache",
@@ -894,16 +894,16 @@
        },
        {
            "name": "twig/twig",
-            "version": "v3.22.2",
+            "version": "v3.23.0",
            "source": {
                "type": "git",
                "url": "https://github.com/twigphp/Twig.git",
-                "reference": "946ddeafa3c9f4ce279d1f34051af041db0e16f2"
+                "reference": "a64dc5d2cc7d6cafb9347f6cd802d0d06d0351c9"
            },
            "dist": {
                "type": "zip",
-                "url": "https://api.github.com/repos/twigphp/Twig/zipball/946ddeafa3c9f4ce279d1f34051af041db0e16f2",
-                "reference": "946ddeafa3c9f4ce279d1f34051af041db0e16f2",
+                "url": "https://api.github.com/repos/twigphp/Twig/zipball/a64dc5d2cc7d6cafb9347f6cd802d0d06d0351c9",
+                "reference": "a64dc5d2cc7d6cafb9347f6cd802d0d06d0351c9",
                "shasum": ""
            },
            "require": {
@@ -957,7 +957,7 @@
            ],
            "support": {
                "issues": "https://github.com/twigphp/Twig/issues",
-                "source": "https://github.com/twigphp/Twig/tree/v3.22.2"
+                "source": "https://github.com/twigphp/Twig/tree/v3.23.0"
            },
            "funding": [
                {
@@ -969,7 +969,7 @@
                    "type": "tidelift"
                }
            ],
-            "time": "2025-12-14T11:28:47+00:00"
+            "time": "2026-01-23T21:00:41+00:00"
        }
    ],
    "packages-dev": [],
--- a/languages/wc-licensed-product-de_CH.mo
+++ b/languages/wc-licensed-product-de_CH.mo
--- a/languages/wc-licensed-product-de_CH.po
+++ b/languages/wc-licensed-product-de_CH.po
--- a/languages/wc-licensed-product.pot
+++ b/languages/wc-licensed-product.pot
--- a/releases/wc-licensed-product-0.3.7.zip
+++ b/releases/wc-licensed-product-0.3.7.zip
--- a/releases/wc-licensed-product-0.3.7.zip.sha256
+++ b/releases/wc-licensed-product-0.3.7.zip.sha256
@@ -0,0 +1 @@
+e93b2ab06f6d43c2179167090e07eda5db6809df6e391baece4ceba321cf33f6  wc-licensed-product-0.3.7.zip
--- a/releases/wc-licensed-product-0.3.9.zip
+++ b/releases/wc-licensed-product-0.3.9.zip
--- a/releases/wc-licensed-product-0.3.9.zip.sha256
+++ b/releases/wc-licensed-product-0.3.9.zip.sha256
@@ -0,0 +1 @@
+fdb65200c368da380df0cabb3c6ac6419d5b4731cd528f630f9b432a3ba5c586  releases/wc-licensed-product-0.3.9.zip
--- a/releases/wc-licensed-product-0.4.0.zip
+++ b/releases/wc-licensed-product-0.4.0.zip
--- a/releases/wc-licensed-product-0.4.0.zip.sha256
+++ b/releases/wc-licensed-product-0.4.0.zip.sha256
@@ -0,0 +1 @@
+cf8769c861d77c327f178049d5fac0d4e47679cc1a1d35c5b613e4cd3fb8674f  wc-licensed-product-0.4.0.zip
--- a/releases/wc-licensed-product-0.5.0.zip
+++ b/releases/wc-licensed-product-0.5.0.zip
--- a/releases/wc-licensed-product-0.5.0.zip.sha256
+++ b/releases/wc-licensed-product-0.5.0.zip.sha256
@@ -0,0 +1 @@
+446804948e5f99d705b548061d5b78180856984c58458640a910ada8f27f5316  wc-licensed-product-0.5.0.zip
--- a/src/Admin/AdminController.php
+++ b/src/Admin/AdminController.php
@@ -572,6 +572,11 @@ final class AdminController
     */
    private function handleCsvExport(): void
    {
+        // Verify nonce for CSRF protection
+        if (!wp_verify_nonce($_GET['_wpnonce'] ?? '', 'export_licenses_csv')) {
+            wp_die(__('Security check failed.', 'wc-licensed-product'));
+        }
+
        if (!current_user_can('manage_woocommerce')) {
            wp_die(__('You do not have permission to export licenses.', 'wc-licensed-product'));
        }
@@ -954,7 +959,7 @@ final class AdminController
                            <span class="dashicons dashicons-admin-network"></span>
                            <?php esc_html_e('Manage Licenses', 'wc-licensed-product'); ?>
                        </a>
-                        <a href="<?php echo esc_url(admin_url('admin.php?page=wc-licenses&action=export_csv')); ?>" class="button">
+                        <a href="<?php echo esc_url(wp_nonce_url(admin_url('admin.php?page=wc-licenses&action=export_csv'), 'export_licenses_csv')); ?>" class="button">
                            <span class="dashicons dashicons-download"></span>
                            <?php esc_html_e('Export to CSV', 'wc-licensed-product'); ?>
                        </a>
@@ -1048,6 +1053,12 @@ final class AdminController
        $this->twig->addFunction(new \Twig\TwigFunction('transfer_nonce', function (): string {
            return wp_create_nonce('transfer_license');
        }));
+        $this->twig->addFunction(new \Twig\TwigFunction('export_csv_url', function (): string {
+            return wp_nonce_url(
+                admin_url('admin.php?page=wc-licenses&action=export_csv'),
+                'export_licenses_csv'
+            );
+        }));

        try {
            echo $this->twig->render('admin/licenses.html.twig', [
@@ -1187,7 +1198,7 @@ final class AdminController
        ?>
        <div class="wrap">
            <h1 class="wp-heading-inline"><?php esc_html_e('Licenses', 'wc-licensed-product'); ?></h1>
-            <a href="<?php echo esc_url(admin_url('admin.php?page=wc-licenses&action=export_csv')); ?>" class="page-title-action">
+            <a href="<?php echo esc_url(wp_nonce_url(admin_url('admin.php?page=wc-licenses&action=export_csv'), 'export_licenses_csv')); ?>" class="page-title-action">
                <span class="dashicons dashicons-download" style="vertical-align: middle;"></span>
                <?php esc_html_e('Export CSV', 'wc-licensed-product'); ?>
            </a>
--- a/src/Admin/DashboardWidgetController.php
+++ b/src/Admin/DashboardWidgetController.php
@@ -55,7 +55,7 @@ final class DashboardWidgetController
    public function renderWidget(): void
    {
        $stats = $this->licenseManager->getStatistics();
-        $licensesUrl = admin_url('admin.php?page=wc-licensed-product-licenses');
+        $licensesUrl = admin_url('admin.php?page=wc-licenses');
        ?>
        <style>
            .wclp-widget-stats {
@@ -96,40 +96,6 @@ final class DashboardWidgetController
                letter-spacing: 0.5px;
                margin-top: 4px;
            }
-            .wclp-widget-divider {
-                border-top: 1px solid #e2e4e7;
-                margin: 16px 0;
-            }
-            .wclp-status-list {
-                display: flex;
-                flex-wrap: wrap;
-                gap: 8px;
-            }
-            .wclp-status-badge {
-                display: inline-flex;
-                align-items: center;
-                gap: 4px;
-                padding: 4px 10px;
-                border-radius: 12px;
-                font-size: 12px;
-                font-weight: 500;
-            }
-            .wclp-status-badge.active {
-                background: #d4edda;
-                color: #155724;
-            }
-            .wclp-status-badge.inactive {
-                background: #e2e3e5;
-                color: #383d41;
-            }
-            .wclp-status-badge.expired {
-                background: #f8d7da;
-                color: #721c24;
-            }
-            .wclp-status-badge.revoked {
-                background: #d6d8db;
-                color: #1b1e21;
-            }
            .wclp-widget-footer {
                margin-top: 16px;
                padding-top: 12px;
@@ -160,61 +126,17 @@ final class DashboardWidgetController
            </div>
        </div>

-        <div class="wclp-widget-divider"></div>
-
-        <h4 style="margin: 0 0 8px 0; font-size: 13px; color: #1d2327;">
-            <?php esc_html_e('Status Breakdown', 'wc-licensed-product'); ?>
-        </h4>
-        <div class="wclp-status-list">
-            <span class="wclp-status-badge active">
-                <span class="dashicons dashicons-yes-alt" style="font-size: 14px; width: 14px; height: 14px;"></span>
-                <?php printf(
-                    esc_html__('Active: %d', 'wc-licensed-product'),
-                    $stats['by_status'][License::STATUS_ACTIVE]
-                ); ?>
-            </span>
-            <span class="wclp-status-badge inactive">
-                <span class="dashicons dashicons-marker" style="font-size: 14px; width: 14px; height: 14px;"></span>
-                <?php printf(
-                    esc_html__('Inactive: %d', 'wc-licensed-product'),
-                    $stats['by_status'][License::STATUS_INACTIVE]
-                ); ?>
-            </span>
-            <span class="wclp-status-badge expired">
-                <span class="dashicons dashicons-clock" style="font-size: 14px; width: 14px; height: 14px;"></span>
-                <?php printf(
-                    esc_html__('Expired: %d', 'wc-licensed-product'),
-                    $stats['by_status'][License::STATUS_EXPIRED]
-                ); ?>
-            </span>
-            <span class="wclp-status-badge revoked">
-                <span class="dashicons dashicons-dismiss" style="font-size: 14px; width: 14px; height: 14px;"></span>
-                <?php printf(
-                    esc_html__('Revoked: %d', 'wc-licensed-product'),
-                    $stats['by_status'][License::STATUS_REVOKED]
-                ); ?>
-            </span>
+        <div class="wclp-widget-stats">
+            <div class="wclp-stat-card">
+                <div class="wclp-stat-number"><?php echo esc_html(number_format_i18n($stats['expiring'])); ?></div>
+                <div class="wclp-stat-label"><?php esc_html_e('Time-limited', 'wc-licensed-product'); ?></div>
+            </div>
+            <div class="wclp-stat-card">
+                <div class="wclp-stat-number"><?php echo esc_html(number_format_i18n($stats['lifetime'])); ?></div>
+                <div class="wclp-stat-label"><?php esc_html_e('Lifetime', 'wc-licensed-product'); ?></div>
+            </div>
        </div>

-        <div class="wclp-widget-divider"></div>
-
-        <h4 style="margin: 0 0 8px 0; font-size: 13px; color: #1d2327;">
-            <?php esc_html_e('License Types', 'wc-licensed-product'); ?>
-        </h4>
-        <p style="margin: 0; font-size: 13px; color: #646970;">
-            <span class="dashicons dashicons-calendar-alt" style="font-size: 14px; width: 14px; height: 14px; vertical-align: text-bottom;"></span>
-            <?php printf(
-                esc_html__('Time-limited: %d', 'wc-licensed-product'),
-                $stats['expiring']
-            ); ?>
-            &nbsp;&nbsp;|&nbsp;&nbsp;
-            <span class="dashicons dashicons-infinity" style="font-size: 14px; width: 14px; height: 14px; vertical-align: text-bottom;"></span>
-            <?php printf(
-                esc_html__('Lifetime: %d', 'wc-licensed-product'),
-                $stats['lifetime']
-            ); ?>
-        </p>
-
        <div class="wclp-widget-footer">
            <a href="<?php echo esc_url($licensesUrl); ?>" class="button button-secondary">
                <?php esc_html_e('View All Licenses', 'wc-licensed-product'); ?>
--- a/src/Admin/DownloadWidgetController.php
+++ b/src/Admin/DownloadWidgetController.php
@@ -0,0 +1,184 @@
+<?php
+/**
+ * Download Statistics Widget Controller
+ *
+ * @package Jeremias\WcLicensedProduct\Admin
+ */
+
+declare(strict_types=1);
+
+namespace Jeremias\WcLicensedProduct\Admin;
+
+use Jeremias\WcLicensedProduct\Product\VersionManager;
+
+/**
+ * Handles the WordPress admin dashboard widget for download statistics
+ */
+final class DownloadWidgetController
+{
+    private VersionManager $versionManager;
+
+    public function __construct(VersionManager $versionManager)
+    {
+        $this->versionManager = $versionManager;
+        $this->registerHooks();
+    }
+
+    /**
+     * Register WordPress hooks
+     */
+    private function registerHooks(): void
+    {
+        add_action('wp_dashboard_setup', [$this, 'registerDashboardWidget']);
+    }
+
+    /**
+     * Register the dashboard widget
+     */
+    public function registerDashboardWidget(): void
+    {
+        if (!current_user_can('manage_woocommerce')) {
+            return;
+        }
+
+        wp_add_dashboard_widget(
+            'wclp_download_statistics',
+            __('Download Statistics', 'wc-licensed-product'),
+            [$this, 'renderWidget']
+        );
+    }
+
+    /**
+     * Render the dashboard widget content
+     */
+    public function renderWidget(): void
+    {
+        $stats = $this->versionManager->getDownloadStatistics();
+        ?>
+        <style>
+            .wclp-download-widget-stats {
+                display: grid;
+                grid-template-columns: 1fr;
+                gap: 12px;
+                margin-bottom: 16px;
+            }
+            .wclp-download-stat-card {
+                background: #f8f9fa;
+                border: 1px solid #e2e4e7;
+                border-radius: 4px;
+                padding: 12px;
+                text-align: center;
+                border-left: 3px solid #2271b1;
+            }
+            .wclp-download-stat-number {
+                font-size: 32px;
+                font-weight: 600;
+                color: #1d2327;
+                line-height: 1.2;
+            }
+            .wclp-download-stat-label {
+                font-size: 12px;
+                color: #646970;
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+                margin-top: 4px;
+            }
+            .wclp-download-list {
+                margin: 0;
+                padding: 0;
+                list-style: none;
+            }
+            .wclp-download-list li {
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                padding: 8px 0;
+                border-bottom: 1px solid #e2e4e7;
+            }
+            .wclp-download-list li:last-child {
+                border-bottom: none;
+            }
+            .wclp-download-list .product-name {
+                font-weight: 500;
+                color: #1d2327;
+                flex: 1;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+                margin-right: 12px;
+            }
+            .wclp-download-list .version-info {
+                font-size: 12px;
+                color: #646970;
+            }
+            .wclp-download-list .download-count {
+                background: #e7f5ff;
+                color: #0a4b78;
+                padding: 2px 8px;
+                border-radius: 10px;
+                font-size: 12px;
+                font-weight: 600;
+                white-space: nowrap;
+            }
+            .wclp-download-section-title {
+                margin: 16px 0 8px 0;
+                font-size: 13px;
+                color: #1d2327;
+                font-weight: 600;
+            }
+            .wclp-no-downloads {
+                color: #646970;
+                font-style: italic;
+                text-align: center;
+                padding: 12px 0;
+            }
+        </style>
+
+        <div class="wclp-download-widget-stats">
+            <div class="wclp-download-stat-card">
+                <div class="wclp-download-stat-number"><?php echo esc_html(number_format_i18n($stats['total'])); ?></div>
+                <div class="wclp-download-stat-label"><?php esc_html_e('Total Downloads', 'wc-licensed-product'); ?></div>
+            </div>
+        </div>
+
+        <h4 class="wclp-download-section-title">
+            <?php esc_html_e('Top Products', 'wc-licensed-product'); ?>
+        </h4>
+        <?php if (!empty($stats['by_product'])): ?>
+            <ul class="wclp-download-list">
+                <?php foreach (array_slice($stats['by_product'], 0, 5) as $product): ?>
+                    <li>
+                        <span class="product-name"><?php echo esc_html($product['product_name']); ?></span>
+                        <span class="download-count">
+                            <?php echo esc_html(number_format_i18n($product['downloads'])); ?>
+                        </span>
+                    </li>
+                <?php endforeach; ?>
+            </ul>
+        <?php else: ?>
+            <p class="wclp-no-downloads"><?php esc_html_e('No downloads yet', 'wc-licensed-product'); ?></p>
+        <?php endif; ?>
+
+        <h4 class="wclp-download-section-title">
+            <?php esc_html_e('Top Versions', 'wc-licensed-product'); ?>
+        </h4>
+        <?php if (!empty($stats['by_version'])): ?>
+            <ul class="wclp-download-list">
+                <?php foreach (array_slice($stats['by_version'], 0, 5) as $version): ?>
+                    <li>
+                        <span class="product-name">
+                            <?php echo esc_html($version['product_name']); ?>
+                            <span class="version-info">v<?php echo esc_html($version['version']); ?></span>
+                        </span>
+                        <span class="download-count">
+                            <?php echo esc_html(number_format_i18n($version['downloads'])); ?>
+                        </span>
+                    </li>
+                <?php endforeach; ?>
+            </ul>
+        <?php else: ?>
+            <p class="wclp-no-downloads"><?php esc_html_e('No downloads yet', 'wc-licensed-product'); ?></p>
+        <?php endif; ?>
+        <?php
+    }
+}
--- a/src/Admin/OrderLicenseController.php
+++ b/src/Admin/OrderLicenseController.php
@@ -36,6 +36,7 @@ final class OrderLicenseController
        // Handle AJAX actions
        add_action('wp_ajax_wclp_update_order_domain', [$this, 'ajaxUpdateOrderDomain']);
        add_action('wp_ajax_wclp_update_license_domain', [$this, 'ajaxUpdateLicenseDomain']);
+        add_action('wp_ajax_wclp_generate_order_licenses', [$this, 'ajaxGenerateOrderLicenses']);

        // Enqueue admin scripts
        add_action('admin_enqueue_scripts', [$this, 'enqueueScripts']);
@@ -93,8 +94,10 @@ final class OrderLicenseController
            return;
        }

-        // Get order domain
-        $orderDomain = $order->get_meta('_licensed_product_domain');
+        // Check for multi-domain format first, then fall back to legacy single domain
+        $multiDomainData = $order->get_meta('_licensed_product_domains');
+        $legacyDomain = $order->get_meta('_licensed_product_domain');
+        $hasMultiDomain = !empty($multiDomainData) && is_array($multiDomainData);

        // Get licenses for this order
        $licenses = $this->licenseManager->getLicensesByOrder($order->get_id());
@@ -103,29 +106,71 @@ final class OrderLicenseController
        ?>
        <div class="wclp-order-licenses">
            <div class="wclp-order-domain-section">
-                <h4><?php esc_html_e('Order Domain', 'wc-licensed-product'); ?></h4>
-                <p class="description">
-                    <?php esc_html_e('The domain specified during checkout. Changing this will not automatically update existing license domains.', 'wc-licensed-product'); ?>
-                </p>
-                <div class="wclp-inline-edit">
-                    <input type="text"
-                           id="wclp-order-domain"
-                           class="regular-text"
-                           value="<?php echo esc_attr($orderDomain); ?>"
-                           data-order-id="<?php echo esc_attr($order->get_id()); ?>"
-                           placeholder="<?php esc_attr_e('example.com', 'wc-licensed-product'); ?>" />
-                    <button type="button" class="button" id="wclp-save-order-domain">
-                        <?php esc_html_e('Save', 'wc-licensed-product'); ?>
-                    </button>
-                    <span class="spinner"></span>
-                    <span class="wclp-status-message"></span>
-                </div>
+                <h4><?php esc_html_e('Order Domains', 'wc-licensed-product'); ?></h4>
+
+                <?php if ($hasMultiDomain): ?>
+                    <p class="description">
+                        <?php esc_html_e('Domains specified during checkout (multi-domain order).', 'wc-licensed-product'); ?>
+                    </p>
+                    <div class="wclp-multi-domain-display" style="margin-top: 10px;">
+                        <?php foreach ($multiDomainData as $item): ?>
+                            <?php
+                            $product = wc_get_product($item['product_id']);
+                            $productName = $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product');
+                            ?>
+                            <div class="wclp-product-domains-item" style="margin-bottom: 10px; padding: 10px; background: #f8f8f8; border-radius: 4px;">
+                                <strong><?php echo esc_html($productName); ?>:</strong><br>
+                                <code><?php echo esc_html(implode(', ', $item['domains'])); ?></code>
+                            </div>
+                        <?php endforeach; ?>
+                    </div>
+                <?php else: ?>
+                    <p class="description">
+                        <?php esc_html_e('The domain specified during checkout. Changing this will not automatically update existing license domains.', 'wc-licensed-product'); ?>
+                    </p>
+                    <div class="wclp-inline-edit">
+                        <input type="text"
+                               id="wclp-order-domain"
+                               class="regular-text"
+                               value="<?php echo esc_attr($legacyDomain); ?>"
+                               data-order-id="<?php echo esc_attr($order->get_id()); ?>"
+                               placeholder="<?php esc_attr_e('example.com', 'wc-licensed-product'); ?>" />
+                        <button type="button" class="button" id="wclp-save-order-domain">
+                            <?php esc_html_e('Save', 'wc-licensed-product'); ?>
+                        </button>
+                        <span class="spinner"></span>
+                        <span class="wclp-status-message"></span>
+                    </div>
+                <?php endif; ?>
            </div>

            <hr />

            <h4><?php esc_html_e('Licenses', 'wc-licensed-product'); ?></h4>

+            <?php
+            // Count expected licenses based on domain data
+            $expectedLicenses = 0;
+            if ($hasMultiDomain) {
+                // Multi-domain: count total domains across all products
+                foreach ($multiDomainData as $item) {
+                    if (isset($item['domains']) && is_array($item['domains'])) {
+                        $expectedLicenses += count($item['domains']);
+                    }
+                }
+            } else {
+                // Legacy: one license per licensed product
+                foreach ($order->get_items() as $item) {
+                    $product = $item->get_product();
+                    if ($product && $product->is_type('licensed')) {
+                        $expectedLicenses++;
+                    }
+                }
+            }
+            $missingLicenses = $expectedLicenses - count($licenses);
+            $hasDomainData = $hasMultiDomain || !empty($legacyDomain);
+            ?>
+
            <?php if (empty($licenses)): ?>
                <p class="description">
                    <?php esc_html_e('No licenses have been generated for this order yet.', 'wc-licensed-product'); ?>
@@ -137,6 +182,20 @@ final class OrderLicenseController
                        <em><?php esc_html_e('Licenses will be generated when the order is marked as paid/completed.', 'wc-licensed-product'); ?></em>
                    <?php endif; ?>
                </p>
+                <?php if ($hasDomainData && $order->is_paid()): ?>
+                    <p style="margin-top: 10px;">
+                        <button type="button" class="button button-primary" id="wclp-generate-licenses" data-order-id="<?php echo esc_attr($order->get_id()); ?>">
+                            <?php esc_html_e('Generate Licenses', 'wc-licensed-product'); ?>
+                        </button>
+                        <span class="spinner" style="float: none; margin-top: 4px;"></span>
+                        <span class="wclp-generate-status"></span>
+                    </p>
+                <?php elseif (!$hasDomainData): ?>
+                    <p class="description" style="margin-top: 10px; color: #d63638;">
+                        <span class="dashicons dashicons-warning"></span>
+                        <?php esc_html_e('Please set the order domain above before generating licenses.', 'wc-licensed-product'); ?>
+                    </p>
+                <?php endif; ?>
            <?php else: ?>
                <table class="widefat striped wclp-licenses-table">
                    <thead>
@@ -223,6 +282,29 @@ final class OrderLicenseController
                    );
                    ?>
                </p>
+
+                <?php if ($missingLicenses > 0 && $hasDomainData && $order->is_paid()): ?>
+                    <p style="margin-top: 10px;">
+                        <span class="dashicons dashicons-warning" style="color: #dba617;"></span>
+                        <?php
+                        printf(
+                            /* translators: %d: Number of missing licenses */
+                            esc_html(_n(
+                                '%d licensed product is missing a license.',
+                                '%d licensed products are missing licenses.',
+                                $missingLicenses,
+                                'wc-licensed-product'
+                            )),
+                            $missingLicenses
+                        );
+                        ?>
+                        <button type="button" class="button" id="wclp-generate-licenses" data-order-id="<?php echo esc_attr($order->get_id()); ?>">
+                            <?php esc_html_e('Generate Missing Licenses', 'wc-licensed-product'); ?>
+                        </button>
+                        <span class="spinner" style="float: none; margin-top: 4px;"></span>
+                        <span class="wclp-generate-status"></span>
+                    </p>
+                <?php endif; ?>
            <?php endif; ?>
        </div>

@@ -248,6 +330,9 @@ final class OrderLicenseController
            .wclp-lifetime { color: #0073aa; font-weight: 500; }
            .wclp-edit-domain-btn { color: #0073aa; text-decoration: none; }
            .wclp-edit-domain-btn .dashicons { font-size: 16px; width: 16px; height: 16px; }
+            .wclp-generate-status { font-style: italic; margin-left: 8px; }
+            .wclp-generate-status.success { color: #46b450; }
+            .wclp-generate-status.error { color: #dc3232; }
        </style>
        <?php
    }
@@ -284,8 +369,9 @@ final class OrderLicenseController
            'strings' => [
                'saving' => __('Saving...', 'wc-licensed-product'),
                'saved' => __('Saved!', 'wc-licensed-product'),
-                'error' => __('Error saving. Please try again.', 'wc-licensed-product'),
+                'error' => __('Error. Please try again.', 'wc-licensed-product'),
                'invalidDomain' => __('Please enter a valid domain.', 'wc-licensed-product'),
+                'generating' => __('Generating...', 'wc-licensed-product'),
            ],
        ]);
    }
@@ -392,4 +478,166 @@ final class OrderLicenseController
        $pattern = '/^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/';
        return (bool) preg_match($pattern, $domain);
    }
+
+    /**
+     * AJAX handler for generating order licenses
+     */
+    public function ajaxGenerateOrderLicenses(): void
+    {
+        check_ajax_referer('wclp_order_license_actions', 'nonce');
+
+        if (!current_user_can('manage_woocommerce')) {
+            wp_send_json_error(['message' => __('Permission denied.', 'wc-licensed-product')]);
+        }
+
+        $orderId = absint($_POST['order_id'] ?? 0);
+
+        if (!$orderId) {
+            wp_send_json_error(['message' => __('Invalid order ID.', 'wc-licensed-product')]);
+        }
+
+        $order = wc_get_order($orderId);
+        if (!$order) {
+            wp_send_json_error(['message' => __('Order not found.', 'wc-licensed-product')]);
+        }
+
+        // Check if order is paid
+        if (!$order->is_paid()) {
+            wp_send_json_error(['message' => __('Order must be paid before licenses can be generated.', 'wc-licensed-product')]);
+        }
+
+        // Check for multi-domain format first
+        $multiDomainData = $order->get_meta('_licensed_product_domains');
+        $legacyDomain = $order->get_meta('_licensed_product_domain');
+
+        if (!empty($multiDomainData) && is_array($multiDomainData)) {
+            // Multi-domain format
+            $result = $this->generateMultiDomainLicenses($order, $multiDomainData);
+        } elseif (!empty($legacyDomain)) {
+            // Legacy single domain format
+            $result = $this->generateLegacyLicenses($order, $legacyDomain);
+        } else {
+            wp_send_json_error(['message' => __('Please set the order domain before generating licenses.', 'wc-licensed-product')]);
+            return;
+        }
+
+        if ($result['generated'] > 0) {
+            wp_send_json_success([
+                'message' => sprintf(
+                    /* translators: %d: Number of licenses generated */
+                    _n(
+                        '%d license generated successfully.',
+                        '%d licenses generated successfully.',
+                        $result['generated'],
+                        'wc-licensed-product'
+                    ),
+                    $result['generated']
+                ),
+                'generated' => $result['generated'],
+                'skipped' => $result['skipped'],
+                'reload' => true,
+            ]);
+        } else {
+            wp_send_json_success([
+                'message' => __('All licenses already exist for this order.', 'wc-licensed-product'),
+                'generated' => 0,
+                'skipped' => $result['skipped'],
+                'reload' => false,
+            ]);
+        }
+    }
+
+    /**
+     * Generate licenses for multi-domain format
+     */
+    private function generateMultiDomainLicenses(\WC_Order $order, array $domainData): array
+    {
+        $generated = 0;
+        $skipped = 0;
+        $orderId = $order->get_id();
+        $customerId = $order->get_customer_id();
+
+        // Index domains by product ID
+        $domainsByProduct = [];
+        foreach ($domainData as $item) {
+            if (isset($item['product_id']) && isset($item['domains']) && is_array($item['domains'])) {
+                $domainsByProduct[(int) $item['product_id']] = $item['domains'];
+            }
+        }
+
+        foreach ($order->get_items() as $item) {
+            $product = $item->get_product();
+            if (!$product || !$product->is_type('licensed')) {
+                continue;
+            }
+
+            $productId = $product->get_id();
+            $domains = $domainsByProduct[$productId] ?? [];
+
+            // Get existing licenses for this product
+            $existingLicenses = $this->licenseManager->getLicensesByOrderAndProduct($orderId, $productId);
+            $existingDomains = array_map(fn($l) => $l->getDomain(), $existingLicenses);
+
+            foreach ($domains as $domain) {
+                $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+
+                // Skip if license already exists for this domain
+                if (in_array($normalizedDomain, $existingDomains, true)) {
+                    $skipped++;
+                    continue;
+                }
+
+                $license = $this->licenseManager->generateLicense(
+                    $orderId,
+                    $productId,
+                    $customerId,
+                    $normalizedDomain
+                );
+
+                if ($license) {
+                    $generated++;
+                }
+            }
+        }
+
+        return ['generated' => $generated, 'skipped' => $skipped];
+    }
+
+    /**
+     * Generate licenses for legacy single domain format
+     */
+    private function generateLegacyLicenses(\WC_Order $order, string $domain): array
+    {
+        $generated = 0;
+        $skipped = 0;
+        $orderId = $order->get_id();
+        $customerId = $order->get_customer_id();
+
+        foreach ($order->get_items() as $item) {
+            $product = $item->get_product();
+            if (!$product || !$product->is_type('licensed')) {
+                continue;
+            }
+
+            // Check if license already exists
+            $existing = $this->licenseManager->getLicenseByOrderAndProduct($orderId, $product->get_id());
+            if ($existing) {
+                $skipped++;
+                continue;
+            }
+
+            $license = $this->licenseManager->generateLicense(
+                $orderId,
+                $product->get_id(),
+                $customerId,
+                $domain
+            );
+
+            if ($license) {
+                $generated++;
+            }
+        }
+
+        return ['generated' => $generated, 'skipped' => $skipped];
+    }
 }
--- a/src/Admin/SettingsController.php
+++ b/src/Admin/SettingsController.php
@@ -202,6 +202,13 @@ final class SettingsController
                'id' => 'wc_licensed_product_default_bind_to_version',
                'default' => 'no',
            ],
+            'enable_multi_domain' => [
+                'name' => __('Enable Multi-Domain Licensing', 'wc-licensed-product'),
+                'type' => 'checkbox',
+                'desc' => __('Allow customers to purchase multiple licenses for different domains at once. Each unit in cart quantity requires a unique domain.', 'wc-licensed-product'),
+                'id' => 'wc_licensed_product_enable_multi_domain',
+                'default' => 'no',
+            ],
            'section_end' => [
                'type' => 'sectionend',
                'id' => 'wc_licensed_product_section_defaults_end',
@@ -387,6 +394,14 @@ final class SettingsController
        return get_option('wc_licensed_product_default_bind_to_version', 'no') === 'yes';
    }

+    /**
+     * Check if multi-domain licensing is enabled
+     */
+    public static function isMultiDomainEnabled(): bool
+    {
+        return get_option('wc_licensed_product_enable_multi_domain', 'no') === 'yes';
+    }
+
    /**
     * Check if expiration warning emails are enabled
     * This checks both the WooCommerce email setting and the old setting for backwards compatibility
--- a/src/Api/ResponseSigner.php
+++ b/src/Api/ResponseSigner.php
@@ -94,8 +94,8 @@ final class ResponseSigner
        $timestamp = time();
        $signingKey = $this->deriveKey($licenseKey);

-        // Sort keys for consistent ordering
-        ksort($data);
+        // Recursively sort keys for consistent ordering (required by client implementation)
+        $data = $this->recursiveKeySort($data);

        // Build signature payload
        $payload = $timestamp . ':' . json_encode(
@@ -109,6 +109,33 @@ final class ResponseSigner
        ];
    }

+    /**
+     * Recursively sort array keys alphabetically
+     *
+     * @param mixed $data The data to sort
+     * @return mixed The sorted data
+     */
+    private function recursiveKeySort(mixed $data): mixed
+    {
+        if (!is_array($data)) {
+            return $data;
+        }
+
+        // Check if array is associative (has string keys)
+        $isAssociative = array_keys($data) !== range(0, count($data) - 1);
+
+        if ($isAssociative) {
+            ksort($data);
+        }
+
+        // Recursively sort nested arrays
+        foreach ($data as $key => $value) {
+            $data[$key] = $this->recursiveKeySort($value);
+        }
+
+        return $data;
+    }
+
    /**
     * Derive a unique signing key for a license
     *
--- a/src/Api/RestApiController.php
+++ b/src/Api/RestApiController.php
@@ -95,29 +95,152 @@ final class RestApiController

    /**
     * Get client IP address
+     *
+     * Security note: Only trust proxy headers when explicitly configured.
+     * Set WC_LICENSE_TRUSTED_PROXIES constant or configure trusted_proxies
+     * in wp-config.php to enable proxy header support.
+     *
+     * @return string Client IP address
     */
    private function getClientIp(): string
    {
-        $headers = [
-            'HTTP_CF_CONNECTING_IP', // Cloudflare
-            'HTTP_X_FORWARDED_FOR',
-            'HTTP_X_REAL_IP',
-            'REMOTE_ADDR',
-        ];
+        // Get the direct connection IP first
+        $remoteAddr = $_SERVER['REMOTE_ADDR'] ?? '0.0.0.0';

-        foreach ($headers as $header) {
-            if (!empty($_SERVER[$header])) {
-                $ips = explode(',', $_SERVER[$header]);
-                $ip = trim($ips[0]);
-                if (filter_var($ip, FILTER_VALIDATE_IP)) {
-                    return $ip;
+        // Only check proxy headers if we're behind a trusted proxy
+        if ($this->isTrustedProxy($remoteAddr)) {
+            // Check headers in order of trust preference
+            $headers = [
+                'HTTP_CF_CONNECTING_IP', // Cloudflare
+                'HTTP_X_FORWARDED_FOR',
+                'HTTP_X_REAL_IP',
+            ];
+
+            foreach ($headers as $header) {
+                if (!empty($_SERVER[$header])) {
+                    $ips = explode(',', $_SERVER[$header]);
+                    $ip = trim($ips[0]);
+                    if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
+                        return $ip;
+                    }
                }
            }
        }

+        // Validate and return direct connection IP
+        if (filter_var($remoteAddr, FILTER_VALIDATE_IP)) {
+            return $remoteAddr;
+        }
+
        return '0.0.0.0';
    }

+    /**
+     * Check if the given IP is a trusted proxy
+     *
+     * @param string $ip The IP address to check
+     * @return bool Whether the IP is a trusted proxy
+     */
+    private function isTrustedProxy(string $ip): bool
+    {
+        // Check if trusted proxies are configured
+        if (!defined('WC_LICENSE_TRUSTED_PROXIES')) {
+            return false;
+        }
+
+        $trustedProxies = WC_LICENSE_TRUSTED_PROXIES;
+
+        // Handle string constant (comma-separated list)
+        if (is_string($trustedProxies)) {
+            $trustedProxies = array_map('trim', explode(',', $trustedProxies));
+        }
+
+        if (!is_array($trustedProxies)) {
+            return false;
+        }
+
+        // Check for special keywords
+        if (in_array('CLOUDFLARE', $trustedProxies, true)) {
+            // Cloudflare IP ranges (simplified - in production, fetch from Cloudflare API)
+            if ($this->isCloudflareIp($ip)) {
+                return true;
+            }
+        }
+
+        // Check direct IP match or CIDR notation
+        foreach ($trustedProxies as $proxy) {
+            if ($proxy === $ip) {
+                return true;
+            }
+
+            // Support CIDR notation
+            if (str_contains($proxy, '/') && $this->ipMatchesCidr($ip, $proxy)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if IP is in Cloudflare range
+     *
+     * @param string $ip The IP to check
+     * @return bool Whether IP belongs to Cloudflare
+     */
+    private function isCloudflareIp(string $ip): bool
+    {
+        // Cloudflare IPv4 ranges (as of 2024)
+        $cloudflareRanges = [
+            '173.245.48.0/20',
+            '103.21.244.0/22',
+            '103.22.200.0/22',
+            '103.31.4.0/22',
+            '141.101.64.0/18',
+            '108.162.192.0/18',
+            '190.93.240.0/20',
+            '188.114.96.0/20',
+            '197.234.240.0/22',
+            '198.41.128.0/17',
+            '162.158.0.0/15',
+            '104.16.0.0/13',
+            '104.24.0.0/14',
+            '172.64.0.0/13',
+            '131.0.72.0/22',
+        ];
+
+        foreach ($cloudflareRanges as $range) {
+            if ($this->ipMatchesCidr($ip, $range)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if an IP matches a CIDR range
+     *
+     * @param string $ip The IP to check
+     * @param string $cidr The CIDR range (e.g., "192.168.1.0/24")
+     * @return bool Whether the IP matches the CIDR range
+     */
+    private function ipMatchesCidr(string $ip, string $cidr): bool
+    {
+        [$subnet, $bits] = explode('/', $cidr);
+
+        if (!filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) ||
+            !filter_var($subnet, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+            return false;
+        }
+
+        $ipLong = ip2long($ip);
+        $subnetLong = ip2long($subnet);
+        $mask = -1 << (32 - (int) $bits);
+
+        return ($ipLong & $mask) === ($subnetLong & $mask);
+    }
+
    /**
     * Register REST API routes
     */
--- a/src/Checkout/CheckoutBlocksIntegration.php
+++ b/src/Checkout/CheckoutBlocksIntegration.php
@@ -10,6 +10,7 @@ declare(strict_types=1);
 namespace Jeremias\WcLicensedProduct\Checkout;

 use Automattic\WooCommerce\Blocks\Integrations\IntegrationInterface;
+use Jeremias\WcLicensedProduct\Admin\SettingsController;

 /**
 * Integration with WooCommerce Checkout Blocks
@@ -30,7 +31,7 @@ final class CheckoutBlocksIntegration implements IntegrationInterface
    public function initialize(): void
    {
        $this->registerScripts();
-        $this->registerBlockExtensionData();
+        $this->registerAdditionalCheckoutFields();
    }

    /**
@@ -45,7 +46,7 @@ final class CheckoutBlocksIntegration implements IntegrationInterface
            wp_register_script(
                'wc-licensed-product-checkout-blocks',
                $scriptUrl,
-                ['wc-blocks-checkout', 'wp-element', 'wp-components', 'wp-i18n'],
+                ['wc-blocks-checkout', 'wp-element', 'wp-components', 'wp-i18n', 'wp-plugins', 'wp-data'],
                WC_LICENSED_PRODUCT_VERSION,
                true
            );
@@ -59,20 +60,33 @@ final class CheckoutBlocksIntegration implements IntegrationInterface
    }

    /**
-     * Register block extension data
+     * Register additional checkout fields using WooCommerce Blocks API
     */
-    private function registerBlockExtensionData(): void
+    private function registerAdditionalCheckoutFields(): void
    {
-        // Pass data to the checkout block script
-        add_filter(
-            'woocommerce_blocks_checkout_block_registration_data',
-            function (array $data): array {
-                $data['wc-licensed-product'] = [
-                    'hasLicensedProducts' => $this->cartHasLicensedProducts(),
-                ];
-                return $data;
+        add_action('woocommerce_blocks_loaded', function (): void {
+            // Check if the function exists (WooCommerce 8.9+)
+            if (!function_exists('woocommerce_register_additional_checkout_field')) {
+                return;
            }
-        );
+
+            // Register the domain field using WooCommerce's checkout fields API
+            // For single domain mode only (multi-domain uses custom JS component)
+            if (!SettingsController::isMultiDomainEnabled()) {
+                woocommerce_register_additional_checkout_field([
+                    'id' => 'wc-licensed-product/domain',
+                    'label' => __('License Domain', 'wc-licensed-product'),
+                    'location' => 'order',
+                    'type' => 'text',
+                    'required' => false,
+                    'attributes' => [
+                        'placeholder' => __('example.com', 'wc-licensed-product'),
+                        'pattern' => '^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$',
+                        'title' => __('Enter a valid domain (without http:// or www)', 'wc-licensed-product'),
+                    ],
+                ]);
+            }
+        });
    }

    /**
@@ -96,13 +110,23 @@ final class CheckoutBlocksIntegration implements IntegrationInterface
     */
    public function get_script_data(): array
    {
+        $isMultiDomain = SettingsController::isMultiDomainEnabled();
+
        return [
            'hasLicensedProducts' => $this->cartHasLicensedProducts(),
-            'fieldLabel' => __('Domain for License Activation', 'wc-licensed-product'),
+            'licensedProducts' => $this->getLicensedProductsFromCart(),
+            'isMultiDomainEnabled' => $isMultiDomain,
            'fieldPlaceholder' => __('example.com', 'wc-licensed-product'),
-            'fieldDescription' => __('Enter the domain where you will use this license (without http:// or www).', 'wc-licensed-product'),
-            'sectionTitle' => __('License Domain', 'wc-licensed-product'),
-            'validationError' => __('Please enter a valid domain for your license activation.', 'wc-licensed-product'),
+            'fieldDescription' => $isMultiDomain
+                ? __('Enter a unique domain for each license (without http:// or www).', 'wc-licensed-product')
+                : __('Enter the domain where you will use the license (without http:// or www).', 'wc-licensed-product'),
+            'sectionTitle' => $isMultiDomain
+                ? __('License Domains', 'wc-licensed-product')
+                : __('License Domain', 'wc-licensed-product'),
+            'validationError' => __('Please enter a valid domain.', 'wc-licensed-product'),
+            'duplicateError' => __('Each license requires a unique domain.', 'wc-licensed-product'),
+            'licenseLabel' => __('License %d:', 'wc-licensed-product'),
+            'singleDomainLabel' => __('Domain', 'wc-licensed-product'),
        ];
    }

@@ -110,18 +134,34 @@ final class CheckoutBlocksIntegration implements IntegrationInterface
     * Check if cart contains licensed products
     */
    private function cartHasLicensedProducts(): bool
+    {
+        return !empty($this->getLicensedProductsFromCart());
+    }
+
+    /**
+     * Get licensed products from cart with quantities
+     *
+     * @return array<int, array{product_id: int, name: string, quantity: int}>
+     */
+    private function getLicensedProductsFromCart(): array
    {
        if (!WC()->cart) {
-            return false;
+            return [];
        }

+        $licensedProducts = [];
        foreach (WC()->cart->get_cart() as $cartItem) {
            $product = $cartItem['data'];
            if ($product && $product->is_type('licensed')) {
-                return true;
+                $productId = $product->get_id();
+                $licensedProducts[] = [
+                    'product_id' => $productId,
+                    'name' => $product->get_name(),
+                    'quantity' => (int) $cartItem['quantity'],
+                ];
            }
        }

-        return false;
+        return $licensedProducts;
    }
 }
--- a/src/Checkout/CheckoutController.php
+++ b/src/Checkout/CheckoutController.php
@@ -10,6 +10,7 @@ declare(strict_types=1);
 namespace Jeremias\WcLicensedProduct\Checkout;

 use Jeremias\WcLicensedProduct\License\LicenseManager;
+use Jeremias\WcLicensedProduct\Admin\SettingsController;

 /**
 * Handles checkout modifications for licensed products
@@ -50,35 +51,75 @@ final class CheckoutController
     */
    private function cartHasLicensedProducts(): bool
    {
-        if (!WC()->cart) {
-            return false;
-        }
-
-        foreach (WC()->cart->get_cart() as $cartItem) {
-            $product = $cartItem['data'];
-            if ($product && $product->is_type('licensed')) {
-                return true;
-            }
-        }
-
-        return false;
+        return !empty($this->getLicensedProductsFromCart());
    }

    /**
-     * Add domain field to checkout form
+     * Get licensed products from cart with quantities
+     *
+     * @return array<int, array{product_id: int, name: string, quantity: int}>
+     */
+    private function getLicensedProductsFromCart(): array
+    {
+        if (!WC()->cart) {
+            return [];
+        }
+
+        $licensedProducts = [];
+        foreach (WC()->cart->get_cart() as $cartItem) {
+            $product = $cartItem['data'];
+            if ($product && $product->is_type('licensed')) {
+                $productId = $product->get_id();
+                $licensedProducts[$productId] = [
+                    'product_id' => $productId,
+                    'name' => $product->get_name(),
+                    'quantity' => (int) $cartItem['quantity'],
+                ];
+            }
+        }
+
+        return $licensedProducts;
+    }
+
+    /**
+     * Add domain fields to checkout form
+     * Shows multiple domain fields if multi-domain is enabled, otherwise single field
     */
    public function addDomainField(): void
    {
-        if (!$this->cartHasLicensedProducts()) {
+        $licensedProducts = $this->getLicensedProductsFromCart();
+        if (empty($licensedProducts)) {
            return;
        }

+        // Check if multi-domain licensing is enabled
+        if (SettingsController::isMultiDomainEnabled()) {
+            $this->renderMultiDomainFields($licensedProducts);
+        } else {
+            $this->renderSingleDomainField();
+        }
+    }
+
+    /**
+     * Render single domain field (legacy mode)
+     */
+    private function renderSingleDomainField(): void
+    {
+        $savedValue = '';
+
+        // Check POST data first (validation failure case)
+        if (isset($_POST['licensed_product_domain'])) {
+            $savedValue = sanitize_text_field($_POST['licensed_product_domain']);
+        } elseif (WC()->session) {
+            $savedValue = WC()->session->get('licensed_product_domain', '');
+        }
+
        ?>
        <div id="licensed-product-domain-field">
            <h3><?php esc_html_e('License Domain', 'wc-licensed-product'); ?></h3>
            <p class="form-row form-row-wide">
                <label for="licensed_product_domain">
-                    <?php esc_html_e('Domain for License Activation', 'wc-licensed-product'); ?>
+                    <?php esc_html_e('Domain', 'wc-licensed-product'); ?>
                    <abbr class="required" title="<?php esc_attr_e('required', 'wc-licensed-product'); ?>">*</abbr>
                </label>
                <input
@@ -87,10 +128,10 @@ final class CheckoutController
                    name="licensed_product_domain"
                    id="licensed_product_domain"
                    placeholder="<?php esc_attr_e('example.com', 'wc-licensed-product'); ?>"
-                    value="<?php echo esc_attr(WC()->checkout->get_value('licensed_product_domain')); ?>"
+                    value="<?php echo esc_attr($savedValue); ?>"
                />
                <span class="description">
-                    <?php esc_html_e('Enter the domain where you will use this license (without http:// or www).', 'wc-licensed-product'); ?>
+                    <?php esc_html_e('Enter the domain where you will use the license (without http:// or www).', 'wc-licensed-product'); ?>
                </span>
            </p>
        </div>
@@ -98,62 +139,276 @@ final class CheckoutController
    }

    /**
-     * Validate domain field during checkout
+     * Render multi-domain fields (one per quantity)
+     */
+    private function renderMultiDomainFields(array $licensedProducts): void
+    {
+        ?>
+        <div id="licensed-product-domain-fields">
+            <h3><?php esc_html_e('License Domains', 'wc-licensed-product'); ?></h3>
+            <p class="wclp-domain-description">
+                <?php esc_html_e('Enter a unique domain for each license (without http:// or www).', 'wc-licensed-product'); ?>
+            </p>
+
+            <?php foreach ($licensedProducts as $productId => $productData): ?>
+                <div class="wclp-product-domains" data-product-id="<?php echo esc_attr($productId); ?>">
+                    <h4>
+                        <?php
+                        echo esc_html($productData['name']);
+                        if ($productData['quantity'] > 1) {
+                            printf(' (×%d)', $productData['quantity']);
+                        }
+                        ?>
+                    </h4>
+
+                    <?php for ($i = 0; $i < $productData['quantity']; $i++): ?>
+                        <?php
+                        $fieldName = sprintf('licensed_domains[%d][%d]', $productId, $i);
+                        $fieldId = sprintf('licensed_domain_%d_%d', $productId, $i);
+                        $savedValue = $this->getSavedDomainValue($productId, $i);
+                        ?>
+                        <p class="form-row form-row-wide wclp-domain-row">
+                            <label for="<?php echo esc_attr($fieldId); ?>">
+                                <?php
+                                printf(
+                                    /* translators: %d: license number */
+                                    esc_html__('License %d:', 'wc-licensed-product'),
+                                    $i + 1
+                                );
+                                ?>
+                                <abbr class="required" title="<?php esc_attr_e('required', 'wc-licensed-product'); ?>">*</abbr>
+                            </label>
+                            <input
+                                type="text"
+                                class="input-text wclp-domain-input"
+                                name="<?php echo esc_attr($fieldName); ?>"
+                                id="<?php echo esc_attr($fieldId); ?>"
+                                placeholder="<?php esc_attr_e('example.com', 'wc-licensed-product'); ?>"
+                                value="<?php echo esc_attr($savedValue); ?>"
+                            />
+                        </p>
+                    <?php endfor; ?>
+                </div>
+            <?php endforeach; ?>
+        </div>
+        <style>
+            #licensed-product-domain-fields { margin-bottom: 20px; }
+            #licensed-product-domain-fields h3 { margin-bottom: 10px; }
+            .wclp-domain-description { margin-bottom: 15px; color: #666; }
+            .wclp-product-domains { margin-bottom: 20px; padding: 15px; background: #f8f8f8; border-radius: 4px; }
+            .wclp-product-domains h4 { margin: 0 0 10px 0; font-size: 1em; }
+            .wclp-domain-row { margin-bottom: 10px; }
+            .wclp-domain-row:last-child { margin-bottom: 0; }
+            .wclp-domain-row label { display: block; margin-bottom: 5px; }
+        </style>
+        <?php
+    }
+
+    /**
+     * Get saved domain value from session/POST
+     */
+    private function getSavedDomainValue(int $productId, int $index): string
+    {
+        // Check POST data first (validation failure case)
+        if (isset($_POST['licensed_domains'][$productId][$index])) {
+            return sanitize_text_field($_POST['licensed_domains'][$productId][$index]);
+        }
+
+        // Check session for blocks checkout
+        if (WC()->session) {
+            $sessionDomains = WC()->session->get('licensed_product_domains', []);
+            foreach ($sessionDomains as $item) {
+                if (isset($item['product_id']) && (int) $item['product_id'] === $productId) {
+                    if (isset($item['domains'][$index])) {
+                        return $item['domains'][$index];
+                    }
+                }
+            }
+        }
+
+        return '';
+    }
+
+    /**
+     * Validate domain fields during checkout
     */
    public function validateDomainField(): void
    {
-        if (!$this->cartHasLicensedProducts()) {
+        $licensedProducts = $this->getLicensedProductsFromCart();
+        if (empty($licensedProducts)) {
            return;
        }

-        $domain = isset($_POST['licensed_product_domain'])
-            ? sanitize_text_field($_POST['licensed_product_domain'])
-            : '';
-
-        if (empty($domain)) {
-            wc_add_notice(
-                __('Please enter a domain for your license activation.', 'wc-licensed-product'),
-                'error'
-            );
-            return;
-        }
-
-        // Validate domain format
-        $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
-        if (!$this->isValidDomain($normalizedDomain)) {
-            wc_add_notice(
-                __('Please enter a valid domain name.', 'wc-licensed-product'),
-                'error'
-            );
+        // Check if multi-domain licensing is enabled
+        if (SettingsController::isMultiDomainEnabled()) {
+            $this->validateMultiDomainFields($licensedProducts);
+        } else {
+            $this->validateSingleDomainField();
        }
    }

    /**
-     * Save domain field to order meta
+     * Validate single domain field
     */
-    public function saveDomainField(int $orderId): void
+    private function validateSingleDomainField(): void
    {
-        if (!$this->cartHasLicensedProducts()) {
+        $domain = isset($_POST['licensed_product_domain']) ? sanitize_text_field($_POST['licensed_product_domain']) : '';
+
+        if (empty($domain)) {
+            wc_add_notice(__('Please enter a domain for your license.', 'wc-licensed-product'), 'error');
            return;
        }

-        if (isset($_POST['licensed_product_domain']) && !empty($_POST['licensed_product_domain'])) {
-            $domain = sanitize_text_field($_POST['licensed_product_domain']);
-            $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+        $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+        if (!$this->isValidDomain($normalizedDomain)) {
+            wc_add_notice(__('Please enter a valid domain for your license.', 'wc-licensed-product'), 'error');
+        }
+    }

-            $order = wc_get_order($orderId);
-            if ($order) {
-                $order->update_meta_data('_licensed_product_domain', $normalizedDomain);
-                $order->save();
+    /**
+     * Validate multi-domain fields
+     */
+    private function validateMultiDomainFields(array $licensedProducts): void
+    {
+        $licensedDomains = $_POST['licensed_domains'] ?? [];
+
+        foreach ($licensedProducts as $productId => $productData) {
+            $productDomains = $licensedDomains[$productId] ?? [];
+            $normalizedDomains = [];
+
+            for ($i = 0; $i < $productData['quantity']; $i++) {
+                $domain = isset($productDomains[$i]) ? sanitize_text_field($productDomains[$i]) : '';
+
+                // Check if domain is empty
+                if (empty($domain)) {
+                    wc_add_notice(
+                        sprintf(
+                            /* translators: 1: product name, 2: license number */
+                            __('Please enter a domain for %1$s (License %2$d).', 'wc-licensed-product'),
+                            $productData['name'],
+                            $i + 1
+                        ),
+                        'error'
+                    );
+                    continue;
+                }
+
+                // Validate domain format
+                $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+                if (!$this->isValidDomain($normalizedDomain)) {
+                    wc_add_notice(
+                        sprintf(
+                            /* translators: 1: product name, 2: license number */
+                            __('Please enter a valid domain for %1$s (License %2$d).', 'wc-licensed-product'),
+                            $productData['name'],
+                            $i + 1
+                        ),
+                        'error'
+                    );
+                    continue;
+                }
+
+                // Check for duplicate domains within same product
+                if (in_array($normalizedDomain, $normalizedDomains, true)) {
+                    wc_add_notice(
+                        sprintf(
+                            /* translators: 1: domain name, 2: product name */
+                            __('The domain "%1$s" is used multiple times for %2$s. Each license requires a unique domain.', 'wc-licensed-product'),
+                            $normalizedDomain,
+                            $productData['name']
+                        ),
+                        'error'
+                    );
+                } else {
+                    $normalizedDomains[] = $normalizedDomain;
+                }
            }
        }
    }

    /**
-     * Display domain in admin order view
+     * Save domain fields to order meta
+     */
+    public function saveDomainField(int $orderId): void
+    {
+        $licensedProducts = $this->getLicensedProductsFromCart();
+        if (empty($licensedProducts)) {
+            return;
+        }
+
+        $order = wc_get_order($orderId);
+        if (!$order) {
+            return;
+        }
+
+        // Check if multi-domain licensing is enabled
+        if (SettingsController::isMultiDomainEnabled()) {
+            $this->saveMultiDomainFields($order, $licensedProducts);
+        } else {
+            $this->saveSingleDomainField($order);
+        }
+    }
+
+    /**
+     * Save single domain field to order meta (legacy format)
+     */
+    private function saveSingleDomainField(\WC_Order $order): void
+    {
+        $domain = isset($_POST['licensed_product_domain']) ? sanitize_text_field($_POST['licensed_product_domain']) : '';
+
+        if (!empty($domain)) {
+            $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+            $order->update_meta_data('_licensed_product_domain', $normalizedDomain);
+            $order->save();
+        }
+    }
+
+    /**
+     * Save multi-domain fields to order meta
+     */
+    private function saveMultiDomainFields(\WC_Order $order, array $licensedProducts): void
+    {
+        $licensedDomains = $_POST['licensed_domains'] ?? [];
+        $domainData = [];
+
+        foreach ($licensedProducts as $productId => $productData) {
+            $productDomains = $licensedDomains[$productId] ?? [];
+            $normalizedDomains = [];
+
+            for ($i = 0; $i < $productData['quantity']; $i++) {
+                $domain = isset($productDomains[$i]) ? sanitize_text_field($productDomains[$i]) : '';
+                if (!empty($domain)) {
+                    $normalizedDomains[] = $this->licenseManager->normalizeDomain($domain);
+                }
+            }
+
+            if (!empty($normalizedDomains)) {
+                $domainData[] = [
+                    'product_id' => $productId,
+                    'domains' => $normalizedDomains,
+                ];
+            }
+        }
+
+        if (!empty($domainData)) {
+            $order->update_meta_data('_licensed_product_domains', $domainData);
+            $order->save();
+        }
+    }
+
+    /**
+     * Display domains in admin order view
     */
    public function displayDomainInAdmin(\WC_Order $order): void
    {
+        // Try new multi-domain format first
+        $domainData = $order->get_meta('_licensed_product_domains');
+        if (!empty($domainData) && is_array($domainData)) {
+            $this->displayMultiDomainsInAdmin($domainData);
+            return;
+        }
+
+        // Fall back to legacy single domain
        $domain = $order->get_meta('_licensed_product_domain');
        if (!$domain) {
            return;
@@ -168,10 +423,40 @@ final class CheckoutController
    }

    /**
-     * Display domain in order emails
+     * Display multi-domain data in admin
+     */
+    private function displayMultiDomainsInAdmin(array $domainData): void
+    {
+        ?>
+        <div class="wclp-order-domains">
+            <strong><?php esc_html_e('License Domains:', 'wc-licensed-product'); ?></strong>
+            <?php foreach ($domainData as $item): ?>
+                <?php
+                $product = wc_get_product($item['product_id']);
+                $productName = $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product');
+                ?>
+                <p style="margin: 5px 0 5px 15px;">
+                    <em><?php echo esc_html($productName); ?>:</em><br>
+                    <?php echo esc_html(implode(', ', $item['domains'])); ?>
+                </p>
+            <?php endforeach; ?>
+        </div>
+        <?php
+    }
+
+    /**
+     * Display domains in order emails
     */
    public function displayDomainInEmail(\WC_Order $order, bool $sentToAdmin, bool $plainText): void
    {
+        // Try new multi-domain format first
+        $domainData = $order->get_meta('_licensed_product_domains');
+        if (!empty($domainData) && is_array($domainData)) {
+            $this->displayMultiDomainsInEmail($domainData, $plainText);
+            return;
+        }
+
+        // Fall back to legacy single domain
        $domain = $order->get_meta('_licensed_product_domain');
        if (!$domain) {
            return;
@@ -189,6 +474,37 @@ final class CheckoutController
        }
    }

+    /**
+     * Display multi-domain data in email
+     */
+    private function displayMultiDomainsInEmail(array $domainData, bool $plainText): void
+    {
+        if ($plainText) {
+            echo "\n" . esc_html__('License Domains:', 'wc-licensed-product') . "\n";
+            foreach ($domainData as $item) {
+                $product = wc_get_product($item['product_id']);
+                $productName = $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product');
+                echo '  ' . esc_html($productName) . ': ' . esc_html(implode(', ', $item['domains'])) . "\n";
+            }
+        } else {
+            ?>
+            <div style="margin-bottom: 15px;">
+                <strong><?php esc_html_e('License Domains:', 'wc-licensed-product'); ?></strong>
+                <?php foreach ($domainData as $item): ?>
+                    <?php
+                    $product = wc_get_product($item['product_id']);
+                    $productName = $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product');
+                    ?>
+                    <p style="margin: 5px 0 5px 15px;">
+                        <em><?php echo esc_html($productName); ?>:</em><br>
+                        <?php echo esc_html(implode(', ', $item['domains'])); ?>
+                    </p>
+                <?php endforeach; ?>
+            </div>
+            <?php
+        }
+    }
+
    /**
     * Validate domain format
     */
--- a/src/Checkout/StoreApiExtension.php
+++ b/src/Checkout/StoreApiExtension.php
@@ -12,6 +12,7 @@ namespace Jeremias\WcLicensedProduct\Checkout;
 use Automattic\WooCommerce\StoreApi\Schemas\V1\CheckoutSchema;
 use Automattic\WooCommerce\StoreApi\StoreApi;
 use Automattic\WooCommerce\StoreApi\Schemas\ExtendSchema;
+use Jeremias\WcLicensedProduct\Admin\SettingsController;
 use Jeremias\WcLicensedProduct\License\LicenseManager;

 /**
@@ -70,6 +71,12 @@ final class StoreApiExtension
     */
    public function getExtensionData(): array
    {
+        if (SettingsController::isMultiDomainEnabled()) {
+            return [
+                'licensed_product_domains' => WC()->session ? WC()->session->get('licensed_product_domains', []) : [],
+            ];
+        }
+
        return [
            'licensed_product_domain' => WC()->session ? WC()->session->get('licensed_product_domain', '') : '',
        ];
@@ -80,6 +87,31 @@ final class StoreApiExtension
     */
    public function getExtensionSchema(): array
    {
+        if (SettingsController::isMultiDomainEnabled()) {
+            return [
+                'licensed_product_domains' => [
+                    'description' => __('Domains for license activation by product', 'wc-licensed-product'),
+                    'type' => 'array',
+                    'context' => ['view', 'edit'],
+                    'readonly' => false,
+                    'items' => [
+                        'type' => 'object',
+                        'properties' => [
+                            'product_id' => [
+                                'type' => 'integer',
+                            ],
+                            'domains' => [
+                                'type' => 'array',
+                                'items' => [
+                                    'type' => 'string',
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
+            ];
+        }
+
        return [
            'licensed_product_domain' => [
                'description' => __('Domain for license activation', 'wc-licensed-product'),
@@ -95,30 +127,103 @@ final class StoreApiExtension
     */
    public function handleExtensionUpdate(array $data): void
    {
-        if (isset($data['licensed_product_domain'])) {
-            $domain = sanitize_text_field($data['licensed_product_domain']);
-            $normalizedDomain = $this->licenseManager->normalizeDomain($domain);
+        if (SettingsController::isMultiDomainEnabled()) {
+            // Multi-domain mode
+            if (isset($data['licensed_product_domains']) && is_array($data['licensed_product_domains'])) {
+                $normalizedData = $this->normalizeDomainsData($data['licensed_product_domains']);

-            if (WC()->session) {
-                WC()->session->set('licensed_product_domain', $normalizedDomain);
+                if (WC()->session) {
+                    WC()->session->set('licensed_product_domains', $normalizedData);
+                }
+            }
+        } else {
+            // Single domain mode
+            if (isset($data['licensed_product_domain'])) {
+                $sanitized = sanitize_text_field($data['licensed_product_domain']);
+                $normalized = $this->licenseManager->normalizeDomain($sanitized);
+
+                if (WC()->session) {
+                    WC()->session->set('licensed_product_domain', $normalized);
+                }
            }
        }
    }

    /**
-     * Process the checkout order - save domain to order meta
+     * Normalize domains data from frontend
+     */
+    private function normalizeDomainsData(array $domainsData): array
+    {
+        $normalized = [];
+
+        foreach ($domainsData as $item) {
+            if (!isset($item['product_id']) || !isset($item['domains']) || !is_array($item['domains'])) {
+                continue;
+            }
+
+            $productId = (int) $item['product_id'];
+            $domains = [];
+
+            foreach ($item['domains'] as $domain) {
+                $sanitized = sanitize_text_field($domain);
+                if (!empty($sanitized)) {
+                    $domains[] = $this->licenseManager->normalizeDomain($sanitized);
+                }
+            }
+
+            if (!empty($domains)) {
+                $normalized[] = [
+                    'product_id' => $productId,
+                    'domains' => $domains,
+                ];
+            }
+        }
+
+        return $normalized;
+    }
+
+    /**
+     * Process the checkout order - save domains to order meta
     */
    public function processCheckoutOrder(\WC_Order $order): void
    {
-        $domain = WC()->session ? WC()->session->get('licensed_product_domain', '') : '';
+        $requestData = json_decode(file_get_contents('php://input'), true);

-        // Also check in the request data for block checkout
-        if (empty($domain)) {
-            $requestData = json_decode(file_get_contents('php://input'), true);
-            if (isset($requestData['extensions'][self::IDENTIFIER]['licensed_product_domain'])) {
-                $domain = sanitize_text_field($requestData['extensions'][self::IDENTIFIER]['licensed_product_domain']);
-                $domain = $this->licenseManager->normalizeDomain($domain);
-            }
+        if (SettingsController::isMultiDomainEnabled()) {
+            $this->processMultiDomainOrder($order, $requestData);
+        } else {
+            $this->processSingleDomainOrder($order, $requestData);
+        }
+    }
+
+    /**
+     * Process order in single domain mode (legacy)
+     */
+    private function processSingleDomainOrder(\WC_Order $order, ?array $requestData): void
+    {
+        $domain = '';
+
+        // Check session first
+        if (WC()->session) {
+            $domain = WC()->session->get('licensed_product_domain', '');
+        }
+
+        // Check in the request data for block checkout (extension data)
+        if (empty($domain) && isset($requestData['extensions'][self::IDENTIFIER]['licensed_product_domain'])) {
+            $sanitized = sanitize_text_field($requestData['extensions'][self::IDENTIFIER]['licensed_product_domain']);
+            $domain = $this->licenseManager->normalizeDomain($sanitized);
+        }
+
+        // Check for wclp_license_domain (from our hidden input)
+        if (empty($domain) && isset($requestData['wclp_license_domain'])) {
+            $sanitized = sanitize_text_field($requestData['wclp_license_domain']);
+            $domain = $this->licenseManager->normalizeDomain($sanitized);
+        }
+
+        // Check for additional_fields (WC Blocks API)
+        if (empty($domain) && isset($requestData['additional_fields']['wc-licensed-product/domain'])) {
+            $sanitized = sanitize_text_field($requestData['additional_fields']['wc-licensed-product/domain']);
+            $domain = $this->licenseManager->normalizeDomain($sanitized);
        }

        if (!empty($domain)) {
@@ -131,4 +236,65 @@ final class StoreApiExtension
            }
        }
    }
+
+    /**
+     * Process order in multi-domain mode
+     */
+    private function processMultiDomainOrder(\WC_Order $order, ?array $requestData): void
+    {
+        $domainData = [];
+
+        // Check session first
+        if (WC()->session) {
+            $domainData = WC()->session->get('licensed_product_domains', []);
+        }
+
+        // Check in the request data for block checkout (extension data)
+        if (empty($domainData) && isset($requestData['extensions'][self::IDENTIFIER]['licensed_product_domains'])) {
+            $domainData = $this->normalizeDomainsData(
+                $requestData['extensions'][self::IDENTIFIER]['licensed_product_domains']
+            );
+        }
+
+        // Check for wclp_license_domains (from our hidden input - JSON string)
+        if (empty($domainData) && isset($requestData['wclp_license_domains'])) {
+            $parsed = json_decode($requestData['wclp_license_domains'], true);
+            if (is_array($parsed)) {
+                $domainData = $this->normalizeDomainsData($parsed);
+            }
+        }
+
+        // Check for licensed_domains in classic format (from DOM injection)
+        if (empty($domainData) && isset($requestData['licensed_domains']) && is_array($requestData['licensed_domains'])) {
+            $domainData = [];
+            foreach ($requestData['licensed_domains'] as $productId => $domains) {
+                if (!is_array($domains)) {
+                    continue;
+                }
+                $normalizedDomains = [];
+                foreach ($domains as $domain) {
+                    $sanitized = sanitize_text_field($domain);
+                    if (!empty($sanitized)) {
+                        $normalizedDomains[] = $this->licenseManager->normalizeDomain($sanitized);
+                    }
+                }
+                if (!empty($normalizedDomains)) {
+                    $domainData[] = [
+                        'product_id' => (int) $productId,
+                        'domains' => $normalizedDomains,
+                    ];
+                }
+            }
+        }
+
+        if (!empty($domainData)) {
+            $order->update_meta_data('_licensed_product_domains', $domainData);
+            $order->save();
+
+            // Clear session data
+            if (WC()->session) {
+                WC()->session->set('licensed_product_domains', []);
+            }
+        }
+    }
 }
--- a/src/Email/LicenseEmailController.php
+++ b/src/Email/LicenseEmailController.php
@@ -194,7 +194,7 @@ final class LicenseEmailController
    }

    /**
-     * Add license key to order item in email
+     * Add license key(s) to order item in email
     */
    public function addLicenseToOrderItem(int $itemId, \WC_Order_Item $item, \WC_Order $order, bool $plainText): void
    {
@@ -203,94 +203,117 @@ final class LicenseEmailController
            return;
        }

-        $license = $this->licenseManager->getLicenseByOrderAndProduct($order->get_id(), $product->get_id());
-        if (!$license) {
+        $licenses = $this->licenseManager->getLicensesByOrderAndProduct($order->get_id(), $product->get_id());
+        if (empty($licenses)) {
            return;
        }

        if ($plainText) {
-            echo "\n" . esc_html__('License Key:', 'wc-licensed-product') . ' ' . esc_html($license->getLicenseKey()) . "\n";
+            echo "\n" . esc_html__('License Keys:', 'wc-licensed-product') . "\n";
+            foreach ($licenses as $license) {
+                echo '  - ' . esc_html($license->getLicenseKey());
+                echo ' (' . esc_html($license->getDomain()) . ')' . "\n";
+            }
        } else {
            ?>
            <div style="margin-top: 10px; padding: 10px; background-color: #f8f9fa; border-left: 3px solid #7f54b3;">
-                <strong><?php esc_html_e('License Key:', 'wc-licensed-product'); ?></strong>
-                <code style="display: block; margin-top: 5px; padding: 5px; background: #fff; font-family: monospace;">
-                    <?php echo esc_html($license->getLicenseKey()); ?>
-                </code>
+                <strong><?php esc_html_e('License Keys:', 'wc-licensed-product'); ?></strong>
+                <?php foreach ($licenses as $license) : ?>
+                    <div style="margin-top: 5px; padding: 5px; background: #fff;">
+                        <code style="font-family: monospace;">
+                            <?php echo esc_html($license->getLicenseKey()); ?>
+                        </code>
+                        <span style="color: #666; margin-left: 10px;">
+                            <?php echo esc_html($license->getDomain()); ?>
+                        </span>
+                    </div>
+                <?php endforeach; ?>
            </div>
            <?php
        }
    }

    /**
-     * Get all licenses for an order
+     * Get all licenses for an order grouped by product
+     *
+     * @return array Array of products with their licenses
     */
    private function getLicensesForOrder(\WC_Order $order): array
    {
-        $licenses = [];
+        $products = [];

        foreach ($order->get_items() as $item) {
            $product = $item->get_product();
            if ($product && $product->is_type('licensed')) {
-                $license = $this->licenseManager->getLicenseByOrderAndProduct($order->get_id(), $product->get_id());
-                if ($license) {
-                    $licenses[] = [
-                        'license' => $license,
+                $licenses = $this->licenseManager->getLicensesByOrderAndProduct($order->get_id(), $product->get_id());
+                if (!empty($licenses)) {
+                    $products[] = [
                        'product_name' => $product->get_name(),
+                        'licenses' => $licenses,
                    ];
                }
            }
        }

-        return $licenses;
+        return $products;
    }

    /**
     * Render license info in HTML format
     */
-    private function renderHtmlLicenseInfo(array $licenses, \WC_Order $order): void
+    private function renderHtmlLicenseInfo(array $products, \WC_Order $order): void
    {
-        $domain = $order->get_meta('_licensed_product_domain');
        ?>
        <div style="margin: 20px 0; padding: 20px; background-color: #f8f9fa; border: 1px solid #e5e5e5; border-radius: 4px;">
            <h2 style="margin-top: 0; color: #333;"><?php esc_html_e('Your License Keys', 'wc-licensed-product'); ?></h2>

-            <?php if ($domain) : ?>
-                <p style="margin-bottom: 15px;">
-                    <strong><?php esc_html_e('Licensed Domain:', 'wc-licensed-product'); ?></strong>
-                    <?php echo esc_html($domain); ?>
-                </p>
-            <?php endif; ?>
+            <?php foreach ($products as $product) : ?>
+                <div style="margin-bottom: 20px;">
+                    <h3 style="margin: 0 0 10px 0; font-size: 1.1em; color: #333;">
+                        <?php echo esc_html($product['product_name']); ?>
+                        <span style="font-weight: normal; color: #666; font-size: 0.9em;">
+                            (<?php
+                            printf(
+                                esc_html(_n('%d license', '%d licenses', count($product['licenses']), 'wc-licensed-product')),
+                                count($product['licenses'])
+                            );
+                            ?>)
+                        </span>
+                    </h3>

-            <table style="width: 100%; border-collapse: collapse;">
-                <thead>
-                    <tr>
-                        <th style="text-align: left; padding: 10px; border-bottom: 2px solid #ddd;"><?php esc_html_e('Product', 'wc-licensed-product'); ?></th>
-                        <th style="text-align: left; padding: 10px; border-bottom: 2px solid #ddd;"><?php esc_html_e('License Key', 'wc-licensed-product'); ?></th>
-                        <th style="text-align: left; padding: 10px; border-bottom: 2px solid #ddd;"><?php esc_html_e('Expires', 'wc-licensed-product'); ?></th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <?php foreach ($licenses as $item) : ?>
-                        <tr>
-                            <td style="padding: 10px; border-bottom: 1px solid #eee;"><?php echo esc_html($item['product_name']); ?></td>
-                            <td style="padding: 10px; border-bottom: 1px solid #eee;">
-                                <code style="background: #fff; padding: 3px 6px; font-family: monospace;">
-                                    <?php echo esc_html($item['license']->getLicenseKey()); ?>
-                                </code>
-                            </td>
-                            <td style="padding: 10px; border-bottom: 1px solid #eee;">
-                                <?php
-                                $expiresAt = $item['license']->getExpiresAt();
-                                echo $expiresAt
-                                    ? esc_html($expiresAt->format(get_option('date_format')))
-                                    : esc_html__('Never', 'wc-licensed-product');
-                                ?>
-                            </td>
-                        </tr>
-                    <?php endforeach; ?>
-                </tbody>
-            </table>
+                    <table style="width: 100%; border-collapse: collapse; background: #fff;">
+                        <thead>
+                            <tr>
+                                <th style="text-align: left; padding: 8px 10px; border-bottom: 2px solid #ddd; font-size: 0.9em;"><?php esc_html_e('License Key', 'wc-licensed-product'); ?></th>
+                                <th style="text-align: left; padding: 8px 10px; border-bottom: 2px solid #ddd; font-size: 0.9em;"><?php esc_html_e('Domain', 'wc-licensed-product'); ?></th>
+                                <th style="text-align: left; padding: 8px 10px; border-bottom: 2px solid #ddd; font-size: 0.9em;"><?php esc_html_e('Expires', 'wc-licensed-product'); ?></th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <?php foreach ($product['licenses'] as $license) : ?>
+                                <tr>
+                                    <td style="padding: 8px 10px; border-bottom: 1px solid #eee;">
+                                        <code style="background: #f5f5f5; padding: 3px 6px; font-family: monospace; font-size: 0.9em;">
+                                            <?php echo esc_html($license->getLicenseKey()); ?>
+                                        </code>
+                                    </td>
+                                    <td style="padding: 8px 10px; border-bottom: 1px solid #eee;">
+                                        <?php echo esc_html($license->getDomain()); ?>
+                                    </td>
+                                    <td style="padding: 8px 10px; border-bottom: 1px solid #eee;">
+                                        <?php
+                                        $expiresAt = $license->getExpiresAt();
+                                        echo $expiresAt
+                                            ? esc_html($expiresAt->format(get_option('date_format')))
+                                            : esc_html__('Never', 'wc-licensed-product');
+                                        ?>
+                                    </td>
+                                </tr>
+                            <?php endforeach; ?>
+                        </tbody>
+                    </table>
+                </div>
+            <?php endforeach; ?>

            <p style="margin-top: 15px; margin-bottom: 0; font-size: 0.9em; color: #666;">
                <?php esc_html_e('You can also view your licenses in your account under "Licenses".', 'wc-licensed-product'); ?>
@@ -302,29 +325,33 @@ final class LicenseEmailController
    /**
     * Render license info in plain text format
     */
-    private function renderPlainTextLicenseInfo(array $licenses, \WC_Order $order): void
+    private function renderPlainTextLicenseInfo(array $products, \WC_Order $order): void
    {
-        $domain = $order->get_meta('_licensed_product_domain');
-
        echo "\n\n";
        echo "==========================================================\n";
        echo esc_html__('YOUR LICENSE KEYS', 'wc-licensed-product') . "\n";
        echo "==========================================================\n\n";

-        if ($domain) {
-            echo esc_html__('Licensed Domain:', 'wc-licensed-product') . ' ' . esc_html($domain) . "\n\n";
-        }
+        foreach ($products as $product) {
+            echo esc_html($product['product_name']);
+            echo ' (' . count($product['licenses']) . ' ' .
+                _n('license', 'licenses', count($product['licenses']), 'wc-licensed-product') . ')';
+            echo "\n";
+            echo "-----------------------------------------------------------\n";

-        foreach ($licenses as $item) {
-            echo esc_html($item['product_name']) . "\n";
-            echo esc_html__('License Key:', 'wc-licensed-product') . ' ' . esc_html($item['license']->getLicenseKey()) . "\n";
+            foreach ($product['licenses'] as $license) {
+                echo esc_html__('License Key:', 'wc-licensed-product') . ' ';
+                echo esc_html($license->getLicenseKey()) . "\n";
+                echo esc_html__('Domain:', 'wc-licensed-product') . ' ';
+                echo esc_html($license->getDomain()) . "\n";
+                echo esc_html__('Expires:', 'wc-licensed-product') . ' ';

-            $expiresAt = $item['license']->getExpiresAt();
-            echo esc_html__('Expires:', 'wc-licensed-product') . ' ';
-            echo $expiresAt
-                ? esc_html($expiresAt->format(get_option('date_format')))
-                : esc_html__('Never', 'wc-licensed-product');
-            echo "\n\n";
+                $expiresAt = $license->getExpiresAt();
+                echo $expiresAt
+                    ? esc_html($expiresAt->format(get_option('date_format')))
+                    : esc_html__('Never', 'wc-licensed-product');
+                echo "\n\n";
+            }
        }

        echo esc_html__('You can also view your licenses in your account under "Licenses".', 'wc-licensed-product') . "\n";
--- a/src/Frontend/AccountController.php
+++ b/src/Frontend/AccountController.php
@@ -107,135 +107,248 @@ final class AccountController

        $licenses = $this->licenseManager->getLicensesByCustomer($customerId);

-        // Enrich licenses with product data and downloads
-        $enrichedLicenses = [];
-        foreach ($licenses as $license) {
-            $product = wc_get_product($license->getProductId());
-            $order = wc_get_order($license->getOrderId());
-
-            // Get available downloads for this license
-            $downloads = [];
-            if ($license->getStatus() === 'active') {
-                $versions = $this->versionManager->getVersionsByProduct($license->getProductId());
-                foreach ($versions as $version) {
-                    if ($version->isActive() && ($version->getAttachmentId() || $version->getDownloadUrl())) {
-                        $downloads[] = [
-                            'version' => $version->getVersion(),
-                            'version_id' => $version->getId(),
-                            'filename' => $version->getDownloadFilename(),
-                            'download_url' => $this->downloadController->generateDownloadUrl(
-                                $license->getId(),
-                                $version->getId()
-                            ),
-                            'release_notes' => $version->getReleaseNotes(),
-                            'released_at' => $version->getReleasedAt()->format(get_option('date_format')),
-                            'file_hash' => $version->getFileHash(),
-                        ];
-                    }
-                }
-            }
-
-            $enrichedLicenses[] = [
-                'license' => $license,
-                'product_name' => $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product'),
-                'product_url' => $product ? $product->get_permalink() : '',
-                'order_number' => $order ? $order->get_order_number() : '',
-                'order_url' => $order ? $order->get_view_order_url() : '',
-                'downloads' => $downloads,
-            ];
-        }
+        // Group licenses by product+order into "packages"
+        $packages = $this->groupLicensesIntoPackages($licenses);

        try {
            echo $this->twig->render('frontend/licenses.html.twig', [
-                'licenses' => $enrichedLicenses,
-                'has_licenses' => !empty($enrichedLicenses),
+                'packages' => $packages,
+                'has_packages' => !empty($packages),
            ]);
        } catch (\Exception $e) {
            // Fallback to PHP template if Twig fails
-            $this->displayLicensesFallback($enrichedLicenses);
+            $this->displayLicensesFallback($packages);
        }
    }

+    /**
+     * Group licenses into packages by product+order
+     *
+     * @param array $licenses Array of License objects
+     * @return array Array of package data
+     */
+    private function groupLicensesIntoPackages(array $licenses): array
+    {
+        $grouped = [];
+
+        foreach ($licenses as $license) {
+            $productId = $license->getProductId();
+            $orderId = $license->getOrderId();
+            $key = $productId . '_' . $orderId;
+
+            if (!isset($grouped[$key])) {
+                $product = wc_get_product($productId);
+                $order = wc_get_order($orderId);
+
+                $grouped[$key] = [
+                    'product_id' => $productId,
+                    'order_id' => $orderId,
+                    'product_name' => $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product'),
+                    'product_url' => $product ? $product->get_permalink() : '',
+                    'order_number' => $order ? $order->get_order_number() : '',
+                    'order_url' => $order ? $order->get_view_order_url() : '',
+                    'licenses' => [],
+                    'downloads' => [],
+                    'has_active_license' => false,
+                ];
+            }
+
+            // Add license to package
+            $grouped[$key]['licenses'][] = [
+                'id' => $license->getId(),
+                'license_key' => $license->getLicenseKey(),
+                'domain' => $license->getDomain(),
+                'status' => $license->getStatus(),
+                'expires_at' => $license->getExpiresAt(),
+                'is_transferable' => in_array($license->getStatus(), ['active', 'inactive'], true),
+            ];
+
+            // Track if package has at least one active license
+            if ($license->getStatus() === 'active') {
+                $grouped[$key]['has_active_license'] = true;
+            }
+        }
+
+        // Add downloads for packages with active licenses
+        foreach ($grouped as $key => &$package) {
+            if ($package['has_active_license']) {
+                $package['downloads'] = $this->getDownloadsForProduct(
+                    $package['product_id'],
+                    $package['licenses'][0]['id'] // Use first license for download URL
+                );
+            }
+        }
+
+        // Sort by order date (newest first) - re-index array
+        return array_values($grouped);
+    }
+
+    /**
+     * Get downloads for a product
+     */
+    private function getDownloadsForProduct(int $productId, int $licenseId): array
+    {
+        $downloads = [];
+        $versions = $this->versionManager->getVersionsByProduct($productId);
+
+        foreach ($versions as $version) {
+            if ($version->isActive() && ($version->getAttachmentId() || $version->getDownloadUrl())) {
+                $downloads[] = [
+                    'version' => $version->getVersion(),
+                    'version_id' => $version->getId(),
+                    'filename' => $version->getDownloadFilename(),
+                    'download_url' => $this->downloadController->generateDownloadUrl(
+                        $licenseId,
+                        $version->getId()
+                    ),
+                    'release_notes' => $version->getReleaseNotes(),
+                    'released_at' => $version->getReleasedAt()->format(get_option('date_format')),
+                    'file_hash' => $version->getFileHash(),
+                ];
+            }
+        }
+
+        return $downloads;
+    }
+
    /**
     * Fallback display method if Twig is unavailable
     */
-    private function displayLicensesFallback(array $enrichedLicenses): void
+    private function displayLicensesFallback(array $packages): void
    {
-        if (empty($enrichedLicenses)) {
+        if (empty($packages)) {
            echo '<p>' . esc_html__('You have no licenses yet.', 'wc-licensed-product') . '</p>';
            return;
        }

        ?>
        <div class="woocommerce-licenses">
-            <?php foreach ($enrichedLicenses as $item): ?>
-                <div class="license-card">
-                    <div class="license-header">
+            <?php foreach ($packages as $package): ?>
+                <div class="license-package">
+                    <div class="package-header">
                        <h3>
-                            <?php if ($item['product_url']): ?>
-                                <a href="<?php echo esc_url($item['product_url']); ?>">
-                                    <?php echo esc_html($item['product_name']); ?>
+                            <?php if ($package['product_url']): ?>
+                                <a href="<?php echo esc_url($package['product_url']); ?>">
+                                    <?php echo esc_html($package['product_name']); ?>
                                </a>
                            <?php else: ?>
-                                <?php echo esc_html($item['product_name']); ?>
+                                <?php echo esc_html($package['product_name']); ?>
                            <?php endif; ?>
                        </h3>
-                        <span class="license-status license-status-<?php echo esc_attr($item['license']->getStatus()); ?>">
-                            <?php echo esc_html(ucfirst($item['license']->getStatus())); ?>
+                        <span class="package-order">
+                            <?php
+                            printf(
+                                /* translators: %s: order number */
+                                esc_html__('Order #%s', 'wc-licensed-product'),
+                                esc_html($package['order_number'])
+                            );
+                            ?>
                        </span>
                    </div>

-                    <div class="license-details">
-                        <div class="license-key-row">
-                            <label><?php esc_html_e('License Key:', 'wc-licensed-product'); ?></label>
-                            <code class="license-key" data-license-key="<?php echo esc_attr($item['license']->getLicenseKey()); ?>">
-                                <?php echo esc_html($item['license']->getLicenseKey()); ?>
-                            </code>
-                            <button type="button" class="copy-license-btn" data-license-key="<?php echo esc_attr($item['license']->getLicenseKey()); ?>" title="<?php esc_attr_e('Copy to clipboard', 'wc-licensed-product'); ?>">
-                                <span class="dashicons dashicons-clipboard"></span>
-                            </button>
-                        </div>
-
-                        <div class="license-info-row">
-                            <span class="license-domain-display" data-license-id="<?php echo esc_attr($item['license']->getId()); ?>">
-                                <strong><?php esc_html_e('Domain:', 'wc-licensed-product'); ?></strong>
-                                <span class="domain-value"><?php echo esc_html($item['license']->getDomain()); ?></span>
-                                <?php if (in_array($item['license']->getStatus(), ['active', 'inactive'], true)): ?>
-                                    <button type="button" class="wclp-transfer-btn"
-                                            data-license-id="<?php echo esc_attr($item['license']->getId()); ?>"
-                                            data-current-domain="<?php echo esc_attr($item['license']->getDomain()); ?>"
-                                            title="<?php esc_attr_e('Transfer to new domain', 'wc-licensed-product'); ?>">
-                                        <span class="dashicons dashicons-randomize"></span>
-                                        <?php esc_html_e('Transfer', 'wc-licensed-product'); ?>
-                                    </button>
-                                <?php endif; ?>
-                            </span>
-                            <span><strong><?php esc_html_e('Expires:', 'wc-licensed-product'); ?></strong>
-                                <?php
-                                $expiresAt = $item['license']->getExpiresAt();
-                                echo $expiresAt
-                                    ? esc_html($expiresAt->format(get_option('date_format')))
-                                    : esc_html__('Never', 'wc-licensed-product');
-                                ?>
-                            </span>
-                        </div>
+                    <div class="package-licenses">
+                        <?php foreach ($package['licenses'] as $license): ?>
+                            <div class="license-entry license-entry-<?php echo esc_attr($license['status']); ?>">
+                                <div class="license-row-primary">
+                                    <div class="license-key-group">
+                                        <code class="license-key"><?php echo esc_html($license['license_key']); ?></code>
+                                        <span class="license-status license-status-<?php echo esc_attr($license['status']); ?>">
+                                            <?php echo esc_html(ucfirst($license['status'])); ?>
+                                        </span>
+                                    </div>
+                                    <div class="license-actions">
+                                        <button type="button" class="copy-license-btn" data-license-key="<?php echo esc_attr($license['license_key']); ?>" title="<?php esc_attr_e('Copy to clipboard', 'wc-licensed-product'); ?>">
+                                            <span class="dashicons dashicons-clipboard"></span>
+                                        </button>
+                                        <?php if ($license['is_transferable']): ?>
+                                            <button type="button" class="wclp-transfer-btn"
+                                                    data-license-id="<?php echo esc_attr($license['id']); ?>"
+                                                    data-current-domain="<?php echo esc_attr($license['domain']); ?>"
+                                                    title="<?php esc_attr_e('Transfer to new domain', 'wc-licensed-product'); ?>">
+                                                <span class="dashicons dashicons-randomize"></span>
+                                            </button>
+                                        <?php endif; ?>
+                                    </div>
+                                </div>
+                                <div class="license-row-secondary">
+                                    <span class="license-meta-item license-domain">
+                                        <span class="dashicons dashicons-admin-site-alt3"></span>
+                                        <?php echo esc_html($license['domain']); ?>
+                                    </span>
+                                    <span class="license-meta-item license-expiry">
+                                        <span class="dashicons dashicons-calendar-alt"></span>
+                                        <?php
+                                        echo $license['expires_at']
+                                            ? esc_html($license['expires_at']->format('Y-m-d'))
+                                            : '<span class="lifetime">' . esc_html__('Lifetime', 'wc-licensed-product') . '</span>';
+                                        ?>
+                                    </span>
+                                </div>
+                            </div>
+                        <?php endforeach; ?>
                    </div>

-                    <?php if (!empty($item['downloads'])): ?>
-                        <div class="license-downloads">
+                    <?php if (!empty($package['downloads'])): ?>
+                        <div class="package-downloads">
                            <h4><?php esc_html_e('Available Downloads', 'wc-licensed-product'); ?></h4>
                            <ul class="download-list">
-                                <?php foreach ($item['downloads'] as $download): ?>
-                                    <li>
-                                        <a href="<?php echo esc_url($download['download_url']); ?>" class="download-link">
+                                <?php
+                                $latest = $package['downloads'][0];
+                                ?>
+                                <li class="download-item download-item-latest">
+                                    <div class="download-row-file">
+                                        <a href="<?php echo esc_url($latest['download_url']); ?>" class="download-link">
                                            <span class="dashicons dashicons-download"></span>
-                                            <?php echo esc_html($download['filename'] ?: sprintf(__('Version %s', 'wc-licensed-product'), $download['version'])); ?>
+                                            <?php echo esc_html($latest['filename'] ?: sprintf(__('Version %s', 'wc-licensed-product'), $latest['version'])); ?>
                                        </a>
-                                        <span class="download-version">v<?php echo esc_html($download['version']); ?></span>
-                                        <span class="download-date"><?php echo esc_html($download['released_at']); ?></span>
-                                    </li>
-                                <?php endforeach; ?>
+                                        <span class="download-version-badge"><?php esc_html_e('Latest', 'wc-licensed-product'); ?></span>
+                                    </div>
+                                    <div class="download-row-meta">
+                                        <span class="download-date"><?php echo esc_html($latest['released_at']); ?></span>
+                                        <?php if (!empty($latest['file_hash'])): ?>
+                                            <span class="download-hash" title="<?php echo esc_attr($latest['file_hash']); ?>">
+                                                <span class="dashicons dashicons-shield"></span>
+                                                <code><?php echo esc_html(substr($latest['file_hash'], 0, 12)); ?>...</code>
+                                            </span>
+                                        <?php endif; ?>
+                                    </div>
+                                </li>
                            </ul>
+
+                            <?php if (count($package['downloads']) > 1): ?>
+                                <div class="older-versions-section">
+                                    <button type="button" class="older-versions-toggle" aria-expanded="false">
+                                        <span class="dashicons dashicons-arrow-down-alt2"></span>
+                                        <?php
+                                        printf(
+                                            esc_html__('Older versions (%d)', 'wc-licensed-product'),
+                                            count($package['downloads']) - 1
+                                        );
+                                        ?>
+                                    </button>
+                                    <ul class="download-list older-versions-list" style="display: none;">
+                                        <?php foreach (array_slice($package['downloads'], 1) as $download): ?>
+                                            <li class="download-item">
+                                                <div class="download-row-file">
+                                                    <a href="<?php echo esc_url($download['download_url']); ?>" class="download-link">
+                                                        <span class="dashicons dashicons-download"></span>
+                                                        <?php echo esc_html($download['filename'] ?: sprintf(__('Version %s', 'wc-licensed-product'), $download['version'])); ?>
+                                                    </a>
+                                                </div>
+                                                <div class="download-row-meta">
+                                                    <span class="download-date"><?php echo esc_html($download['released_at']); ?></span>
+                                                    <?php if (!empty($download['file_hash'])): ?>
+                                                        <span class="download-hash" title="<?php echo esc_attr($download['file_hash']); ?>">
+                                                            <span class="dashicons dashicons-shield"></span>
+                                                            <code><?php echo esc_html(substr($download['file_hash'], 0, 12)); ?>...</code>
+                                                        </span>
+                                                    <?php endif; ?>
+                                                </div>
+                                            </li>
+                                        <?php endforeach; ?>
+                                    </ul>
+                                </div>
+                            <?php endif; ?>
                        </div>
                    <?php endif; ?>
                </div>
--- a/src/Frontend/DownloadController.php
+++ b/src/Frontend/DownloadController.php
@@ -35,6 +35,9 @@ final class DownloadController
        // Add download endpoint
        add_action('init', [$this, 'addDownloadEndpoint']);

+        // Register query var for the endpoint
+        add_filter('query_vars', [$this, 'addDownloadQueryVar']);
+
        // Handle download requests
        add_action('template_redirect', [$this, 'handleDownloadRequest']);
    }
@@ -47,6 +50,15 @@ final class DownloadController
        add_rewrite_endpoint('license-download', EP_ROOT | EP_PAGES);
    }

+    /**
+     * Register the download query var
+     */
+    public function addDownloadQueryVar(array $vars): array
+    {
+        $vars[] = 'license-download';
+        return $vars;
+    }
+
    /**
     * Handle download request
     */
@@ -160,8 +172,12 @@ final class DownloadController
        $downloadUrl = $version->getDownloadUrl();

        if ($attachmentId) {
+            // Increment download count before serving
+            $this->versionManager->incrementDownloadCount($versionId);
            $this->serveAttachment($attachmentId, $version->getVersion());
        } elseif ($downloadUrl) {
+            // Increment download count before redirect
+            $this->versionManager->incrementDownloadCount($versionId);
            // Redirect to external URL
            wp_redirect($downloadUrl);
            exit;
--- a/src/Installer.php
+++ b/src/Installer.php
@@ -35,8 +35,9 @@ final class Installer
        // Set version in options
        update_option('wc_licensed_product_version', WC_LICENSED_PRODUCT_VERSION);

-        // Register the licenses endpoint before flushing rewrite rules
+        // Register endpoints before flushing rewrite rules
        add_rewrite_endpoint('licenses', EP_ROOT | EP_PAGES);
+        add_rewrite_endpoint('license-download', EP_ROOT | EP_PAGES);

        // Flush rewrite rules for REST API and My Account endpoints
        flush_rewrite_rules();
@@ -103,6 +104,7 @@ final class Installer
            download_url VARCHAR(512) DEFAULT NULL,
            attachment_id BIGINT UNSIGNED DEFAULT NULL,
            file_hash VARCHAR(64) DEFAULT NULL,
+            download_count BIGINT UNSIGNED NOT NULL DEFAULT 0,
            is_active TINYINT(1) NOT NULL DEFAULT 1,
            released_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
            created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--- a/src/License/LicenseManager.php
+++ b/src/License/LicenseManager.php
@@ -49,8 +49,11 @@ class LicenseManager
    ): ?License {
        global $wpdb;

-        // Check if license already exists for this order and product
-        $existing = $this->getLicenseByOrderAndProduct($orderId, $productId);
+        // Normalize domain first for duplicate detection
+        $normalizedDomain = $this->normalizeDomain($domain);
+
+        // Check if license already exists for this order, product, and domain
+        $existing = $this->getLicenseByOrderProductAndDomain($orderId, $productId, $normalizedDomain);
        if ($existing) {
            return $existing;
        }
@@ -161,6 +164,49 @@ class LicenseManager
        return $row ? License::fromArray($row) : null;
    }

+    /**
+     * Get all licenses for an order and product
+     *
+     * @return License[]
+     */
+    public function getLicensesByOrderAndProduct(int $orderId, int $productId): array
+    {
+        global $wpdb;
+
+        $tableName = Installer::getLicensesTable();
+        $rows = $wpdb->get_results(
+            $wpdb->prepare(
+                "SELECT * FROM {$tableName} WHERE order_id = %d AND product_id = %d ORDER BY created_at ASC",
+                $orderId,
+                $productId
+            ),
+            ARRAY_A
+        );
+
+        return array_map(fn(array $row) => License::fromArray($row), $rows ?: []);
+    }
+
+    /**
+     * Get license by order, product, and domain
+     */
+    public function getLicenseByOrderProductAndDomain(int $orderId, int $productId, string $domain): ?License
+    {
+        global $wpdb;
+
+        $tableName = Installer::getLicensesTable();
+        $row = $wpdb->get_row(
+            $wpdb->prepare(
+                "SELECT * FROM {$tableName} WHERE order_id = %d AND product_id = %d AND domain = %s",
+                $orderId,
+                $productId,
+                $domain
+            ),
+            ARRAY_A
+        );
+
+        return $row ? License::fromArray($row) : null;
+    }
+
    /**
     * Get all licenses for an order
     */
--- a/src/License/PluginLicenseChecker.php
+++ b/src/License/PluginLicenseChecker.php
@@ -52,6 +52,11 @@ final class PluginLicenseChecker
     */
    private ?bool $isLocalhostCached = null;

+    /**
+     * Cached self-licensing check result
+     */
+    private ?bool $isSelfLicensingCached = null;
+
    /**
     * Get singleton instance
     */
@@ -84,6 +89,11 @@ final class PluginLicenseChecker
            return true;
        }

+        // Always valid when self-licensing (server URL points to this installation)
+        if ($this->isSelfLicensing()) {
+            return true;
+        }
+
        // Check cache first
        $cached = get_transient(self::CACHE_KEY);
        if ($cached !== false) {
@@ -107,6 +117,11 @@ final class PluginLicenseChecker
            return true;
        }

+        // Always valid when self-licensing (server URL points to this installation)
+        if ($this->isSelfLicensing()) {
+            return true;
+        }
+
        // Check settings are configured
        $serverUrl = $this->getLicenseServerUrl();
        $licenseKey = $this->getLicenseKey();
@@ -176,6 +191,7 @@ final class PluginLicenseChecker
        delete_transient(self::CACHE_KEY);
        delete_transient(self::ERROR_CACHE_KEY);
        $this->isLocalhostCached = null;
+        $this->isSelfLicensingCached = null;
    }

    /**
@@ -215,6 +231,60 @@ final class PluginLicenseChecker
        return false;
    }

+    /**
+     * Check if self-licensing (license server URL points to this installation)
+     *
+     * Prevents circular dependency where plugin tries to validate against itself.
+     * Plugins can only be validated against the original store from which they were obtained.
+     */
+    public function isSelfLicensing(): bool
+    {
+        if ($this->isSelfLicensingCached !== null) {
+            return $this->isSelfLicensingCached;
+        }
+
+        $serverUrl = $this->getLicenseServerUrl();
+
+        // No server URL configured - not self-licensing
+        if (empty($serverUrl)) {
+            $this->isSelfLicensingCached = false;
+            return false;
+        }
+
+        // Parse both URLs to compare domains
+        $serverParsed = parse_url($serverUrl);
+        $siteUrl = get_site_url();
+        $siteParsed = parse_url($siteUrl);
+
+        // Get normalized domains (lowercase, no www prefix)
+        $serverDomain = $this->normalizeDomain($serverParsed['host'] ?? '');
+        $siteDomain = $this->normalizeDomain($siteParsed['host'] ?? '');
+
+        // If domains match, this is self-licensing
+        if ($serverDomain === $siteDomain) {
+            $this->isSelfLicensingCached = true;
+            return true;
+        }
+
+        $this->isSelfLicensingCached = false;
+        return false;
+    }
+
+    /**
+     * Normalize a domain for comparison (lowercase, strip www)
+     */
+    private function normalizeDomain(string $domain): string
+    {
+        $domain = strtolower(trim($domain));
+
+        // Strip www. prefix
+        if (str_starts_with($domain, 'www.')) {
+            $domain = substr($domain, 4);
+        }
+
+        return $domain;
+    }
+
    /**
     * Get the current domain from the site URL
     */
--- a/src/Plugin.php
+++ b/src/Plugin.php
@@ -11,6 +11,7 @@ namespace Jeremias\WcLicensedProduct;

 use Jeremias\WcLicensedProduct\Admin\AdminController;
 use Jeremias\WcLicensedProduct\Admin\DashboardWidgetController;
+use Jeremias\WcLicensedProduct\Admin\DownloadWidgetController;
 use Jeremias\WcLicensedProduct\Admin\OrderLicenseController;
 use Jeremias\WcLicensedProduct\Admin\SettingsController;
 use Jeremias\WcLicensedProduct\Admin\VersionAdminController;
@@ -98,6 +99,7 @@ final class Plugin
        $this->twig = new Environment($loader, [
            'cache' => WP_CONTENT_DIR . '/cache/wc-licensed-product/twig',
            'auto_reload' => true, // Always check for template changes
+            'autoescape' => 'html', // Explicitly enable HTML autoescape for XSS protection
        ]);

        // Add WordPress functions as Twig functions
@@ -153,6 +155,7 @@ final class Plugin
            new OrderLicenseController($this->licenseManager);
            new SettingsController();
            new DashboardWidgetController($this->licenseManager);
+            new DownloadWidgetController($this->versionManager);

            // Show admin notice if unlicensed and not on localhost
            if (!$isLicensed && !$licenseChecker->isLocalhost()) {
@@ -205,15 +208,50 @@ final class Plugin
            return;
        }

+        // Try new multi-domain format first
+        $domainData = $order->get_meta('_licensed_product_domains');
+        if (!empty($domainData) && is_array($domainData)) {
+            $this->generateLicensesMultiDomain($order, $domainData);
+            return;
+        }
+
+        // Fall back to legacy single domain format
+        $this->generateLicensesSingleDomain($order);
+    }
+
+    /**
+     * Generate licenses for new multi-domain format
+     */
+    private function generateLicensesMultiDomain(\WC_Order $order, array $domainData): void
+    {
+        $orderId = $order->get_id();
+        $customerId = $order->get_customer_id();
+
+        // Index domains by product ID for quick lookup
+        $domainsByProduct = [];
+        foreach ($domainData as $item) {
+            if (isset($item['product_id']) && isset($item['domains']) && is_array($item['domains'])) {
+                $domainsByProduct[(int) $item['product_id']] = $item['domains'];
+            }
+        }
+
+        // Generate licenses for each licensed product
        foreach ($order->get_items() as $item) {
            $product = $item->get_product();
-            if ($product && $product->is_type('licensed')) {
-                $domain = $order->get_meta('_licensed_product_domain');
-                if ($domain) {
+            if (!$product || !$product->is_type('licensed')) {
+                continue;
+            }
+
+            $productId = $product->get_id();
+            $domains = $domainsByProduct[$productId] ?? [];
+
+            // Generate a license for each domain
+            foreach ($domains as $domain) {
+                if (!empty($domain)) {
                    $this->licenseManager->generateLicense(
                        $orderId,
-                        $product->get_id(),
-                        $order->get_customer_id(),
+                        $productId,
+                        $customerId,
                        $domain
                    );
                }
@@ -221,6 +259,29 @@ final class Plugin
        }
    }

+    /**
+     * Generate licenses for legacy single domain format
+     */
+    private function generateLicensesSingleDomain(\WC_Order $order): void
+    {
+        $domain = $order->get_meta('_licensed_product_domain');
+        if (empty($domain)) {
+            return;
+        }
+
+        foreach ($order->get_items() as $item) {
+            $product = $item->get_product();
+            if ($product && $product->is_type('licensed')) {
+                $this->licenseManager->generateLicense(
+                    $order->get_id(),
+                    $product->get_id(),
+                    $order->get_customer_id(),
+                    $domain
+                );
+            }
+        }
+    }
+
    /**
     * Get Twig environment
     */
--- a/src/Product/ProductVersion.php
+++ b/src/Product/ProductVersion.php
@@ -24,6 +24,7 @@ class ProductVersion
    private ?string $downloadUrl;
    private ?int $attachmentId;
    private ?string $fileHash;
+    private int $downloadCount;
    private bool $isActive;
    private \DateTimeInterface $releasedAt;
    private \DateTimeInterface $createdAt;
@@ -44,6 +45,7 @@ class ProductVersion
        $version->downloadUrl = $data['download_url'] ?: null;
        $version->attachmentId = !empty($data['attachment_id']) ? (int) $data['attachment_id'] : null;
        $version->fileHash = $data['file_hash'] ?? null;
+        $version->downloadCount = (int) ($data['download_count'] ?? 0);
        $version->isActive = (bool) $data['is_active'];
        $version->releasedAt = new \DateTimeImmutable($data['released_at']);
        $version->createdAt = new \DateTimeImmutable($data['created_at']);
@@ -144,6 +146,11 @@ class ProductVersion
        return $this->fileHash;
    }

+    public function getDownloadCount(): int
+    {
+        return $this->downloadCount;
+    }
+
    /**
     * Get the download URL from attachment
     */
@@ -197,6 +204,7 @@ class ProductVersion
            'download_url' => $this->downloadUrl,
            'attachment_id' => $this->attachmentId,
            'file_hash' => $this->fileHash,
+            'download_count' => $this->downloadCount,
            'is_active' => $this->isActive,
            'released_at' => $this->releasedAt->format('Y-m-d H:i:s'),
            'created_at' => $this->createdAt->format('Y-m-d H:i:s'),
--- a/src/Product/VersionManager.php
+++ b/src/Product/VersionManager.php
@@ -276,4 +276,98 @@ class VersionManager

        return (int) $count > 0;
    }
+
+    /**
+     * Increment download count for a version
+     */
+    public function incrementDownloadCount(int $versionId): bool
+    {
+        global $wpdb;
+
+        $tableName = Installer::getVersionsTable();
+        $result = $wpdb->query(
+            $wpdb->prepare(
+                "UPDATE {$tableName} SET download_count = download_count + 1 WHERE id = %d",
+                $versionId
+            )
+        );
+
+        return $result !== false;
+    }
+
+    /**
+     * Get total download count across all versions
+     */
+    public function getTotalDownloadCount(): int
+    {
+        global $wpdb;
+
+        $tableName = Installer::getVersionsTable();
+        $count = $wpdb->get_var("SELECT COALESCE(SUM(download_count), 0) FROM {$tableName}");
+
+        return (int) $count;
+    }
+
+    /**
+     * Get download statistics per product
+     */
+    public function getDownloadStatistics(): array
+    {
+        global $wpdb;
+
+        $tableName = Installer::getVersionsTable();
+
+        // Get total downloads
+        $totalDownloads = $this->getTotalDownloadCount();
+
+        // Get downloads per product (top 10)
+        $byProduct = $wpdb->get_results(
+            "SELECT product_id, SUM(download_count) as downloads
+             FROM {$tableName}
+             GROUP BY product_id
+             ORDER BY downloads DESC
+             LIMIT 10",
+            ARRAY_A
+        );
+
+        // Get downloads per version (top 10)
+        $byVersion = $wpdb->get_results(
+            "SELECT id, product_id, version, download_count
+             FROM {$tableName}
+             WHERE download_count > 0
+             ORDER BY download_count DESC
+             LIMIT 10",
+            ARRAY_A
+        );
+
+        // Enrich product data with names
+        $productsWithNames = [];
+        foreach ($byProduct ?: [] as $row) {
+            $product = wc_get_product((int) $row['product_id']);
+            $productsWithNames[] = [
+                'product_id' => (int) $row['product_id'],
+                'product_name' => $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product'),
+                'downloads' => (int) $row['downloads'],
+            ];
+        }
+
+        // Enrich version data with product names
+        $versionsWithNames = [];
+        foreach ($byVersion ?: [] as $row) {
+            $product = wc_get_product((int) $row['product_id']);
+            $versionsWithNames[] = [
+                'version_id' => (int) $row['id'],
+                'product_id' => (int) $row['product_id'],
+                'product_name' => $product ? $product->get_name() : __('Unknown Product', 'wc-licensed-product'),
+                'version' => $row['version'],
+                'downloads' => (int) $row['download_count'],
+            ];
+        }
+
+        return [
+            'total' => $totalDownloads,
+            'by_product' => $productsWithNames,
+            'by_version' => $versionsWithNames,
+        ];
+    }
 }
--- a/templates/admin/licenses.html.twig
+++ b/templates/admin/licenses.html.twig
@@ -1,6 +1,6 @@
 <div class="wrap">
    <h1 class="wp-heading-inline">{{ __('Licenses') }}</h1>
-    <a href="{{ admin_url }}?action=export_csv" class="page-title-action">
+    <a href="{{ export_csv_url() }}" class="page-title-action">
        <span class="dashicons dashicons-download" style="vertical-align: middle;"></span>
        {{ __('Export CSV') }}
    </a>
@@ -143,8 +143,8 @@
                            </td>
                            <td class="wclp-editable-cell" data-field="status" data-license-id="{{ item.license.id }}">
                                <span class="wclp-display-value">
-                                    <span class="license-status license-status-{{ item.license.status }}">
-                                        {{ item.license.status|capitalize }}
+                                    <span class="license-status license-status-{{ esc_attr(item.license.status) }}">
+                                        {{ esc_html(item.license.status)|capitalize }}
                                    </span>
                                </span>
                                <button type="button" class="wclp-edit-btn button-link" title="{{ __('Edit') }}">
--- a/templates/frontend/licenses.html.twig
+++ b/templates/frontend/licenses.html.twig
@@ -1,81 +1,130 @@
-{% if not has_licenses %}
+{% if not has_packages %}
    <p>{{ __('You have no licenses yet.') }}</p>
 {% else %}
    <div class="woocommerce-licenses">
-        {% for item in licenses %}
-            <div class="license-card">
-                <div class="license-header">
-                    <h3>
-                        {% if item.product_url %}
-                            <a href="{{ esc_url(item.product_url) }}">{{ esc_html(item.product_name) }}</a>
-                        {% else %}
-                            {{ esc_html(item.product_name) }}
-                        {% endif %}
-                    </h3>
-                    <span class="license-status license-status-{{ item.license.status }}">
-                        {{ item.license.status|capitalize }}
+        {% for package in packages %}
+            <div class="license-package">
+                <div class="package-header">
+                    <div class="package-title">
+                        <h3>
+                            {% if package.product_url %}
+                                <a href="{{ esc_url(package.product_url) }}">{{ esc_html(package.product_name) }}</a>
+                            {% else %}
+                                {{ esc_html(package.product_name) }}
+                            {% endif %}
+                        </h3>
+                        <span class="package-order">
+                            {{ __('Order') }}
+                            {% if package.order_url %}
+                                <a href="{{ esc_url(package.order_url) }}">#{{ esc_html(package.order_number) }}</a>
+                            {% else %}
+                                #{{ esc_html(package.order_number) }}
+                            {% endif %}
+                        </span>
+                    </div>
+                    <span class="package-license-count">
+                        {{ package.licenses|length }} {{ package.licenses|length == 1 ? __('License') : __('Licenses') }}
                    </span>
                </div>

-                <div class="license-details">
-                    <div class="license-key-row">
-                        <label>{{ __('License Key:') }}</label>
-                        <code class="license-key" data-license-key="{{ esc_attr(item.license.licenseKey) }}">
-                            {{ esc_html(item.license.licenseKey) }}
-                        </code>
-                        <button type="button" class="copy-license-btn" data-license-key="{{ esc_attr(item.license.licenseKey) }}" title="{{ __('Copy to clipboard') }}">
-                            <span class="dashicons dashicons-clipboard"></span>
-                        </button>
-                    </div>
-
-                    <div class="license-info-row">
-                        <span class="license-domain-display" data-license-id="{{ item.license.id }}">
-                            <strong>{{ __('Domain:') }}</strong>
-                            <span class="domain-value">{{ esc_html(item.license.domain) }}</span>
-                            {% if item.license.status == 'active' or item.license.status == 'inactive' %}
-                                <button type="button" class="wclp-transfer-btn"
-                                        data-license-id="{{ item.license.id }}"
-                                        data-current-domain="{{ esc_attr(item.license.domain) }}"
-                                        title="{{ __('Transfer to new domain') }}">
-                                    <span class="dashicons dashicons-randomize"></span>
-                                    {{ __('Transfer') }}
-                                </button>
-                            {% endif %}
-                        </span>
-                        <span><strong>{{ __('Expires:') }}</strong>
-                            {% if item.license.expiresAt %}
-                                {{ item.license.expiresAt|date('Y-m-d') }}
-                            {% else %}
-                                {{ __('Never') }}
-                            {% endif %}
-                        </span>
-                    </div>
+                <div class="package-licenses">
+                    {% for license in package.licenses %}
+                        <div class="license-entry license-entry-{{ esc_attr(license.status) }}">
+                            <div class="license-row-primary">
+                                <div class="license-key-group">
+                                    <code class="license-key">{{ esc_html(license.license_key) }}</code>
+                                    <span class="license-status license-status-{{ esc_attr(license.status) }}">
+                                        {{ esc_html(license.status)|capitalize }}
+                                    </span>
+                                </div>
+                                <div class="license-actions">
+                                    <button type="button" class="copy-license-btn" data-license-key="{{ esc_attr(license.license_key) }}" title="{{ __('Copy to clipboard') }}">
+                                        <span class="dashicons dashicons-clipboard"></span>
+                                    </button>
+                                    {% if license.is_transferable %}
+                                        <button type="button" class="wclp-transfer-btn"
+                                                data-license-id="{{ license.id }}"
+                                                data-current-domain="{{ esc_attr(license.domain) }}"
+                                                title="{{ __('Transfer to new domain') }}">
+                                            <span class="dashicons dashicons-randomize"></span>
+                                        </button>
+                                    {% endif %}
+                                </div>
+                            </div>
+                            <div class="license-row-secondary">
+                                <span class="license-meta-item license-domain">
+                                    <span class="dashicons dashicons-admin-site-alt3"></span>
+                                    {{ esc_html(license.domain) }}
+                                </span>
+                                <span class="license-meta-item license-expiry">
+                                    <span class="dashicons dashicons-calendar-alt"></span>
+                                    {% if license.expires_at %}
+                                        {{ license.expires_at|date('Y-m-d') }}
+                                    {% else %}
+                                        <span class="lifetime">{{ __('Lifetime') }}</span>
+                                    {% endif %}
+                                </span>
+                            </div>
+                        </div>
+                    {% endfor %}
                </div>

-                {% if item.downloads is defined and item.downloads is not empty %}
-                    <div class="license-downloads">
+                {% if package.downloads is defined and package.downloads is not empty %}
+                    <div class="package-downloads">
                        <h4>{{ __('Available Downloads') }}</h4>
                        <ul class="download-list">
-                            {% for download in item.downloads %}
-                                <li class="download-item">
-                                    <div class="download-row-file">
-                                        <a href="{{ esc_url(download.download_url) }}" class="download-link">
-                                            <span class="dashicons dashicons-download"></span>
-                                            {{ esc_html(download.filename ?: 'Version ' ~ download.version) }}
-                                        </a>
-                                    </div>
-                                    <div class="download-row-meta">
-                                        <span class="download-date">{{ esc_html(download.released_at) }}</span>
-                                        {% if download.file_hash %}
-                                            <span class="download-hash" title="{{ esc_attr(download.file_hash) }}">
-                                                <span class="dashicons dashicons-shield"></span>
-                                                <code>{{ download.file_hash[:12] }}...</code>
-                                            </span>
-                                        {% endif %}
-                                    </div>
-                                </li>
-                            {% endfor %}
+                            {# Show only the latest version (first item) #}
+                            {% set latest = package.downloads|first %}
+                            <li class="download-item download-item-latest">
+                                <div class="download-row-file">
+                                    <a href="{{ esc_url(latest.download_url) }}" class="download-link">
+                                        <span class="dashicons dashicons-download"></span>
+                                        {{ esc_html(latest.filename ?: 'Version ' ~ latest.version) }}
+                                    </a>
+                                    <span class="download-version-badge">{{ __('Latest') }}</span>
+                                </div>
+                                <div class="download-row-meta">
+                                    <span class="download-date">{{ esc_html(latest.released_at) }}</span>
+                                    {% if latest.file_hash %}
+                                        <span class="download-hash" title="{{ esc_attr(latest.file_hash) }}">
+                                            <span class="dashicons dashicons-shield"></span>
+                                            <code>{{ latest.file_hash[:12] }}...</code>
+                                        </span>
+                                    {% endif %}
+                                </div>
+                            </li>
                        </ul>
+
+                        {# Show older versions in collapsible if more than one version exists #}
+                        {% if package.downloads|length > 1 %}
+                            <div class="older-versions-section">
+                                <button type="button" class="older-versions-toggle" aria-expanded="false">
+                                    <span class="dashicons dashicons-arrow-down-alt2"></span>
+                                    {{ __('Older versions') }} ({{ package.downloads|length - 1 }})
+                                </button>
+                                <ul class="download-list older-versions-list" style="display: none;">
+                                    {% for download in package.downloads|slice(1) %}
+                                        <li class="download-item">
+                                            <div class="download-row-file">
+                                                <a href="{{ esc_url(download.download_url) }}" class="download-link">
+                                                    <span class="dashicons dashicons-download"></span>
+                                                    {{ esc_html(download.filename ?: 'Version ' ~ download.version) }}
+                                                </a>
+                                            </div>
+                                            <div class="download-row-meta">
+                                                <span class="download-date">{{ esc_html(download.released_at) }}</span>
+                                                {% if download.file_hash %}
+                                                    <span class="download-hash" title="{{ esc_attr(download.file_hash) }}">
+                                                        <span class="dashicons dashicons-shield"></span>
+                                                        <code>{{ download.file_hash[:12] }}...</code>
+                                                    </span>
+                                                {% endif %}
+                                            </div>
+                                        </li>
+                                    {% endfor %}
+                                </ul>
+                            </div>
+                        {% endif %}
                    </div>
                {% endif %}
            </div>
--- a/wc-licensed-product.php
+++ b/wc-licensed-product.php
@@ -3,7 +3,7 @@
 * Plugin Name: WooCommerce Licensed Product
 * Plugin URI: https://src.bundespruefstelle.ch/magdev/wc-licensed-product
 * Description: WooCommerce plugin to sell software products using license keys with domain-based validation.
- * Version: 0.3.5
+ * Version: 0.5.0
 * Author: Marco Graetsch
 * Author URI: https://src.bundespruefstelle.ch/magdev
 * License: GPL-2.0-or-later
@@ -28,7 +28,7 @@ if (!defined('ABSPATH')) {
 }

 // Plugin constants
-define('WC_LICENSED_PRODUCT_VERSION', '0.3.5');
+define('WC_LICENSED_PRODUCT_VERSION', '0.5.0');
 define('WC_LICENSED_PRODUCT_PLUGIN_FILE', __FILE__);
 define('WC_LICENSED_PRODUCT_PLUGIN_DIR', plugin_dir_path(__FILE__));
 define('WC_LICENSED_PRODUCT_PLUGIN_URL', plugin_dir_url(__FILE__));
Author	SHA1	Message	Date
magdev	c45816b491	Add release package v0.5.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 18:35:26 +01:00
magdev	bcabf8feb2	Bump version to 0.5.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 18:32:24 +01:00
magdev	83836d69af	Implement multi-domain licensing for v0.5.0 - Add multi-domain checkout support for WooCommerce Blocks - Fix domain field rendering using ExperimentalOrderMeta slot - Add DOM injection fallback for checkout field rendering - Update translations with new multi-domain strings (de_CH) - Update email templates for grouped license display - Refactor account page to group licenses by product/order Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 18:31:36 +01:00
magdev	550a84beb9	Update CLAUDE.md with v0.4.0 session history Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 17:01:50 +01:00
magdev	7d48028f62	Add release package v0.4.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:45:33 +01:00
magdev	2ec3f42b1f	Bump version to 0.4.0 - Add CHANGELOG entry for self-licensing prevention feature - Update plugin header and constant to 0.4.0 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:42:39 +01:00
magdev	4817175f99	Add self-licensing prevention to PluginLicenseChecker - Add isSelfLicensing() method to detect when license server URL points to same installation - Bypass license validation when self-licensing detected (prevents circular dependency) - Add normalizeDomain() helper for domain comparison - Update translations Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:41:56 +01:00
magdev	a4561057fa	Update CLAUDE.md with v0.3.9 session history Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:11:09 +01:00
magdev	d15c59b7c3	Add release package v0.3.9 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:10:00 +01:00
magdev	4a90e6b18b	Bump version to 0.3.9 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:08:41 +01:00
magdev	502a8c7cd7	Update translation template with current line references Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:07:46 +01:00
magdev	6b83fce8b2	Fix admin order license generation bug - Add 'Generate Licenses' button to order meta box for admin-created orders - Add AJAX handler for manual license generation - Show warning when domain is not set or order is not paid - Handle partial license generation (when some products already have licenses) - Update German translations for new strings (365 translated) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 16:06:13 +01:00
magdev	8c33eaff29	Clean up known bugs section after v0.3.8 fix Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 15:38:19 +01:00
magdev	98002ae3d7	Update CLAUDE.md with v0.3.8 session history Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 15:37:14 +01:00
magdev	a93381dce6	Bump version to 0.3.8 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 15:34:38 +01:00
magdev	a522455a0a	Fix duplicate translation string causing sprintf error Removed duplicated German translation text that had two %s placeholders causing ArgumentCountError in settings page. Updated composer.lock with latest client library (64d215c). Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 15:34:06 +01:00
magdev	2de6abe133	Update CLAUDE.md with v0.3.7 session history Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 10:21:49 +01:00
magdev	8d60758f23	Add release package v0.3.7 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 10:19:53 +01:00
magdev	82bec621c6	Bump version to 0.3.7 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 10:18:33 +01:00
magdev	034593f896	Dashboard widget improvements and download counter feature (v0.3.7) - Fixed: Dashboard widget "View All Licenses" link used wrong page slug - Fixed: Download links in customer account resulted in 404 errors - Removed: Redundant "Status Breakdown" section from dashboard widget - Changed: License Types section now uses card style layout - Added: Download counter for licensed product versions - Added: Download Statistics admin dashboard widget - Updated translations (356 strings) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 10:17:46 +01:00
magdev	202f8a6dc0	Update composer.lock with latest client library Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-23 21:23:27 +01:00
magdev	36b51c9fc8	Update CLAUDE.md with v0.3.6 session history - Document security hardening changes (CSRF, IP spoofing, XSS) - Add recursive key sorting fix for response signing - Document trusted proxy configuration - Add release information (SHA256, package size) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-23 21:22:26 +01:00
magdev	d0aaf3180f	Merge branch 'main' into dev	2026-01-23 21:21:25 +01:00
magdev	35d802c2b8	Security improvements and API compatibility fixes (v0.3.6) - Add recursive key sorting for response signing compatibility - Fix IP header spoofing in rate limiting with trusted proxy support - Add CSRF protection to CSV export with nonce verification - Explicit Twig autoescape for XSS prevention - Escape status values in CSS classes - Update README with security documentation and trusted proxy config - Update translations for v0.3.6 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-23 21:18:32 +01:00
magdev	4e683e2ff4	Update CLAUDE.md roadmap after v0.3.5 release Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-23 16:24:37 +01:00
				`@@ -0,0 +1 @@`
				`e93b2ab06f6d43c2179167090e07eda5db6809df6e391baece4ceba321cf33f6 wc-licensed-product-0.3.7.zip`
				`@@ -0,0 +1 @@`
				`fdb65200c368da380df0cabb3c6ac6419d5b4731cd528f630f9b432a3ba5c586 releases/wc-licensed-product-0.3.9.zip`
				`@@ -0,0 +1 @@`
				`cf8769c861d77c327f178049d5fac0d4e47679cc1a1d35c5b613e4cd3fb8674f wc-licensed-product-0.4.0.zip`
				`@@ -0,0 +1 @@`
				`446804948e5f99d705b548061d5b78180856984c58458640a910ada8f27f5316 wc-licensed-product-0.5.0.zip`