LycheeOrg/Lychee
43.1
Weak · 17 November 2026
282.6k
lines of production code
PHP
with TypeScript
5
measurements over time
What this system is
Features
API validation layer for the new Renamer module
This change introduces the HTTP request validation classes for the Renamer feature, enabling users to create, update, list, and delete renaming rules, as well as preview and execute renames on photos and albums. The \CreateRenamerRuleRequest\ and \UpdateRenamerRuleRequest\ classes enforce the structure of rules (including needle, replacement, mode, and photo/album scope flags) and ensure users can only modify their own rules. \PreviewRenameRequest\ and \RenameRequest\ handle the authorization and validation for applying these rules to specific media items, while \TestRenamerRequest\ allows users to test rule logic against candidate strings. \DeleteRenamerRuleRequest\ and \ListRenamerRulesRequest\ complete the CRUD operations for managing the rule set.
app/Http/Requests/Renamer · high confidence
Add Helpers facade for static access to utility methods
A new \Helpers\ facade has been introduced in the application, providing static access to the \App\\Assets\\Helpers\ class. This allows developers to call utility methods such as \getTmpDir\, \getExtension\, \hasPermissions\, \secondsToHMS\, and \censor\ via the \Helpers\ alias, simplifying usage across the codebase.
app/Facades · high confidence
Add LDAP authentication support and a combined session/token auth guard
Users can now authenticate against an LDAP directory via the new LdapService, which handles user search, binding, and group membership queries. Additionally, the application introduces a custom SessionOrTokenGuard that allows a single route to accept either a session-based login or an API token, ensuring consistency if both are present and preventing user mismatch errors.
app/Services/Auth · high confidence
Add Laminas Text Table decorator interface
The application now includes the \DecoratorInterface\ from the Laminas Text Table component within the \app/Contracts/Laminas\ namespace. This interface defines methods for retrieving specific characters used to render table borders and dividers (such as corners, lines, and crossings), enabling the application to support structured text-based table formatting consistent with the Laminas library.
app/Contracts/Laminas · high confidence
Add NSFW detection request validation
This change introduces request validation classes for the new NSFW detection feature. It adds a bulk scan endpoint for administrators to trigger scans on albums, a read-only endpoint for users to retrieve detection results for specific photos, and a webhook endpoint that accepts detection results from an external classification service using API key authentication.
app/Http/Requests/Nsfw · high confidence
Add color extraction from pictures
Users can now extract dominant colors from images. This change introduces a new color extraction system in the app/Image/ColourExtractor directory, featuring two implementations: FarzaiExtractor, which uses the Farzai Color Palette library and supports both GD and Imagick backends, and LeagueExtractor, which uses the League Color Extractor library with GD. An ImageFactoryForColourExtraction helper class manages the creation of image instances from Flysystem files, handling stream buffering and backend selection based on configuration.
app/Image/ColourExtractor · high confidence
Added PHPStan stubs for Safe GD image functions
Added stub files for the Safe library's GD image functions (such as imagecreatefromstring, imagecreatetruecolor, imagejpeg, and imagepng) and the ImageException class. These stubs provide type information for static analysis, bridging the gap until the Safe library natively supports these types in version 2.0.
phpstan · high confidence
Added Vite development entry point with configuration diagnostics
A new \vite/index.html\ file has been introduced to serve as the entry point for the Vite local development environment. This HTML file loads the application script and includes a hidden diagnostic overlay that displays when the application is misconfigured. The overlay guides users to verify their \APP\_URL\, \TRUSTED\_PROXIES\, reverse proxy forwarding headers, and \APP\_FORCE\_HTTPS\ settings, ensuring that common deployment issues are surfaced immediately during local development.
vite · high confidence
Added browsable album title listing for Frame view
A new action class, ListBrowsableAlbumTitles, has been introduced in the Frame actions namespace to support the Frame album line feature. This component retrieves a sorted list of album titles that a user can browse to from a specific photo, ensuring that only albums meeting the browsability search rules are included, while excluding those that require a direct link.
app/Actions/Frame · high confidence
Added database optimization actions
Users can now explicitly optimize and analyze the database to improve performance. New action classes (OptimizeDb, OptimizeTables) have been introduced to handle database-specific maintenance tasks: OptimizeDb runs OPTIMIZE TABLE for MySQL, VACUUM for PostgreSQL and SQLite, while OptimizeTables runs ANALYZE commands across all supported database drivers. These actions provide feedback on the status of the optimization process.
app/Actions/Db · high confidence
Added shop-specific exception classes for better error handling
This change introduces five new exception classes within the \App\\Exceptions\\Shop\ namespace to provide more granular error reporting for the webshop backend. These include \BasketDeletionFailedException\ for failed basket deletions, \InvalidPurchaseOptionException\ and \PhotoNotPurchasableException\ to handle purchase validation errors, \OrderIsNotPendingException\ to prevent modification of non-pending orders, and \ProviderConfigurationNotFoundException\ to indicate missing payment provider configurations. These exceptions extend the base \BaseLycheeException\ and return appropriate HTTP status codes (403 Forbidden, 500 Internal Server Error, or 501 Not Implemented) to improve the clarity of error responses for users and developers.
app/Exceptions/Shop · high confidence
Admin bulk-edit albums capability
Administrators can now apply partial metadata and visibility changes to multiple albums in a single operation. The new BulkEditAlbumsAction processes updates in three groups: base album properties (description, copyright, layout, sorting, NSFW status, and published date), album-specific settings (license, thumbnail aspect ratio, timeline, and sorting), and visibility/permission policies (public status, link requirements, and access grants). This allows efficient batch management of album attributes without needing to edit each album individually.
app/Actions/Admin · high confidence
Arabic localization for v8 admin and gallery features
Added comprehensive Arabic translations for the v8 front-end, covering the admin dashboard (including NSFW moderation and security alerts), bulk album editing, contact form, design system, diagnostics, duplicate finder, fix-tree maintenance, flow page, gallery views (smart albums, search, timeline, layouts), server import, jobs page, landing page configuration, and various dialogs (login, share, upload, camera).
lang · high confidence
Asynchronous processing for uploads, metadata, and album maintenance
The application now offloads heavy operations to background jobs to improve responsiveness. Photo uploads are processed via ProcessImageJob and ImportImageJob, supporting features like title/description injection, expected ID pre-allocation, and optional watermarking. ZIP imports are handled by ExtractZip with built-in zip-bomb protection, followed by CleanUpExtraction. Metadata updates (title, description, tags, ratings) are written to files asynchronously via EmbedMetadataJob (gated by config and requiring exiftool). Album maintenance is also asynchronous: RecomputeAlbumStatsJob and RecomputeAlbumSizeJob recalculate computed fields and size statistics, RecomputeAlbumPhotoBucketsJob handles sorting bucket updates, and CleanupOrphanedPersonAlbumsJob removes empty person albums. Additional jobs include DispatchNsfwScanJob and DispatchFaceScanJob for AI-driven content moderation and recognition, GeodecodeLocationJob for reverse geocoding, ExtractColoursJob for color palette extraction, and FileDeleterJob for secure file removal.
app/Jobs · high confidence
Backend API for the contact form
This change introduces the backend infrastructure for the contact form feature. The new \ContactController\ handles storing public messages (with optional security question and consent validation), listing messages for administrators, and updating or deleting specific messages. Supporting request classes enforce validation rules for message content and admin permissions, ensuring that only authorized users can manage the contact message queue.
app/Http/Controllers/Contact, app/Http/Requests/Contact · high confidence
Backend support for face quick naming and asset serving
This change introduces the backend infrastructure for the face quick naming feature and improves asset delivery. It adds a new \QueryFaceQueue\ action that efficiently retrieves a queue of unassigned faces with suggested person names and cluster sizes in a single database query, and a \RecountFaceCounters\ action to maintain accurate face counts on photos and persons. Additionally, it adds a \ServesSizeVariantAssetTrait\ that handles serving image variants with S3 temporary redirects and fallback logic for missing files, which is shared by both general asset endpoints and the new face-specific photo variant endpoint.
app/Actions/Face · high confidence
Backend validation and payload construction for configurable webhooks
Administrators can now configure webhooks via the API, with this change introducing the server-side request validation and payload building logic. New request classes in app/Http/Requests/Webhook enforce that only users with administrative privileges can create, read, update, delete, or list webhook configurations, and they validate fields such as name, event type, HTTP method, URL, payload format, and optional security secrets. The WebhookPayloadBuilder service in app/Services/Webhook constructs the outgoing webhook payload, allowing administrators to toggle the inclusion of photo IDs, album IDs, titles, and specific size variants in the notification data.
app/Http/Requests/Webhook, app/Services/Webhook · high confidence
Batch renaming and preview for albums and photos
Users can now preview and apply bulk rename rules to albums and photos. New action classes (PreviewAlbums, PreviewPhotos, RenameAlbums, RenamePhotos) allow selecting specific items or scoping to a parent album (including descendants), processing changes in chunks of 100 to manage memory, and updating titles in batch. The rename operation also re-splits titles into base and index components using TitleSplitter.
app/Actions/Renamer · high confidence
Comprehensive authorization system with granular access control and query filtering
The application now uses a structured Laravel Policy system to manage permissions for albums, photos, users, and AI vision features. Regular policies (e.g., AlbumPolicy, PhotoPolicy) handle instance-level checks for actions like viewing, editing, downloading, and sharing, while query policies (AlbumQueryPolicy, PhotoQueryPolicy) apply database-level filters to ensure users only see data they are authorized to access. Admins bypass most checks via a base policy override. New features include configurable face permission modes for AI vision operations, user-group management policies, and live metrics access controls.
app/Policies · high confidence
Custom OpenAPI schema generation for Laravel Data classes
A new \DataToResponse\ extension has been added to the OpenAPI resource layer to integrate with the Scramble documentation generator. This component automatically converts Spatie Laravel Data classes into OpenAPI schema definitions by reflecting their public properties and mapping PHP types (such as int, string, bool, and unions) to their corresponding API documentation types, ensuring that API responses based on these data objects are accurately documented.
app/Http/Resources/OpenApi · high confidence
Expanded admin maintenance tools for album stats, face recognition, and system health
The admin maintenance interface now includes a comprehensive set of controllers for managing system integrity and AI-driven features. Administrators can backfill missing album size statistics and precomputed fields (like date ranges and cover IDs) to ensure accurate album listings. New tools allow bulk scanning for faces, resetting stuck or failed face scan statuses, purging orphaned face embeddings from the AI Vision service, and running face clustering. The system also provides utilities to fix broken album trees, clear stuck job histories, flush caches and queues, and generate missing size variants or file sizes. Additionally, order fulfillment can be manually retried for the webshop, and database optimization is available.
app/Http/Controllers/Admin/Maintenance · high confidence
Expanded diagnostics with detailed system, database, and version reporting
The diagnostics report now includes several new informational sections to help users verify their environment. It reports the number of foreign keys in the database (SQLite, MySQL, PostgreSQL), identifies the specific Docker image variant (LinuxServer.io, LycheeOrg, FrankenPHP, or custom), and details available image processing extensions (Imagick and GD) along with their versions. System checks now display the PHP integer size (32/64-bit), timezone, and upload limits. Version reporting distinguishes between release, tag, and git channels, shows the Lychee edition (SE, Pro, Signature), and flags tampered installations. Additionally, it checks whether APP\_URL and APP\_DIR are set to non-default values to prevent visual issues.
app/Actions/Diagnostics/Pipes/Infos · high confidence
Input validation for Webshop purchasable items and size configurations
This change introduces a suite of new request validation classes in the ShopManagement namespace to support the Webshop feature. These classes enforce authorization checks (ensuring only the owner can manage items) and validate input data for creating, updating, and deleting purchasable albums and photos, as well as managing associated print and pixel size definitions. The validation rules ensure that prices, license types, size variants, and references to existing print/pixel sizes are correctly formatted and present before processing.
app/Http/Requests/ShopManagement · high confidence
Introduce NSFW detection data transfer objects
Added new DTOs in the app/DTO/Nsfw namespace to structure NSFW moderation results. NsfwBboxData defines bounding box coordinates, NsfwDetectionItemData represents individual detection items with labels and confidence scores, and NsfwDetectionResultsData aggregates these into categorized lists (block, review, sensitive) along with boolean flags indicating whether the photo should be blocked, reviewed, or marked as sensitive.
app/DTO/Nsfw · high confidence
Introduce Timeline API resources for photo browsing
Added new API resource classes (\InitResource\ and \TimelineResource\) to support the Timeline feature. \InitResource\ exposes the current photo layout, timeline page enablement status, root configuration, and album rights to the client. \TimelineResource\ handles the serialization of paginated photo collections, automatically calculating pagination metadata (current page, total items, etc.) and linking photos with previous/next IDs for navigation. It also applies photo granularity settings and enforces per-photo access grants before returning the data.
app/Http/Resources/Timeline · high confidence
Introduce Webshop API resource layer
Added a comprehensive set of API resources in the Shop namespace to structure webshop data for the frontend. This includes resources for catalog items (albums and photos), purchasable configurations (prices, print sizes, pixel sizes), checkout options (payment providers, currency, guest checkout settings), and order management (order details, order items with thumbnails and size variants). These resources standardize the JSON responses for the webshop backend, enabling features like print and pixel size support and order item display.
app/Http/Resources/Shop · high confidence
Introduce Webshop backend controllers for browsing, ordering, and checkout
This change adds the core backend controllers for the new Webshop feature, enabling users to browse purchasable items, manage their shopping basket, and complete payments. The new BasketController handles adding photos, albums, prints, and pixel-size digital downloads to the basket, as well as retrieving and deleting the basket. The CatalogController and CatalogueSizesController expose the catalog of purchasable items and their available print/pixel sizes with prices. The CheckoutController manages the payment flow, including creating sessions, processing payments via providers like PayPal, and finalizing orders. Finally, the OrderController allows for listing orders and marking them as paid or delivered.
app/Http/Controllers/Shop · high confidence
Introduce backend webshop services and PayPal payment gateway
This change adds the core backend logic for a new webshop feature, introducing services to manage shopping baskets, orders, and purchasable items (photos and albums with size/license variants). It also implements a custom PayPal payment gateway using the official PayPal Server SDK, integrated via the Omnipay library, allowing users to purchase digital or print versions of their photos.
app/Actions/Shop · high confidence
Introduce data structures for the duplicate finder feature
Added two new resource classes, \Duplicate\ and \DuplicateCount\, within the \app/Http/Resources/Models/Duplicates\ namespace. The \Duplicate\ class structures individual duplicate entries by extracting album and photo identifiers, titles, checksums, and generating a small-size URL from the model's short path. The \DuplicateCount\ class aggregates counts for pure duplicates, title-based duplicates, and duplicates found within the same album. These resources are annotated for TypeScript transformation to support frontend integration.
app/Http/Resources/Models/Duplicates · high confidence
Introduce live metrics tracking and API feed
Added a new live metrics system that records user interactions (such as views and actions) in real-time. This includes a new \CleanupMetrics\ action to manage the retention of this data based on configurable time limits and cleanup modes (synchronous or deferred), and a \QueryLiveMetrics\ action that powers the \GET /api/v3/Metrics\ endpoint. The API feed aggregates recent events by action, album, and minute, joining relevant album and photo metadata while respecting user permissions, and supports pagination via a configurable result limit.
app/Actions/Metrics · high confidence
Introduce standalone photo upload pipeline
A new standalone photo upload flow has been added, implemented as a series of processing pipes in the \app/Actions/Photo/Pipes/Standalone\ directory. This pipeline handles the complete lifecycle of a standalone photo upload, including applying user-provided metadata (title and description), applying watermarks, auto-renaming, and creating size variants (original, raw, and placeholders). It also integrates AI-powered features such as automatic face scanning and NSFW moderation, while managing file placement, checksum calculation, and support for specific formats like Google Motion Pictures.
app/Actions/Photo/Pipes/Standalone · high confidence
Introduces a centralized, tag-based caching infrastructure for album listings
A new caching layer has been added to the application, centered around \CacheKeyProvider\ and \ManagedCacheService\ in the \app/Services/Cache\ directory. \CacheKeyProvider\ acts as the single source of truth for generating cache keys and tags for album, tag, and person listings, ensuring that producers and invalidators agree on key shapes to prevent silent eviction misses. \ManagedCacheService\ provides a generic memoization mechanism with tag-based eviction, allowing specific cached entries (like album children or flow descriptions) to be invalidated when their underlying data changes, while respecting global and per-user configuration switches for enabling or disabling the cache.
app/Services/Cache · high confidence
Introduces new image processing and file abstraction contracts
This change adds a suite of new interfaces in the \app/Contracts/Image\ and \app/Contracts/Exceptions\ namespaces to standardize how the application handles image data and errors. Specifically, it defines \ImageHandlerInterface\ for loading, scaling, cropping, rotating, and saving images, \BinaryBlob\ and \MediaFile\ for unified stream-based file operations (supporting local files, uploads, and remote disks), \ColourPaletteExtractorInterface\ for extracting dominant colors from images, and \StreamStats\ for tracking stream metadata. It also introduces exception interfaces (\LycheeException\, \ExternalLycheeException\, \InternalLycheeException\, \HttpExceptionHandler\) to structure error handling. These contracts provide the foundational API for image manipulation and file management within the application.
app/Contracts/Image · high confidence
Introduction of ImportPipe interface for import processing
Added the ImportPipe interface in the app/Contracts/Import namespace, defining a handle method that accepts an ImportDTO state and a closure for the next step in the chain. This establishes the contract for individual stages within the import pipeline, supporting the revamped and faster import synchronization logic.
app/Contracts/Import · high confidence
Introduction of centralized factory classes for core entities
The application now uses dedicated factory classes in app/Factories to manage the creation and retrieval of albums, persons, IDs, and payment gateways. AlbumFactory centralizes the logic for finding and instantiating various album types (including smart albums like Highlighted, Timeline, and Best Pictures) and handles eager loading of photo relations. IdFactory provides a standardized method for generating URL-safe random IDs. PersonFactory manages the retrieval or creation of person records, applying default configuration for searchability. OmnipayFactory handles the initialization and validation of payment gateway providers, specifically supporting PayPal and other Omnipay-compatible services.
app/Factories · high confidence
Login request now supports 'remember me' functionality
The login validation logic has been updated to accept and process a 'remember me' boolean field from the client. This allows users to opt into persistent sessions during authentication, with the request class now exposing a method to determine if this preference was set, while still enforcing standard username and password rules.
app/Http/Requests/Session · high confidence
New AI Vision controllers for face detection, person management, and NSFW moderation
This change introduces a comprehensive set of new API controllers in the AiVision namespace to support AI-driven photo analysis. Face detection is handled by FaceDetectionController (scanning, results, and clustering) and FaceClusterController (managing unassigned face clusters). Person management is provided by PeopleController (CRUD), PersonClaimController (claiming, unclaiming, merging), SelfieClaimController (selfie-based claiming), AlbumPeopleController (listing persons in albums), PersonPhotosController (listing photos by person), and PhotoFacesController (face overlays). Face operations are managed by FaceController (assigning, dismissing, batch operations, and cleanup) and FaceMaintenanceController (admin quality review). Additionally, NSFW moderation is introduced via NsfwDetectionController (bulk scanning and results processing) and NsfwConfigController (configuration retrieval).
app/Http/Controllers/AiVision · high confidence
New AI-powered image services for face detection, NSFW moderation, and file handling
This update introduces a suite of new backend services in the Image module to support advanced AI features and broader file compatibility. Face detection is now handled by a dedicated FaceDetectionService that manages batch scanning jobs and a FacialRecognitionService that communicates with an external AI Vision API for matching and embedding management. NSFW moderation is implemented via NsfwDetectionService and NsfwActionService, which dispatch scans to an external classification service and apply configurable actions (block, review, or mark) based on user trust levels. Additionally, the FileExtensionService has been expanded to support AVIF, HEIC/HEIF, and various RAW image formats, enabling the system to process and convert these new file types.
app/Services/Image · high confidence
New API resource classes for album protection, timeline, and photo data
This change introduces a new set of data transfer objects in the \app/Http/Resources/Models/Utils\ directory to structure API responses. \AlbumProtectionPolicy\ exposes album security settings (public access, password requirements, download/upload permissions) to the frontend. \PreComputedPhotoData\ and \PreformattedPhotoData\ provide structured photo metadata, including EXIF details, GPS coordinates (respecting privacy settings), and formatted dates. \PreFormattedAlbumData\ handles album header information, including title colors, palettes, and date ranges. \TimelineData\ adds granular date formatting for timeline views, supporting both photo and album sorting. \HeaderFocusData\, \PersonNameResource\, and \UserToken\ provide specific data structures for header image focus points, person names, and authentication tokens respectively. All classes are annotated for TypeScript generation.
app/Http/Resources/Models/Utils · high confidence
New API resource classes for collections and pagination
The API now exposes dedicated collection and pagination resource classes (e.g., PaginatedPhotosResource, PaginatedAlbumsResource, PaginatedPersonsResource, PaginatedWebhookResource, RootAlbumResource, PositionDataResource, ContactMessageCollectionResource, LandingFeaturedItemCollection, LandingLinkCollection, PaginatedClustersResource, PaginatedFaceResource, PaginatedModerationResource, UserGroupDataResource). These resources standardize how lists and paginated data are serialized for the frontend, including timeline data setup for albums and photos, and exposing user permissions for features like user groups.
app/Http/Resources/Collections · high confidence
New API resources for bulk album editing and server import
Added new API resource classes to support the bulk album edit and server import features. BulkAlbumResource and PaginatedBulkAlbumResource expose album metadata (including sorting, layout, and visibility settings) and nested left/right tree values (\_lft, \_rgt) to enable client-side depth calculation for bulk operations. BulkAlbumIdsResource provides a truncated list of matching album IDs with a capped flag. ImportFromServerResource, ImportDirectoryResource, and ImportFromServerOptionsResource expose server import configuration (such as symlink, duplicate skipping, and metadata resync settings) and report the status of directory import jobs.
app/Http/Resources/Admin · high confidence
New API v3 album endpoints for pagination, bulk editing, and access permissions
The gallery API introduces a suite of new controllers in \app/Http/Controllers/Gallery\ to support a redesigned, paginated album browsing experience and bulk operations. \AlbumListController\ provides a lightweight, rights-curated, and cacheable flat listing of albums (\GET /api/v3/Albums\) with optional bulk-edit fields and parent IDs. \AlbumHeadController\ serves album metadata without children or photos, enabling the frontend to load metadata separately from content. \AlbumChildrenController\ and \AlbumPhotosController\ handle paginated retrieval of child albums and photos respectively, supporting sorting and timeline granularity. \AlbumAccessPermissionListController\ exposes a Struct-of-Arrays listing of all albums and their user/group permissions for the bulk-share admin page. Additionally, \AlbumTracksController\ adds support for managing multi-track audio for albums, and \AlbumTagsController\ provides tags available within specific albums.
app/Http/Controllers/Gallery · high confidence
New CLI commands for batch image processing and migration
A suite of new Artisan commands has been added to the \app/Console/Commands/ImageProcessing\ directory to handle batch operations on existing media. These include \lychee:decode\_GPS\_locations\ to reverse-geocode missing photo locations, \lychee:detect\_360\ to identify 360° photos, \lychee:extract\_colour\_palette\ to generate color palettes, \lychee:exif\_lens\ to populate missing EXIF metadata (ISO, aperture, lens, etc.), \lychee:generate\_thumbs\ to create missing image variants, \lychee:encode\_placeholders\ to process low-quality placeholders, \lychee:variant\_filesize\ to correct missing file sizes, \lychee:video\_data\ to generate video thumbnails and metadata, and \lychee:takedate\ to update creation dates from EXIF data. Additionally, \lychee:s3\_migrate\ and \lychee:track\_s3\_migrate\ are provided to move existing local photos and audio tracks to an S3 storage backend.
app/Console/Commands/ImageProcessing · high confidence
New DecorateBackedEnum trait for PHP enums
A new \DecorateBackedEnum\ trait has been added to the \app/Enum/Traits\ directory, providing three utility methods (\names\, \values\, and \array\) that can be used by PHP backed enums to easily retrieve their case names, values, or a combined associative array.
app/Enum · high confidence
New Insights feature with detailed photo and video statistics
Added a comprehensive Insights feature that provides users with detailed statistics about their media library. This includes an overview of total items, storage usage, and people/places data; time-based analysis such as capture spans, calendars, and upload rhythms; device and lens usage counts; exposure distributions (ISO, shutter, aperture, focal length); format details like orientation and aspect ratios; and a timeline of significant events like first captures, longest videos, and milestones. The implementation uses efficient accumulators and caching to compute these metrics without impacting performance.
app/Http/Requests/Insights, app/Http/Resources/Insights · high confidence
New Oauth action class for authentication and registration
A new Oauth action class has been introduced to handle OAuth authentication flows. It provides methods to validate OAuth providers, authenticate users by linking existing accounts or automatically creating new ones based on configuration, and register new OAuth credentials for existing users. The logic includes determining usernames from provider data and managing user sessions via Laravel's Auth facade.
app/Actions/Oauth · high confidence
New WebAuthn credential management request validators
Added three new form request classes in the WebAuthn namespace to handle credential operations: DeleteCredentialRequest for removing credentials, EditCredentialRequest for renaming them with strict ownership checks (ensuring users can only edit their own credentials unless they are administrators), and ListCredentialsRequest for listing credentials. These validators enforce specific authorization policies and input rules for the WebAuthn feature set.
app/Http/Requests/WebAuthn · high confidence
New admin panel controllers for bulk album editing, moderation, and shop management
The admin area now includes dedicated controllers for several new management capabilities. Administrators can perform bulk edits on albums (including metadata updates, ownership transfers, and deletion) via the new BulkAlbumController. A ModerationController allows admins to review and bulk-approve photos flagged by NSFW detection. Shop management is supported through controllers for managing print and pixel size catalogues, setting albums and photos as purchasable, and updating prices. Additional controllers provide admin access to landing page configuration (featured items and links), system diagnostics, server-side photo imports, job history, security advisories, and user/group management.
app/Http/Controllers/Admin · high confidence
New album request validators for v8 API endpoints
The application introduces a comprehensive set of new HTTP request validation classes in the \app/Http/Requests/Album\ directory to support the v8 API. These validators handle specific album operations including creation (regular, person, and tag albums), deletion, moving, merging, and renaming. They also manage album content interactions such as fetching children, photos, and buckets, as well as managing album tracks (GPX files) and protection policies. Each class implements specific authorization checks using the \AlbumPolicy\ and validates input data according to the new API structure, ensuring that only authorized users can perform actions like editing, deleting, or transferring album ownership.
app/Http/Requests/Album · high confidence
New and refactored maintenance console commands
The \app/Console/Commands\ area now includes a comprehensive suite of new and refactored Artisan commands to improve system maintenance and operational control. Administrators can now use \lychee:fix-permissions\ to automatically correct directory and file permissions on POSIX systems, and \lychee:fix-tree\ to repair the nested set model of the album hierarchy. The \lychee:diagnostics\ command provides a structured view of system, configuration, and error information, while \lychee:ghostbuster\ helps clean up orphaned files and dead symbolic links. Bulk data integrity is supported by \lychee:recompute-album-sizes\, \lychee:recompute-album-stats\, and \lychee:recompute-buckets\ for backfilling album statistics and sorting buckets. AI-driven features are managed via \lychee:scan-faces\ and \lychee:rescan-failed-faces\ for face detection jobs. The \lychee:sync\ command has been updated to use background jobs for improved performance, and \lychee:photos\_added\_notification\ handles email notifications for new uploads. Additionally, \lychee:webhook-test\ allows for immediate testing of webhook configurations.
app/Console/Commands · high confidence
New backend actions for map viewport queries and album map points
Added four new PHP classes in app/Actions/Map to power the map API endpoints. QueryMapBuckets handles grid-based clustering and singleton photo detection for the map viewport, QueryMapPhotos fetches individual photos within the viewport with a cap to prevent performance issues, QueryAlbumMapPoints retrieves geotagged points for a specific album, and ResolvesMapPhotoSource provides shared logic for resolving photo scopes and applying bounding box filters.
app/Actions/Map · high confidence
New backend services for admin stats, timeline bucketing, security, and URL handling
This change introduces a suite of new service classes in app/Services to support backend functionality. AdminStatsService provides a cached overview of gallery statistics (photos, albums, users, storage, jobs). AlbumBucketComputer and PhotoBucketComputer centralize the logic for computing timeline bucket IDs based on sorting columns and granularity. SecurityAdvisoriesService fetches and filters GitHub security advisories for the running version. GalleryLockState manages the gallery password unlock cookie and lock state. GpxValidation and UrlValidation enforce strict security checks on uploaded GPX files and imported URLs, respectively, to prevent XSS, XXE, and SSRF. MoneyService handles currency operations for the webshop. PersonAlbumMatcher builds queries for person album visibility. TemporaryLinkSigner generates secure, rotating codes for temporary image links. TitleSplitter enables natural sorting of titles at the database layer. UrlGenerator creates signed or encrypted image URLs. VersionRangeChecker evaluates semver ranges for security checks.
app/Services · high confidence
New configuration files for Clockwork, CORS, Laravel Data, Debugbar, and feature flags
This change introduces a set of new configuration files that define the default settings for several key components. The \config/clockwork.php\ file enables the Clockwork debugging tool with granular control over collected data (cache, database, HTTP requests, etc.). The \config/cors.php\ file sets up Cross-Origin Resource Sharing rules for API and Sanctum endpoints. The \config/data.php\ file configures the Spatie Laravel Data package for type-safe data transfer objects. The \config/debugbar.php\ file enables the Laravel Debugbar for development insights. The \config/features.php\ file introduces feature flags for capabilities like S3 storage, LDAP authentication, webhooks, and vulnerability checks. Additionally, new config files for \feed.php\, \honeypot.php\, \image-optimizer.php\, \ldap.php\, \log-viewer.php\, \markdown.php\, and \octane.php\ are added to configure RSS feeds, security honeypots, image optimization, LDAP connections, log viewing, markdown rendering, and the Octane server respectively.
config · high confidence
New console commands for creating and updating Lychee users
Added two new Artisan commands, \lychee:create\_user\ and \lychee:update\_user\, to manage user accounts via the command line. The create command allows administrators to provision new users with specific permissions (upload, edit settings, administer) and automatically grants admin rights if no other users exist. The update command enables changing a user's password by username.
app/Console/Commands/UserManagment · high confidence
New developer tooling and automation scripts
The repository now includes a suite of new scripts to streamline development workflows. A new Rector rule (\VariableCasingRector\) automatically converts variable names to camelCase during static analysis. A \check\_translations.php\ script validates that translation keys are consistent across all language files. Git hooks (\pre-commit\, \post-merge\) have been added to automatically run code formatters (php-cs-fixer, Prettier) and handle dependency installation/migrations upon merging. Additionally, \gen\_release.php\ automates the creation of version bump migrations, \generate-js-types.sh\ ensures TypeScript definitions are up-to-date, and \install\_files.php\ sets up initial project files and hooks.
scripts · high confidence
New development and build configuration files added
Added standard configuration files to improve development consistency and build reproducibility: a \.dockerignore\ to exclude unnecessary files from Docker builds, an \.editorconfig\ to enforce consistent coding styles across editors, a \.php-cs-fixer.php\ for PHP code formatting, a \.prettierrc.json\ for frontend formatting, and a \.trivyignore\ to suppress known security warnings in the Frankenphp base image. Also added \AGENTS.md\ and \DESIGN.md\ to document development workflows and the v8 design system.
(repo-wide) · high confidence
New email notification for added photos
Users will now receive an email notification when new photos are added to the system. This is implemented via a new \PhotosAdded\ mailable class that renders the \emails.photos-added\ markdown template, passing along the site title and the details of the added photos.
app/Mail · high confidence
New embed resources for albums, photos, and public streams
Added new API resource classes (EmbedAlbumInfo, EmbedAlbumResource, EmbedPhotoResource, EmbedStreamResource) that provide minimal, publicly visible data optimized for embedding Lychee galleries on external websites. These resources expose album metadata, photo details with size variants and EXIF data, and public photo streams, ensuring that only accessible content is included in embeds.
app/Http/Resources/Embed · high confidence
New event-driven listeners for caching, metrics, webhooks, and order fulfillment
This change introduces a suite of new event listeners in the \app/Listeners\ directory to handle specific application behaviors. \ManagedCache\Invalidator\ classes (for album, photo, map, search, and user listings) now automatically evict cached data when underlying domain events occur, ensuring data consistency. \CacheListener\ and \LogQueryTimeout\ provide configurable logging for cache hits/misses and slow SQL queries, respectively. \MetricsListener\ records usage statistics and live metrics to the database when enabled. \WebhookListener\ dispatches external webhook notifications for photo add, move, and delete events. \OrderCompletedListener\ handles the automatic fulfillment of webshop orders by linking items to size variants. Finally, \Recompute\\ listeners trigger background jobs to recalculate album sizes, stats, and user thumbnails when photos or albums change, and \RotateLicenseKeyOnLogin\ rotates admin license keys upon login.
app/Listeners · high confidence
New frontend entry points and album interaction logic
The application now includes dedicated JavaScript entry points for two frontend versions: \app-v8.ts\ initializes the new Nuxt UI-based interface, while \app.ts\ serves the legacy PrimeVue interface. Additionally, a suite of new composables in \resources/js/composables/album/\ has been added to handle core gallery interactions, including drag-and-select, folder drop uploads, photo actions (highlighting, rotation, header setting), album statistics, and tree validation for album structures.
resources · high confidence
New image processing infrastructure and watermarking support
The application introduces a new internal architecture for image handling within the app/Image directory. This includes a Watermarker module that applies configurable watermarks to images based on user authentication status and specific configuration settings (such as position, opacity, and scaling). Additionally, a PlaceholderEncoder has been added to generate low-quality base64-encoded placeholders for faster loading, while a CoordinateCalculator handles the precise positioning logic for watermarks. The SizeVariantDefaultFactory and SizeVariantDimensionHelpers classes now manage the creation and dimension constraints for various image size variants (thumbnails, small, medium, etc.), and StreamStat/StreamStatFilter classes enable on-the-fly checksum and byte counting for image streams.
app/Image · high confidence
New maintenance request validators for system administration tasks
Added a new set of HTTP request validation classes in the Maintenance namespace to handle specific administrative operations. These include CleaningRequest for managing filesystem extraction and image job roots, CreateThumbsRequest for generating specific size variants (including placeholders), FullTreeUpdateRequest for restructuring album hierarchies, MigrateRequest for handling user authentication and migration logic, RegisterRequest for secure key-based registration, and SearchDuplicateRequest for finding duplicate images with configurable constraints. All validators enforce appropriate authorization policies requiring admin-level permissions.
app/Http/Requests/Maintenance · high confidence
New metadata services for disk usage, EXIF extraction, location decoding, and 360° photo support
The app/Metadata directory now contains dedicated services that enhance how Lychee handles file information and storage. DiskUsage provides diagnostic data on total, free, and used space for the installation and uploads. Extractor centralizes metadata collection using a prioritized reader chain (FFprobe, Exiftool, Imagick, native) and adds support for XMP sidecars, 360° panorama detection, and live-photo metadata. Geodecoder decodes GPS coordinates into human-readable location names, supporting both a local reverse-geocoding endpoint and the public Nominatim service with rate limiting and caching. Writer enables embedding title, description, tags, and ratings back into image files via Exiftool. These changes improve metadata accuracy, add new media capabilities, and provide users with storage diagnostics.
app/Metadata · high confidence
New metrics events for album and photo interactions
Added new event classes in the app/Events/Metrics directory to track specific user interactions with albums and photos. This includes AlbumDownload, AlbumShared, and AlbumVisit for album-level metrics, as well as PhotoDownload, PhotoFavourite, PhotoShared, and PhotoVisit for photo-level metrics. These events extend base classes (BaseAlbumMetricsEvent and BasePhotoMetricsEvent) to standardize how interaction data (visitor\_id, action type, entity ID) is structured for database insertion, enabling the system to record statistics for downloads, shares, visits, and favorites.
app/Events/Metrics · high confidence
New request classes for user management operations
Added four new form request classes in the UserManagement namespace to handle API validation and authorization for user management: AddUserRequest for creating new users with configurable upload, administration, and quota permissions; SetUserSettingsRequest for updating existing user settings including username, password, and trust levels; DeleteUserRequest for removing users with owner-id validation; and ManagmentListUsersRequest for listing users. These classes enforce the CAN\_CREATE\_OR\_EDIT\_OR\_DELETE policy gate and validate specific attributes like username, password, upload trust levels, and quotas.
app/Http/Requests/UserManagement · high confidence
New request validation classes for live metrics endpoints
The application introduces three new HTTP request validation classes in the \app/Http/Requests/Metrics\ directory to handle incoming API requests for metrics data. \GetLiveMetricsListRequest\ validates requests for the live metrics list, enforcing that the user is logged in, has the necessary authorization policy (\CAN\_SEE\_LIVE\), and that the \features.struct-of-array\ configuration flag is enabled. \MetricsRequest\ provides a base authorization check for live metrics access without additional feature flags. \PhotoMetricsRequest\ handles validation for photo-specific metrics, requiring specific photo IDs, a visitor ID, and a starting ID, while bypassing standard authorization checks as it is used solely for metrics collection purposes.
app/Http/Requests/Metrics · high confidence
New request validation classes for statistics endpoints
Added four new HTTP request validation classes (CountsRequest, SpacePerAlbumRequest, SpacePerUserRequest, SpaceSizeVariantRequest) in the app/Http/Requests/Statistics directory. These classes define authorization rules and input validation for various statistics features, including enforcing ownership filtering for non-admin users and checking specific permissions like CAN\_SEE\_STATISTICS, CAN\_ACCESS, and CAN\_EDIT.
app/Http/Requests/Statistics · high confidence
New statistics actions for upload counts and storage space
Added new \Counts\ and \Spaces\ action classes in \app/Actions/Statistics\ to provide detailed usage metrics. The \Counts\ class exposes methods to retrieve the number of photos uploaded or taken per day over a specified time range, as well as the earliest creation or capture dates for a user. The \Spaces\ class calculates total storage usage per user or album, leveraging a pre-computed \album\_size\_statistics\ table for performance, and breaks down space consumption by size variant type (e.g., thumb, original, raw) for both album-contained and unalbummed photos.
app/Actions/Statistics · high confidence
New structured API resources for granular permission and module availability checks
The application now exposes a comprehensive set of new API resources in the \app/Http/Resources/Rights\ directory to provide the frontend with precise, fine-grained control over the user interface. These resources—\AlbumRightsResource\, \PhotoRightsResource\, \GlobalRightsResource\, and specific sub-resources for settings, users, and modules—aggregate complex policy checks into simple boolean flags. This allows the UI to dynamically enable or disable features such as face recognition operations, the webshop, watermarker configuration, and user group management based on the current user's specific permissions and system configuration, rather than relying on coarse global checks.
app/Http/Resources/Rights · high confidence
New structured configuration resources for the gallery frontend
The application now exposes a comprehensive set of structured configuration resources in the \app/Http/Resources/GalleryConfigs\ directory to drive the frontend UI. These new data classes—such as \InitConfig\, \LandingPageResource\, \AlbumConfig\, \FooterConfig\, \ContactConfig\, and \NsfwConfigResource\—centralize the retrieval of gallery settings, including layout modes, timeline behaviors, NSFW moderation presets, contact form details, and landing page branding. By providing these structured DTOs, the backend now delivers a unified and type-safe configuration payload to the client, enabling features like dynamic background modes, granular album timeline controls, and customizable footer/social media links without requiring the frontend to query individual settings.
app/Http/Resources/GalleryConfigs · high confidence
New structured search tokens for albums and photos
The search interface now supports a set of new query tokens that allow you to filter results more precisely. For albums, you can use \date:\ to filter by creation date (e.g., \date:2024-05-01\ or \date:\>2024-01-01\) and \tag:\ to filter by album tags (e.g., \tag:vacation\). For photos, you can filter by \date:\ (taken date), \tag:\ (photo tags), \color:\ (by hex code or CSS name, e.g., \color:red\), \rating:\ (by average or your own rating, e.g., \rating:avg:\>=4\), \ratio:\ (by aspect ratio, e.g., \ratio:landscape\), and \type:\ (by MIME type). These tokens replace or supplement previous plain-text search methods, offering more granular control over your library.
app/Actions/Search/Strategies · high confidence
New tree-based directory import and direct file import actions
The import workflow now includes a new tree-based directory import that automatically creates album structures from the source folder hierarchy, alongside a new method to import individual files directly while bypassing tree creation. These changes introduce a pipeline-driven architecture for directory imports and add explicit file extension validation before queuing jobs, improving both the structural organization of imported content and the reliability of the import process.
app/Actions/Import · high confidence
New typed statistics resources for albums, counts, sizes, and user space
The application now exposes structured, strongly-typed data objects for statistics endpoints. New resource classes—Album, CountsData, DayCount, Sizes, and UserSpace—standardize how album details, daily upload counts (including configurable thresholds), image size variants, and per-user storage usage are serialized. These resources also integrate TypeScript type generation, ensuring that frontend consumers receive consistent, type-safe data shapes for these statistical views.
app/Http/Resources/Statistics · high confidence
New utility classes and asset handling strategies in app/Assets
This change introduces several new classes to the app/Assets directory to support internal application logic and file management. It adds a terminal table display utility (ArrayToTextTable), a feature flag manager (Features), and various helper functions for system diagnostics and data formatting (Helpers). It also introduces a database boolean parser (DbBool) to correctly handle PostgreSQL boolean values. Furthermore, it implements new file naming strategies for size variants and watermarks (BaseSizeVariantNamingStrategy, SizeVariantGroupedWithRandomSuffixNamingStrategy, WatermarkGroupedWithRandomSuffixNamingStrategy), which organize media files using random suffixes and directory grouping to improve scalability and security.
app/Assets · high confidence
New validation and authorization layer for face recognition features
This change introduces a comprehensive set of request validation classes in app/Http/Requests/Face to support the new face recognition capabilities. These classes enforce strict authorization and input validation for key operations: assigning faces to people (including batch assignments and cluster management), dismissing or destroying dismissed faces, triggering face detection scans (per photo or album), and receiving results from the external AI Vision service. The validation logic ensures that users have the correct permissions (e.g., CAN\_ASSIGN\_FACE\_ON\_PHOTO, CAN\_EDIT) before any face-related action is taken, and that required parameters (like person\_id or new\_person\_name) are provided correctly to prevent ambiguous or invalid state changes.
app/Http/Requests/Face · high confidence
New version metadata classes for release, git, and database tracking
The application now uses a new set of classes in app/Metadata/Versions to manage version information. FileVersion reads the local version from version.md and checks for updates against the remote update feed. GitHubVersion tracks the local git branch, commit ID, and compares it against the GitHub master branch to report how many commits behind the local installation is. InstalledVersion determines if the installation is a release or development build and retrieves the database migration version. These changes provide a more structured way to display version status and update availability to users.
app/Metadata/Versions · high confidence
New view components for metadata, theming, and webshop integration
The application introduces three new view components in \app/View/Components\ to handle specific UI concerns. The \Meta\ component now generates page metadata, including social Open Graph images (using medium-sized images for albums and photos) and loading indicator settings. The \Style\ component dynamically generates CSS color palettes based on configurable accent colors (primary, secondary, etc.), enabling users to customize the visual theme. The \Webshop\ component exposes webshop availability and payment gateway support (Mollie, Stripe) to the frontend, gated by supporter status and configuration.
app/View · high confidence
New web-based installation wizard for Lychee
The application now includes a dedicated, multi-step web installer located in app/Http/Controllers/Install. This wizard guides users through a structured setup process: Welcome (step 0), System Requirements validation (step 1), File Permissions check (step 2), Environment (.env) configuration (step 3), Database migration and key generation (step 4), and finally Admin user creation (step 5). This replaces or supplements previous installation methods by providing a browser-based interface for initial configuration and admin account setup.
app/Http/Controllers/Install · high confidence
Scheduled photo notification and expanded command loading
The application now automatically sends a database notification to users when new photos are added, driven by a new \lychee:photos\_added\_notification\ Artisan command scheduled to run weekly. Additionally, the console kernel has been restructured to load commands from several new subdirectories (Laravel, Legacy, UserManagment, ImageProcessing), broadening the available CLI capabilities.
app/Console · high confidence
Smart albums now support per-user ratings and configurable top-rated collections
The Smart Albums module has been expanded with two new user-centric albums: 'My Rated Pictures', which lists all photos the current user has rated (ordered by their personal rating), and 'My Best Pictures', which shows the user's top N highest-rated photos with tie-inclusion logic. Additionally, a new 'Best Pictures' album displays the library-wide top N rated photos. These new albums, alongside existing rating-based albums (One through Five Stars), introduce per-user filtering and custom sorting behaviors, while the underlying BaseSmartAlbum now supports configurable visibility overrides and per-owner scoping for smart albums.
app/SmartAlbums · high confidence
Support for Live Photos via MOV container format
The application now supports Live Photos by introducing a new MOVFormat class that configures FFMpeg to output video streams in a Quicktime (MOV) container. This change ensures compatibility with the frontend's live photos kit, which requires the MOV format rather than the native MP4 container used by standard video codecs. Additionally, a new HasAbstractAlbumProperties trait has been added to standardize access to album properties such as ID, title, thumbnail, and associated photos.
app/ModelFunctions · high confidence
Support for associating video files with photos as live partners
Users can now upload video files alongside photos to create 'live photo' pairs. The system automatically determines the video file path, handles storage placement (including local and S3 disks), and updates the photo record to link the video as its live partner.
app/Actions/Photo/Pipes/VideoPartner · high confidence
Timeline access control and validation logic
The application now enforces specific authorization and validation rules for the new Timeline feature. Access to the timeline is restricted based on the \timeline\_page\_enabled\ configuration, and public access to photos is controlled by the \timeline\_photos\_public\ setting, requiring authentication if public access is disabled. Additionally, requests for specific timeline entries validate the date format according to the configured \timeline\_photos\_granularity\ and ensure the provided photo ID exists in the database.
app/Http/Requests/Timeline · high confidence
Architecture
Introduces model contracts and interfaces for albums, size variants, and time handling
This change adds a new set of interfaces and abstract classes in the \app/Contracts/Models\ directory to define the structural contracts for the application's data models. Specifically, it introduces \AbstractAlbum\ to standardize the interface for all album types (including virtual smart albums), \SizeVariantFactory\ and \AbstractSizeVariantNamingStrategy\ to manage the creation and naming of photo size variants, \HasRandomID\ and \HasUTCBasedTimes\ to enforce consistent ID generation and timezone-aware datetime handling across models. These contracts provide a stable API for model implementations, ensuring that components like albums and photos adhere to specific method signatures for IDs, thumbnails, permissions, and time conversions.
app/Contracts/Models · high confidence
New pipe interfaces for photo creation workflow
The app/Contracts/PhotoCreate directory now defines a set of new interfaces (InitPipe, PhotoPipe, StandalonePipe, DuplicatePipe, PhotoPartnerPipe, VideoPartnerPipe, SharedPipe) that establish the contract for a pipe-based photo creation pipeline. These interfaces standardize how different stages of photo processing—such as initial setup, standalone uploads, duplicates, and partner media (photos/videos)—are handled via a chain of responsibility pattern using specific DTOs.
app/Contracts/PhotoCreate · high confidence
Refactored API request validation into reusable traits
The application's HTTP request validation logic has been restructured by extracting common attributes into a set of reusable traits within the \app/Http/Requests/Traits\ directory. This change introduces dedicated traits for various request components, including album management (e.g., \HasAlbumTrait\, \HasAbstractAlbumTrait\), user permissions (\HasAccessPermissionTrait\, \HasUserGroupTrait\), media properties (\HasPhotoTrait\, \HasFaceTrait\), and system features like map viewports (\HasMapViewportTrait\) and visitor identification (\HasVisitorIdTrait\). By centralizing these validation rules and data accessors, the codebase now supports a more modular and consistent approach to handling API requests, as demonstrated by the new \UserGroup\ request classes that compose these traits.
app/Http/Requests/Traits · high confidence
Refactored model architecture with new extension traits
The model layer has been restructured to use a set of new extension traits in app/Models/Extensions, replacing the previous implementation. This includes AbstractBaseConfigMigration and BaseConfigMigration for standardized configuration handling, CachesAlbumUserThumb for per-viewer thumbnail caching, FiltersUploadValidation for enforcing upload validation visibility, ForwardsToParentImplementation for parent-child model relations, HasBidirectionalRelationships for two-way model associations, HasRandomIDAndLegacyTimeBasedID for random ID generation, ResolvesUserContext for user context resolution, SizeVariants for managing photo size variants, SortingDecorator for query sorting, ThrowsConsistentExceptions for unified error handling, Thumb for thumbnail creation, ToArrayThrowsNotImplemented to enforce resource usage, and UTCBasedTimes for consistent timestamp handling.
app/Models/Extensions · high confidence
Removal of legacy application models and helper classes
The legacy \app/\ directory structure has been removed, deleting core model classes (\Album\, \Photo\, \User\, \Configs\, \Logs\) and utility classes (\Helpers\, \Response\, \Validate\). This eliminates the previous Eloquent-based data access layer, password hashing logic, and image processing helpers, indicating a significant architectural shift in how the application manages data and user interactions.
app · high confidence
Reorganized album and photo listing controllers into the AlbumListing namespace
The gallery's album and photo listing endpoints have been restructured into a new \App\\Http\\Controllers\\Gallery\\AlbumListing\ namespace. This change consolidates previously scattered logic into dedicated controllers: \AlbumRootController\ handles the root gallery view (including the new \own\/\shared\ scope dimension), \AlbumChildrenController\ manages sub-album tiers (buckets, data, and rights), \PhotoChildrenController\ serves the photo tier (buckets, ratios, and details), and flat, un-bucketed listings for smart, tag, person, and pinned albums are now handled by their respective controllers (\AlbumSmartController\, \AlbumTagController\, \AlbumPersonController\, \AlbumPinnedController\). This refactoring aligns the codebase with the new Structs-Of-Arrays query actions and improves the organization of the V3 API's album and photo listing endpoints.
app/Http/Controllers/Gallery/AlbumListing · high confidence
Standardized HTTP request contracts and attribute constants
The application now uses a set of dedicated interfaces in \app/Contracts/Http/Requests\ (such as \HasAlbum\, \HasPhoto\, \HasLicense\, and \HasUserGroup\) to define the expected data for HTTP requests, replacing ad-hoc access patterns. A new \RequestAttribute\ class centralizes all request payload keys (e.g., \ALBUM\_ID\_ATTRIBUTE\, \PHOTO\_IDS\_ATTRIBUTE\, \LICENSE\_ATTRIBUTE\) as constants, ensuring consistent naming across the codebase. Additionally, \MiddlewareCheck\ and \Redirection\ interfaces standardize middleware assertions and HTTP redirections.
app/Contracts/Http · high confidence
Behavioural changes
1 commit (0 fixes) modifying app/Actions/WebAuthn, app/Services/WebAuthn
A change to existing behaviour in app/Actions/WebAuthn, app/Services/WebAuthn — 1 commit, 6 files: “feat(webauthn): replace abandoned webauthn with web-webauthn-lib (\#4957)” (refs \#4957).
app/Actions/WebAuthn, app/Services/WebAuthn · medium confidence · unverified
2 commits (0 fixes) modifying app/Actions/Insights, app/DTO/Insights
A change to existing behaviour in app/Actions/Insights, app/DTO/Insights — 2 commits, 26 files: “perf(insights): make every Insights query linear on large libraries (\#4959)”; “Improved insights (\#4848)” (refs \#4959, \#4848).
app/Actions/Insights, app/DTO/Insights · medium confidence · unverified
2 commits (0 fixes) modifying app/Http/Controllers/Traits
A change to existing behaviour in app/Http/Controllers/Traits — 2 commits, 1 file: “Speed up thumb loading (\#4912)”; “Face quick naming (\#4886)” (refs \#4912, \#4886).
app/Http/Controllers/Traits · medium confidence · unverified
6 commits (1 fix) modifying app/Http/Redirections
A change to existing behaviour in app/Http/Redirections — 6 commits (1 fix), 4 files: “move contracts where they belong (\#1638)”; “Add proper install admin screen on v8 (\#4567)”; “Version 7.0.1 - Fix eternal darkmode (\#3916)”; and 3 more (refs \#1638, \#4567, \#3916, \#2891, \#4961, …).
app/Http/Redirections · medium confidence · unverified
7 commits (1 fix) modifying app/Actions/Photo/Pipes/Duplicate
A change to existing behaviour in app/Actions/Photo/Pipes/Duplicate — 7 commits (1 fix), 4 files: “Avoid uploading a picture of another user and getting extra perks (\#4805)”; “feat(smart-albums): index On This Day by month and day (\#4941)”; “Version 7.0.1 - Fix eternal darkmode (\#3916)”; and 4 more (refs \#4805, \#4941, \#3916, \#2369, \#4282, …).
app/Actions/Photo/Pipes/Duplicate, app/Http/Requests/Person · medium confidence · unverified
API resources migrated to Spatie Laravel-Data with TypeScript generation
The \app/Http/Resources/Models\ directory has been completely rewritten to use the \Spatie\\Laravel-Data\ package instead of Laravel's built-in \JsonResource\. All model resources (such as \HeadAlbumResource\, \FaceResource\, and \ConfigResource\) now extend the \Data\ base class and are annotated with \\#\[TypeScript()\]\ to automatically generate TypeScript types for the frontend. This change standardizes the API response structure, enforces strict data typing, and introduces new fields like \slug\ (restricted to supporters) and \statistics\ (gate-controlled) in album resources.
app/Http/Resources/Models · high confidence
Add Unicode support for Laminas text table decorators
A new Unicode decorator class has been added to the Laminas metadata module to properly handle Unicode characters in text-based table rendering. This implementation ensures that box-drawing characters and other special symbols are correctly encoded and displayed, improving the visual integrity of text tables that rely on the Laminas text component.
app/Metadata/Laminas · high confidence
Admin bulk album edit validation rules
The admin bulk album edit feature now enforces strict input validation for its API endpoints. Administrators can now list albums with pagination (supporting 100, 200, or 500 items per page), search for albums by ID, and perform bulk operations including deleting albums, patching metadata (such as description, copyright, license, sorting, and visibility settings), and transferring ownership. All operations require administrator privileges and validate that at least one field is provided for updates, ensuring data integrity during bulk management tasks.
app/Http/Requests/Admin/BulkAlbumEdit · high confidence
Admin setup validation during installation
The installation process now enforces strict validation for the initial admin account creation. A new request class validates that the username and password meet specific rules and ensures that an admin user has not already been created, preventing duplicate admin accounts during the setup phase.
app/Http/Requests/Install · high confidence
Admin-only access control for Security Advisories index endpoint
The Security Advisories index endpoint now enforces strict authorization, allowing only users with administrative privileges to retrieve advisory data. Unauthenticated requests will receive a 401 error, while authenticated non-admin users will receive a 403 Forbidden response, ensuring that sensitive security information is not exposed to regular users.
app/Http/Requests/Admin/SecurityAdvisories · high confidence
Admin-only authorization for moderation queue endpoints
The moderation queue endpoints (listing, retrieving a single photo, and bulk approving) are now restricted to administrators. New request validation classes enforce that only users with the may\_administrate flag can access these features, ensuring that non-admin users cannot view or modify the moderation queue.
app/Http/Requests/Moderation · high confidence
Album and photo-specific renaming rules
Users can now define and apply renaming rules separately for albums and photos. The system introduces dedicated \AlbumRenamer\ and \PhotoRenamer\ classes that filter the global set of user-defined rules based on whether they are targeting albums or photos, allowing for distinct naming conventions for each content type.
app/Metadata/Renamer · high confidence
Album creation concurrency fix and new v8 breadcrumb feature
Album creation is now protected against race conditions that could corrupt the nested-set tree structure when multiple albums are created simultaneously, ensuring data integrity. Additionally, a new breadcrumb navigation feature has been added for the v8 interface, allowing users to see and navigate the hierarchical path of albums while respecting their access permissions.
lychee-org/lychee · high confidence
Album permission propagation and cached thumbnail cleanup
The sharing system now supports propagating access permissions to nested sub-albums. When an administrator updates or overwrites permissions on a parent album, the new settings are automatically applied to all descendant albums, ensuring consistent access control across the hierarchy. To prevent security leaks during this process, any cached user-specific thumbnails that might reveal content to users who have lost access are purged immediately.
app/Actions/Sharing · high confidence
Authorization checks added for Diagnostics and Jobs endpoints
The application now enforces access control on the Diagnostics and Jobs request handlers. The Diagnostics endpoint requires the user to have the CAN\_SEE\_DIAGNOSTICS permission, while the Jobs endpoint requires the CAN\_SEE\_LOGS permission. These checks are implemented via the SettingsPolicy gate, ensuring that only authorized users can access system diagnostics and job logs.
app/Http/Requests/Diagnostics, app/Http/Requests/Jobs · high confidence
Authorization logic for Flow API endpoints
New request classes (FlowRequest, GetFlowListRequest) define access control for the Flow feature. Authenticated users can access Flow if the 'flow\_enabled' config is true; guests require both 'flow\_enabled' and 'flow\_public' to be true. Additionally, the GetFlowListRequest is gated by the 'features.struct-of-array' config flag, ensuring it only functions when that structural feature is enabled.
app/Http/Requests/Flow · high confidence
Centralize application constants and refine access permissions
The application now uses dedicated constant classes in the \app/Constants\ directory to manage configuration values, improving maintainability and clarity. Key updates include the introduction of \AccessPermissionConstants\ to define specific permission attributes (such as \GRANTS\_MOVE\) and table names, supporting a more granular access control system. Job processing priorities are now explicitly defined in \JobQueue\ with \high\ and \low\ queues, and random ID generation parameters are standardized in \RandomID\. Additionally, \FileSystem\ constants clarify upload and job directories, while \PhotoAlbum\ and \PersonAlbumPersons\ constants standardize database table and column references for album relations.
app/Constants · high confidence
Centralized album and photo query logic with caching and filtering
The application now uses dedicated repository classes (AlbumRepository, PhotoRepository, ConfigManager) to handle data access, replacing previous inline query logic. Album queries are now paginated, support configurable sorting criteria, and utilize a managed cache service to improve performance for album listings and tag-based album searches. Photo queries for albums now support optional filtering by tags (with AND/OR logic) and person IDs, while ensuring non-admin users only see validated photos. Configuration values are now accessed through a centralized ConfigManager with type-safe getters and local caching.
app/Repositories · high confidence
Complete backend rewrite with new controller architecture and security enhancements
The application has undergone a major backend refactoring, replacing the legacy AlbumController with a new suite of specialized controllers (Auth, Profile, Oauth, SecurePath, Metrics, Renamer, Statistics, Tags, Users, Version, and Vue) to support the unified Nuxt UI frontend. This change introduces LDAP authentication support with local fallback, a honeypot-based anti-scanning mechanism, and secure, signed-path file serving to prevent path traversal attacks. It also adds new capabilities for user profile management, OAuth integration, live metrics tracking, bulk photo/album renaming, and detailed usage statistics, while removing the old monolithic controller structure.
app/Http/Controllers · high confidence
Comprehensive DTO layer refactoring for type safety and new capabilities
The application's data transfer object (DTO) layer has been completely rewritten to use strict, immutable value objects, replacing previous loose structures. This change introduces dedicated DTOs for new features including Webhooks (WebhookPayload), the Webshop (CheckoutDTO, PurchasableOption, PixelSizeAssignment), LDAP authentication (LdapConfiguration, LdapUser), and chunked ZIP downloads (ChunkSlice). It also standardizes bulk operations (BulkAlbumPatchData), import workflows (ImportDTO, ImportMode, FolderNode), and map interactions (MapViewport). By enforcing typed fields and explicit validation, the system now provides more reliable data handling for admin statistics, access permissions, and metadata management.
app/DTO · high confidence
Comprehensive diagnostics overhaul with new integrity and service checks
The diagnostics system has been completely refactored into a modular pipeline of individual check classes, significantly expanding the scope of environment validation. New checks verify database integrity (detecting photos without originals and size variants with missing file sizes), validate the existence of an admin user, and ensure authentication methods (Basic, OAuth, WebAuthn) are correctly configured. The system now also checks the health and configuration of external AI Vision services (face recognition and NSFW detection), validates the APP\_URL against the current request host to prevent WebAuthn and asset display failures, and performs detailed filesystem permission audits. Additional integrity features include computing installation hashes, listing database foreign keys for performance debugging, and verifying PHP ini settings and extension support (GD, Imagick, PDF handling).
app/Actions/Diagnostics/Pipes/Checks · high confidence
Comprehensive exception handling architecture overhaul
The application's error handling has been completely restructured to improve reliability and user experience. A new \BaseLycheeException\ class now serves as the foundation for all application-specific errors, ensuring consistent HTTP status code mapping and secure message presentation to end-users while hiding internal implementation details. Over 30 new, specific exception classes have been introduced to cover distinct failure scenarios such as LDAP authentication, media file processing, installation states, and permission issues, replacing generic error reporting with precise, actionable feedback. Additionally, the central \Handler\ class has been significantly expanded and refactored to address framework inconsistencies, ensuring that exceptions are correctly mapped, logged, and rendered as either JSON or HTML responses depending on the client's request type.
app/Exceptions · high confidence
Consistent error handling for database query operations
The application now uses a custom query builder (\FixedQueryBuilder\) and trait (\FixedQueryBuilderTrait\) to wrap core Eloquent methods like \where\, \select\, and \join\. This change ensures that internal errors during query construction are caught and re-thrown as specific \QueryBuilderException\ instances, providing more consistent and catchable error handling for users when database queries fail.
app/Eloquent · high confidence
Diagnostics system refactored to use Laravel Pipelines
The diagnostics subsystem has been restructured to use Laravel's Pipeline pattern, separating checks into distinct, composable classes for errors, configuration, system info, and disk space. This change introduces a modular architecture where individual diagnostic checks (such as database integrity, PHP version, and security advisories) are implemented as separate pipe classes, allowing for easier maintenance and the ability to skip specific checks. The refactoring also includes a new Configuration class that safely handles legacy database schemas and ensures sensitive data is masked in diagnostic reports.
app/Actions/Diagnostics · high confidence
Efficient batch deletion of size variants with async file cleanup
The system now deletes multiple size variant records in a single database operation rather than one-by-one, significantly improving performance for bulk removals. Additionally, the action now supports S3 storage disks alongside local storage, ensuring that associated image files (including watermarked versions) are correctly identified and queued for asynchronous deletion via background jobs, regardless of where the media is stored.
app/Actions/SizeVariant · high confidence
Frame access now requires explicit configuration and album selection
The Frame feature now enforces stricter access controls: users must have the 'mod\_frame\_enabled' configuration option turned on, and they must either provide a specific album ID or have a 'random\_album\_id' configured in the system settings. If these conditions are not met, access to the frame is denied with an unauthorized error, preventing accidental or unauthorized frame usage.
app/Http/Requests/Frame · high confidence
Improved bootstrap error handling and configuration initialization
The application now provides clearer, user-friendly error pages for critical bootstrap failures, such as missing Composer dependencies, disabled Apache mod\_rewrite, or incorrect file permissions on the storage and .env files, instead of showing generic PHP errors. Additionally, the bootstrap process now sets a specific User-Agent string for HTTP requests and configures file permissions (umask) to ensure proper group-writable access for cache files, while also supporting a configurable base path via the APP\_BASE\_PATH environment variable.
bootstrap · high confidence
Input validation for landing page configuration
Added request validation classes for managing landing page featured items and links. Administrators can now create, update, delete, and reorder featured items and links through the API, with built-in links protected from deletion and URL modification.
app/Http/Requests/LandingFeaturedItem, app/Http/Requests/LandingLink · high confidence
Introduce structured Flow resources for album presentation and configuration
The Flow feature now uses dedicated resource classes (FlowResource, FlowItemResource, InitResource) to structure API responses. FlowItemResource handles album data serialization, including photo collections, cover images with access-based downgrading, markdown-converted descriptions with caching, and configurable date formatting. FlowResource provides paginated album listings with standard pagination metadata. InitResource exposes frontend configuration flags for Flow behavior, such as enabling/disabling the flow, image headers, carousels, NSFW blurring, and compact mode, with some features restricted to supporters.
app/Http/Resources/Flow · high confidence
Introduce structured validation for basket and catalog operations
This change adds a suite of new HTTP request validation classes to the application's backend. In the basket area, it introduces dedicated request handlers for adding albums, photos, pixel items, and print items, as well as for retrieving, deleting, and removing items from the basket. These classes enforce specific validation rules (such as required enum types for size variants and licenses) and authorization checks, including a security fix for guest users that prevents them from adopting orders belonging to registered users. Additionally, new request classes are added for catalog operations to retrieve album access and purchasable size variants, standardizing how input data is validated and processed for these features.
app/Http/Requests/Basket · high confidence
Introduces structured search token parsing and strategy interfaces
The search system now uses a dedicated \SearchToken\ data transfer object to represent individual parsed query components (such as modifiers like 'tag' or 'date', operators, and values) instead of raw strings. To support this, new contract interfaces (\AlbumSearchTokenStrategy\ and \PhotoSearchTokenStrategy\) have been added to define how these tokens are applied to database queries for albums and photos respectively. This change refactors the internal search logic to be more modular and type-safe, allowing distinct strategies to handle different search modifiers.
app/Contracts/Search, app/DTO/Search · high confidence
Introduction of BaseConfigMigration for legacy configuration handling
A new abstract class, BaseConfigMigration, has been added to the application's legacy migration infrastructure. This class provides a standardized mechanism for inserting and deleting configuration entries in the 'configs' database table, enforcing specific data types (boolean, positive, integer) and confidentiality levels. It serves as the base for migrations prior to April 2024, ensuring consistent handling of legacy configuration data during database updates.
app/Legacy · high confidence
Legacy Lychee v3 data migration and database schema updates
This change introduces a suite of database migrations to support importing data from the legacy Lychee v3 installation. The migrations handle moving settings, albums, and photos from the old v3 tables into the new Lychee-Laravel schema, including mapping legacy sorting configurations and handling ID truncation for 32-bit compatibility. Additionally, it establishes the new database structure for the application, creating tables for user-album relationships, pages, symbolic links, and photo metadata (such as live photos and image direction), while also configuring the centralized \configs\ table with default values and categories for application settings.
database/migrations · high confidence
Major HTTP middleware overhaul and security hardening
The application's HTTP kernel has been significantly restructured to improve security and maintainability. Global middleware now includes a new \FixStatusCode\ handler and \SecureHeadersMiddleware\ for Content Security Policy enforcement, replacing older Laravel maintenance checks with \PreventRequestsDuringMaintenance\. The \web\ and \web-admin\ route groups now explicitly enforce CSRF verification and session authentication, while the \api\ group introduces \gallery\_password\ protection, latency tracking, and album slug resolution. Additionally, a comprehensive set of new route middleware aliases has been added, including \login\_required\, \gallery\_password\, \unlock\_with\_password\, and \feature\ flags, allowing for finer-grained access control and feature toggling across the application.
app/Http · high confidence
Major application bootstrapping and service provider overhaul
The application's service providers have been significantly expanded to support a more complex architecture. AppServiceProvider now registers numerous singletons (including factories, policies, and versioning services), defines request macros for verification and configuration access, and sets up database observers, stream filters, and Octane-specific settings. AuthServiceProvider introduces a custom 'session-or-token' authentication guard, maps policies for a wider range of models (including LiveMetrics and UserGroups), and exposes static methods to check OAuth, WebAuthn, and basic auth availability. EventServiceProvider now wires up extensive event listeners for caching, metrics, album/photo statistics recomputation, license key rotation, webhooks, and managed cache invalidation, while also integrating multiple Socialite providers (Authelia, Authentik, Kanidm, etc.). RouteServiceProvider has been updated to define explicit route groups for web, admin, and API v2/v3 endpoints, and to configure API rate limiting. Additionally, a new TypeScriptTransformerServiceProvider has been added to configure TypeScript generation from PHP classes.
app/Providers · high confidence
Middleware layer refactored for Laravel 11 and stricter request handling
The middleware layer has been completely rewritten to support Laravel 11, replacing legacy classes (such as \AdminCheck\, \AlbumPWCheck\, and \TrustProxies\) with a new set of focused middlewares. This update introduces granular control over installation, migration, and admin user status, enforces strict content-type validation for API requests, and adds feature flags to enable or disable specific capabilities. Security and performance are improved through a new \CacheControl\ middleware for identity-dependent responses, a \ReadOnlyStartSession\ for efficient image serving, and enhanced CSRF protection that supports API token authentication. Additionally, album slugs are now automatically resolved to IDs, and RSS feed metadata can be dynamically configured at request time.
app/Http/Middleware · high confidence
Migrated validation rules to Laravel 10 ValidationRule interface
The custom validation rules in app/Rules have been refactored to implement Laravel's modern ValidationRule interface, replacing the deprecated Rule interface. A new ValidateTrait bridges the legacy passes/message pattern to the new validate/fail signature, ensuring compatibility during the upgrade. This change updates the validation layer to align with Laravel 10 standards without altering the underlying business logic for users.
app/Rules · high confidence
New API request validation classes for album listing, permission listing, and gallery unlocking
Three new request classes have been added to the Gallery namespace to handle input validation and authorization for specific API endpoints. AlbumListV3Request validates the GET /api/v3/Albums endpoint, introducing admin-gated optional flags (with\_parent\_id, for\_bulk\_edit) that are forbidden for non-admin users. AlbumAccessPermissionListRequest handles the GET /api/v3/Albums::accessPermissions endpoint, restricting access to users who own at least one album or are admins. UnlockGalleryRequest validates the gallery unlock process, requiring a password via the PasswordRule. These changes refine how the API validates inputs and enforces access policies for these specific operations.
app/Http/Requests/Gallery · high confidence
New Docker entrypoint with strict validation, privilege dropping, and worker mode
The Docker container now uses a comprehensive entrypoint script that enforces security and configuration correctness at startup. It validates environment variables (including support for \_FILE secrets for keys and passwords), checks for misconfigurations (such as mounted .env files), ensures database connectivity, and strictly manages file permissions for the www-data user. The entrypoint drops privileges from root to www-data by default (configurable via RUN\_AS\_ROOT) and introduces a new 'worker' mode (LYCHEE\_MODE=worker) that runs queue workers with automatic restart and migration-wait logic, enabling horizontal scaling alongside the existing 'web' mode.
docker · high confidence
New Editable API resource classes for albums, configuration, and uploads
The application introduces a new set of data-transfer objects in the \app/Http/Resources/Editable\ namespace to standardize how album metadata, configuration settings, and upload details are serialized for the API. \EditableBaseAlbumResource\ now exposes a comprehensive set of album properties—including sorting criteria, layout options, timeline granularities, and specific fields for tag and person albums—while \EditableConfigResource\ handles key-value configuration pairs. Additionally, \UploadMetaResource\ has been updated to include \title\, \description\, and \expected\_id\ fields in upload responses, enabling clients to supply and receive this metadata during the upload process.
app/Http/Resources/Editable · high confidence
New Eloquent attribute casts for timezones, money, and read-only enforcement
The application introduces three new Eloquent casts in the \app/Casts\ directory to improve data handling and integrity. \DateTimeWithTimezoneCast\ ensures datetime attributes preserve their original timezone information and correctly compares instants across different database engines (fixing spurious dirty-state changes on PostgreSQL). \MoneyCast\ automatically converts between integer cent values in the database and \Money\ objects in PHP, supporting configurable default currencies. \MustNotSetCast\ prevents accidental modification of specific model attributes by throwing an exception if a set operation is attempted, optionally suggesting an alternative attribute to use instead.
app/Casts · high confidence
New Struct-of-Arrays query layer for photo listing endpoints
The photo listing API endpoints (buckets, ratios, and details) now use a new Struct-of-Arrays query layer in \app/Actions/Photo/StructOfArrays\ to improve performance. This change introduces dedicated query classes (\QueryPhotoBuckets\, \QueryPhotoRatios\, \QueryPhotoDetails\) that replace previous per-photo policy evaluations and Eloquent hydration patterns with optimized SQL joins and raw scalar selections. Key improvements include resolving photo access grants in a single grouped query instead of N+1 policy checks, using \LEFT JOIN\s for size variants to compute aspect ratios efficiently, and implementing live bucket ID computation for smart albums where bucket IDs are not stored. The \ResolvesPhotoGrants\ class specifically addresses an N+1 query issue by replacing per-photo policy evaluations with a single SQL query that groups access permissions across all containing albums.
app/Actions/Photo/StructOfArrays · high confidence
New album listing and flow actions with caching and refined access control
The app/Actions/Albums directory now contains new action classes (Flow, PositionData, Top) that replace previous logic for generating album listings and map data. The Top action introduces a structured TopAlbumDTO response, separating smart, tag, person, pinned, and root/shared albums, and integrates with the ManagedCacheService to cache these listings based on user and sorting criteria. The Flow action implements configurable flow strategies (AUTO, OPT\_IN) with specific ordering and NSFW filtering, while the PositionData action optimizes map photo queries by limiting size variants. All actions enforce stricter access controls via AlbumQueryPolicy and PhotoQueryPolicy, ensuring users only see albums and photos they are permitted to access.
app/Actions/Albums · high confidence
New contracts for diagnostic pipelines and external/JSON requests
The application introduces new interface contracts to standardize diagnostic processing and external data fetching. \DiagnosticPipe\ and \DiagnosticStringPipe\ define the contract for pipeline-based diagnostic handlers, allowing users to benefit from more structured and complete diagnostic reports. Additionally, \ExternalRequest\ and \JsonRequest\ interfaces abstract external HTTP interactions, providing consistent methods for clearing caches, retrieving age text, and fetching data (raw or decoded JSON) with optional caching support.
app/Contracts · high confidence
New diagnostics resource classes for structured API responses
The diagnostics subsystem now uses a set of new data-transfer objects (extending Spatie Laravel Data) to structure API responses. These include AlbumTree for album hierarchy details, ChangeLogInfo for version history, CleaningState for storage checks, ErrorLine and Errors for diagnostic reporting, Permissions for tree integrity, StatisticsCheckResource for missing item counts, and TreeState for nested-set validation metrics. This refactoring standardizes how diagnostic data is serialized and exposed to the frontend.
app/Http/Resources/Diagnostics · high confidence
New domain events for album, photo, and user state changes
The application now dispatches a comprehensive set of domain events in the \app/Events\ namespace to signal state changes. These include \AlbumSaved\, \AlbumDeleted\, and \AlbumComputedDataUpdated\ to track album modifications and computed data updates; \PhotoAdded\, \PhotoDeleted\, \PhotoMoved\, \PhotoSaved\, and \PhotoBucketsRecomputed\ to handle photo lifecycle and listing cache invalidation; and \UserGroupMembershipChanged\ to track user permission updates. Additionally, specific cache-invalidation events like \AlbumListingCacheFlushRequested\ and \MapListingCacheFlushRequested\ are introduced to manage global cache coherence for album and map listings.
app/Events · high confidence
New embed request validation for filtering by author
A new \EmbededRequest\ class has been introduced to handle validation and authorization for embed endpoints. This change enables users to filter embedded albums and streams by author using the \data-author\ attribute (passed as a query parameter), supporting comma-separated usernames. It also enforces pagination limits (capped at 500), offset handling, and sort order validation, while ensuring that only public albums without password or link restrictions are accessible via embeds.
app/Http/Requests/Embed · high confidence
New image processing handler architecture with PDF security hardening
The image handling subsystem has been refactored into a modular handler system located in app/Image/Handlers. This introduces a dispatcher (ImageHandler) that selects between GD and Imagick backends, with Imagick prioritized when available. Key behavioral changes include: 1) PDF uploads are now protected against resource exhaustion by validating the /MediaBox dimensions before Ghostscript processing, rejecting files with excessively large declared page sizes; 2) Video thumbnail generation is now enabled by default, using FFmpeg to extract frames based on configurable modes (first, middle, or custom timestamp); 3) Google Motion Pictures (photos with embedded video) are now supported, with the video stream extracted and saved as a separate .mov file; 4) Lossless image optimization is conditionally applied for local files when enabled in configuration; 5) The system now properly handles stream seeking for non-local files by buffering them in memory when necessary.
app/Image/Handlers · high confidence
New import pipeline with album/album deletion and job-based photo import
The import process in app/Actions/Import/Pipes has been restructured into a new pipe-based pipeline. BuildTree constructs a folder tree while skipping Lychee-reserved directories. CreateNonExistingAlbums creates or reuses albums (supporting optional title renaming) to match the folder structure. DeleteMissingAlbums and DeleteMissingPhotos can remove database records for albums or photos that no longer exist on disk, with dry-run support. ImportPhotos adds new images to albums, optionally skipping duplicates early, and queues ImportImageJob, RecomputeAlbumSizeJob, and RecomputeAlbumStatsJob for later processing. ExecuteBatch dispatches those queued jobs. PruneEmptyNodes removes empty folders and fails if the entire import path is empty. HasReporterTrait provides unified status reporting to CLI/web clients and test silencing.
app/Actions/Import/Pipes · high confidence
New internal exception classes for zip extraction and model assumptions
The application now includes a set of new internal exception classes in the \app/Exceptions/Internal\ directory to improve error handling and debugging. Specifically, \ZipBombDetectedException\ and \ZipExtractionException\ have been added to distinguish between zip-bomb protection rejections and general extraction failures, while \FailedModelAssumptionException\ and \MissingModelAttributeException\ provide more specific signals for model-related logic errors. These changes support the new zip upload extraction feature and refine the internal error reporting mechanism.
app/Exceptions/Internal · high confidence
New optimized search query implementation for photos
A new \QuerySearchPhotos\ class has been added to handle photo search queries using a Struct of Arrays pattern. This implementation replaces previous logic with a single, flat database query that avoids Eloquent hydration and relation eager-loading, improving performance by resolving display gates once per request. It supports configurable sorting, rating visibility, and thumbnail info overlays, and includes logic to detect result truncation by fetching one extra row.
app/Actions/Search/StructOfArrays · high confidence
New pipe-based architecture for installation and update processes
The installation and update workflows have been refactored to use a new pipe-based architecture located in app/Actions/InstallUpdate/Pipes. This change introduces a series of specialized classes—including ArtisanKeyGenerate, ArtisanMigrate, ArtisanViewClear, and QueryExceptionChecker—that handle specific steps such as generating encryption keys, running database migrations, clearing view caches, and validating database integrity. These components replace previous implementation details with a structured, modular approach to managing the installation and update lifecycle.
app/Actions/InstallUpdate/Pipes · high confidence
New profile request validators for registration, OAuth, and shared album visibility
This change introduces a new set of Laravel request validation classes in the Profile namespace to handle specific user profile operations. The new \RegistrationRequest\ enforces username, email, and password rules for new user sign-ups, while \UpdateProfileRequest\ manages profile updates with conditional logic for basic authentication. Additionally, \ClearOauthRequest\ and \OauthListRequest\ provide structured validation for managing OAuth provider connections, and \UpdateSharedAlbumsVisibilityRequest\ allows users to configure the visibility of their shared albums using a specific enum. These validators centralize authorization checks and input validation for these profile-related features.
app/Http/Requests/Profile · high confidence
New request classes for managing settings configurations
The application introduces dedicated Laravel request validation classes for the Settings area: GetAllConfigsRequest retrieves all configuration values, SetConfigsRequest validates and processes bulk updates to editable configuration keys and values, and SetCSSSettingRequest and SetJSSettingRequest handle the validation and storage of custom CSS and JavaScript snippets. All operations require the user to pass the SettingsPolicy::CAN\_EDIT authorization gate.
app/Http/Requests/Settings · high confidence
New structured API request validation for album sharing operations
The application introduces a dedicated set of Laravel request classes in app/Http/Requests/Sharing to handle sharing-related API endpoints with stricter validation and authorization. AddSharingRequest now enforces that at least one user or user group is specified when granting permissions, and validates all granular access rights (edit, delete, move, download, full photo access, upload) as required booleans. EditSharingRequest and DeleteSharingRequest validate specific permission IDs and load the corresponding AccessPermission records. ListSharingRequest and ListAllSharingRequest provide standardized authorization checks for viewing shares, while PropagateSharingRequest adds support for overriding existing share settings on albums. These changes ensure that sharing operations are validated consistently before reaching the business logic layer.
app/Http/Requests/Sharing · high confidence
New structured honeypot pipeline for detecting malicious access attempts
The application now uses a dedicated pipe-based architecture in app/Actions/HoneyPot to intercept and handle suspicious requests. This new system includes a base class for consistent error handling (preserving path information in logs) and specific handlers: it checks if the honeypot is enabled, blocks attempts to access .env files, and flags requests matching configured honeypot paths or cross-product patterns by returning a 418 (I'm a teapot) status instead of a standard 404. This provides more granular detection and better debugging information for security events.
app/Actions/HoneyPot · high confidence
New structured request classes for Map API endpoints
The Map API endpoints now use dedicated request validation classes (GetMapBucketsRequest, GetMapPhotosRequest, GetMapTracksRequest, and MapDataRequest) to handle input validation and authorization. These classes enforce specific rules for album access and viewport parameters, with GetMapTracksRequest requiring an album ID while others make it optional. Authorization checks are gated behind the 'features.struct-of-array' configuration flag for bucket, photo, and track endpoints, ensuring consistent access control across map-related API calls.
app/Http/Requests/Map · high confidence
New v3 search request validation classes
The API now includes dedicated request validation classes for the v3 search endpoints (\GetSearchV3Request\, \GetSearchV3DetailsRequest\, \InitSearchRequest\). These classes enforce stricter input validation, such as requiring search terms to be valid base64-encoded strings and checking the \features.struct-of-array\ configuration flag before authorizing access. They also introduce support for sorting criteria and, in the details endpoint, a capped array of photo IDs for batch operations.
app/Http/Requests/Search · high confidence
New validation and authorization logic for checkout operations
This change introduces five new request classes (CancelRequest, CreateSessionRequest, FinalizeRequest, OfflineRequest, ProcessRequest) within the app/Http/Requests/Checkout directory. These classes define the specific validation rules, authorization checks, and data preparation logic for various stages of the checkout process, such as creating payment sessions, finalizing transactions, handling offline payments, and processing payments. They ensure that only authorized users can perform these actions and that the incoming data meets the required format and constraints before being processed by the backend.
app/Http/Requests/Checkout · high confidence
New validation and authorization logic for order management endpoints
This change introduces four new request validation classes in the Order module to enforce specific business rules for order operations. GetOrderRequest now handles retrieval with flexible authorization for both logged-in users (checking ownership) and anonymous users (via transaction ID). ListOrderRequest adds support for filtering orders, specifically allowing users to control whether pending orders are included in the list. MarkAsPaidOrderRequest restricts marking orders as paid to administrators and ensures the order is in an offline status. MarkAsDeliveredOrderRequest restricts delivery marking to administrators and validates that the order is completed or closed, while also verifying that the provided items belong to the order.
app/Http/Requests/Order · high confidence
New validation requests for admin import and stats features
Added new request validation classes in the admin area to support importing from server and managing admin statistics. Specifically, \ImportFromServerRequest\ validates the core import operation including directory paths, symlink options, and conflict checks, while \ImportFromServerBrowseRequest\ and \ImportFromServerOptionsRequest\ handle browsing and configuration options. \AdminStatsRequest\ and \AdminUpdateStatusRequest\ provide validation for admin statistics and status updates. All requests enforce appropriate authorization policies.
app/Http/Requests/Admin · high confidence
Photo management actions refactored to a pipeline architecture with enhanced duplicate and rating handling
The photo management logic in app/Actions/Photo has been completely restructured to use a pipeline pattern, replacing the previous monolithic implementation. Photo creation now flows through distinct stages (Init, Standalone, Duplicate, PhotoPartner) via dedicated pipe classes, allowing for more granular control over metadata hydration, duplicate detection, and live photo pairing. The system now supports configurable duplicate handling, including options to skip unowned or untrusted duplicates, and preserves original RAW files while generating JPEG conversions. Photo deletion has been optimized for efficiency by batching database operations and deferring physical file removal. Additionally, photo rating functionality now uses atomic database transactions to prevent race conditions, and archive downloads support chunked transfers with version-specific ZIP handling.
app/Actions/Photo · high confidence
Public directory restructured for Laravel 11 and new installer
The public directory has been reorganized to support the migration to Laravel 11 and the new installer. The entry point is now a standard Laravel \index.php\ that bootstraps the application kernel. A new installer frontend has been added under \public/installer/\, including its own CSS and Font Awesome assets. The application logo has been updated to a new SVG version, and placeholder images for missing covers and empty states have been replaced. Additionally, a \robots.txt\ file has been added to control search engine indexing, and a symlink has been created to link \public/storage\ to the application's public storage directory.
public · high confidence
RSS feed generation now respects photo access controls and includes enclosure details
The RSS feed generator has been rewritten to ensure that only photos the current user is authorized to view are included, applying the same searchability and NSFW filters used by the main application. Each feed item now links to the specific album containing the photo, uses a stable unique identifier based on the photo's ID and creation date, and includes an enclosure with the correct file URL, MIME type, and size. The feed is sorted by newest first and respects configuration limits for recent days and maximum items.
app/Actions/RSS · high confidence
Refactor user management into dedicated action classes
User creation, updates, LDAP provisioning, notifications, and API token management have been consolidated into specific action classes (Create, Save, ProvisionLdapUser, Notify, TokenDisable, TokenReset) within the app/Actions/User directory. This change centralizes user-related logic, ensuring that user creation validates for duplicate usernames and emails, LDAP users are automatically provisioned with correct attributes and admin status, and API tokens are securely generated and disabled.
app/Actions/User · high confidence
Refactored API request validation and authorization flow
The application's HTTP request handling has been restructured to ensure input validation occurs before authorization checks. A new \BaseApiRequest\ class overrides Laravel's default behavior to validate request data first, then check user permissions, preventing unnecessary database queries for unauthorized users. An \AbstractEmptyRequest\ base class was introduced to simplify request classes that require no validation rules or post-processing, such as the new \ListUsersRequest\ and \UsersRequest\ classes which now explicitly define their authorization logic using Laravel's Gate and Auth facades.
app/Http/Requests · high confidence
Refactored Eloquent relationship classes for albums and photos
The \app/Relations\ directory has been completely rewritten with new, custom Eloquent relationship classes (such as \BaseHasManyPhotos\, \HasManyChildAlbums\, \HasManyChildPhotos\, and \HasAlbumThumb\) to replace the previous implementation. This change introduces stricter access control by routing photo and album queries through dedicated policies (\PhotoQueryPolicy\, \AlbumQueryPolicy\) and supports advanced features like bidirectional relations, recursive photo fetching, and user-context-aware sorting and visibility filtering.
app/Relations · high confidence
Refactored album actions into dedicated service classes
The album management logic in app/Actions/Album has been reorganized into specific action classes (such as Delete, Merge, Move, SetHeader, and SetProtectionPolicy) to replace the previous monolithic implementation. This change improves code maintainability and separation of concerns by isolating distinct album operations like deletion, merging, moving, header setting, and protection policy management into their own focused classes, while also introducing new classes for creating tag and person albums and handling archive generation.
app/Actions/Album · high confidence
Refactored album header, photo collection, and timeline logic into reusable resource traits
The application now uses three new traits in the API resource layer to centralize and improve specific data-fetching behaviors. \HasHeaderUrl\ handles the logic for selecting an album cover image, respecting the new 'compact header' configuration and ensuring empty albums return no header. \HasPrepPhotoCollection\ introduces a per-photo downgrade map to correctly enforce full-resolution access rights based on individual photo ownership or album grants, replacing the previous flawed boolean-based approach, and also manages previous/next photo navigation IDs. \HasTimelineData\ standardizes how timeline granularity settings (for both albums and photos) are resolved, falling back to user preferences when no specific candidate is provided.
app/Http/Resources/Traits · high confidence
Refactored album listing and rights queries for improved performance
The album listing and rights endpoints now use a new Struct-of-Arrays architecture to significantly improve data retrieval speed. This change introduces dedicated query builders for retrieving children of regular albums, tag albums, and person albums, alongside a shared resource builder that assembles the response data in a memory-efficient format. Additionally, rights queries for album children now correctly evaluate move permissions based on the parent album's access settings, ensuring that users with appropriate privileges can reorganize album contents.
app/Actions/Album/StructOfArrays · high confidence
Refactored authorization logic into dedicated traits for albums and photos
Authorization checks for editing albums and photos, moving/merging albums, moving photos, and highlighting photos have been extracted into specific traits (e.g., AuthorizeCanEditAlbumTrait, AuthorizeCanMovePhotosTrait). This change centralizes permission logic using Laravel's Gate facade and specific policies (AlbumPolicy, PhotoPolicy), ensuring that operations like moving photos across owners or merging albums correctly verify permissions such as CAN\_EDIT, CAN\_MOVE, CAN\_DELETE, and CAN\_TRANSFER. It also introduces a guard to prevent authorization bypasses where a user's permission on one album is incorrectly applied to photos belonging to a different album.
app/Http/Requests/Traits/Authorize · high confidence
Refactored external HTTP request handling into a dedicated Json metadata layer
The \app/Metadata/Json\ directory has been restructured to centralize and standardize how the application fetches external data. A new base class, \ExternalRequestFunctions\, now handles HTTP GET requests with configurable caching (TTL), error logging, and test-environment isolation, while \JsonRequestFunctions\ extends this to automatically parse JSON responses. Specific request classes (\AdvisoriesRequest\, \ChangeLogsRequest\, \CompareRequest\, \UpdateRequest\) have been introduced to manage distinct external endpoints—such as GitHub Security Advisories, changelogs, and version comparisons—using configuration-driven URLs and headers. This change improves code maintainability and reliability for external metadata updates by removing ad-hoc request logic and enforcing consistent caching and error handling across all external data sources.
app/Metadata/Json · high confidence
Refactored installation and migration checks into dedicated middleware components
The installation status, database migration status, and admin user presence are now verified by new, specific middleware classes (IsInstalled, IsMigrated, HasAdminUser) that implement the MiddlewareCheck interface. This change improves robustness during installation and updates: IsInstalled now gracefully handles database connection failures (such as missing drivers or authentication errors) instead of crashing, and HasAdminUser correctly handles the scenario where the 'may\_administrate' column does not yet exist in the users table, ensuring the system can properly detect or create an admin user during the setup process.
app/Http/Middleware/Checks · high confidence
Refactored installation and update checks with new minimum PHP version
The installation and update logic has been restructured into dedicated action classes (ApplyMigration, CheckUpdateAvailability, DefaultConfig, PermissionsChecker, RequirementsChecker). This change raises the minimum supported PHP version to 8.2.0 and introduces a new system for checking server requirements and folder permissions during installation. It also centralizes the logic for checking update availability against GitHub releases, ensuring users are notified of new versions only when the update-check feature and the 'check\_for\_updates' setting are enabled.
app/Actions/InstallUpdate · high confidence
Refactored photo API request validation into dedicated classes
The photo-related API request validation logic has been reorganized from a monolithic structure into a set of dedicated request classes within the \app/Http/Requests/Photo\ directory. This change introduces specific validators for distinct operations—including uploading (\UploadPhotoRequest\), editing (\EditPhotoRequest\), moving/copying (\MovePhotosRequest\, \CopyPhotosRequest\), deleting (\DeletePhotosRequest\), and retrieving assets or details (\GetPhotoAssetRequest\, \GetPhotoDetailsRequest\)—each implementing specific contracts and traits. This refactoring centralizes validation rules, authorization checks (using \Gate\ and \PhotoPolicy\/\AlbumPolicy\), and data processing for photo endpoints, improving code maintainability and separation of concerns.
app/Http/Requests/Photo · high confidence
Refactored photo initialization into a modular pipe system with improved RAW and metadata handling
The photo upload and import initialization process has been restructured into a series of dedicated pipes within the \app/Actions/Photo/Pipes/Init\ directory. This change introduces specific steps for validating supported media formats, detecting and converting RAW files to JPEG while preserving originals, finding duplicate photos via checksums, and linking live photo components. Metadata extraction now prioritizes the original RAW file over converted JPEGs to preserve EXIF data, and import modes can now selectively skip metadata loading. This modular approach replaces previous monolithic logic, making the upload flow more robust and easier to extend.
app/Actions/Photo/Pipes/Init · high confidence
Refactored photo processing into a modular pipe system
The photo upload and import workflows have been restructured into a series of dedicated processing steps (pipes) within the \app/Actions/Photo/Pipes/Shared\ directory. This change introduces specific handlers for distinct tasks: \HydrateMetadata\ now manages the conditional population of EXIF data (such as title, tags, and 360-degree photo attributes) into the photo object; \SetUploadValidated\ applies trust-level rules to determine if a photo requires validation; \SetParent\ handles the linking of photos to albums and triggers necessary database events; and \Save\ persists the final photo record and its tags. Additionally, new pipes enable asynchronous background processing for color palette extraction (\ExtractColourPalette\) and reverse-geocoding (\GeodecodeLocation\), as well as direct uploading of image variants to S3 (\UploadSizeVariantsToS3\) when the feature is active. This modular approach separates concerns, allowing features like S3 storage, color extraction, and geocoding to be toggled or modified independently within the photo creation pipeline.
app/Actions/Photo/Pipes/Shared · high confidence
Refactored photo upload data structures into dedicated DTOs
The photo upload process now uses specific Data Transfer Objects (StandaloneDTO, DuplicateDTO, VideoPartnerDTO, PhotoPartnerDTO, and InitDTO) to manage upload context. This change introduces support for user-supplied title and description overrides during upload, allows disabling watermarks per upload, and enables pre-allocating photo IDs to return expected IDs in the response before the upload job completes.
app/DTO/PhotoCreate · high confidence
Refactored tag API resources to use structured data classes
The tag-related API endpoints now return structured data via new resource classes (PhotoTagResource, TagResource, TagWithPhotosAndAlbumsResource, and TagsResource) built on Spatie Laravel-Data. This change standardizes the JSON response format for tags, including photo and album associations, and introduces a can\_edit permission flag in the TagsResource to indicate whether the current user has permission to edit tags.
app/Http/Resources/Tags · high confidence
Removal of default Laravel authentication controllers
The default authentication controllers (ForgotPassword, Login, Register, and ResetPassword) have been removed from the application. This change eliminates the built-in scaffolding for user registration, login, and password reset workflows, meaning users can no longer register or reset passwords through these standard endpoints unless custom implementations are added.
app/Http/Controllers/Auth · high confidence
Route files restructured into versioned, modular groups
The application's routing layer has been reorganized from a single monolithic \routes/web.php\ and \routes/api.php\ into distinct, versioned files (\routes/web\_v2.php\, \routes/api\_v2.php\, \routes/api\_v3.php\, \routes/web-admin-v2.php\, \routes/web-install.php\). This change introduces a new API v3 surface (\/api/v3/...\) that provides Struct-of-Arrays endpoints for albums, photos, search, and maps, coexisting with the existing v2 API. The v2 API routes have been expanded to support new features such as album tracks, watermarking, and a webshop backend. Legacy routes (v1 API, broadcast channels, console commands) have been removed.
routes · high confidence
Search results now enforce per-photo access controls
The search API now correctly restricts full-resolution photo access based on user permissions. Previously, search results potentially over-granted full-resolution access to photos. The new \ResultsResource\ implementation resolves photo grant structures for each item, ensuring that full-size variants are downgraded when the user lacks the necessary authorization, while still returning paginated results for albums and photos.
app/Http/Resources/Search · high confidence
Search v3 introduces structured token parsing and strategy-based filtering
The search system has been refactored to use a new v3 architecture that parses search queries into structured tokens and applies specific strategies for filtering. Users can now use modifiers like \tag:\, \date:\, \type:\, \ratio:\, \color:\, \make:\, \lens:\, \aperture:\, \iso:\, \shutter:\, \focal:\, \title:\, \description:\, \location:\, \model:\, and \rating:\ to refine searches. The \rating:\ modifier supports sub-modifiers \avg\ and \own\ with comparison operators (e.g., \rating:avg:\>=4\). This change also introduces a new \AlbumSearch\ class for album-specific searches and a \ColourNameMap\ for resolving CSS color names. The \PhotoSearch\ class now uses a strategy registry to apply these filters, and the \SearchTokenParser\ handles the parsing of raw query strings into these tokens.
app/Actions/Search · high confidence
Secure zip extraction with bomb and path-traversal protection
The application now uses a new SafeZipExtractor service to handle untrusted zip uploads, protecting against zip-bomb attacks and path-traversal (zip-slip) vulnerabilities. This service validates archive metadata before extraction, enforces strict limits on total uncompressed size, per-file size, entry count, and compression ratio, and ensures extracted files remain within the designated destination directory.
app/Services/Zip · high confidence
Smart albums now support dynamic property access via MimicModel trait
The new MimicModel trait in app/SmartAlbums/Utils enables smart album objects to behave like standard Eloquent models by allowing dynamic property access (e.g., $album-\>photos). This means users can interact with smart album data using familiar getter-style syntax, with automatic conversion of property names to studly case and fallback to direct property access, ensuring consistent data retrieval across the smart albums feature.
app/SmartAlbums/Utils · high confidence
Specialized query builders for domain models
The application now uses dedicated query builder classes (e.g., AlbumBuilder, PhotoBuilder, TagAlbumBuilder) for its models instead of generic query interfaces. This change enables fine-grained control over query construction, such as adding virtual columns like \is\_recursive\_nsfw\ to albums or handling PostgreSQL boolean compatibility, and ensures that specific logic (like adding null placeholders for \max\_taken\_at\ in TagAlbum and PersonAlbum queries) is applied only when models are actually hydrated, avoiding unnecessary complexity in sub-queries.
app/Models/Builders · high confidence
Standalone migration helpers for bucket keys and title sorting
Added standalone, frozen copies of the bucket key computation logic and title splitting algorithms to the \database/migrations/TemporaryModels\ directory. These classes (\BucketKeyBackfill\, \TitleSplitter\, \TitleSplitResult\, and \OptimizeTables\) are decoupled from live application code to ensure that historical database migrations remain runnable even if the main application services change or are removed in the future. This supports the backfill migrations for Feature 092 (bucket keys) and Feature 060 (title sorting) by providing stable, self-contained implementations for computing sort keys and optimizing database tables during migration execution.
database/migrations/TemporaryModels · high confidence
Structured exception handling for installation, migration, and environment errors
The application now uses dedicated exception handlers to manage setup and environment issues more gracefully. When the database is inaccessible, the encryption key is missing, or a migration is required, users are automatically redirected to the appropriate setup or migration screens instead of seeing raw error pages. Similarly, if the Vite manifest is missing, a clear instruction to run 'npm run dev' is displayed. This ensures a smoother onboarding experience and clearer feedback during configuration.
app/Exceptions/Handlers · high confidence
Support for ZipStream 2.1 and 3.1 via version-specific traits
The archive service now supports both ZipStream 2.1 and 3.1 by introducing \Zip21Trait\ and \Zip31Trait\. These traits allow the application to dynamically select the appropriate zip creation logic based on the installed \maennchen/zipstream-php\ version, ensuring compatibility across different dependency configurations while maintaining consistent archive generation behavior for users.
app/Services/Archives · high confidence
Tag management now supports albums and respects multi-user privacy
The tag system has been refactored to allow tags to be associated with albums in addition to photos. This change introduces new backend actions (DeleteTag, EditTag, MergeTag, ListTags, GetTagWithPhotosAndAlbums) that handle these new relationships. Crucially, all tag operations now enforce strict user isolation: non-admin users can only see, modify, or delete tags linked to their own photos and albums, preventing data leakage between users. The system also includes logic to safely merge tags and clean up unused ones without affecting other users' data.
app/Actions/Tag · high confidence
Unified file handling via new stream-based abstraction layer
The application introduces a new \App\\Image\\Files\ namespace containing a hierarchy of classes (\AbstractBinaryBlob\, \BaseMediaFile\, \FlysystemFile\, \NativeLocalFile\, \UploadedFile\, \DownloadedFile\, \InMemoryBuffer\, and temporary file variants) that standardize how media files are read, written, and moved. This change replaces direct filesystem operations with a unified stream-based API, enabling consistent handling of files across local storage, remote Flysystem disks, and in-memory buffers. Users benefit from improved reliability during file uploads, URL imports, and storage migrations, as the new layer avoids issues related to filesystem permissions, cross-mount-point moves, and temporary file management.
app/Image/Files · high confidence
Update DatabaseSeeder with license headers and modern PHP syntax
The database seeder now includes MIT license and copyright headers, uses the modern \void\ return type declaration, and switches the commented-out example from calling a specific seeder class to using the Laravel factory pattern (\User::factory(10)-\>create()\).
database/seeds · high confidence
User model refactored with enums, WebAuthn, and user-group integration
The User model has been significantly updated to support modern authentication and permission features. It now implements WebAuthn authentication via the Laragear/WebAuthn package, enabling passwordless login support. User permissions and preferences are managed through typed enums, specifically \UserSharedAlbumsVisibility\ for controlling shared album visibility and \UserUploadTrustLevel\ for managing upload privileges. Additionally, the model automatically loads associated user groups to streamline permission checks, and includes relationships for OAuth credentials and person data.
app/Models · high confidence
V3 API resources adopt Struct-of-Arrays response format
The V3 API response shapes for albums, photos, maps, search, and metrics have been redesigned to use a Struct-of-Arrays pattern, where each field is a parallel, index-aligned array rather than an array of per-item objects. This change introduces new resource classes (such as AlbumListResource, PhotoRatioResource, and MapBucketResource) that return flat, unpaginated lists ordered for efficient client-side tree reconstruction and rendering. The new format includes pre-computed display labels for bucket headers, dedicated bulk-edit field blocks, and specific optimizations for map clustering and search result truncation, requiring clients to update their data-parsing logic to handle the new array-based structure. Also in this area: 1 commit (1 fix) fixing app/Http, app/Services; Refactored album and photo bucketing to use a unified scheme and added face quick-naming queue.
app/Http/Resources/V3 · low confidence · unverified
WebAuthn authentication now supports username-based login
The WebAuthn login flow has been updated to allow users to authenticate using their username in addition to user IDs. The new WebAuthnLoginController accepts an optional 'username' field during the assertion options phase, enabling the system to locate the correct user account before validating the WebAuthn credential. This change relies on the Laragear/WebAuthn library for handling the underlying WebAuthn assertions and attestations.
app/Http/Controllers/WebAuthn · high confidence
Fixes
1 commit (1 fix) fixing app/Contracts, app/Services
A fix in app/Contracts, app/Services — 1 commit (1 fix), 3 files: “fix(ssrf): avoid obscure IP scenarios (\#4965)” (refs \#4965). Also in this area: Added OpenTelemetry tracing service for application spans.
app/Contracts/Telemetry, app/Services/Telemetry · low confidence · unverified
Add secure path request validation for image links
A new SecurePathRequest class has been introduced to validate access to secure image paths. This change ensures that requests for these paths are only authorized if either the 'secure\_image\_link\_enabled' or 'temporary\_image\_link\_enabled' configuration option is active, thereby preventing unauthorized access to potentially sensitive image URLs.
app/Http/Requests/SecurePath · high confidence
Fix MySQL placeholder limit errors during bulk album and photo deletion
The deletion process for albums and photos now chunks database queries to stay within MySQL's prepared-statement placeholder limit (65,535), preventing 'Error 1390' failures when deleting large numbers of items. For albums, the new \AlbumsToBeDeletedDTO\ processes deletions in batches of 1,000 IDs, ensuring correct ordering of dependent records and nested-set gap removal. For photos, \PhotosToBeDeletedDTO\ chunks operations to 500 IDs, handling soft deletes, cover/header resets, file deletions, and database record cleanup in manageable batches to maintain stability during bulk removals.
app/DTO/Delete · high confidence
Structured exception handling for secure link validation
The application now uses specific exception classes within the \App\\Exceptions\\SecurePaths\ namespace to handle errors related to secure links. This includes distinct handling for invalid payloads, invalid signatures, expired signatures, incorrect paths, and path traversal attacks. Notably, path traversal attempts now trigger a specific HTTP 418 (I'm a teapot) response, which supports fail-to-ban honeypot mechanisms, while other validation errors return standard 403 or 404 responses.
app/Exceptions/SecurePaths · high confidence
Test coverage
Added test coverage for AI Vision face recognition features; Comprehensive database model factories for testing.
Dependencies
Major dependency overhaul: Laravel 13, Vue 3, Vite 8, and Tailwind 4
The project has performed a comprehensive upgrade of its core technology stack. The backend has moved from Laravel 5.6 to Laravel 13, requiring PHP 8.4 and replacing legacy packages with modern equivalents like \laravel/octane\ and \laragear/webauthn\. On the frontend, the build system has shifted from Laravel Mix/Webpack to Vite 8, and the UI framework has upgraded from Vue 2 to Vue 3, accompanied by Tailwind CSS 4 and PrimeVue 4. This change also introduces new payment integrations (Stripe, PayPal, Mollie) and updates the development tooling to use ESLint 10 and Playwright for testing.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 40.4 → 43.1 (+2.7)
- Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 51.5 → 37.5 (-14.0)
- Architecture 72.8 → 75.3 (+2.5)
- Maturity 79.6 → 82.7 (+3.1)
- Readiness 30.3 → 41.1 (+10.8)
- Security 67.8 → 70.3 (+2.5)
- Domain Modelling 55.3 → 55.3 (0.0)
- Accessibility 37.2 → 39.6 (+2.4)
- Performance 100.0 → 100.0 (0.0)
Resolved (90)
- Classify ADR enforcement: ADR-0003: Album Computed Fields Pre-computation Strategy (docs/specs/6-decisions/ADR-0003-album-computed-fields-precomputation.md)
- Classify ADR enforcement: ADR-0004: Multi-Group Permission Merge Policy (docs/specs/6-decisions/ADR-0004-multi-group-permission-merge.md)
- Classify ADR enforcement: ADR-0005: Replace PrimeVue with Nuxt UI (standalone Vue mode) (docs/specs/6-decisions/ADR-0005-nuxt-ui-migration.md)
- Classify ADR enforcement: ADR-0006: Dual-tree, feature-flag-gated cutover strategy for the Nuxt UI migration (docs/specs/6-decisions/ADR-0006-nuxt-ui-dual-tree-toggle.md)
- Classify ADR enforcement: ADR-0007: Exempting a dedicated route from the admin_user:set gate to serve v8's admin-setup page (docs/specs/6-decisions/ADR-0007-v8-admin-setup-gate-bypass.md)
- Classify ADR enforcement: ADR-0008: Temporary-link signing and authorization model for the v3 asset endpoint (docs/specs/6-decisions/ADR-0008-v3-asset-endpoint-signing-and-authorization.md)
- Classify ADR enforcement: ADR-0009: API v3 response-shape precedent — Struct-of-Arrays for collections, binary passthrough for single-item endpoints (docs/specs/6-decisions/ADR-0009-api-v3-response-shape-precedent.md)
- Classify ADR enforcement: ADR-0010: Purge cached album covers on revocation rather than re-checking permissions per asset request (docs/specs/6-decisions/ADR-0010-album-user-thumb-cache-purge-on-revocation.md)
- Classify ADR enforcement: ADR-0011: Move grant separate from Edit, and cross-owner guards (docs/specs/6-decisions/ADR-0011-move-grant-separate-from-edit.md)
- Classify ADR enforcement: ADR-069-01: Bounding strategies for v3 Struct-of-Arrays collection endpoints (docs/specs/6-decisions/ADR-069-01-v3-collection-bounding-strategies.md)
- Classify ADR enforcement: ADR-071-01: Date Scrubber Ticks Are Derived Client-Side; Bucket Storage Stays Unchanged (docs/specs/6-decisions/ADR-071-01-date-scrubber-ticks-derived-client-side.md)
- Classify ADR enforcement: ADR-074-01: Gallery Password as a Per-Visitor Unlock, Not a Guest Account (docs/specs/6-decisions/ADR-074-01-gallery-password-visitor-unlock.md)
- Classify ADR enforcement: ADR-074-02: Gallery Unlock Stored in an Encrypted Cookie (docs/specs/6-decisions/ADR-074-02-gallery-unlock-encrypted-cookie.md)
- Classify ADR enforcement: ADR-074-03: A Write-Only password Config Type (docs/specs/6-decisions/ADR-074-03-password-config-type.md)
- Classify ADR enforcement: ADR-082-01: In-house TypeScript + WebGL2 sphere renderer (docs/specs/6-decisions/ADR-082-01-in-house-webgl2-sphere-renderer.md)
- Classify ADR enforcement: ADR-085-01: Insights replaces the Statistics page (docs/specs/6-decisions/ADR-085-01-insights-replaces-statistics-page.md)
- Classify ADR enforcement: ADR-085-02: Insights are scoped to one owner, administrators choose the owner (docs/specs/6-decisions/ADR-085-02-owner-scoped-insights.md)
- Classify ADR enforcement: ADR-085-03: Insights are computed in one streamed PHP pass, cached per library revision (docs/specs/6-decisions/ADR-085-03-insights-single-pass-aggregation.md)
- Classify ADR enforcement: ADR-085-04: ECharts draws the Insights charts (docs/specs/6-decisions/ADR-085-04-echarts-chart-library.md)
- Classify ADR enforcement: ADR-086-01: Album Map Points Endpoint and Server-Side Map Header Decision (docs/specs/6-decisions/ADR-086-01-album-map-points-endpoint.md)
- …and 70 more
New (127)
- ADR decides a question another record already decided (docs/specs/6-decisions/ADR-102-01-direct-tile-urls.md)
- Edited copies of one member (3 members, 1+ corresponding lines) (app/Http/Requests/Basket/AddPhotoToBasketRequest.php)
- Edited copies of one member (3 members, 14+ corresponding lines) (app/Http/Middleware/AdminUserStatus.php)
- Edited copies of one member (3 members, 15+ corresponding lines) (app/Exceptions/Handlers/AdminSetterHandler.php)
- Edited copies of one member (3 members, 15+ corresponding lines) (app/Relations/HasManyBidirectionally.php)
- Edited copies of one member (3 members, 16+ corresponding lines) (app/Http/Controllers/Gallery/AlbumListController.php)
- Edited copies of one member (3 members, 19+ corresponding lines) (app/Http/Controllers/Gallery/AlbumListing/AlbumRootController.php)
- Edited copies of one member (3 members, 26+ corresponding lines) (app/Actions/Shop/OrderService.php)
- Edited copies of one member (3 members, 4+ corresponding lines) (app/Http/Requests/Face/ClusterResultsRequest.php)
- Edited copies of one member (3 members, 4+ corresponding lines) (app/SmartAlbums/FiveStarsAlbum.php)
- Edited copies of one member (3 members, 5+ corresponding lines) (app/Http/Requests/Basket/AddPhotoToBasketRequest.php)
- Edited copies of one member (3 members, 6+ corresponding lines) (app/Http/Resources/Collections/PaginatedModerationResource.php)
- Edited copies of one member (4 members, 12+ corresponding lines) (app/Http/Controllers/Gallery/SearchListingController.php)
- Edited copies of one member (4 members, 13+ corresponding lines) (app/Listeners/ManagedCacheAlbumListingInvalidator.php)
- Edited copies of one member (4 members, 5+ corresponding lines) (app/Http/Resources/Admin/PaginatedBulkAlbumResource.php)
- Edited copies of one member (4 members, 8+ corresponding lines) (app/Policies/PhotoPolicy.php)
- Edited copies of one member (5 members, 10+ corresponding lines) (app/Policies/AlbumPolicy.php)
- Edited copies of one member (5 members, 21+ corresponding lines) (app/Http/Controllers/Gallery/AlbumListing/AlbumChildrenController.php)
- Edited copy of a member (10 corresponding lines) (app/Actions/Diagnostics/Pipes/Checks/ForeignKeyListInfo.php)
- Edited copy of a member (10 corresponding lines) (app/DTO/AlbumSortingCriterion.php)
- …and 107 more
Changes since last survey
- 22 commits — 15 feature/other, 7 fixes
By area
- (root) — 11 commits
- docs/specs — 4 commits
- .github/workflows — 2 commits
- resources/js — 2 commits
- app/Actions — 1 commit
- app/Services — 1 commit
- tests/Feature_v3 — 1 commit
Notable commits
- fix: Fix s3 loading on Version 8 (#4980)
- fix: Fix view clear at version update (#4986)
- fix: Fixes search header disappearing on mobile after hard-refreshing a search results URL (#4978)
- fix: fix vp (#4979)
- fix: fix(auth): show inline feedback for throttled password logins (#4964)
- fix: fix(jobs): treat duplicate skips as handled outcome instead of job failure (#4988)
- fix: fix(ssrf): avoid obscure IP scenarios (#4965)
- change: bump to version 7.13.0 (#4967)
- change: chore(deps): bump composer from 2.11.0 to 2.11.1 (#4974)
- change: chore(deps): bump node from c6ad9e9 to 8996bb5 (#4976)
- change: chore(deps): bump php from f49965c to baf3ea1 (#4975)
- change: chore(deps): bump the actions-deps group with 8 updates (#4977)
- change: chore(deps): bump the production-dependencies group with 10 updates (#4970)
- change: chore(deps): bump the production-dependencies group with 5 updates (#4971)
- change: chore(deps): bump vite-plus from 1.4.0 to 1.5.0 in the vite-plus group across 1 directory (#4969)
- change: chore(deps-dev): bump the development-dependencies group with 4 updates (#4972)
- change: chore(deps-dev): bump the development-dependencies group with 6 updates (#4973)
- change: deps updates (#4987)
- change: feat(v8): Update index to speed up insights (#4960)
- change: feat(v8): Use Struct-of-Arrays approach by default. (#4961)
- …and 2 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
LycheeOrg/Lychee was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit a4bb5af354568a3543208905c424795e44d1c231 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.