OrchardCMS/OrchardCore

This system is a modular, multi-tenant content management platform built on .NET, designed to manage content structures, user interfaces, and administrative workflows. It provides a comprehensive suite of tools for content modeling, including rich text editing, localization, and automated routing, alongside a modernized admin interface and GraphQL API for data access. The architecture supports distributed deployments with features like background job processing, distributed caching, and tenant-specific configuration, all underpinned by a robust service container and extensible module system.

181 changes.

This period focused on modernizing the Orchard Core platform by migrating to .NET 6 minimal hosting, replacing Newtonsoft.Json with System.Text.Json, and rewriting the admin theme with TypeScript and Bootstrap 5. Significant architectural changes included a comprehensive refactor of the display management system to support complex UI layouts, the introduction of a Liquid view engine, and the standardization of content management abstractions. The work also established foundational services for new features such as workflows, XML-RPC, and enhanced user authentication via ASP.NET Core Identity.

122 changes.

This period focused on enabling multi-instance deployments by introducing database-backed shell configuration, Azure Blob and Amazon S3 storage providers, and distributed caching and locking mechanisms. It also established foundational abstractions for content localization, calendar support, and a new notification system, while refactoring core services like user authentication and media handling to support these scalable architectures.

103 changes.

This period focused on introducing pluggable abstraction layers for search, SMS, and email to support multiple backend providers, while simultaneously migrating the core JSON serialization infrastructure from Newtonsoft.Json to System.Text.Json. The work also included establishing new foundational modules for indexing, queries, and data-driven localization, alongside significant refactoring of tenant-specific configuration and cleanup mechanisms.

Introduces a new Amazon S3 implementation of the Orchard Core file store, allowing users to configure AWS S3 buckets as a backend for media and file storage. The change adds the AwsFileStore service, along with supporting classes for AWS-specific storage options (bucket name, base path, bucket creation/removal settings) and image cache options, enabling seamless integration with Amazon S3 for file operations.

src/OrchardCore/OrchardCore.FileStorage.AmazonS3 · high confidence

The new \BlobShellsOrchardCoreBuilderExtensions\ class enables Orchard Core to load site and shell settings from Azure Blob Storage. By calling \AddAzureShellsConfiguration\, users can register services that replace the default configuration sources with \BlobShellsSettingsSources\, \BlobShellConfigurationSources\, and \BlobShellsConfigurationSources\, allowing shell data to be persisted and retrieved from an Azure Blob container instead of the local file system.

src/OrchardCore/OrchardCore.Shells.Azure/Extensions · high confidence

The OrchardCore.Configuration.KeyVault module now supports Azure Key Vault as a configuration source. Users can integrate secrets from Azure Key Vault into their Orchard Core application by using the new extension methods (AddOrchardCoreAzureKeyVault) which accept a TokenCredential. The configuration is driven by the 'OrchardCore:OrchardCore\_KeyVault\_Azure:VaultURI' or 'OrchardCore:OrchardCore\_KeyVault\Azure:KeyVaultName' settings keys, with an optional 'ReloadInterval' for automatic secret refresh. A custom secret manager handles key name translation, replacing '---' with '\' and '--' with ':' to ensure compatibility with configuration providers.

src/OrchardCore/OrchardCore.Configuration.KeyVault · high confidence

The OrchardCore.Infrastructure.Commands module now provides the core infrastructure for executing CLI commands. This includes a command manager that matches user arguments to registered handlers, a parser for command-line arguments and switches, and a builder that introspects handler types to discover available commands and their help text. These services are registered via the OrchardCoreBuilder, enabling the application to process and execute command-line inputs.

src/OrchardCore/OrchardCore.Infrastructure/Commands · high confidence

A new ContentPreviewFeature class has been introduced in the OrchardCore.ContentPreview.Abstractions module. This feature provides a singleton instance with a Previewing property, allowing other parts of the application to detect whether a content item is currently being previewed.

src/OrchardCore/OrchardCore.ContentPreview.Abstractions · high confidence

The GraphQL client library now includes new extension methods to simplify HTTP requests. \HttpRequestExtensions\ adds support for PATCH, PUT, and POST operations with automatic JSON serialization, using \System.Text.Json\ and standard MIME types. \HttpContentExtensions\ provides a helper to deserialize response streams into strongly-typed objects, and \StringExtensions\ offers a utility to format strings for GraphQL queries.

src/OrchardCore/OrchardCore.Apis.GraphQL.Client/Extensions · high confidence

A new index record, LocalizedContentItemIndex, has been added to the ContentLocalization.Abstractions module. This record stores metadata for localized content items, including DocumentId, ContentItemId, LocalizationSet, Culture, Published status, and Latest status, enabling the system to efficiently query and manage localized content versions.

src/OrchardCore/OrchardCore.ContentLocalization.Abstractions/Records · high confidence

A new ManifestInfo class has been introduced in the OrchardCore.Environment.Extensions.Manifests namespace to serve as a concrete implementation of the IManifestInfo interface. This class wraps a ModuleAttribute to expose module metadata properties such as Name, Description, Type, Author, Website, Version, and Tags, enabling consistent access to extension manifest information within the application.

src/OrchardCore/OrchardCore/Extensions/Manifests · high confidence

The OrchardCore.Feeds.Core module now includes built-in support for generating RSS 2.0 feeds. This change introduces the RssFeedBuilder and RssFeedBuilderProvider classes, which handle the creation of RSS XML structures and register the provider via dependency injection, enabling applications to output content in RSS format alongside existing feed types.

src/OrchardCore/OrchardCore.Feeds.Core · high confidence

Developers can now use a convenient extension method on ISmsService to send SMS messages by specifying only the recipient phone number and message body, with the method automatically handling the creation of the SmsMessage object and returning a Result type to indicate success or failure.

src/OrchardCore/OrchardCore.Sms.Abstractions/Extensions · high confidence

The OrchardCore.Logging.Serilog module now provides a new middleware, SerilogTenantNameLoggingMiddleware, which automatically enriches log entries with the current tenant's name. This is exposed via the UseSerilogTenantNameLogging extension method on IApplicationBuilder, allowing developers to easily integrate tenant-specific context into their Serilog logging pipeline for better traceability in multi-tenant environments.

src/OrchardCore/OrchardCore.Logging.Serilog · high confidence

A new ShellBlueprint class has been introduced in the OrchardCore.Abstractions library to hold the information required to initialize an IoC container for a specific tenant. This model, which includes shell settings, a shell descriptor, and a mapping of type dependencies to feature information, is generated by the ICompositionStrategy and passed to the IShellContainerFactory during the tenant startup process.

src/OrchardCore/OrchardCore.Abstractions/Shell/Builders/Models · high confidence

The Sitemaps module introduces a new SitemapMetadataAspect class that allows content items to specify change frequency, priority, and exclusion status for their inclusion in sitemaps.

src/OrchardCore/OrchardCore.Sitemaps.Abstractions/Aspects · high confidence

New types have been added to the \System.Text.Json.Settings\ namespace to support JSON merging operations: \JsonMergeSettings\ (controlling array handling, null value handling, and property name comparison), \MergeArrayHandling\ (defining strategies like Concat, Union, Replace, and Merge), and \MergeNullValueHandling\ (defining whether to ignore or merge null values). These classes provide the configuration options needed for merging JSON content using the built-in System.Text.Json library.

src/OrchardCore/OrchardCore.Abstractions/Json/Settings · high confidence

A new \IdGeneratorMethod\ class has been introduced in the scripting entities layer, implementing \IGlobalMethodProvider\ to expose a \uuid\ function. This allows scripts to generate unique identifiers by leveraging the \IIdGenerator\ service, making UUID generation directly available within the scripting environment.

src/OrchardCore/OrchardCore.Infrastructure/Entities/Scripting · high confidence

Users can now perform bulk operations to enable or disable multiple features at once via the new FeatureService and BulkActionViewModel. This change introduces a service method that accepts a list of features and an action (Enable or Disable), allowing administrators to manage feature states more efficiently than one-by-one.

src/OrchardCore/OrchardCore.Features.Core/Services · high confidence

Users can now disable SQLite connection pooling via the \OrchardCore\_Data\_Sqlite:UseConnectionPooling\ setting in appsettings. This is useful when the default connection pooling behavior (which locks the database file) interferes with external tasks like backups, though disabling it may incur a performance penalty.

src/OrchardCore/OrchardCore.Data.YesSql/Options · high confidence

A new CacheTicketStore implementation has been added to the OrchardCore.Users.Core module, providing a distributed caching solution for authentication tickets. This component implements the ITicketStore interface, allowing authentication sessions to be persisted in a distributed cache (such as Redis or SQL Server) rather than solely in memory, which supports better scalability and session continuity across multiple application instances.

src/OrchardCore/OrchardCore.Users.Core/Authentication · high confidence

The shell configuration subsystem now includes internal helpers to parse JSON streams and strings into the standard configuration dictionary format and to convert existing configuration data into JSON objects. This enables the platform to natively handle JSON-based configuration sources and facilitates bidirectional conversion between configuration data and JSON representations without relying on external libraries.

src/OrchardCore/OrchardCore.Abstractions/Shell/Configuration/Internal · high confidence

A new Liquid filter named \console\_log\ has been added to the Content Management Display module, allowing developers to output content item data to the browser console during template rendering. This filter is active only in non-production environments and supports various input types including strings, JSON nodes, content items, parts, and shapes, facilitating easier debugging of Liquid templates.

src/OrchardCore/OrchardCore.ContentManagement.Display/Liquid · high confidence

The ReCaptcha module now includes a ValidateReCaptchaAttribute action filter that automatically validates reCAPTCHA responses on protected controller actions. When applied, the filter checks for the reCAPTCHA token in the request form data and verifies it against the reCAPTCHA service; if validation fails or the token is missing, it adds a localized error message to the model state, preventing the action from executing successfully.

src/OrchardCore/OrchardCore.ReCaptcha.Core/ActionFilters · high confidence

The Trumbowyg WYSIWYG editor now includes a colors plugin (v1.2) that allows users to apply foreground and background colors to text. This change adds the necessary JavaScript logic, UI icons, and CSS styles to support a color picker dropdown with a predefined palette, custom color input, and localization for multiple languages.

src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/colors · high confidence

The Trumbowyg rich-text editor now includes a new 'pasteembed' plugin. When users paste a URL into the editor, this plugin automatically fetches metadata from external services (noembed.com or maxmade.nl) to convert the link into an embedded iframe preview. If the services fail to provide embed code, the URL is inserted as a standard hyperlink, improving the content creation experience by allowing rich media previews from simple pastes.

src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/pasteembed · high confidence

The DeploymentPlanIndex and its provider have been added to the OrchardCore.Deployment.Core project, enabling deployment plans to be indexed by name via YesSql. This allows the system to efficiently query and retrieve deployment plans based on their names, improving search and filtering capabilities within the deployment module.

src/OrchardCore/OrchardCore.Deployment.Core/Indexes · high confidence

The Builtin commands module now includes a HelpCommand that allows users to view help information for all available commands or specific commands via the CLI. The command supports two modes: 'help commands' to list all available commands with their descriptions, and 'help \<command\>' to display detailed help for a specific command. This enhances the user experience by providing built-in documentation for the command-line interface.

src/OrchardCore/OrchardCore.Infrastructure/Commands/Builtin · high confidence

A new PermissionHandler has been introduced in the security infrastructure to enforce user permissions. This handler checks if an authenticated user holds the required permission via the IPermissionGrantingService and succeeds the authorization requirement if granted, ensuring that access control logic is consistently applied based on user claims.

src/OrchardCore/OrchardCore.Infrastructure/Security/AuthorizationHandlers · high confidence

The OrchardCore.Admin.Abstractions package now provides the core abstractions for the admin interface, including the AdminAttribute for intercepting requests to verify admin access, AdminOptions with a trimmed AdminUrlPrefix, and specific permissions (AccessAdminPanel, ManageAdminSettings) to control who can view or configure the admin panel. It also defines the IAdminThemeService interface for managing admin themes and exposes documentation constants.

src/OrchardCore/OrchardCore.Admin.Abstractions · high confidence

The Notifications module now provides structured filtering for the admin notification list, allowing administrators to filter by read status (read/unread), sort order (oldest/newest), and text content, while automatically scoping results to the current user. Additionally, a new query mechanism and caching infrastructure have been added to efficiently retrieve and cache the top unread notifications for individual users, improving performance for the notification badge display.

src/OrchardCore/OrchardCore.Notifications.Core · high confidence

The Audit Trail module now provides a structured framework for recording and managing system events. Administrators can view a paginated list of audit events with advanced filtering capabilities, including search, category, user, and date-based filters, as well as customizable sorting. The system exposes a set of abstractions and services that allow modules to register custom event handlers, define new event categories with localized descriptions, and contribute specific filter options to the admin list view. This enables granular, extensible auditing across the Orchard Core platform.

src/OrchardCore/OrchardCore.AuditTrail.Abstractions · high confidence

A new AutomaticDataMigrations tenant event has been added to the data module. This component automatically triggers data migrations for a tenant shell every time it is activated, ensuring that the tenant's data schema is up to date without requiring manual intervention.

src/OrchardCore/OrchardCore.Data/Migration · high confidence

The Autoroute module now indexes routes for content items nested within containers. When a content item with an Autoroute part is published, the system recursively processes its contained children, generating index entries that link the container's path with the specific JSON path of each contained item. This enables correct URL resolution for hierarchical content structures.

src/OrchardCore/OrchardCore.Autoroute.Core/Indexes · high confidence

The Autoroute module now supports resolving content items using handles that start with a specific slug prefix (defined in \AutorouteConstants.SlugPrefix\). A new \AutorouteHandleProvider\ service implements \IContentHandleProvider\ to intercept these prefixed handles, strip the prefix, and look up the corresponding entry in the \IAutorouteEntries\ cache. This allows external systems or internal logic to reference content items by their URL-friendly slug path rather than just their internal content item ID, provided the handle is prefixed correctly.

src/OrchardCore/OrchardCore.Autoroute.Core/Services · high confidence

Added new configuration sources that allow Orchard Core shell settings (including per-tenant application settings, environment-specific settings, and tenant lists) to be stored in Azure Blob Storage instead of the local file system. These components implement the IShellConfigurationSources, IShellsConfigurationSources, and IShellsSettingsSources interfaces to read and write JSON configuration data to blobs, and include logic to automatically migrate existing local configuration files to the blob store when the MigrateFromFiles option is enabled.

src/OrchardCore/OrchardCore.Shells.Azure/Configuration · high confidence

The Azure Blob file store now automatically detects and supports Azure Data Lake Storage Gen2 (Hierarchical Namespace) for native directory operations and atomic moves, while falling back to flat-namespace semantics for Gen1 accounts. A new validator ensures container names strictly follow Azure naming rules, and configuration options allow explicit override of the namespace detection when auto-detection fails.

src/OrchardCore/OrchardCore.FileStorage.AzureBlob · high confidence

The localization module now supports multiple calendar systems (Hebrew, Hijri, Gregorian, Julian, Persian, UmAlQura) via new BclCalendars and DefaultCalendarManager components, allowing applications to handle date formatting beyond the default Gregorian calendar. Additionally, NullStringLocalizer and NullHtmlLocalizer have been made public and updated to correctly handle pluralization arguments and formatted strings, ensuring that placeholder arguments are preserved even when localization resources are missing or the module is disabled.

src/OrchardCore/OrchardCore/Localization · high confidence

A new configurable system for managing temporary files has been introduced, allowing operators to specify a custom base path for tenant-scoped temporary storage via the \OrchardCore:TempDirectory\ configuration section. This replaces the default reliance on the operating system's temporary directory, enabling deployment to larger or shared volumes (such as Azure Files or AWS EFS) to avoid space limitations. The implementation includes a new \ITempDirectoryProvider\ interface and \DefaultTempDirectoryProvider\ that ensures strict tenant isolation by scoping temporary files to sub-directories named after the tenant, along with supporting utilities for path resolution and file provider extensions.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Files · high confidence

The \OrchardCore.Email.Abstractions\ library now includes \EmailServiceExtensions\ that provide convenient \SendAsync\ methods for \IEmailService\. These extensions allow developers to send emails by specifying recipients, subject, and body content (supporting both HTML and text formats) without manually constructing \MailMessage\ objects. All new methods return a \Result\ type to indicate success or failure and accept a \CancellationToken\ for cancellation support.

src/OrchardCore/OrchardCore.Email.Abstractions/Extensions · high confidence

The deployment core now provides the central \DeploymentManager\ service, which orchestrates the execution of deployment plans by iterating through defined steps and coordinating with registered sources, target providers, and target handlers. It also introduces \TemporaryFileBuilder\, a disposable utility for creating and managing temporary directories and files during deployment operations, ensuring automatic cleanup when disposed.

src/OrchardCore/OrchardCore.Deployment.Core/Services · high confidence

This change introduces the foundational services for the Orchard Core Recipes system within the \OrchardCore.Recipes.Core\ module. It adds \RecipeExecutor\ to handle the parsing and step-by-step execution of JSON-based recipes, including support for variables, parameters, and nested recipes. \RecipeHarvester\ and \ApplicationRecipeHarvester\ are added to discover recipe files from extensions and the application content folder. \RecipeReader\ provides the logic for deserializing recipe files, while \RecipeMigrator\ enables executing recipes as part of the data migration pipeline. Additionally, \RecipeEnvironmentFeatureProvider\ injects context such as the admin user ID and site name into the recipe execution environment.

src/OrchardCore/OrchardCore.Recipes.Core/Services · high confidence

The application now supports loading shell settings and configuration directly from the database. A new extension method, AddDatabaseShellsConfiguration, registers the database as the primary source for shell settings and configuration, replacing previous sources. Additionally, a new utility allows creating shell contexts using database-specific options like provider, connection string, and table prefix.

src/OrchardCore/OrchardCore.Infrastructure/Shells.Database/Extensions · high confidence

The OrchardCore.Elasticsearch.Core library has been significantly expanded to support full index lifecycle management and content picker integration. Users can now manage Elasticsearch indices via Deployment Plans, with new steps to add index settings, rebuild indices, and reset indices, all categorized under 'Search'. The library introduces comprehensive Index Profile Handlers to validate index names, configure analyzers, and define type mappings (including support for source data storage and dynamic templates for inherited fields and locations). Additionally, it provides a Content Picker Result Provider to allow content editors to select items from Elasticsearch indices, and adds Recipe step handlers to automate index creation, rebuilding, and resetting during site provisioning.

src/OrchardCore/OrchardCore.Elasticsearch.Core · high confidence

Developers can now inject custom claims into the OpenID Connect userinfo endpoint response. This change introduces the IUserInfoClaimsProvider interface and UserInfoClaimsContext, allowing implementations to inspect the authenticated user's principal and append additional entries to the claims dictionary after standard scope-based claims (profile, email, phone, roles) have been processed.

src/OrchardCore/OrchardCore.OpenId.Core/Abstractions/Handlers · high confidence

The media search indexing system now supports extensible text extraction for media files. A new \IMediaFileTextProvider\ interface allows implementations to produce textual representations of media files (such as extracting text from PDFs), and a \MediaFileIndexingOptions\ class with \RegisterMediaFileTextProvider\ enables registering these providers by file extension. A \ServiceCollectionExtensions\ method simplifies DI registration, allowing developers to plug in custom text extraction logic for specific file types to improve search indexability.

src/OrchardCore/OrchardCore.Media.Abstractions/Indexing · high confidence

The shape placement system now supports extensible filtering through a new \IPlacementNodeFilterProvider\ interface and a built-in \PathPlacementNodeFilterProvider\. This allows placement rules in \placement.json\ to include dynamic conditions (such as matching the current request path) beyond static properties like display type or differentiator. The \ShapePlacementParsingStrategy\ has been updated to resolve and apply these filter providers when processing placement nodes, enabling more context-aware shape placement decisions.

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapePlacementStrategy · high confidence

Adds a new generic deployment step that allows site settings to be included in deployment plans. This change introduces a reusable \SiteSettingsPropertyDeploymentStep\ along with its associated source, driver, factory, and view model, enabling modules to register specific site settings for export and import via a standardized mechanism.

src/OrchardCore/OrchardCore.Settings.Core/Deployment · high confidence

The GraphQL schema for the User type has been updated to dynamically include fields for any registered custom user settings. When querying a user, the API now automatically resolves and returns data for any content types marked with the 'CustomUserSettings' stereotype, allowing users to access their extended profile properties directly through the GraphQL interface.

src/OrchardCore/OrchardCore.Users.Core/GraphQL · high confidence

Users can now filter content items retrieved via GraphQL content picker fields by their publication status (Published, Draft, or Latest). This is achieved through new DataLoader extensions that batch-load content items and apply specific version filters based on a 'status' argument, ensuring that only the relevant version of a content item is returned for each query context.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Extensions · high confidence

The GraphQL API for content items now exposes indexed content fields for filtering and sorting. Users can filter content items using specific field values via the new \ContentItemWhereInput\ types and order results using the new \ContentItemOrderByInput\ types. This capability is driven by the \DynamicContentFieldsIndexAliasProvider\ and \IContentFieldProvider\ interfaces, which dynamically map content field indexes to GraphQL filter fields, allowing queries to leverage search indexes for performance.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries/Types · high confidence

The DefaultQueryManager service is introduced to handle the lifecycle of queries, including creating, retrieving, listing, updating, and deleting them. It manages query persistence via a QueriesDocument and coordinates with registered IQueryHandler implementations through lifecycle events (initializing, initialized, updating, deleting, deleted). The service also supports executing queries by resolving the appropriate IQuerySource from the service provider and allows changing the query source during updates.

src/OrchardCore/OrchardCore.Queries.Core/Services · high confidence

The OrchardCore.Rules.Abstractions package now provides the foundational types for the Rules feature, including the Condition, Rule, and ConditionGroup models, along with the IConditionEvaluator and IConditionOperator interfaces. It introduces a generic ConditionEvaluator base class that uses ValueTask for async evaluation and ConditionOperatorOptions that leverage FrozenDictionary for efficient operator lookup. The ServiceCollectionExtensions class offers AddRuleCondition for registering new conditions and includes deprecated AddCondition methods to guide users toward the new registration pattern.

src/OrchardCore/OrchardCore.Rules.Abstractions · high confidence

This change introduces the core extension methods and middleware infrastructure for the OrchardCore Modules layer, establishing the foundation for multi-tenant request handling. It adds the \UseOrchardCore\ middleware pipeline to initialize tenant containers and routing, registers essential services (such as localization, data protection, and anti-forgery) via \ServiceCollectionExtensions\, and provides configuration helpers for managing global, tenant, and setup features. Additionally, it implements atomic pipeline building for tenants and configures background service support, effectively wiring up the modular architecture that allows Orchard Core to manage isolated tenant contexts within a single application.

src/OrchardCore/OrchardCore/Modules/Extensions · high confidence

The repository has been initialized with essential configuration files to support development and deployment. This includes a .NET 10.0 Dockerfile for containerized builds, a .NET SDK 10.0.302 global.json, and an .editorconfig defining C\# coding standards and StyleCop rules. Project structure is supported by Directory.Build.props for centralized package references (StyleCop.Analyzers) and build acceleration settings. Developer tooling is configured via .vsconfig for Visual Studio, .prettierrc for frontend formatting, and .yarnrc.yml for Yarn 4 package management. Documentation is set up with .readthedocs.yml and mkdocs.yml, while contributor tracking is managed via .all-contributorsrc. Additional files include .gitattributes for line-ending consistency, .gitignore for build artifacts, and AGENTS.md providing guidelines for LLM agents.

(repo-wide) · high confidence

Added the AdminMenu and AdminNode model classes to the OrchardCore.AdminMenu.Abstractions package. AdminMenu provides a container for menu items with methods to retrieve, remove, and insert nodes by ID or position, while AdminNode extends MenuItem to support hierarchical navigation with unique identifiers and recursive tree operations for managing nested menu structures.

src/OrchardCore/OrchardCore.AdminMenu.Abstractions/Models · high confidence

A new IMarkdownService interface has been added to the OrchardCore.Markdown.Abstractions module, defining a ToHtml method that accepts a markdown string and returns the corresponding HTML. This establishes the core abstraction for markdown processing within the framework, allowing implementations to convert markdown content into HTML output.

src/OrchardCore/OrchardCore.Markdown.Abstractions · high confidence

The OrchardCore.Search.Lucene.Abstractions package now defines the core contracts for the Lucene search implementation, including ILuceneAnalyzer for managing analyzers, ILuceneQueryProvider and ILuceneQueryService for building and executing JSON-based search queries, and ILuceneSearchQueryService for executing raw Lucene queries. It also introduces supporting types such as LuceneOptions, LuceneQueryContext, LuceneQueryResults, and LuceneTopDocs to facilitate search configuration and result handling.

src/OrchardCore/OrchardCore.Search.Lucene.Abstractions · high confidence

Adds a new GraphQL client library for Orchard Core, providing the \OrchardGraphQLClient\ entry point and specific resource builders (\ContentResource\, \ContentTypeQueryResourceBuilder\, \ContentTypeCreateResourceBuilder\, \ContentPartBuilder\) to programmatically construct and execute GraphQL queries and mutations against the Orchard Core API.

src/OrchardCore/OrchardCore.Apis.GraphQL.Client · high confidence

This change adds the OrchardCore.ContentFields.Core module, providing the core data models and settings for a suite of new content fields. The diff introduces field definitions for Boolean, ContentPicker, Date, DateTime, Html, Link, LocalizationSetContentPicker, MultiText, Numeric, Text, Time, UserPicker, and Youtube fields, along with their corresponding settings classes (e.g., TextFieldSettings now supports MinLength and MaxLength, HtmlFieldSettings includes SanitizeHtml and RenderLiquid options). It also adds a DataLocalizationContext helper for field localization and a FieldBehaviorType enum to control field editability.

src/OrchardCore/OrchardCore.ContentFields.Core · high confidence

This change adds a complete localization provider for GNU Portable Object (.po) files within Orchard Core. It introduces a new file location provider that reads .po files from the content root, a parser to handle .po syntax including escape sequences and plural forms, and a translation provider to load these into the localization system. Additionally, it provides custom string and HTML localizers that respect parent culture fallbacks and correctly handle pluralization arguments, enabling developers to manage translations using standard .po files.

src/OrchardCore/OrchardCore.Localization.Core/PortableObject · high confidence

The new Rate Limits module adds the core infrastructure for managing tenant rate-limit policies, including models for policies and limiters (fixed-window, sliding-window, token-bucket, concurrency), a document-based policy store, and recipe handlers to import/export policies. It also provides deployment sources to export all rate-limit policies as a deployment plan step, enabling administrators to move rate-limit configurations between environments.

src/OrchardCore/OrchardCore.RateLimits.Core · high confidence

This change introduces the core abstractions for the new SMS module, enabling developers to send messages through pluggable providers. It defines the ISmsService and ISmsProvider interfaces, allowing multiple SMS providers to be registered and resolved via ISmsProviderResolver. The SmsMessage model now includes a 'From' field to specify the sender's phone number, and SmsProviderOptions provides a configuration API to add, remove, or replace provider implementations dynamically.

src/OrchardCore/OrchardCore.Sms.Abstractions · high confidence

The OrchardCore.Sitemaps.Abstractions module now provides the core configuration types for the Sitemaps feature. This includes SitemapsOptions for global route values and sitemap identification, a dedicated SitemapsPermissions class defining the 'ManageSitemaps' permission, and new classes (SitemapsRazorPagesOptions and SitemapsRazorPagesContentTypeOption) that allow developers to configure how Razor Pages content types are handled within sitemaps, including specifying page names and route value generation logic.

src/OrchardCore/OrchardCore.Sitemaps.Abstractions · high confidence

This change adds the core services and models required to send SMS notifications via Twilio. It introduces a new \TwilioSmsProvider\ that handles message delivery using Twilio's API, along with configuration classes (\TwilioOptions\, \TwilioSettings\) to manage account credentials securely. The update also includes a \LogSmsProvider\ for debugging (writing messages to logs instead of sending them), a \DefaultSmsProviderResolver\ to select the active provider, and an \SmsNotificationProvider\ to integrate SMS into the existing notification system. Users can now configure Twilio credentials in site settings to enable two-factor authentication or other SMS-based notifications.

src/OrchardCore/OrchardCore.Sms.Core/Services · high confidence

The URL Rewriting module is now available, allowing administrators to manage URL rewrite and redirect rules through a new set of abstractions and core services. This change adds the \IRewriteRuleHandler\, \IRewriteRulesManager\, and \IRewriteRulesStore\ interfaces, along with implementations that persist rules to a document store and apply them via ASP.NET Core's \RewriteOptions\. It includes specific handlers for \UrlRedirectRule\ (supporting 301/302/307/308 redirects, case-insensitivity, and query string policies) and \UrlRewriteRule\ (supporting pattern substitution and skipping further rules). The module also integrates with the admin URL prefix to ensure rewrite rules do not interfere with administrative access.

src/OrchardCore/OrchardCore.UrlRewriting.Core · high confidence

The Documents location now provides a concrete DocumentStore implementation that wraps a YesSql ISession. This class manages document loading, caching, and persistence, supporting both mutable and immutable document workflows with concurrency checking and post-commit hooks for cache updates.

src/OrchardCore/OrchardCore.Data.YesSql/Documents · high confidence

A new base class, MediaEventHandlerBase, has been added to simplify the implementation of media event handlers by providing default no-op implementations for all media lifecycle events (creation, deletion, moving). Additionally, a new DefaultMediaFileStoreCacheEventHandler has been introduced to automatically invalidate the media cache when files or directories are deleted or moved, ensuring that cached content remains consistent with the underlying file store.

src/OrchardCore/OrchardCore.Media.Core/Events · high confidence

The Roles.Core module now provides a new DefaultSystemRoleProvider that manages system roles (Administrator, Authenticated, Anonymous) and allows administrators to define custom system roles via the SystemRoleOptions.AdditionalSystemRoles configuration. The provider also supports customizing the admin role name through SystemRoleOptions.SystemAdminRoleName or shell settings, ensuring consistent role management across the application.

src/OrchardCore/OrchardCore.Roles.Core · high confidence

The Content Localization Abstractions module now exposes a structured handler model for localization events. This includes the \LocalizationContentContext\ to carry context (original item, target culture, and localization set), along with \IContentLocalizationHandler\ and \IContentLocalizationPartHandler\ interfaces and their corresponding base classes (\ContentLocalizationHandlerBase\ and \ContentLocalizationPartHandlerBase\). These components allow developers to hook into the \LocalizingAsync\ and \LocalizedAsync\ lifecycle phases for content items and specific content parts, providing a standardized way to implement custom localization logic.

src/OrchardCore/OrchardCore.ContentLocalization.Abstractions/Handlers · high confidence

Added the LocalizationEntry and LocalizationPart classes to the ContentLocalization.Abstractions package. LocalizationPart implements ILocalizable and provides properties for LocalizationSet and Culture, while LocalizationEntry defines the underlying storage structure with a long DocumentId, ContentItemId, LocalizationSet, and Culture fields.

src/OrchardCore/OrchardCore.ContentLocalization.Abstractions/Models · high confidence

This change establishes the foundational SMS module within Orchard Core, introducing a pluggable architecture that allows administrators to configure and switch between different SMS providers (such as Twilio or a logging fallback) via settings. It registers the core \ISmsService\ and provider resolution logic, defines the \ManageSmsSettings\ permission for secure administration, and provides the base view model for the settings UI, enabling two-factor authentication and other SMS-based workflows to be backed by external services.

src/OrchardCore/OrchardCore.Sms.Core · high confidence

This change adds the foundational interfaces and types for the Orchard Core notifications feature within the abstractions package. It defines the contract for sending messages via \INotificationService\ and \INotificationMethodProvider\, supporting both plain text and HTML bodies through \INotificationMessage\. The update also introduces \INotificationEvents\ to allow hooks into the notification lifecycle (creating, sending, failed), a \Notification\ entity for storage, and a \NotificationSendResult\ that reports success, failure, or partial success for each delivery attempt.

src/OrchardCore/OrchardCore.Notifications.Abstractions · high confidence

This change adds the foundational data models for the new Notifications module in Orchard Core. It introduces \NotificationMessage\ and \NotificationBodyInfo\ to support both text and HTML notification bodies, allowing users to receive rich content. Configuration is handled via \NotificationOptions\, which exposes settings for cache expiration (absolute and sliding), the number of unread notifications displayed in the navbar, and an option to disable HTML body sanitization. The module also defines \NotificationStatus\, \NotificationOrder\, and \NotificationBulkAction\ enums to manage read states, sorting, and bulk operations, alongside \ListNotificationOptions\ for filtering and pagination logic. User preferences are stored in \UserNotificationPreferencesPart\, enabling users to select notification methods and opt out of specific channels.

src/OrchardCore/OrchardCore.Notifications.Core/Models · high confidence

This change introduces the foundational components for the localization system within OrchardCore.Localization.Core. It adds a DefaultPluralRuleProvider that implements Unicode CLDR pluralization rules for a wide range of languages, allowing the system to correctly format numbers in different locales. A new LocalizationManager is added to coordinate translation providers and pluralization rules, utilizing memory caching to optimize performance when retrieving culture dictionaries. Additionally, a new ManageCultures permission is defined to control access to culture management features.

src/OrchardCore/OrchardCore.Localization.Core · high confidence

The Notifications module now includes a new \NotificationService\ that orchestrates sending notifications via multiple providers, supporting both text and HTML message bodies. An \EmailNotificationProvider\ has been added to handle email delivery, while a \CacheNotificationEventsHandler\ ensures the top unread notification count in the navigation bar is refreshed immediately after a notification is sent. Additionally, admin notification list filtering is now supported via a new \DefaultNotificationAdminListFilterParser\ and associated model binder.

src/OrchardCore/OrchardCore.Notifications.Core/Services · high confidence

This change introduces the foundational scripting infrastructure for Orchard Core, adding the \DefaultScriptingManager\ to handle directive parsing and engine resolution, \CommonGeneratorMethods\ to provide global scripting functions (such as base64, HTML decoding, and gzip decompression), and the \FilesScriptEngine\ for file-based script execution. It also registers these components via \AddScripting\ extension methods in both \OrchardCoreBuilder\ and \IServiceCollection\, establishing the DI wiring for the scripting subsystem.

src/OrchardCore/OrchardCore.Infrastructure/Scripting · high confidence

Added the \DataLocalizedString\ class and \ILocalizationDataProvider\ interface to the \OrchardCore.Abstractions/Localization/Data\ namespace, establishing the core abstraction for retrieving localized strings from data sources. The \DataLocalizedString\ class encapsulates context, name, and value, and implements an implicit conversion to string as well as a \ToString()\ method that returns the value, enabling seamless integration with existing string-based localization consumers.

src/OrchardCore/OrchardCore.Abstractions/Localization/Data · high confidence

This change introduces a new data-driven localization system within Orchard Core, allowing translations to be managed dynamically via the database rather than static resource files. It adds core components including \DataLocalizer\ for resolving strings, \DataResourceManager\ for caching and retrieving translations, and \DataLocalizationPermissions\ to control access to translation management. This enables administrators to manage dynamic translations and view statistics through a new editor, supporting per-culture permissions and fallback to parent cultures.

src/OrchardCore/OrchardCore.Localization.Core/Data · high confidence

The caching subsystem now includes a new \IMessageBus\ interface and a \DistributedSignal\ implementation that uses it to propagate cache invalidation signals across multiple nodes. This allows applications to maintain consistent cache states in distributed environments by publishing and subscribing to signal events, while the existing local \Signal\ component continues to handle single-instance scenarios.

src/OrchardCore/OrchardCore.Abstractions/Caching, src/OrchardCore/OrchardCore/Caching · high confidence

This change adds a new distributed shell synchronization mechanism that keeps tenant states consistent across multiple Orchard Core instances. It introduces a \DistributedShellHostedService\ that uses a distributed cache (like Redis) to share shell identifiers, allowing instances to detect when tenants are created, removed, or reloaded by other nodes. The \DistributedContext\ class manages the lifecycle of the distributed cache connection and shell context, ensuring proper disposal and reference counting. This enables multi-instance deployments to maintain a unified view of tenants without manual intervention.

src/OrchardCore/OrchardCore/Shell/Distributed · high confidence

This change adds a new document management layer to OrchardCore.Infrastructure that synchronizes documents between a persistent store and a multi-level cache (memory and distributed). It introduces DefaultDocumentSerializer for JSON serialization with optional GZip compression, DocumentManager for standard document handling with failover logic, and VolatileDocumentManager for in-memory-only documents that support atomic updates via distributed locking. The system registers these services via AddDocumentManagement, including DocumentEntityManager for entity-level property management, and ensures cache invalidation consistency across memory and distributed caches.

src/OrchardCore/OrchardCore.Infrastructure/Documents · high confidence

A new FileDocumentStore implementation has been added to handle document persistence by serializing data to individual JSON files within the tenant's application data directory. This component integrates with the ambient transaction system, ensuring that file updates occur only after a successful database commit, and supports custom file naming via the FileDocumentStoreAttribute. It utilizes System.Text.Json for serialization and includes concurrency control via semaphores to safely manage read/write operations on the file system.

src/OrchardCore/OrchardCore.Data/Documents · high confidence

The OrchardCore File Storage module now includes a new \FileSystemStore\ implementation that allows storing files and media directly on the local disk. This feature enables users to configure a physical directory path for file storage, supporting hierarchical namespaces and atomic moves, and exposes the store via the standard \IFileStore\ interface for use with media galleries and other file-dependent features.

src/OrchardCore/OrchardCore.FileStorage.FileSystem · high confidence

This change introduces the core infrastructure for modular tenant isolation and background task processing within the Modules layer. It adds the \ModularTenantContainerMiddleware\ and \ModularTenantRouterMiddleware\ to replace the default service provider with tenant-specific scopes and handle request routing based on URL prefixes. It also introduces the \ModularBackgroundService\ to execute background tasks asynchronously across tenants, ensuring proper context isolation and lock management. Supporting components include \DefaultClientIPAddressAccessor\ for IP resolution, \DefaultOrchardHelper\ for context access, and \PoweredByMiddleware\ for response headers.

src/OrchardCore/OrchardCore/Modules · high confidence

The Feeds module now includes a set of new model classes in the \OrchardCore.Feeds.Models\ namespace to support feed generation and configuration. \FeedContext\ provides the execution context with an updater, format, and builder, while \FeedResponse\ manages the resulting XML elements, a collection of \FeedItem\s, and contextualization hooks. \FeedItem\ and its generic variant \FeedItem\<TItem\>\ represent individual entries, and \FeedMetadata\ allows content items to disable RSS feeds or specify a proxy URL. \ContextualizeContext\ supplies service provider and URL helper instances for these hooks.

src/OrchardCore/OrchardCore.Feeds.Abstractions/Models · high confidence

This change introduces a set of new view models in the Search Abstractions layer to structure search-related UI data. SearchFormViewModel now exposes Terms, Index, and Placeholder properties for search input handling. SearchIndexViewModel aggregates the search context, including Terms, Index, PageTitle, the SearchFormViewModel, SearchResultsViewModel, Pager, and the resulting ContentItems. SearchResultsViewModel carries the Index, ContentItems, and a new Highlights dictionary to support search result highlighting. SearchPartViewModel provides a simple model with a required Placeholder and IndexName for part-level search configuration. These models replace ad-hoc or implicit data structures, providing a consistent contract for search form rendering, result display, and highlighting across the search module.

src/OrchardCore/OrchardCore.Search.Abstractions/ViewModels · high confidence

The display management layer now supports building page titles from multiple segments with positional control. The new IPageTitleBuilder interface and PageTitleBuilder implementation allow developers to add title parts at specific positions, set a fixed title to override segments, and generate the final HTML title string using a configurable separator (defaulting to ' - '). This enables more flexible and structured title composition for pages.

src/OrchardCore/OrchardCore.DisplayManagement/Title · high confidence

The OrchardCore.Shortcodes.Abstractions module now provides the foundational types for registering and managing shortcodes. Developers can use the new ServiceCollectionExtensions to register shortcode providers and delegates via DI, while ShortcodeOptions and ShortcodeDescriptor define the metadata structure for shortcode definitions. Additionally, a new ManageShortcodeTemplates permission is introduced to control access to shortcode template management.

src/OrchardCore/OrchardCore.Shortcodes.Abstractions · high confidence

The document infrastructure now exposes a dedicated options hierarchy in the \OrchardCore.Documents.Options\ namespace to configure document caching, serialization, and synchronization behavior. This includes \DocumentOptionsBase\ (extending \DistributedCacheEntryOptions\) for core settings like concurrency checks, consistency checks, synchronization latency, compression thresholds, and lock timeouts, alongside specific interfaces and classes for named options (\IDocumentNamedOptions\, \DocumentNamedOptions\) handling cache keys and shared options (\IDocumentSharedOptions\, \DocumentSharedOptions\) managing failover retry latency. This change provides a standardized, extensible way to configure document storage behavior across the application.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Documents/Options · high confidence

This change introduces the core data models for managing tenant feature profiles and tenant lifecycle states. It adds the \FeatureProfile\ and \FeatureRule\ classes, allowing administrators to define specific sets of features and themes (via include/exclude rules) that can be assigned to tenants. It also introduces \FeatureProfilesRuleOptions\ to provide a configurable dictionary for validating these feature rules. Additionally, the \TenantState\ enum is added to explicitly track the lifecycle status of a tenant (Uninitialized, Initializing, Running, Disabled, Invalid), providing a clearer state management foundation for the shell environment.

src/OrchardCore/OrchardCore.Abstractions/Shell/Models · high confidence

A new Assets Manager tool has been added to the repository to handle the building, minification, and bundling of frontend assets. This tool replaces the previous Gulp-based pipeline for the Media and Resources modules and introduces support for multiple bundlers, including Parcel, Vite, and Webpack, as well as dedicated scripts for SCSS compilation, concatenation, and minification. It enforces a specific Node.js version (via fnm or Volta), normalizes line endings for consistent source maps, and outputs assets following Orchard Core conventions (e.g., generating both minified and non-minified files with source maps).

.scripts/assets-manager · high confidence

Adds new model classes to the OrchardCore.XmlRpc.Abstractions package to represent XML-RPC data structures, including XRpcArray, XRpcStruct, XRpcData, XRpcMethodCall, and XRpcMethodResponse. These classes provide the foundational types for serializing and deserializing XML-RPC method calls and responses, supporting typed data handling, parameter lists, and fault reporting.

src/OrchardCore/OrchardCore.XmlRpc.Abstractions/Models · high confidence

The OrchardCore.Queries.Abstractions module now defines the core interfaces and base classes for the named query system, including IQueryManager for CRUD operations and execution, IQueryHandler for lifecycle events, and IQuerySource for data providers. It also introduces a permission model (QueryPermissions) that allows administrators to control who can manage queries and who is authorized to execute specific named queries via the API, enabling granular security for query-based endpoints.

src/OrchardCore/OrchardCore.Queries.Abstractions · high confidence

This change adds the foundational interfaces and types for the content localization feature within the OrchardCore.ContentLocalization.Abstractions module. It introduces the IContentLocalizationManager interface, which defines the contract for managing localized content sets (including retrieving items by set/culture, cloning items for localization, and deduplicating results). It also adds the CultureAspect class to hold culture metadata on content items, the ILocalizable interface for marking content as localizable, and specific permissions (LocalizeContent, LocalizeOwnContent, ManageContentCulturePicker) to control access to these features. Additionally, a helper extension method is provided to easily retrieve the culture for a given content item.

src/OrchardCore/OrchardCore.ContentLocalization.Abstractions · high confidence

The Recipes.Abstractions module now provides a RecipesConstants class that centralizes the folder name ("Recipes") and file extension (".recipe.json") for recipe files, and a ServiceCollectionExtensions helper that allows adding recipe step handlers as scoped services in a single call.

src/OrchardCore/OrchardCore.Recipes.Abstractions · high confidence

The Cache module now provides a complete tenant-level caching system. It registers a DefaultTagCache implementation that uses IMemoryCache to track and invalidate items by tags, and introduces CacheScopeManager to handle nested cache scopes with restrictive expiry merging. CacheContextManager aggregates context discriminators from providers (Features, Query, Roles, Route, User, KnownValue) to support context-aware caching. The DI setup registers these services as scoped, uses a singleton IMemoryCache per tenant, and configures distributed signaling via ISignal (falling back to a local Signal if no IMessageBus is available) to keep caches in sync.

src/OrchardCore/OrchardCore.Infrastructure/Cache · high confidence

A new BackgroundTaskScheduler class has been added to the OrchardCore.BackgroundTasks namespace to manage the execution timing of background tasks. This component determines if a task is ready to run by comparing the current time against a scheduled next occurrence, specifically handling timezone conversions via an injected IClock and ITimeZone interface when a timezone is configured. It exposes properties for task settings, state, and release status, and provides methods to check run eligibility (CanRun) and execute the task (Run), effectively centralizing the logic for when background jobs should trigger based on cron schedules and site time.

src/OrchardCore/OrchardCore/BackgroundTasks · high confidence

A new DistributedShellMarkerService class has been added to the OrchardCore.Abstractions module, providing a marker service for distributed shell operations.

src/OrchardCore/OrchardCore.Abstractions/Shell/Distributed · high confidence

The OrchardCore.DynamicCache.Abstractions package now exposes core interfaces and configuration for dynamic caching capabilities. This includes the IDynamicCache interface for low-level cache operations (get, set, remove) using standard distributed cache entry options, the IDynamicCacheService interface which integrates with the tag removal event system for cache invalidation, and the DynamicCacheOptions class to configure failover retry latency.

src/OrchardCore/OrchardCore.DynamicCache.Abstractions · high confidence

A new abstraction, IHtmlSanitizerService, has been added to the OrchardCore.Infrastructure.Abstractions.Html namespace. This interface defines a single Sanitize method that accepts an HTML string and returns a sanitized version, providing a standardized contract for HTML sanitization logic within the infrastructure layer.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Html · high confidence

A new IShellDescriptorManager interface has been added to the OrchardCore.Abstractions library, providing methods to retrieve the current shell configuration (GetShellDescriptorAsync) and update stored shell descriptor information with optimistic concurrency control (UpdateShellDescriptorAsync). This interface serves as the primary abstraction for host-level shell descriptor management.

src/OrchardCore/OrchardCore.Abstractions/Shell/Descriptor · high confidence

The OpenID module now exposes specific descriptor classes (OpenIdApplicationDescriptor, OpenIdAuthorizationDescriptor, OpenIdScopeDescriptor, and OpenIdTokenDescriptor) that extend the corresponding base types from OpenIddict. The application descriptor additionally exposes a Roles property, allowing applications to be associated with specific roles.

src/OrchardCore/OrchardCore.OpenId.Core/Abstractions/Descriptors · high confidence

The OrchardCore.Rules.Core module now includes a RuleService that evaluates rules by checking if all defined conditions are met. This service is registered via the AddRules extension method and relies on a condition resolver to evaluate individual conditions asynchronously.

src/OrchardCore/OrchardCore.Rules.Core · high confidence

The OrchardCore.XmlRpc.Abstractions package now exposes core abstractions for XML-RPC integration, including the IXmlRpcDriver and IXmlRpcHandler interfaces for processing requests and setting capabilities, along with a new XmlRpcContext class that aggregates HTTP context, URL helpers, and RPC method call/response data for use by handlers and drivers.

src/OrchardCore/OrchardCore.XmlRpc.Abstractions · high confidence

The .scripts/bloom directory introduces Bloom, a new JavaScript framework for shared admin components and services. This includes a new README and branding assets, a comprehensive TypeScript ambient declaration file (ambient.d.ts) that provides type definitions for legacy global libraries (such as jQuery, CodeMirror, Bootstrap, and various Orchard Core-specific helpers) to support modern ES module consumption, and new reusable UI components for bulk actions (bulk-action-confirm, bulk-select-list) and checkbox-driven DOM relationships (checkbox-relations).

.scripts/bloom · high confidence

This change introduces a new Liquid tag helper system that allows Liquid templates to invoke standard ASP.NET Core Tag Helpers (such as \asp-for\, \asp-action\, etc.). The implementation includes a factory that scans registered Tag Helpers and an activator that maps Liquid arguments to Tag Helper properties, supporting attribute matching, dictionary properties, and model expressions. This enables developers to leverage existing UI components directly within Liquid views.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/TagHelpers · high confidence

Users can now have default ASP.NET Core data annotations validation messages (such as those for Required, EmailAddress, or Range) translated into the current culture. This is achieved by introducing a LocalizedValidationMetadataProvider that intercepts validation metadata and replaces standard English error strings with localized equivalents from PO resource files, ensuring form validation feedback respects the user's language settings.

src/OrchardCore/OrchardCore.Localization.Core/DataAnnotations · high confidence

The Media field now exposes configurable settings in its settings view, allowing administrators to control whether multiple media items can be selected, whether media text is allowed, whether anchors are permitted, and which file extensions are allowed for upload.

src/OrchardCore/OrchardCore.Media.Core/Settings · high confidence

This change introduces the OrchardCore.Application.Cms.Core.Targets package, which provides MSBuild props and targets to manage build artifacts. Specifically, it excludes media and MS cache directories from default item inclusion, removes App\_Data and Localization files from compilation and content packaging while ensuring they are published, and adds build/publish targets to ensure required directories exist and copy translation files. Additionally, it adds ServiceExtensions to register the core CMS services (including MVC, security, data access, and tag helpers) via AddOrchardCms, and introduces infrastructure services like PhoneFormatValidator and API Problem Details support.

src/OrchardCore/OrchardCore.Application.Cms.Core.Targets · high confidence

The OrchardCore.Flows.Core module now includes new model classes for FlowPart and BagPart, enabling the storage of contained content items and widgets. A key behavioral addition is the introduction of FlowMetadata and FlowPartSettings, which allow authors to set a default alignment (Left, Center, Right, Justify, or Inherit) for flow containers, with alignment inheritance support. BagPartSettings provide configuration for contained content types, stereotypes, display type, and item collapsing, while BagPartBlocksEditorSettings customize the editor UI text. These models form the data foundation for the new block-based flow editing experience.

src/OrchardCore/OrchardCore.Flows.Core · high confidence

This change introduces a new set of extension methods in the OrchardCore GraphQL abstractions layer to enhance field handling and query capabilities. Users can now use \ResolveLockedAsync\ for thread-safe field resolution, apply metadata to fields via \WithPartCollapsedMetaData\, \WithPartNameMetaData\, etc., and enforce access control using \RequirePermission\ on types and field builders. Additionally, paging support is added through \PagingArguments\ and a \Page\ helper that respects \first\, \last\, and \skip\ arguments, defaulting to a configured result count when neither \first\ nor \last\ is specified. Case-insensitive field existence checks are also available via \HasFieldIgnoreCase\.

src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions/Extensions · high confidence

The GraphQL query layer now includes new abstractions and types to support more flexible content filtering. A new \IFilterInputObjectGraphType\ interface and \WhereInputObjectGraphType\ base class provide standardized methods for adding scalar filter fields, supporting equality, multi-value (in/not\_in), string-specific (contains, starts\_with, etc.), and numeric comparison operators. A new \TimeSpanGraphType\ scalar type has been added to handle time interval values in queries. Additionally, an \INamedQueryProvider\ interface is introduced to allow resolving named query definitions.

src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions/Queries · high confidence

This change introduces new extension methods for HtmlContentBuilder to simplify appending separated values and whitespace, adds a new HtmlContentString class for more efficient HTML encoding of strings, and includes a ShapeDebugInfoHtmlContent class for rendering debug comments around shape content.

src/OrchardCore/OrchardCore.DisplayManagement/Html · high confidence

This change introduces a new HTML sanitization infrastructure within OrchardCore.Infrastructure.Html, providing a dedicated service (IHtmlSanitizerService) and Razor helper (SanitizeHtml) to safely process HTML content. The default configuration explicitly removes the 'form' tag to prevent injection attacks, while allowing 'class' attributes and 'mailto'/'tel' URL schemes. The system is designed for extensibility, allowing modules to register custom configuration actions via the new ConfigureHtmlSanitizer extension method.

src/OrchardCore/OrchardCore.Infrastructure/Html · high confidence

A new static helper class, HttpBackgroundJob, has been added to the OrchardCore.Abstractions.BackgroundJobs module. This component allows developers to schedule background tasks to run in an isolated ShellScope after the current HTTP request finishes. It handles critical context management by waiting for the original HttpContext to be released (with a 60-second timeout), creating a new HttpContext for the background scope, and restoring the original user's identity. The helper also supports passing up to five arguments to the background job function and includes logging for observability and error handling.

src/OrchardCore/OrchardCore.Abstractions/BackgroundJobs · high confidence

A new IRecipeEventHandler interface has been added to the OrchardCore.Recipes.Events namespace, providing hooks for recipe execution lifecycle events including RecipeExecutingAsync, RecipeStepExecutingAsync, RecipeStepExecutedAsync, RecipeExecutedAsync, and ExecutionFailedAsync. The interface includes documentation noting that handlers should be registered as application-level transient or singleton services rather than tenant-level services, due to the recipe executor creating separate scopes for each step that may be based on new shells.

src/OrchardCore/OrchardCore.Recipes.Abstractions/Events · high confidence

A new extension method, IsViewOrPageResult, is now available on ResultExecutingContext within the Display Management Abstractions. This method allows developers to easily check if the current result is either a ViewResult or a PageResult, simplifying conditional logic in filters and middleware that need to distinguish between these specific result types.

src/OrchardCore/OrchardCore.DisplayManagement.Abstractions/Extensions · high confidence

The OrchardCore.Abstractions library now includes two new extension classes to simplify JSON handling. JsonNodeExtensions adds GetEnumValue and TryGetEnumValue methods, allowing JsonNode instances to be safely converted to enum types by handling both string and integer representations. JsonSerializerOptionsExtensions introduces a Merge method that combines configuration settings (such as naming policies, converters, and resolvers) from a source options object into a destination object, facilitating easier composition of JSON serialization configurations.

src/OrchardCore/OrchardCore.Abstractions/Json/Extensions · high confidence

The shell configuration layer now includes three new sources that manage settings via JSON files in the application data directory. \ShellConfigurationSources\ handles per-tenant \appsettings.json\ files, supporting add, save, and remove operations for tenant-specific configuration. \ShellsConfigurationSources\ loads global shell settings from \appsettings.json\ and environment-specific variants (e.g., \appsettings.Production.json\). \ShellsSettingsSources\ manages a central tenants registry file (\tenants.json\), allowing save and remove operations for tenant metadata. These components implement the \IShellConfigurationSources\, \IShellsConfigurationSources\, and \IShellsSettingsSources\ interfaces respectively, providing a structured way to persist and retrieve shell and tenant configuration data using \System.Text.Json\.

src/OrchardCore/OrchardCore/Shell/Configuration · high confidence

The Liquid template engine now supports a new \{% cache %}\ block tag that caches rendered content based on a key, with options to vary by context or tags, and to set absolute, sliding, or specific-time expiration. Additionally, helper tags (\{% cache\_dependency %}\, \{% cache\_expires\_after %}\, \{% cache\_expires\_on %}\, \{% cache\_expires\_sliding %}\) allow fine-grained control over cache dependencies and expiration policies within the block.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/Cache · high confidence

This change introduces several new Liquid filters to the Display Management module. The \append\_version\ filter adds file versioning to URLs, while \localize\ enables string translation using the view localizer. New shape-related filters include \new\_shape\ for creating shapes, \shape\_properties\ for mutating shape properties, \shape\_render\ for rendering shapes as HTML content, and \shape\_stringify\ for converting shapes to strings. Additionally, \resource\_url\ prefixes resource paths with the configured CDN base URL, \html\_class\ converts strings to CSS class names, and \sanitize\_html\ cleans HTML input. The previously used \supported\_cultures\ filter is now marked as obsolete in favor of \Culture.SupportedCultures\.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/Filters · high confidence

This release adds a comprehensive suite of Liquid tags to the Display Management module, enabling deeper control over shape rendering and layout. Developers can now mutate shape properties directly in templates using tags like \add\_classes\, \add\_alternates\, \add\_wrappers\, \add\_attributes\, and \shape\_add\_property\, as well as clear or remove them. Layout and rendering are enhanced with \layout\, \render\_body\, and \render\_section\ tags, while the \anchor\ tag provides a Liquid interface for generating action, route, and page links. Additional tags include \shape\_cache\ for caching configuration, \shape\_pager\ for pager customization, \http\_context\_add\_item\/\http\_context\_remove\_item\ for context management, and \antiforgery\_token\ for security.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/Tags · high confidence

Liquid templates can now access new context objects: \Culture\ (with properties like \Name\, \NativeName\, \DisplayName\, \SupportedCultures\, and \DefaultCulture\), \HostingEnvironment\ (exposing \IsDevelopment\, \IsStaging\, \IsProduction\, and \Name\), \HttpContext\ (providing access to \Items\), \Request\ (exposing query string, headers, cookies, form data, route values, and URI components), and \TrackingConsent\ (exposing \CanTrack\, \HasConsent\, \IsConsentNeeded\, \CookieName\, and \CookieValue\). These additions allow template authors to dynamically render content based on localization, environment, request details, and privacy consent status without requiring custom view models.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/Values · high confidence

This change introduces a new Liquid view engine for Orchard Core, allowing developers to use \.liquid\ files as Razor-like views. It adds a \LiquidViewTemplate\ that parses and renders Liquid templates, integrating with the ASP.NET MVC view pipeline via \LiquidPage\ and \LiquidViewsFeatureProvider\. The update includes a comprehensive \LiquidViewParser\ that registers numerous Liquid tags and filters for shape manipulation (e.g., \shape\_add\_alternates\, \zone\), HTTP context access (\httpcontext\_add\_items\), and caching (\cache\). It also establishes a new \LiquidTemplateContext\ to expose ASP.NET Core services (like \ViewContext\, \HttpContext\, \Request\) and Orchard Core shapes to Liquid templates, along with configuration options in \LiquidViewOptions\ for file providers and parser customization.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid · high confidence

The Lucene search module now supports a broader range of query filters, including fuzzy matching, geographic bounding box and distance queries, match phrases, prefixes, ranges, terms, and wildcards. These new filter providers allow users to perform more complex and precise searches, such as finding content within a specific geographic area or matching text with typos.

src/OrchardCore/OrchardCore.Lucene.Core/QueryProviders/Filters · high confidence

The Lucene search abstraction layer now includes explicit models for indexing configuration: a \Mapping\ class to represent content type index information, a \Property\ class defining field settings (such as analyzers, storage, boosting, and scaling factors), and a \Types\ enum listing supported Lucene data types (e.g., Text, Keyword, Date, ScaledFloat). These classes provide the foundational schema for how content properties are mapped and indexed in Lucene.

src/OrchardCore/OrchardCore.Search.Lucene.Abstractions/Indexing · high confidence

The Lucene search module now includes dedicated query providers for a comprehensive set of structured query types, enabling more precise and flexible search capabilities. Users can now utilize boolean logic (must, must\_not, should, filters), fuzzy matching with configurable parameters, phrase matching with slop, standard match queries with AND/OR operators, prefix, wildcard, and regular expression searches, as well as range queries for numeric and string data. Additionally, support for simple query strings and term/term-sets queries has been added, allowing for complex, multi-field search expressions that were previously unsupported or required workarounds.

src/OrchardCore/OrchardCore.Lucene.Core/QueryProviders · high confidence

This change introduces new extension methods for ASP.NET Core MVC controllers and model state, including \ChallengeOrForbid\ and \InternalServerError\ on \ControllerBase\, as well as \AddModelError\ and \AddModelErrors\ on \ModelStateDictionary\. It also adds \AddMvc\ to \OrchardCoreBuilder\, which configures tenant-level MVC services, registers a custom shell route address scheme, and suppresses unhandled security metadata checks for performance and CORS compatibility.

src/OrchardCore/OrchardCore.Mvc.Core/Extensions · high confidence

This change introduces new utility extension methods in the OrchardCore.Mvc.Core.Utilities namespace to improve developer experience and URL generation. ControllerTypeExtensions now provides a ControllerName method that correctly extracts the controller name from types inheriting from ControllerBase, ensuring accurate naming conventions. StringExtensions adds several new methods including CamelFriendly for converting camelCase strings to space-separated text, Ellipsize for safe text truncation, HtmlClassify for generating CSS-friendly class names, and RemoveTags for stripping HTML tags with optional decoding to prevent XSS vulnerabilities. Additionally, UrlHelperExtensions introduces ToAbsoluteAction, GetBaseUrl, and ToAbsoluteUrl methods that properly handle absolute URLs when media is served from a CDN, preventing invalid concatenated URLs in SEO image links and other media references.

src/OrchardCore/OrchardCore.Mvc.Core/Utilities · high confidence

This change introduces two new components to the platform. First, it adds a \DeleteFileResultFilter\ in the Deployment Core module that automatically removes physical files after they are served via an MVC result, ensuring temporary deployment artifacts are cleaned up. Second, it establishes the MetaWeblog API abstraction layer by adding the \IMetaWeblogDriver\ interface and a base \MetaWeblogDriver\ class, providing the contract for implementing MetaWeblog-compatible blog drivers within Orchard Core.

src/OrchardCore/OrchardCore.Deployment.Core/Mvc, src/OrchardCore/OrchardCore.MetaWeblog.Abstractions · high confidence

A new ModuleFeature class has been added to the OrchardCore.Features.Core.Models namespace to represent the state of a module's feature. This model exposes properties for the feature descriptor, enabled status, dependency information, and update requirements, providing a structured way to manage feature metadata within the application.

src/OrchardCore/OrchardCore.Features.Core/Models · high confidence

This change introduces core infrastructure for OpenAPI integration, including an ApiProblemDetailsMiddleware that ensures API clients receive structured RFC 9457 Problem Details bodies for 401 and 403 errors instead of HTML pages. It adds OpenAPI-specific permissions (ManageOpenApi, ViewOpenApiContent) and settings to control anonymous schema access, along with marker interfaces for Swagger, ReDoc, and Scalar UI features. Additionally, a new OpenApiClientGenerator tool is provided to automate the regeneration of NSwag client code by spinning up a temporary CMS instance, capturing the swagger.json, and running the code generator.

src/OrchardCore/OrchardCore.Infrastructure/ErrorHandling, src/OrchardCore/OrchardCore.OpenApi.Core, tools · high confidence

A new \Page\ base class has been added to the \OrchardCore.DisplayManagement.RazorPages\ namespace, extending ASP.NET Core's \Microsoft.AspNetCore.Mvc.RazorPages.Page\. This class provides Orchard-specific helpers for Razor Pages, including properties and methods to create shapes (\New\, \Factory\), render shapes asynchronously (\DisplayAsync\), access the Orchard display helper (\Orchard\), manage theme layout alternates (\ViewLayout\), and handle page titles (\Title\, \RenderTitleSegments\). It also ensures the \ViewContext\ is properly propagated to the \ViewContextAccessor\ for use by other subsystems.

src/OrchardCore/OrchardCore.DisplayManagement/RazorPages · high confidence

Added UserRazorHelperExtensions to provide Razor view helpers for fetching user data. The new GetUserByIdAsync method allows retrieving a single user by their ID, while GetUsersByIdsAsync enables loading a list of users by their IDs, both leveraging the YesSql session for database queries.

src/OrchardCore/OrchardCore.Users.Core/Razor · high confidence

This change introduces the \OrchardRazorHelperExtensions\ class, providing two new capabilities for Razor views. First, it adds a \DisplayAsync\ extension method that simplifies rendering a \ContentItem\ by automatically building the display shape and executing it via the display helper. Second, it adds a \ConsoleLog\ helper that injects a script tag into the page to output objects (such as strings, JSON nodes, content items, or shapes) to the browser's developer console, with automatic nullification in production environments to prevent information leakage.

src/OrchardCore/OrchardCore.ContentManagement.Display/Razor · high confidence

This change introduces the core Razor integration components for Orchard Core's display management system. It adds the \IRazorPage\ interface and \RazorPage\<TModel\>\ base class, which provide developers with convenient helpers like \New\ for creating shapes, \DisplayAsync\ and \DisplayAsAsync\ for rendering them, and \ThemeLayout\ for managing layout alternates. The \RazorViewActionFilter\ is introduced to automatically inject site settings, theme layout, and theme information into the view context via \RazorViewFeature\, ensuring these resources are available to Razor views. Additionally, the \RazorShapeTemplateViewEngine\ enables rendering shape templates as Razor views, supporting custom file extensions via \IRazorViewExtensionProvider\.

src/OrchardCore/OrchardCore.DisplayManagement/Razor · high confidence

The display management system now includes a new \ShapeAttributeBindingStrategy\ that allows developers to bind shape rendering directly to static or instance methods on services. This strategy scans registered \IShapeAttributeProvider\ services for methods decorated with \ShapeAttribute\, automatically generating binding delegates that resolve method parameters from the \DisplayContext\ (such as the \Shape\ object) and invoke the target method to produce HTML content, supporting both synchronous and asynchronous return types.

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapeAttributeStrategy · high confidence

This change introduces the \ShellScope\ class and its associated extension methods (\ShellScopeExtensions\) and service wrapper (\ShellScopeServices\) within the \OrchardCore.Abstractions\ project. \ShellScope\ acts as a custom \IServiceScope\ that manages the execution flow, state, and disposal of a tenant shell, including reference counting for the parent \ShellContext\. It provides static helpers (\Set\, \Get\, \GetOrCreate\) for sharing data across the scope's lifetime and supports child scope creation. The extensions allow registering callbacks to run before disposal (\RegisterBeforeDispose\), deferring signals or tasks until after disposal (\AddDeferredSignal\, \AddDeferredTask\), and handling exceptions (\AddExceptionHandler\). \ShellScopeServices\ wraps the service provider to ensure keyed service resolution respects the current shell scope context.

src/OrchardCore/OrchardCore.Abstractions/Shell/Scope · high confidence

A new StringExtensions class has been added to the OrchardCore.ContentManagement.Abstractions utilities, providing static helper methods for string manipulation relevant to content items. This includes CamelFriendly for converting camelCase to readable text, Ellipsize for truncating text with word-boundary awareness, RemoveTags for stripping HTML, ToSafeName for generating valid technical identifiers by removing diacritics and invalid characters, and IsValidUrlSegment for validating URL components against RFC standards. It also introduces a check for reserved content property names via IsReservedContentName.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Utilities · high confidence

Added the ITagHelpersProvider interface and two concrete implementations (AssemblyTagHelpersProvider and TagHelpersProvider\<T\>) to the DisplayManagement.Abstractions module. These components allow the framework to discover and register Tag Helper types from specific assemblies or generic type definitions, enabling more flexible and programmatic Tag Helper registration.

src/OrchardCore/OrchardCore.DisplayManagement.Abstractions/TagHelpers · high confidence

The Trumbowyg WYSIWYG editor in Orchard Core now includes several new plugins that expand content editing capabilities. Users can select from a dropdown of web-safe font families (such as Arial, Georgia, and Courier New) to style text. Line height can be adjusted via a dropdown offering Small, Regular, Large, and Extra large options. A history plugin adds standard Undo and Redo buttons with keyboard shortcuts (Z and Y). The mention plugin allows inserting user mentions (formatted as @login) via a configurable dropdown source. Finally, the template plugin enables inserting predefined HTML content blocks through a template selector, provided the templates are configured in the editor options.

(repo-wide) · high confidence

The OrchardCore.XmlRpc.Abstractions module now exposes two new service interfaces, IXmlRpcReader and IXmlRpcWriter, to handle the conversion between XML-RPC entities and XML. IXmlRpcReader provides methods to map XML elements into RPC method calls, data, structs, and arrays, while IXmlRpcWriter handles the reverse process, mapping RPC method responses, data, structs, and arrays back into XML elements.

src/OrchardCore/OrchardCore.XmlRpc.Abstractions/Services · high confidence

This change introduces a new set of abstract display drivers and editor context classes in the OrchardCore.ContentTypes.Abstractions project to standardize how content type, part, and field definitions are edited. It adds base classes like ContentPartDefinitionDisplayDriver and ContentTypePartDefinitionDisplayDriver\<TPart\>, along with corresponding interfaces (IContentPartDefinitionDisplayDriver, etc.) and context classes (UpdatePartEditorContext, UpdateTypeEditorContext) that expose a builder and an 'isNew' flag. This provides a consistent foundation for implementing editors for content definitions across the platform.

src/OrchardCore/OrchardCore.ContentTypes.Abstractions/Editors · high confidence

The SEO module now exposes a new \IRobotsProvider\ interface that allows implementations to contribute custom content to the generated \robots.txt\ file. Additionally, a \RobotsSettings\ class has been introduced to allow users to configure whether all agents are allowed, whether the admin area is disallowed, and to specify additional rules. These changes are supported by new constants and permission definitions (\ManageSeoSettings\) to manage these SEO-related settings.

src/OrchardCore/OrchardCore.Seo.Abstractions · high confidence

This change introduces a new set of abstractions in the AdminMenu module to support localized admin menu nodes and flexible navigation building. It adds the IAdminMenuAccessor interface for retrieving admin menus, the IAdminNodeNavigationBuilder interface for constructing navigation items based on node type names, and the IAdminNodeProviderFactory interface (along with a generic implementation) for creating admin node instances. Additionally, the abstract AdminNodeDataLocalizationProvider class is added to facilitate localization data retrieval for admin menu nodes by leveraging the menu accessor.

src/OrchardCore/OrchardCore.AdminMenu.Abstractions/Services · high confidence

This change introduces the core abstractions for the new background task system in Orchard Core. It adds the \IBackgroundTask\ interface and a \BackgroundTaskAttribute\ that allows developers to configure task metadata (title, schedule, description) and enable atomic execution via distributed locks (\LockTimeout\, \LockExpiration\). The system now supports \IBackgroundTaskEventHandler\ to hook into task lifecycle events and \IBackgroundTaskSettingsProvider\ for external configuration. Additionally, \ShellContextExtensions\ provides utilities to create HTTP contexts for background operations, enabling features like URL generation within the tenant pipeline.

src/OrchardCore/OrchardCore.Abstractions/BackgroundTasks · high confidence

The workflow abstractions layer now provides two new base classes, ActivityDisplayDriver and ActivityDisplayDriver\<TActivity, TEditViewModel\>, to simplify the creation of UI drivers for workflow activities. These classes handle the standard display logic for thumbnails and design views, as well as the edit and update workflows for activity configuration, allowing developers to focus on specific activity details rather than boilerplate display management code.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Display · high confidence

The OrchardCore.Abstractions module introduces a new \OrchardCoreBuilder\ class that allows developers to register service configuration and request pipeline actions for tenants using a fluent API. This builder collects \ConfigureServices\ and \Configure\ delegates (both synchronous and asynchronous variants) along with an \EnableFeature\ helper, storing them in ordered \StartupActions\ objects. These actions are then executed by a new \StartupActionsStartup\ class, which implements \StartupBase\ to invoke the registered delegates in the correct order during tenant initialization.

src/OrchardCore/OrchardCore.Abstractions/Modules/Builder · high confidence

The OrchardCore.Infrastructure.Abstractions.Cache package now exposes a new set of interfaces and classes to manage cache contexts, scopes, and tagging. Developers can use CacheContext to define expiry policies (absolute, relative, or sliding) and associate specific contexts and tags with cached items. The ICacheScopeManager interface allows entering and exiting cache scopes while adding dependencies and contexts, and ICacheContextManager/ICacheContextProvider enable dynamic discriminator population. Additionally, ITagCache and ITagRemovedEventHandler provide a mechanism to tag cached items and handle tag removal events, facilitating more granular cache invalidation.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Cache · high confidence

This change introduces five new cache context providers in the OrchardCore.Infrastructure.Cache module that allow the caching system to vary cache entries based on specific request and site attributes. FeaturesCacheContextProvider includes feature hashes in the cache key, QueryCacheContextProvider incorporates query string parameters, RolesCacheContextProvider considers user roles, RouteCacheContextProvider uses the request path, and UserCacheContextProvider accounts for the authenticated user's identity. These providers enable more granular cache invalidation and variation, ensuring that cached content is correctly served based on these contextual factors.

src/OrchardCore/OrchardCore.Infrastructure/Cache/CacheContextProviders · high confidence

The \OrchardCore.Infrastructure.Abstractions\ module now includes a new command-line execution framework. This adds core abstractions and types for defining and running CLI commands, including \ICommandHandler\ and \ICommandManager\ interfaces, context and descriptor classes (\CommandContext\, \CommandDescriptor\), and attributes for naming commands (\CommandNameAttribute\) and defining switches (\OrchardSwitchAttribute\, \OrchardSwitchesAttribute\). It also provides a \DefaultCommandHandler\ base class that handles switch parsing, argument binding, and method invocation, along with a \CommandParser\ for splitting command-line strings into arguments.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Commands · high confidence

The Content Types Abstractions module now exposes a comprehensive set of event handlers and context classes to allow developers to intercept and modify content definitions. The new IContentDefinitionHandler interface enables customization during the building phase of content types, parts, and fields, while IContentDefinitionEventHandler provides hooks for lifecycle events such as creation, updates, removal, and import. This allows modules to programmatically adjust metadata and structure before definitions are finalized or persisted.

src/OrchardCore/OrchardCore.ContentTypes.Abstractions/Events · high confidence

The OrchardCore.ContentTypes.Abstractions module now exposes a new IContentDefinitionService interface that provides a unified API for managing content type definitions, including creating and removing types, adding and removing parts and fields, and altering field and part settings via new AlterFieldContext and AlterTypePartContext data transfer objects. Additionally, a ContentTypesOptions class for configuring default thumbnail paths and categories, and a DataLocalizationContext constant for content type localization have been added to support these operations.

src/OrchardCore/OrchardCore.ContentTypes.Abstractions · high confidence

The Contents Tag Helpers module now includes new Razor tag helpers: \ContentItemTagHelper\ renders a content item as a shape, and \ContentLinkTagHelper\ generates anchor links for content items. The link helper supports attributes like \display-for\, \edit-for\, \admin-for\, \remove-for\, and \create-for\ to link to the respective content management pages, and it respects a \PreviewUrl\ aspect if available to link directly to a preview.

src/OrchardCore/OrchardCore.Contents.TagHelpers · high confidence

A new ContentOptionsViewModel has been introduced to support extensible filtering and bulk actions in the contents admin list. This view model defines the data structure for content list options, including search text, selected content type, ordering (Modified, Published, Created, Title), status (Draft, Published, AllVersions, Latest, Owner), and bulk actions (PublishNow, Unpublish, Remove). It also includes properties for populating UI lists such as content statuses, sorts, bulk actions, content type options, and creatable types, along with pagination and route value information.

src/OrchardCore/OrchardCore.Contents.Core/ViewModels · high confidence

The content management routing layer introduces a new set of abstractions to handle autoroute entries and their configuration. This includes the \AutorouteEntry\ class, which now uses a \long\ for \DocumentId\ and stores content item paths, along with \AutorouteOptions\ for defining global route values and specific keys for content item IDs. The system also defines \IAutorouteEntries\ for asynchronous lookup and updates of these entries, and introduces aspect classes (\RouteHandlerAspect\ and \ContainedContentItemsAspect\) to manage route handler properties and JSON-based accessors for contained content items.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Routing · high confidence

Two new model classes, BodyAspect and FullTextAspect, have been added to the content management abstractions. BodyAspect provides a property to store HTML content, while FullTextAspect includes a list of string segments to represent full-text content. These models enable developers to attach and manage specific types of content data within Orchard Core content items.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Models · high confidence

Developers can now access content items directly via the IOrchardHelper interface without needing to inject additional services. The new extension methods allow fetching content by handle (e.g., aliases or slugs), by ID, by version ID, or by querying specific content types, simplifying content access in views and services.

src/OrchardCore/OrchardCore.Contents.Core/Extensions · high confidence

The content management display layer now introduces dedicated context classes—BuildFieldDisplayContext, BuildFieldEditorContext, UpdateFieldEditorContext, BuildPartDisplayContext, BuildPartEditorContext, and UpdatePartEditorContext—to provide handlers with explicit access to ContentPart, ContentTypePartDefinition, and ContentPartFieldDefinition metadata during rendering and editing. This allows display and editor handlers to make more informed decisions based on the specific part and field being processed, rather than relying solely on the generic build context.

src/OrchardCore/OrchardCore.ContentManagement.Display/Models · high confidence

This change introduces a new set of interfaces and constants in the OrchardCore.Localization.Abstractions project to support data-driven localization. Specifically, it adds the IDataLocalizer interface for retrieving localized strings by name and context, the IDataLocalizerFactory for creating localizer instances, the IDataTranslationProvider interface extending ITranslationProvider for translation services, and a Constants class defining a context separator character. These abstractions provide the foundational API for future implementations of data-based localization features.

src/OrchardCore/OrchardCore.Localization.Abstractions/Data · high confidence

Added two new classes, DataMigration and DataMigrationRecord, to the OrchardCore.Data.Migration.Records namespace. DataMigration represents a single database migration with a class name and an optional version number, while DataMigrationRecord serves as the container for these migrations, featuring a long-typed Id and a list of DataMigration instances.

src/OrchardCore/OrchardCore.Data/Migration/Records · high confidence

The Entities module now includes a new DefaultIdGenerator that produces 26-character Base32 strings from GUIDs, along with ServiceCollectionExtensions and OrchardCoreBuilderExtensions to register this generator and the associated IdGeneratorMethod for scripting. Users can now opt into this ID generation capability by calling the new AddIdGeneration extension methods.

src/OrchardCore/OrchardCore.Infrastructure/Entities · high confidence

This change introduces three new deployment step types within the Indexing module's deployment pipeline: IndexProfileDeploymentSource, RebuildIndexDeploymentSource, and ResetIndexDeploymentSource. These allow administrators to include index profile exports, index rebuilds, and index resets directly in deployment plans. Each step supports filtering by specific index names or including all indexes, and they are categorized under 'Indexing' in the UI for easier discovery.

src/OrchardCore/OrchardCore.Indexing.Core/Deployments · high confidence

This change introduces a suite of new extension methods and helper classes within the DisplayManagement module to simplify common development tasks and enhance theme handling. Developers can now use \AddShapeTableProvider\<T\>()\ for cleaner service registration, \AddTenantReloadWarningWrapper()\ to easily inject reload warnings into shape contexts, and convenience methods on \IDisplayManager\ to build displays and editors with default model instances. Additionally, new \HttpContextExtensions\ provide a robust \GetActionContextAsync()\ method, while \ExtensionInfoExtensions\ and \ThemeExtensionInfo\ offer improved utilities for identifying themes and managing base theme dependencies, alongside \RazorHelperExtensions\ for culture and directionality checks.

src/OrchardCore/OrchardCore.DisplayManagement/Extensions · high confidence

The indexing abstraction layer has been replaced with a new architecture centered on the \DocumentIndex\ model, which introduces support for indexing complex objects and vector embeddings (for AI/search features) alongside standard types like text, numbers, and geo-points. This change introduces a granular handler system (\IContentPartIndexHandler\, \IContentFieldIndexHandler\) that allows index providers to build entries for specific content parts and fields, and adds lifecycle notification events (\DocumentsAddedOrUpdated\, \DocumentsDeleted\) to \IDocumentIndexHandler\ so handlers can react to index changes. The system also introduces \RecordIndexingTask\ for tracking indexing operations and \IIndexProfileManager\ for managing index configurations.

src/OrchardCore/OrchardCore.Indexing.Abstractions · high confidence

The Documents abstraction layer introduces a new set of interfaces and classes to manage the synchronization of documents and entities between persistent stores and shared caches. This includes \IDocumentEntity\ and \DocumentEntity\ to represent entities stored as documents, along with \IDocumentEntityManager\ and \IDocumentManager\ (and their volatile/non-persistent counterparts) to handle atomic updates, caching, and property management. These changes provide a structured API for keeping document data consistent across storage and cache layers.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Documents · high confidence

The \OrchardCore.Data.Abstractions/Documents\ area now introduces a new document store API (\IDocumentStore\) that supports mutable and immutable document loading, concurrency checking, and cancellation before commit. It adds lifecycle hooks via \AfterCommitSuccess\ and \AfterCommitFailure\ delegates, allowing applications to react to commit outcomes. A new \Document\ class implements \IDocument\ with an identifier and read-only flag, and a \FileDocumentStoreAttribute\ enables file-based document storage via the \IFileDocumentStore\ interface, which syncs with the ambient transaction.

src/OrchardCore/OrchardCore.Data.Abstractions/Documents · high confidence

A new EmailAddressValidator service has been added to the email infrastructure, implementing IEmailAddressValidator to check if an email address is valid by verifying the presence of an '@' symbol and using MimeKit's MailboxAddress.TryParse. This service is registered via a new OrchardCoreBuilder extension method, AddEmailAddressValidator, allowing applications to opt-in to this validation capability.

src/OrchardCore/OrchardCore.Infrastructure/Email · high confidence

The system now includes a dedicated email validation capability via the new IEmailAddressValidator interface and EmailAddressAttribute. Users can apply the EmailAddressAttribute to model properties to enforce email format validation, which leverages the new validator service and supports localized error messages for invalid inputs.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Email · high confidence

A new \ExceptionExtensions\ class has been added to the \OrchardCore.Modules\ namespace, providing static helper methods for exception handling. Users can now use \IsFatal()\ to quickly identify critical exceptions like \OutOfMemoryException\, \SecurityException\, or \SEHException\, and \IsFileSharingViolation()\ to detect specific file I/O errors. Additionally, \LogException()\ offers a standardized way to log exceptions with context about the source type and method.

src/OrchardCore/OrchardCore.Abstractions/Modules/Exceptions · high confidence

Developers can now hook into the media lifecycle through a new set of event handlers and context classes in the Media Abstractions layer. The diff introduces interfaces like \IMediaCreatingEventHandler\ and \IMediaEventHandler\, along with specific context classes (e.g., \MediaCreatingContext\, \MediaPermittedStorageContext\), allowing extensions to intercept and modify media creation streams, react to file/directory creation, deletion, and movement, and constrain permitted storage limits during operations.

src/OrchardCore/OrchardCore.Media.Abstractions/Events · high confidence

The \OrchardCore.Users.Abstractions\ module now exposes a comprehensive set of extensibility points for the user authentication and registration flow. Developers can hook into login, logout, password recovery, and registration processes via new interfaces (\ILoginFormEvent\, \ILogoutFormEvent\, \IPasswordRecoveryFormEvents\, \IRegistrationFormEvents\) and corresponding abstract base classes that provide default no-op implementations. Additionally, two-factor authentication requirements can now be customized through the new \ITwoFactorAuthenticationHandler\ and \ITwoFactorAuthenticationHandlerCoordinator\ interfaces, allowing modules to define specific 2FA policies per user.

src/OrchardCore/OrchardCore.Users.Abstractions/Events · high confidence

The Queries module now provides helper methods to simplify service registration and query retrieval. Developers can use \AddQuerySource\ to register a specific query source implementation with a named key, automatically handling scoped service bindings. Additionally, \IQueryManager\ now includes extension methods \ListQueriesBySourceAsync\ and \ListQueriesAsync(bool)\ to filter queries by source name or sorting status without manually constructing \QueryContext\ objects.

src/OrchardCore/OrchardCore.Queries.Abstractions/Extensions, src/OrchardCore/OrchardCore.Queries.Core/Extensions · high confidence

The OrchardCore.Abstractions module introduces a new set of interfaces and helper classes to support file provider implementations. This includes the IStaticFileProvider interface for identifying providers that serve static files, and IVirtualPathBaseProvider for managing virtual path bases. Additionally, new concrete types like EmbeddedDirectoryContents and EmbeddedDirectoryInfo provide directory handling capabilities for embedded resources, while the NormalizedPaths utility aids in resolving file and folder structures from normalized path collections. A new FileInfoExtensions class also adds synchronous and asynchronous methods for reading file contents.

src/OrchardCore/OrchardCore.Abstractions/Modules/FileProviders · high confidence

A new \FilesScriptEngine\ and \FilesScriptScope\ have been introduced in the OrchardCore Infrastructure module, enabling scripts to read file contents via two specific commands: \text('path')\ to retrieve raw file text and \base64('path')\ to retrieve the file content as a Base64-encoded string. This adds a new capability for script-based content retrieval from the file system, integrated into the existing scripting infrastructure through the \IScriptingEngine\ interface.

src/OrchardCore/OrchardCore.Infrastructure/Scripting/Files · high confidence

Recipe authors can now access application configuration values, recipe parameters, and defined variables directly within recipe scripts using the new \configuration\, \parameters\, and \variables\ global methods. The \configuration\ method retrieves values from the shell configuration, \parameters\ exposes recipe input parameters, and \variables\ allows reading and evaluating script-defined variables, including support for nested script evaluation. These methods are registered via the new \ConfigurationMethodProvider\, \ParametersMethodProvider\, and \VariablesMethodProvider\ classes, enhancing the flexibility of recipe execution.

src/OrchardCore/OrchardCore.Recipes.Core · high confidence

The HealthChecks.Abstractions module now exposes a \HealthChecksOptions\ class that allows users to configure the health check URL (defaulting to \/health/live\) and toggle a \ShowDetails\ flag to include detailed dependency information in the response. Additionally, an \IHealthChecksResponseWriter\ interface is introduced to define how health reports are written to the HTTP context, providing a standardized way to format and deliver health status data to consumers.

src/OrchardCore/OrchardCore.HealthChecks.Abstractions · high confidence

The \OrchardCore.Indexing.Abstractions/Models\ area now includes several new model and context classes to support the indexing subsystem. These include \CreateIndexingTaskContext\ for defining task parameters, \IndexProfile\ as an entity representing index configuration, and various context classes (\IndexCreateContext\, \IndexProfileExportingContext\, \IndexProfileResetContext\, \IndexProfileSynchronizedContext\, \IndexRebuildContext\, \IndexRemoveContext\) that encapsulate state for different indexing operations. Additionally, \IndexProfileKey\ is introduced as a record struct for identifying index profiles by provider and type.

src/OrchardCore/OrchardCore.Indexing.Abstractions/Models · high confidence

This location introduces several new public APIs to support core infrastructure needs. It adds the IPhoneFormatValidator interface for validating phone number formats, and the MediaTypeNamesExtended class providing constants for various application and text media types (such as JSON:API, GraphQL, and SQL variants). Additionally, it implements the Result pattern with Result and Result\<TValue\> classes, allowing operations to return success or failure states with localized error messages via ResultError.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions · high confidence

The OrchardCore.Localization.Abstractions package now includes a comprehensive set of new types to support advanced localization features. This introduces a new \CultureDictionary\ and \CultureDictionaryRecord\ structure for managing translations, along with \CultureDictionaryRecordKey\ for efficient key handling. A key addition is the \IJSLocalizer\ interface and its associated extension methods (\GetJSLocalizations\), which enable framework-agnostic JavaScript localization helpers, allowing server-side translations to be consumed by client-side scripts (such as the Media Gallery). The update also adds infrastructure for pluralization (\IPluralRuleProvider\, \PluralForm\, \PluralFormNotFoundException\) and language direction constants (\LanguageDirection\), providing the foundational contracts needed for robust, multi-language support in both backend and frontend contexts.

src/OrchardCore/OrchardCore.Localization.Abstractions · high confidence

The localization abstraction layer now includes new types to support calendar selection and more robust culture management. A new \CalendarName\ enum and \ICalendarManager\/\ICalendarSelector\ interfaces allow applications to determine and select specific calendars (e.g., Hebrew, Hijri, Gregorian) alongside standard culture settings. Additionally, a \CultureScope\ class and \CultureOptions\ are introduced to let developers explicitly control whether the current culture depends on local computer settings, addressing issues where system settings inadvertently influenced application behavior. The \ILocalizationService\ interface is also updated to expose \GetAllCulturesAndAliases()\ and a \FallBackToParentCultures\ property, enabling more granular control over culture resolution and aliasing.

src/OrchardCore/OrchardCore.Abstractions/Localization · high confidence

This change introduces new extension methods in the OrchardCore.Localization.Abstractions package to improve localization capabilities. Developers can now determine the text direction (RTL or LTR) for a given culture using the new CultureInfoExtensions. Additionally, IStringLocalizer, IHtmlLocalizer, and IViewLocalizer now support a Plural method, allowing for easier handling of pluralized strings by specifying singular and plural forms directly, which simplifies the process of displaying localized content that varies based on count.

src/OrchardCore/OrchardCore.Localization.Abstractions/Extensions · high confidence

The OrchardCore.Localization.Core module now exposes new extension methods for IServiceCollection to simplify localization setup. Developers can use AddPortableObjectLocalization to enable translation via Portable Object (PO) files, including support for configuring plural rules and file locations. Additionally, AddDataAnnotationsPortableObjectLocalization allows data annotation attributes to be localized from PO files, while AddDataLocalization registers services for data-based translation storage. These changes provide a more structured way to integrate various localization providers into the application's dependency injection container.

src/OrchardCore/OrchardCore.Localization.Core/Extensions · high confidence

The locking subsystem now exposes a new set of core interfaces: ILock, ILocker, ILocalLock, and IDistributedLock. The ILock interface defines methods for acquiring named locks with optional expiration times (including support for indefinite expiration via null/TimeSpan.MaxValue), attempting to acquire locks with a timeout, and checking if a lock is already held. ILocker represents the acquired lock handle and implements disposal interfaces. ILocalLock and IDistributedLock extend ILock to distinguish between local and distributed locking implementations.

src/OrchardCore/OrchardCore.Abstractions/Locking · high confidence

This change introduces several new model binders in the OrchardCore.Mvc.Core module to improve how form data is processed. The CheckMarkModelBinder now recognizes '✓' and '✗' characters as valid boolean inputs, allowing UI components to use these symbols instead of standard true/false values. The CommaSeparatedStringArrayModelBinder enables binding comma-separated strings (e.g., 'a,b') or repeated query parameters into string arrays, simplifying multi-value input handling. Additionally, the SafeBoolModelBinder prevents FormatExceptions by gracefully handling invalid boolean inputs and adding a validation error instead of crashing, which improves stability for forms like the login screen where unexpected values might be submitted.

src/OrchardCore/OrchardCore.Mvc.Core/ModelBinding · high confidence

The Display Management Abstractions layer now includes new interfaces for model binding (\IUpdateModel\ and \IUpdateModelAccessor\) and extension methods for \ModelStateDictionary\. These additions provide a standardized way to update and validate models within the display management context, including support for prefixed keys and validation result binding, decoupling the display manager from specific handler implementations.

src/OrchardCore/OrchardCore.DisplayManagement.Abstractions/ModelBinding · high confidence

The DisplayManagement module now includes a new set of classes in the ModelBinding namespace to manage model state and updates. This introduces a filter (ModelBinderAccessorFilter) that injects an IUpdateModel implementation into the HTTP context for both Controllers and Razor PageModels. It provides specific updaters (ControllerModelUpdater, PageModelUpdater) that delegate to the framework's native model binding, a wrapper (ModelStateWrapperUpdater) that preserves common model state across child content items by merging and clearing state during updates, and utility classes like NullModelUpdater and PrefixedModelUpdater to handle default behaviors and prefix transformations.

src/OrchardCore/OrchardCore.DisplayManagement/ModelBinding · high confidence

The Autoroute module now includes dedicated model classes: \AutoroutePart\ defines the content part settings (including path constraints, homepage assignment, and routing behavior), and \AutorouteStateDocument\ provides a document-based storage structure for autoroute state. These models establish the data structure for the autoroute feature within the content management system.

src/OrchardCore/OrchardCore.Autoroute.Core/Model · high confidence

This change introduces a new set of extension methods in the OrchardCore.Abstractions module to simplify common development patterns. HttpContextExtensions adds UseShellScopeServices to wire the current shell scope into request services and ChallengeOrForbid to handle authentication challenges or forbids in a single call. StringExtensions provides utility methods for converting hex strings to byte arrays and performing ordinal case-insensitive comparisons. StringBuilderExtensions offers helpers to append comma-separated values for strings and characters. Additionally, InvokeExtensions provides robust, exception-safe wrappers for invoking event handlers, including new asynchronous variants that improve performance and prevent thread starvation during event dispatch.

src/OrchardCore/OrchardCore.Abstractions/Modules/Extensions · high confidence

The OrchardCore.Abstractions/Modules area now introduces the core abstractions for the new module system, including the Application and Module classes that represent the application and individual modules, along with interfaces like IApplicationContext, IStartup, and IAsyncStartup for pipeline configuration. It also adds a suite of static file providers (ApplicationStaticFileProvider, ModuleEmbeddedStaticFileProvider, ModuleProjectStaticFileProvider, etc.) that enable serving static assets from module assemblies and project wwwroot folders, supporting both embedded resources and physical files in development. Additionally, it defines configuration options via BackgroundServiceOptions and attributes like FeatureAttribute, RequireFeaturesAttribute, and RequiredStartupAttribute to control feature composition and startup behavior.

src/OrchardCore/OrchardCore.Abstractions/Modules · high confidence

The placement system now includes dedicated providers for filtering shape placement based on content part and content type. The new \ContentPartPlacementNodeFilterProvider\ allows placement rules to target specific content parts within an item, while \ContentTypePlacementNodeFilterProvider\ enables targeting by content type, including support for wildcard prefixes (e.g., \News\*\) that match both the content type name and its stereotype. These filters are implemented using \System.Text.Json.Nodes\ for expression parsing, replacing previous dependencies.

src/OrchardCore/OrchardCore.ContentManagement.Display/Placement · high confidence

The Queries module introduces a new set of model classes to define query structures and execution states. The \Query\ class now serves as the core entity, exposing properties for the query's technical name, data source, return schema, and a flag to control whether Content Items are returned. Additionally, a hierarchy of context classes (\QueryContextBase\, \DataQueryContextBase\, and specific states like \InitializingQueryContext\, \UpdatingQueryContext\, \DeletedQueryContext\, etc.) has been added to manage the lifecycle and data payload of query operations, alongside a \ListQueryResult\ for returning paginated query records.

src/OrchardCore/OrchardCore.Queries.Abstractions/Models · high confidence

The Recipes module introduces a set of new service interfaces to define how recipes are discovered, executed, and processed. IRecipeExecutor handles the main execution flow, IRecipeHarvester discovers available recipes, IRecipeReader parses recipe descriptors, and IRecipeMigrator manages data migrations triggered by recipes. Additionally, IRecipeEnvironmentProvider allows populating the execution environment, while IRecipeStepHandler and its abstract base class NamedRecipeStepHandler provide the contract for individual recipe steps, enabling developers to implement handlers for specific step types.

src/OrchardCore/OrchardCore.Recipes.Abstractions/Services · high confidence

The indexing module now includes new recipe step handlers that allow users to create, update, reset, and rebuild index profiles directly through recipes. The \CreateOrUpdateIndexProfileStep\ enables importing or updating index configurations by validating providers and types before creation. The \ResetIndexStep\ and \RebuildIndexStep\ allow resetting or fully rebuilding specific or all indexes, with the rebuild operation executing asynchronously in the background and using distributed locks to prevent conflicts.

src/OrchardCore/OrchardCore.Indexing.Core/Recipes · high confidence

The ResourceManagement.Abstractions project now defines the core interfaces and types for the resource system, including the IResourceManager interface for registering and rendering scripts, styles, links, and meta tags, and the IResourcesTagHelperProcessor for customizing the \<resources /\> tag helper output. New data models such as LinkEntry and MetaEntry provide structured ways to manage HTML attributes and self-closing tag rendering. The RequireSettings class has been expanded to support inline resource definitions via an InlineDefinition action, and the ResourceLocation enum now includes an Inline option, enabling developers to register and render script and style content directly within the page flow rather than only as external file references.

src/OrchardCore/OrchardCore.ResourceManagement.Abstractions · high confidence

The ResourceManagement module now provides a set of new Razor tag helpers (LinkTagHelper, MetaTagHelper, ResourcesTagHelper, ScriptTagHelper, and StyleTagHelper) that allow developers to declaratively register and render static resources. These helpers support features such as specifying resource names or source URLs, managing dependencies via the \DependsOn\ attribute, controlling render location with the \at\ attribute (e.g., Head or Foot), enabling CDN fallbacks, appending version query strings for cache busting, and defining inline script or style content directly in views.

src/OrchardCore/OrchardCore.ResourceManagement/TagHelpers · high confidence

This change introduces new routing components in OrchardCore.Abstractions to support advanced endpoint matching and link generation. It adds the FormValueRequiredAttribute and FormValueRequiredMatcherPolicy, allowing developers to mark endpoints that require specific form fields to be present for a match, thereby influencing route selection based on POST data. Additionally, it provides the IShellRouteValuesAddressScheme interface and ShellRouteValuesAddressScheme implementation, enabling tenants to define custom schemes for generating links via RouteValuesAddress. Supporting utilities include PathStringExtensions for normalized segment comparison and RouteEndpointKey for immutable, hashable endpoint identification.

src/OrchardCore/OrchardCore.Abstractions/Routing · high confidence

The \OrchardCore.Infrastructure.Abstractions/Scripting\ area now exposes a new set of interfaces and types that enable custom global methods in script evaluation. \IGlobalMethodProvider\ allows implementations to supply a list of \GlobalMethod\ instances, which are then made available to the \IScriptingManager\ during script execution. The \IScriptingEngine\ interface defines the contract for evaluating scripts (synchronously and asynchronously) and creating scopes with access to these methods, file providers, and service providers. This change introduces the abstraction layer for extending scripting capabilities rather than implementing the engines themselves.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Scripting · high confidence

The search module now includes new model classes to support search configuration and UI components: \SearchFormPart\ allows configuring a search form with a target index and placeholder text, while \SearchSettings\ introduces a \DefaultIndexProfileName\ property (deprecating the older \ProviderName\ property) to specify the default search index. Additionally, \IndexRecipeStep\ and \IndexSettingsBase\ provide the data structures for defining index settings in deployment recipes, and \RecipeExecutionContextExtensions\ adds a helper method to extract these index settings from recipe execution contexts, simplifying the process of configuring search indexes during site setup.

src/OrchardCore/OrchardCore.Search.Abstractions/Models · high confidence

The DisplayManagement module introduces three new abstract driver classes to support rendering and editing specific sections of an entity. SectionDisplayDriverBase provides the core logic to extract, display, edit, and update a typed section property within an entity model, allowing developers to override the property name via a virtual PropertyName. SectionDisplayDriver offers a concrete base for these drivers with sealed lifecycle methods that delegate to the base implementation. SiteDisplayDriver extends SectionDisplayDriverBase specifically for ISite models, adding a SettingsGroupId check to ensure the driver only handles updates and displays when the context's group ID matches the configured settings group.

src/OrchardCore/OrchardCore.DisplayManagement/Entities · high confidence

The OrchardCore.Infrastructure.Abstractions.Security package now includes foundational types for managing security: ApiAuthorizationOptions for configuring API authentication schemes, PermissionRequirement and IPermissionGrantingService to integrate custom permissions with ASP.NET Core's authorization system, and extension methods to simplify permission checks. It also defines constants for standard security headers (CSP, Permissions-Policy, Referrer-Policy, X-Content-Type-Options) and marks the SiteOwner permission as deprecated in favor of the Administrator role.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Security · high confidence

A new ISetupEventHandler interface has been introduced in the OrchardCore.Setup.Abstractions module, allowing developers to hook into the setup lifecycle. This interface defines three asynchronous methods—SetupAsync, FailedAsync, and SucceededAsync—that enable custom logic to run during the setup process, when it fails, and when it successfully completes, providing a standardized way to extend and monitor the initial configuration workflow.

src/OrchardCore/OrchardCore.Setup.Abstractions/Events · high confidence

This change introduces a suite of new Tag Helpers in the DisplayManagement module to give developers finer control over shape rendering and metadata directly in Razor views. The new \<shape\> tag helper (BaseShapeTagHelper) allows creating shapes with typed properties, caching configuration (fixed/sliding duration, context, tags), and custom IDs. A companion \<metadata\> tag helper enables setting display types. Additional helpers allow manipulating shape alternates, wrappers, and CSS classes via \<add-alternate\>, \<remove-alternate\>, \<clear-alternates\>, \<add-wrapper\>, \<remove-wrapper\>, \<clear-wrappers\>, \<add-class\>, \<remove-class\>, and \<clear-classes\>. The \<zone\> tag helper now supports adding content to layout zones with position control and logs a warning if the zone is not a Shape. New \<datetime\> and \<timespan\> helpers render specific shape types. A \<user-display-name\> helper renders the current user's name with optimized caching. The \<input\> tag helper now supports an asp-is-disabled attribute, and a \<validation-message\> helper adds Bootstrap-compatible validation error classes.

src/OrchardCore/OrchardCore.DisplayManagement/TagHelpers · high confidence

The display management subsystem now uses a new ShapeTemplateStrategy to automatically discover and bind shapes from template files (such as Fluid views). This change introduces a harvester-based architecture that scans specific sub-paths (e.g., Views, Views/Items) within enabled features, normalizes file names into canonical shape types, and associates the resulting shapes with all features enabled for the containing module. It also adds configuration options to customize the file providers used for locating these templates, allowing for more flexible view resolution across modules.

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapeTemplateStrategy · high confidence

The shell builder layer now exposes new interfaces (ICompositionStrategy, IShellContainerFactory, IShellContextFactory, IShellPipeline) and models (ShellContext, ShellBlueprint) to define how tenant containers are composed and activated. To support multi-instance deployments, ShellContextExtensions and ShellContextOptions introduce configurable distributed locking (with specific timeout and expiration settings) for shell activation and removal, ensuring atomic operations and preventing race conditions during tenant lifecycle events.

src/OrchardCore/OrchardCore.Abstractions/Shell/Builders · high confidence

Added three new implementations of IShellDescriptorManager in the Settings namespace: AllFeaturesShellDescriptorManager (exposes all available extensions), ConfiguredFeaturesShellDescriptorManager (loads features from configuration, including always-enabled ones and resolving missing dependencies), and SetFeaturesShellDescriptorManager (uses a predefined set of features). These managers provide flexible ways to define which features are active in a shell descriptor.

src/OrchardCore/OrchardCore/Shell/Descriptor · high confidence

The OrchardCore.Abstractions.Shell namespace now exposes a comprehensive set of interfaces and models to manage tenant (shell) lifecycles, including \IShellHost\ for initializing, reloading, and releasing shell contexts, \IShellReleaseManager\ for deferring releases until HTTP requests complete, and \IShellRemovalManager\ for handling tenant deletion with local/shared resource options. It introduces \IShellEvents\ and \IShellContextEvents\ to hook into shell loading, releasing, reloading, and creation phases, alongside \IFeatureEventHandler\ and \IFeatureProfilesService\ for granular feature lifecycle and profile management. Tenant configuration is standardized via \ShellSettings\ (with \VersionId\/\TenantId\ support) and \ShellOptions\, while \IRunningShellTable\ handles host/path-based tenant matching and \IShellDescriptorFeaturesManager\ manages feature updates against shell descriptors.

src/OrchardCore/OrchardCore.Abstractions/Shell · high confidence

This change introduces a suite of new extension methods in the OrchardCore.Abstractions shell extensions to simplify tenant and feature management. Developers can now easily check tenant states (e.g., IsRunning, IsDisabled), manage URL prefixes and hosts, and control shell context settings (e.g., WithSharedSettings). It also adds convenient helpers for the ShellFeaturesManager to enable or disable features by ID, and for the ShellHost to reload or release all shell contexts, streamlining common administrative operations.

src/OrchardCore/OrchardCore.Abstractions/Shell/Extensions · high confidence

The Shortcodes abstraction layer now exposes four new service interfaces to support shortcode processing: IShortcodeService for executing shortcodes with a provided context, IShortcodeContextProvider for supplying default context to the service, IShortcodeDescriptorManager for retrieving registered shortcode descriptors, and IShortcodeDescriptorProvider for discovering them. These interfaces establish the contract for how shortcodes are processed, discovered, and contextualized within the Orchard Core platform.

src/OrchardCore/OrchardCore.Shortcodes.Abstractions/Services · high confidence

The Sitemaps module introduces a set of new service interfaces to manage sitemap generation and content routing. These include ISitemapManager for loading, caching, and updating sitemap types; IRouteableContentTypeCoordinator and IRouteableContentTypeProvider to identify routable content types and determine their routes; ISitemapHelperService for path validation and slug generation; and ISitemapIdGenerator for creating unique identifiers. Additionally, ISitemapSourceFactory and its generic implementation SitemapSourceFactory are added to instantiate sitemap sources with unique IDs, providing the foundational abstractions for the sitemap feature.

src/OrchardCore/OrchardCore.Sitemaps.Abstractions/Services · high confidence

The OrchardCore.SourceGenerators package now includes several new components to improve performance and catch configuration errors at compile time. A new \ArgumentsFromInterceptor\ optimizes \Arguments.From\ calls with anonymous types by generating interceptors that bypass reflection overhead. The \ShapeFactoryGenerator\ has been enhanced to generate explicit \IShape\ wrappers for display drivers and attributed models, improving shape creation efficiency. Additionally, two new analyzers have been added: \SealedShapeTypeAnalyzer\ (OCSG001) warns when sealed types are used in proxy-based shape creation, and \FeatureAttributeTargetAnalyzer\ (OCSG002) warns when \FeatureAttribute\ targets reference features not defined in the current module.

src/OrchardCore/OrchardCore.SourceGenerators · high confidence

Added StringExtensions and TransliterationSlugServiceExtensions to the OrchardCore.Abstractions localization library. The new StringExtensions.Transliterate method converts non-Latin characters to their ASCII equivalents using AnyAscii, and TransliterationSlugServiceExtensions.SlugifyAndTransliterate provides a convenience method to generate URL-friendly slugs from text that has been transliterated first.

src/OrchardCore/OrchardCore.Abstractions/Localization/Extensions · high confidence

A new \StringExtensions\ class has been added to the Display Management utilities, providing an \EncodeAlternateElement\ method that safely encodes dashes and dots in strings for use in filenames. This optimization replaces dashes with double underscores and dots with single underscores, using efficient span-based operations to minimize allocations and improve performance during Liquid rendering and shape handling.

src/OrchardCore/OrchardCore.DisplayManagement.Abstractions/Utilities · high confidence

The content management metadata layer now uses dedicated settings classes (ContentSettings, ContentTypeSettings, ContentPartSettings, ContentPartFieldSettings, ContentTypePartSettings, and FieldSettings) to store configuration data, replacing previous ad-hoc storage. These models expose properties for content type options (Creatable, Listable, Draftable, Versionable, Securable, Stereotype, Category, ThumbnailPath), part options (Attachable, Reusable, DisplayName, Description, DefaultPosition), and field options (DisplayName, Description, Editor, DisplayMode, Position, Hint, Required). Extension methods are provided on the definition builders (e.g., Creatable, Listable, WithDisplayName, WithEditor) to configure these settings fluently, enabling more structured and type-safe definition of content type metadata.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Metadata/Settings · high confidence

The OrchardCore.Abstractions module now exposes a set of new interfaces and extension methods to handle time and time zone operations more robustly. Developers can use IClock and ILocalClock to retrieve UTC or local times and convert between them, while new services like ITimeZoneSelectListProvider and ITimeZoneSelector simplify rendering time zone pickers and determining the current request's time zone. Additionally, ISlugService provides text transformation for URL slugs, and ClockExtensions offers convenient helper methods for DateTime conversions.

src/OrchardCore/OrchardCore.Abstractions/Modules/Services · high confidence

The system now includes new services for handling time zones and URL slugs. A new \Clock\ service provides time zone data using NodaTime, including a \DefaultTimeZoneSelectListProvider\ to generate a sorted list of valid time zones for user selection. The \LocalClock\ service determines the local time zone by evaluating registered selectors and handles conversions between UTC and local time, respecting the current calendar. Additionally, a \SlugService\ is introduced to generate URL-friendly slugs from text, featuring Unicode normalization, support for non-ASCII characters, and configurable separators.

src/OrchardCore/OrchardCore/Modules/Services · high confidence

This change introduces a comprehensive set of new model classes in the Users.Core module to support enhanced authentication flows and account settings. Key additions include configuration models for two-factor authentication (AuthenticatorApp, Email, and SMS providers), external login options, and specific token providers for email confirmation and password resets. The User entity has been expanded to support phone numbers, user claims, and login info, while new forms (LoginForm, ForgotPasswordForm, ResetPasswordForm) and settings (LoginSettings, TwoFactorLoginSettings, RegistrationOptions) provide granular control over login behavior, persistent cookies, and user registration validation.

src/OrchardCore/OrchardCore.Users.Core/Models · high confidence

The user management interface now supports advanced filtering and bulk operations on the user list. A new \UserIndexOptions\ view model introduces specific filters for user status (All, Approved, Pending, EmailPending, Enabled, Disabled) and sorting options (Name, Email). It also defines available bulk actions including Delete, Enable, Disable, Approve, ChallengeEmail, and ConfirmEmail, allowing administrators to manage multiple users efficiently from the index page.

src/OrchardCore/OrchardCore.Users.Core/ViewModels · high confidence

This location introduces the abstraction layer for user lifecycle and external login events, providing new interfaces and context classes that allow modules to react to user creation, deletion, updates, enable/disable, and email confirmation, as well as to customize external login username generation and user property updates.

src/OrchardCore/OrchardCore.Users.Abstractions/Handlers · high confidence

The Users.Abstractions module now exposes a comprehensive set of service interfaces for user lifecycle management. IMembershipService provides core authentication capabilities including password checking and claims principal creation. IUserService defines the primary API for user operations, supporting authentication via username or email, user creation, registration, enabling/disabling accounts, and password management (change and reset). Additional interfaces include IUserClaimsProvider for custom claim generation and IUserIdGenerator for unique user ID creation.

src/OrchardCore/OrchardCore.Users.Abstractions/Services · high confidence

The Users.Abstractions module now includes dedicated data models for user registration and identity claims. A new RegisterUserForm class has been added to capture the username, email, and password required for new user sign-ups, while a UserClaim class provides a structured representation of user claims with a helper method to convert them into standard security claims.

src/OrchardCore/OrchardCore.Users.Abstractions/Models · high confidence

Added four new YesSql indexes to the Users module to improve query performance and enable specific user lookups. The new \UserByClaimIndex\ allows finding users by claim type and value, supporting individual user claims. \UserByLoginInfoIndex\ enables lookup by external login provider and key. \UserByRoleNameIndex\ provides a reduced count of users per role, including a marker for users with no roles (Authenticated only). \UserIndex\ exposes key account properties like UserId, NormalizedUserName, NormalizedEmail, enabled status, lockout settings, and access failed count for efficient filtering and sorting.

src/OrchardCore/OrchardCore.Users.Core/Indexes · high confidence

The OrchardCore.Abstractions package now includes several new utility classes and interfaces to support core platform functionality. It introduces a Base64 helper with optimized, buffer-pooled decoding methods (including a new DecodeToStream and a deprecated DecodedToStream), and an IdGenerator that produces compact, URL-safe identifiers using Crockford's Base32 encoding. A new MemoryStreamFactory wraps the RecyclableMemoryStream library to provide pooled memory streams for improved performance. Additionally, the package adds IClientIPAddressAccessor and IOrchardHelper interfaces, a SnakeCaseNamingPolicy for JSON serialization, and ProblemDetailsApiLocalization extensions that allow API controllers and minimal APIs to return standardized, localized Problem Details responses (400, 403, 404, and validation errors) instead of generic HTML or unlocalized text.

src/OrchardCore/OrchardCore.Abstractions · high confidence

A new extension method, GetViewFilePaths, has been added to the OrchardCore.Mvc.FileProviders namespace. This utility allows developers to efficiently retrieve a list of view file paths from an IFileProvider, supporting filtering by sub-path, file extensions, and specific view folders, with options for recursive depth-first search. This simplifies the process of locating view files within modular or composite file systems.

src/OrchardCore/OrchardCore.Mvc.Core/FileProviders · high confidence

Added GroupViewModel, GroupingsViewModel, and GroupingViewModel classes to the DisplayManagement view models. These classes provide a structured way to handle grouped shape data, with GroupingsViewModel holding an array of string-keyed groupings and GroupingViewModel representing a single grouping, both inheriting from a base GroupViewModel that includes an identifier.

src/OrchardCore/OrchardCore.DisplayManagement/ViewModels · high confidence

The OrchardCore.FileStorage.Abstractions package now defines a new generic virtual file store interface (IFileStore) that standardizes file operations such as reading, writing, moving, and copying across different storage backends, along with capability flags for hierarchical namespaces and atomic moves. Additionally, a new pre-upload processing pipeline has been introduced via the IFileEventHandler interface and FileCreationService, allowing extensions to intercept and modify file streams before they are persisted to the store.

src/OrchardCore/OrchardCore.FileStorage.Abstractions · high confidence

The OrchardCore.Workflows.Abstractions module now exposes a new \WorkflowOptions\ class and \ActivityRegistration\ model that allow modules to programmatically register, unregister, and query workflow activities and their associated display drivers. This change introduces a fluent API (\RegisterActivity\, \UnregisterActivityType\, \IsActivityRegistered\) along with generic extension methods, enabling developers to manage the set of available workflow activities at runtime without modifying static configuration.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Options · high confidence

The Content Management Abstractions now include a new ContentEventContext class and ContentEventConstants class to support workflow activities related to content events. The ContentEventContext provides structured data including event name, content type, item ID, version ID, and a flag indicating if it is a start event. The ContentEventConstants class defines standard input keys for content items, content events, and user actions, enabling more consistent data passing in workflow scenarios.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Workflows · high confidence

The workflow abstraction layer now includes a comprehensive set of new model classes to define and manage workflow structures and runtime state. This introduces core entities such as WorkflowType and Workflow for definitions and instances, along with ActivityRecord, Transition, and Outcome to model the graph of activities and their connections. Runtime execution is supported by new context classes like WorkflowExecutionContext, which tracks input/output, activity history, and provides cancellation and faulting capabilities, as well as specialized contexts for expressions and scripts. Additionally, lifecycle event contexts (e.g., WorkflowCreatedContext, WorkflowTypeUpdatedContext) are provided to support extensibility points for workflow events.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Models · high confidence

This change introduces a new set of helper extension methods in the OrchardCore Workflows abstractions layer to improve workflow usability and reliability. Users benefit from localized workflow status messages (e.g., 'Aborted', 'Executing') via \GetLocalizedStatus\, and safer activity title retrieval with \GetTitleOrDefault\ that handles missing metadata gracefully. The update also adds distributed locking support for atomic workflows and singleton/exclusive events through \TryAcquireWorkflowLockAsync\ and \TryAcquireWorkflowTypeLockAsync\, ensuring proper concurrency control. Additionally, new utility methods like \HasStartActivity\ and \IsMissingStartActivity\ help validate workflow configurations, while \AddActivity\ simplifies registering custom activities with their display drivers. Dictionary and list extensions provide safer value retrieval and range operations, and script syntax naming is standardized via \GetSyntaxName\.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Helpers · high confidence

The workflow module introduces a set of new service interfaces and abstract base classes in the abstractions layer to support workflow execution, storage, and lifecycle management. Key additions include IWorkflowManager for starting, triggering, and restarting workflows, IWorkflowStore and IWorkflowTypeStore for persistence, and IActivityLibrary for managing activity definitions. The update also adds IWorkflowExpressionEvaluator and IWorkflowScriptEvaluator for evaluating workflow logic, IWorkflowFaultHandler for error handling, and base classes (WorkflowHandlerBase, WorkflowTypeHandlerBase, WorkflowExecutionContextHandlerBase) to simplify implementing custom workflow event handlers and context processing.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Services · high confidence

The ReCaptcha module now registers its core services, including the ReCaptchaService as a singleton and the ReCaptchaTagHelper, while configuring an HttpClient with resilience policies (retry logic) for API calls. It also defines constants for Google's ReCaptcha endpoints and establishes a ManageReCaptchaSettings permission.

src/OrchardCore/OrchardCore.ReCaptcha.Core · high confidence

The ReCaptcha module now includes a dedicated ReCaptchaService for verifying tokens against the Google API and a ReCaptchaShape for rendering the widget. This change adds new files (ReCaptchaResponse, ReCaptchaService, ReCaptchaShape) to the Services directory, establishing the core logic and UI integration for the feature.

src/OrchardCore/OrchardCore.ReCaptcha.Core/Services · high confidence

The ReCaptcha tag helper now exposes 'language' and 'onload' attributes on the \<captcha\> element. Setting 'language' allows you to specify the ISO language code for the captcha display, falling back to the site default if omitted, while 'onload' lets you define a JavaScript callback to execute once the reCAPTCHA widget has loaded.

src/OrchardCore/OrchardCore.ReCaptcha.Core/TagHelpers · high confidence

The DisplayManagement shapes layer has been significantly refactored to support new admin UI components and improve internal performance. New shape providers introduce AdminTabs, Card, CardContainer, Column, and ColumnContainer components, enabling structured tabbed and card-based layouts in the administration interface. The core Shape and ShapeMetadata classes now utilize an optimized AlternatesCollection for lookups and support tab, card, and column grouping metadata, allowing developers to organize shapes into complex UI structures. Additionally, the system introduces ContentFileInfo and DirectoryContents file providers to abstract file access, and adds a ShapeSerializer for safe JSON serialization of shape hierarchies. These changes enhance the flexibility of the display management system while maintaining backward compatibility through the existing Shape interface.

src/OrchardCore/OrchardCore.DisplayManagement/Shapes · high confidence

Orchard Core now supports storing tenant shell configuration and settings in the database instead of the file system. This change introduces new configuration sources (\DatabaseShellConfigurationSources\ and \DatabaseShellsSettingsSources\) that read and write tenant data to database documents (\DatabaseShellConfigurations\ and \DatabaseShellsSettings\) using YesSql. The system includes an automatic migration path (\MigrateFromFiles\) to move existing file-based settings into the database, and allows configuration of the database provider, connection string, and table prefix via \DatabaseShellsStorageOptions\. This enables multi-server deployments where tenant settings are shared across instances via a central database.

src/OrchardCore/OrchardCore.Infrastructure/Shells.Database/Configuration · high confidence

The Sitemaps module now exposes a new set of abstractions in the \OrchardCore.Sitemaps.Abstractions\ package, defining the core interfaces and base classes for sitemap generation. This includes \ISitemapBuilder\ for constructing the XML output, \IContentItemsQueryProvider\ for fetching content, and specialized builders (\ISitemapSourceBuilder\, \ISitemapTypeBuilder\) with corresponding base classes to allow extensible sitemap source and type handling. Additionally, it introduces \ISitemapContentItemExtendedMetadataProvider\ to support advanced sitemap features like hreflang and image metadata, as well as handlers (\ISitemapUpdateHandler\) to manage sitemap updates when content changes.

src/OrchardCore/OrchardCore.Sitemaps.Abstractions/Builders · high confidence

The Sitemaps module now supports caching sitemap files via new \ISitemapCacheProvider\ and \ISitemapCacheFileResolver\ interfaces, allowing for improved performance and management of generated sitemap data. Additionally, users can now configure sitemaps to include content by specific content types using \ContentTypesSitemapSource\, which offers options to index all types or select specific ones, limit the number of items, and set change frequency and priority. A new \CustomPathSitemapSource\ allows for manual management of custom paths within the sitemap, also supporting change frequency and priority settings. These models are built on a refactored \SitemapType\ base class that handles path normalization and caching file names.

src/OrchardCore/OrchardCore.Sitemaps.Abstractions/Models · high confidence

The \ThemeViewLocationExpanderProvider\ now enables Razor MVC views to be located within theme folders (Pages/ and Views/) and allows the application itself to act as a super-theme for MVC view discovery. This means that MVC views can now be overridden by active themes and the application, following the same inheritance pattern previously available for other display shapes.

src/OrchardCore/OrchardCore.DisplayManagement/LocationExpander · high confidence

This update introduces a structured mechanism for removing tenants, including dedicated handlers to clean up shell settings, site folders, and web roots, alongside a new feature validation system that enforces application feature restrictions for non-default tenants, validates default-tenant-only features, and applies configurable feature profiles to control which features are allowed per tenant.

src/OrchardCore/OrchardCore/Shell · high confidence

The Overrides module now includes a new set of classes (TenantJsonConfigurationSource, TenantJsonConfigurationProvider, TenantJsonStreamConfigurationSource, TenantJsonStreamConfigurationProvider) and extension methods (AddTenantJsonFile, AddTenantJsonStream) that allow configuration to be loaded from JSON files or streams specifically scoped to the current tenant shell. This enables tenant-specific overrides of configuration settings via JSON, distinct from the global application configuration.

src/OrchardCore/OrchardCore.Abstractions/Modules/Overrides · high confidence

The Overrides module now includes dedicated classes for handling Razor views at the tenant level. A new TenantRazorCompiledItemLoader scans assemblies for Razor attributes and instantiates TenantRazorCompiledItem objects, which are then exposed via the TenantCompiledRazorAssemblyPart. This allows the application to correctly identify and load tenant-specific compiled Razor items.

src/OrchardCore/OrchardCore.Mvc.Core/Overrides · high confidence

The Trumbowyg rich-text editor now includes two new plugins: a Base64 plugin that allows users to insert images directly as base64-encoded data via a file picker, and a Noembed plugin that enables embedding content (such as videos) by pasting a URL and fetching metadata via the noembed.com proxy. These additions expand the editor's capabilities for handling media content without requiring external file uploads or manual iframe insertion.

src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/noembed · high confidence

The Trumbowyg WYSIWYG editor now includes three new plugins: an emoji picker for inserting emojis, a font size selector allowing users to change text size (including custom sizes), and a Giphy integration for searching and inserting GIFs. These additions enhance the content creation capabilities within the editor.

(repo-wide) · high confidence

The workflows module now exposes a dedicated trimming service and configuration options to manage the lifecycle of workflow instances. Administrators can control the batch size for deletion operations via the new WorkflowTrimmingOptions (defaulting to 5000 instances per run), allowing them to adjust performance and avoid timeouts during cleanup. The IWorkflowTrimmingService interface provides the mechanism to execute these trimming tasks based on a retention period and batch size.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Trimming · high confidence

This change introduces a new abstraction layer for the Roles module, defining core interfaces such as IRole, IRoleService, and ISystemRoleProvider, along with supporting models like Role and RoleClaim. It replaces the deprecated ISystemRoleNameProvider with the new ISystemRoleProvider and adds event handlers (IRoleCreatedEventHandler, IRoleUpdatedEventHandler, IRoleRemovedEventHandler) to allow services to react to role lifecycle changes. Extension methods on IRoleService provide utilities for retrieving role names, filtering assignable roles, and determining accessible roles based on user authorization.

src/OrchardCore/OrchardCore.Roles.Abstractions · high confidence

The content permission logic has been extracted from the OrchardCore.Contents module into a new OrchardCore.Contents.Core library. This change introduces a centralized set of permission definitions (CommonPermissions) and a helper system (ContentTypePermissionsHelper) that dynamically generates per-content-type permissions (e.g., EditOwn\_{ContentType}) based on global templates. It also provides extension methods (AuthorizationServiceExtensions) to simplify authorization checks against content types and owners, making these permission capabilities available to other modules without requiring a direct reference to the main Contents module.

src/OrchardCore/OrchardCore.Contents.Core · high confidence

A new LockedAsyncFieldResolver class has been introduced in the GraphQL resolvers to wrap field resolution logic. This component acquires an execution context lock before invoking the underlying resolver and releases it afterward, ensuring that GraphQL field resolvers do not access the session in parallel. This change addresses concurrency issues where multiple fields might attempt to access the session simultaneously, thereby stabilizing session state during GraphQL query execution.

src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions/Resolvers · high confidence

The AdminMenu.Abstractions package has been updated to replace the previous registration mechanism with a new \AddAdminNode\ extension method, which simplifies registering admin menu nodes by handling service bindings for the node, its builder, and its display driver in a single call. This change also introduces a dedicated \AdminMenuPermissions\ class to centralize permission definitions (\ManageAdminMenu\ and \ViewAdminMenuAll\) and a \DataLocalizationContext\ helper to standardize localization string formatting for admin menus. These changes affect how modules register and manage admin menu items, requiring updates to any code that previously used the old registration pattern or defined permissions locally.

src/OrchardCore/OrchardCore.AdminMenu.Abstractions · high confidence

New AssemblyInfo.cs files have been added to the Properties folders for the OrchardCore.Admin.Abstractions and OrchardCore.Mvc.Core modules. These files explicitly define assembly metadata such as product names, COM visibility settings, and GUIDs, ensuring consistent metadata exposure for these specific components.

src/OrchardCore/OrchardCore.Admin.Abstractions/Properties, src/OrchardCore/OrchardCore.Mvc.Core/Properties · high confidence

The Azure AI Search core module has been restructured to provide a more robust foundation for search indexing. This change introduces a new constants class and naming helper to ensure index and field names comply with Azure AI Search specifications, preventing validation errors. It adds a comprehensive set of deployment sources and steps (for exporting, rebuilding, and resetting indexes) that integrate with the deployment pipeline, allowing administrators to manage index lifecycles via recipes. The module also implements new handlers for mapping content fields to Azure AI Search index structures, supporting vector search configurations, and defines new permissions and options models to manage search settings and authentication types.

src/OrchardCore/OrchardCore.AzureAI.Core · high confidence

The Azure shell storage implementation now relies on a new \IShellsFileStore\ interface and its \BlobShellsFileStore\ service. This change decouples the shell storage logic from direct Azure Blob SDK calls, instead delegating file operations (creating, reading, and removing files) to a generic \IFileStore\ implementation. For users, this simplifies the underlying storage mechanism and aligns the Azure shell provider with a more standardized file storage pattern, potentially making it easier to swap or mock storage backends in the future.

src/OrchardCore/OrchardCore.Shells.Azure/Services · high confidence

The indexing system now processes content updates asynchronously in the background rather than synchronously during the request lifecycle. A new \IndexingContentHandler\ collects content item changes (create, update, delete, publish) into deferred tasks that are executed after the current shell scope completes. This ensures that multiple changes within a single request or recipe are batched together, reducing redundant index operations and improving performance when managing content.

src/OrchardCore/OrchardCore.Indexing.Core/Handlers · high confidence

The content management display layer now uses a new ContentItemDisplayManager and ContentItemAlternatesFactory to automatically generate and cache shape alternates for content items. This ensures that display and editor shapes for content items and their parts are rendered with optimized, cached alternate patterns based on stereotypes and content types, improving performance and consistency in how content is presented and edited.

src/OrchardCore/OrchardCore.ContentManagement.Display · high confidence

The Autoroute module now consolidates its configuration values and security definitions into dedicated static classes. A new \AutorouteConstants\ class defines the \SlugPrefix\ constant, ensuring consistent handling of the slug prefix across the module. Additionally, \AutoroutePermissions\ has been extracted to a standalone class to manage module-specific permissions, such as \SetHomepage\, improving code organization and reducing cross-module dependencies.

src/OrchardCore/OrchardCore.Autoroute.Core · high confidence

The OpenID Core module now consolidates its configuration constants and permission definitions into dedicated static classes. Users will find that entity types, feature identifiers, and claim prefixes are managed via OpenIdConstants, while administrative access controls for applications, scopes, clients, servers, and validation settings are explicitly defined in OpenIdPermissions, providing a clearer separation of concerns for module configuration and security.

src/OrchardCore/OrchardCore.OpenId.Core · high confidence

The setup configuration keys (such as SiteName, AdminUsername, DatabaseName, and DatabaseSchema) are now defined as constants in the new SetupConstants class. This change provides a single, centralized location for these string literals, ensuring consistency across the application and reducing the risk of typos when referencing setup parameters.

src/OrchardCore/OrchardCore.Abstractions/Setup · high confidence

The indexing subsystem now uses a centralized set of string constants for index field names (such as owner, author, content type, and full text) defined in ContentIndexingConstants, alongside a new ContentIndexMetadata model to track indexing scope (latest version, specific content types, and culture). This refactoring standardizes how content indexing fields are referenced and configured, ensuring consistency across the indexing process.

src/OrchardCore/OrchardCore.Contents.Core/Indexing, src/OrchardCore/OrchardCore.Indexing.Core/Models · medium confidence

The indexing core has been restructured to centralize index management and improve reliability. Index profiles are now persisted as documents in the database, managed by a new DefaultIndexProfileManager and DefaultIndexProfileStore that handle creation, updates, and validation with proper event handling. The ContentIndexInitializerService ensures indexes are created on shell activation and triggers background indexing via deferred tasks, while the IndexInitializerService cleans up indexes when shells are removed. The new IndexingTaskManager batches and deduplicates indexing tasks before flushing them to the database, and the NamedIndexingService processes these tasks in batches with distributed locking to prevent concurrent indexing conflicts. This architecture supports multiple indexing providers through keyed service registrations and provides configurable batch sizes for tuning performance.

src/OrchardCore/OrchardCore.Indexing.Core · high confidence

The Users module now provides a single \AddUsers()\ extension method to register all user-related services (including stores, role handling, indexing, two-factor authentication, and JSON serialization) in one call, simplifying startup configuration. Additionally, a new \ExternalLoginInfoExtensions\ class allows extracting the email address from external login info by checking standard and custom claim types, supporting more flexible external identity providers.

src/OrchardCore/OrchardCore.Users.Core/Extensions · high confidence

The chunked file upload functionality, including the \ChunkFileUploadService\, its associated background task for purging abandoned uploads, and the service registration extension, has been moved into the \OrchardCore.Media.Core\ module. This change centralizes the handling of large file uploads and their temporary storage cleanup within the core media infrastructure, ensuring that abandoned chunks are automatically cleaned up via a scheduled background task.

src/OrchardCore/OrchardCore.Media.Core/Services · high confidence

The document storage system now exposes a comprehensive set of configurable options via \DocumentOptionsSetup\, allowing administrators to fine-tune caching, synchronization, and locking behaviors. Users can now explicitly set the \SynchronizationLatency\ (defaulting to 1 second), \CompressThreshold\ (defaulting to 10,000 bytes), and \LockTimeout\/\LockExpiration\ (defaulting to 10,000 ms) through configuration sections. The setup also supports shared and named configuration scopes for properties like \CacheKey\, \CheckConcurrency\, \CheckConsistency\, and cache expiration policies (\AbsoluteExpiration\, \SlidingExpiration\), providing greater control over document persistence and caching strategies.

src/OrchardCore/OrchardCore.Infrastructure/Documents/Options · high confidence

The content definition record classes in the metadata records namespace have been updated to use file-scope namespace declarations and C\# collection expressions for initializing list properties. This change modernizes the code style and reduces boilerplate in the record classes that define content types, parts, and fields.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Metadata/Records · high confidence

The content management core has been rewritten to replace Newtonsoft.Json with System.Text.Json, introducing a new \ContentItemConverter\ for serialization and changing the \ContentItem.Id\ primary key from \int\ to \long\. The codebase now uses file-scoped namespaces, collection expressions, and \FrozenDictionary\ for lookups, while adding new extension methods like \AlterAsync\ and \GetOrCreate\ to simplify content part manipulation and migration of settings.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions · high confidence

The content type and part definition builders in the metadata API now enforce stricter validation: names must start with a letter, contain only valid characters, and cannot be reserved internal names, throwing exceptions if these rules are violated. Additionally, when adding a field to a part via the builder, if no explicit display name is configured, the field's technical name is automatically used as its display name. The builders also introduce new methods like \WithPart\<TPart\>\, \RemovePart\<TPart\>\, and \WithDisplayName\ (replacing the deprecated \DisplayedAs\), while maintaining backward compatibility with the older \Named\ and \DisplayedAs\ methods which are now marked obsolete.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Metadata/Builders · high confidence

The system now includes a dedicated JSON converter for the UserLoginInfo type, ensuring that login provider details (LoginProvider, ProviderKey, and ProviderDisplayName) are correctly serialized and deserialized. This change improves reliability when handling user authentication data in JSON formats, preventing potential issues with default serialization behavior.

src/OrchardCore/OrchardCore.Users.Core/Json · high confidence

The deployment module's permission definitions and service registration have been relocated to the core library. A new \DeploymentPermissions\ class now centrally defines permissions such as ManageDeploymentPlan, Export, Import, and remote instance management, while a deprecated \CommonPermissions\ class provides backward-compatible aliases. Additionally, the \AddDeploymentServices\ extension method in \ServiceCollectionExtensions\ now registers the \IDeploymentManager\ service directly from the core project, decoupling permission references from the main module assembly.

src/OrchardCore/OrchardCore.Deployment.Core · high confidence

The DisplayManagement module has been refactored to improve performance and reduce allocations. A new \Arguments\ system with \GenerateArgumentsAttribute\ enables source-generated property access for models, avoiding reflection overhead. Shape creation now uses \IShapeFactory\ with state-passing callbacks to minimize closure allocations, and placement resolution has been optimized to strip suffixes for more flexible matching. Additionally, the module introduces \GenerateShapeAttribute\ for compile-time shape implementations, a new \LayoutAccessor\ for scoped layout access, and updated service registrations in \OrchardCoreBuilderExtensions\ to support these changes.

src/OrchardCore/OrchardCore.DisplayManagement · high confidence

The dynamic JSON handling classes in OrchardCore.Abstractions have been rewritten to use System.Text.Json instead of the deprecated Newtonsoft.Json. This change introduces new dynamic wrapper types (JsonDynamicArray, JsonDynamicObject, JsonDynamicValue) that support dynamic member access, indexing, and implicit conversions, ensuring that code relying on dynamic JSON manipulation continues to function correctly after the underlying library removal.

src/OrchardCore/OrchardCore.Abstractions/Json/Dynamic · high confidence

The OrchardCore.Email.Abstractions library has been restructured to support multiple email providers (such as SMTP and Azure Communication Services) via a new IEmailProvider interface and IEmailProviderResolver, allowing users to configure and switch between different sending backends. Additionally, the MailMessage model now supports both HTML and plain text bodies simultaneously (HtmlBody and TextBody), replacing the deprecated single Body property, and includes updated settings for SMTP configuration including proxy support and pickup directory options.

src/OrchardCore/OrchardCore.Email.Abstractions · high confidence

The DataMigrationManager now supports static data migration methods and verifies return types before invocation, allowing for more flexible migration definitions. It also includes fixes for the Uninstall and UninstallAsync methods to ensure proper cleanup of feature data, and ensures that data migrations are assigned to a single feature to prevent conflicts. Additionally, the manager now uses more efficient collection initializations and language keywords for type references.

src/OrchardCore/OrchardCore.Data.YesSql/Migration · high confidence

The workflow abstractions layer now centralizes configuration and security definitions. A new WorkflowConstants class provides string keys for form-originated HTTP redirect tasks, while a new WorkflowsPermissions class explicitly defines the ManageWorkflows, ExecuteWorkflows, and ManageWorkflowSettings permissions. This structural change isolates these specific resources to avoid module-to-module references.

src/OrchardCore/OrchardCore.Workflows.Abstractions · high confidence

Administrators can now assign permissions to specific site settings groups (such as General or Debugging) rather than managing all settings under a single broad permission. This change introduces a new permission system where access to individual settings groups is controlled via distinct permissions, allowing for more precise role-based access control within the site settings interface.

src/OrchardCore/OrchardCore.Settings.Core · high confidence

The OrchardCore.Apis.GraphQL.Abstractions package now provides the core abstractions for the GraphQL API, including a new permission model with distinct permissions for executing queries (ExecuteGraphQL) and mutations (ExecuteGraphQLMutations), alongside a dedicated GraphQLPermissionContext for authorization checks. It introduces configuration via GraphQLSettings (exposing endpoints, query depth/complexity limits, and result pagination controls), schema building interfaces (ISchemaBuilder, ISchemaFactory) to support thread-safe schema generation, and a GraphQLUserContext for managing request-scoped user data. Additionally, it provides DI extension methods to simplify registering GraphQL input and output graph types.

src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions · high confidence

The Content Management GraphQL module now explicitly registers its permission provider via a new \Permissions\ class and a dedicated \AddContentGraphQL\ service extension. This ensures that the \ApiViewContent\ permission is correctly associated with the Administrator role and available for query-time checks, replacing previous implicit or scattered permission handling.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL · high confidence

A new FileSizeHelper class has been added to format file sizes into human-readable strings using dependency-injected localization, replacing the previous static FileSizeHelpers class. The original FileSizeHelpers class is now marked as obsolete and directs users to use the new helper, ensuring consistent formatting behavior across the media module.

src/OrchardCore/OrchardCore.Media.Core/Helpers · high confidence

The ResourceManagement module now supports explicit positioning of resources in the output. Developers can require scripts or styles to appear at the very beginning or end of the head or body sections by using the new ResourcePosition.First and ResourcePosition.Last options. The underlying ResourceDictionary tracks these positions to ensure correct rendering order. Additionally, the resource resolution logic now detects and throws an error for circular dependencies between resources, preventing infinite loops during rendering.

src/OrchardCore/OrchardCore.ResourceManagement · high confidence

The shape rendering and creation subsystems now support asynchronous event handling. Implementers of IShapeDisplayEvents can use DisplayingAsync and DisplayedAsync to perform async operations during shape rendering, while IShapeFactoryEvents can utilize async hooks in the ShapeCreatingContext and ShapeCreatedContext to modify shapes during creation. This change enables drivers and modules to execute database queries or other I/O-bound tasks within these lifecycle events without blocking the rendering thread.

src/OrchardCore/OrchardCore.DisplayManagement/Implementation · high confidence

The routing layer now uses a new \IAreaControllerRouteMapper\ interface and a \DefaultAreaControllerRouteMapper\ implementation to handle area-based routes. This change introduces a standard URL pattern (\/{area}/{controller}/{action}/{id?}\) for mapping area controllers, replacing previous implicit or hardcoded routing logic. The \RoutingHelper\ class provides utility methods to extract route values and replace placeholders, enabling more specialized or constrained route mappings (such as for admin areas) to be implemented by swapping or extending this mapper.

src/OrchardCore/OrchardCore.Mvc.Core/Routing · high confidence

The GraphQL query system now uses a new set of expression classes (such as AndExpression, OrExpression, and SimpleExpression) to build SQL predicates. This change introduces a structured way to combine conditions (AND/OR), handle comparisons (equal, like, greater/less than), and manage database aliases, ensuring that generated SQL correctly respects database schema configurations and table prefixes.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries/Predicates · high confidence

The Content Card editing UI now uses strongly typed shape classes (ContentCardShape, ContentCardFrameShape, ContentCardFieldsEditShape) instead of dynamic shapes. This change provides explicit properties for content item data, editor controls, and layout settings, improving type safety and developer experience when working with content card shapes.

src/OrchardCore/OrchardCore.ContentTypes.Abstractions/Shapes · high confidence

The \OrchardCore.Recipes.Abstractions\ module now includes a new set of model classes (\RecipeDescriptor\, \RecipeExecutionContext\, \RecipeExecutionException\, \RecipeResult\, \RecipeStepResult\, and \RecipeEnvironmentFeature\) that define the structure for recipe metadata, execution context, and results. This change establishes the foundational data types for how recipes are described, executed, and reported, replacing or supplementing previous internal implementations with a standardized abstraction layer.

src/OrchardCore/OrchardCore.Recipes.Abstractions/Models · high confidence

The JavaScript scripting engine has been updated to Jint 4.15, introducing support for asynchronous scripting and lazy registration of global methods to improve performance. A key behavioral change is that script evaluations can now be properly cancelled via cancellation tokens, preventing unbounded execution from hanging indefinitely. Additionally, a stack overflow guard is enabled by default to prevent runaway recursion from crashing the process, and JSON dynamic objects are now correctly wrapped for script access.

src/OrchardCore/OrchardCore.Scripting.JavaScript · high confidence

The Liquid rendering engine has been upgraded to Fluid 2.0, introducing a new set of abstraction interfaces in OrchardCore.Liquid.Abstractions to support the updated library. This change replaces the previous implementation with new core types including ILiquidTemplateManager for rendering templates, ILiquidFilter for defining async filters, and LiquidTemplateContext to manage template state and service access. Additionally, new helper classes like FluidOptionsParser, LiquidFilterDelegateResolver, and LiquidPropertyAccessor are introduced to facilitate template parsing, filter resolution via dependency injection, and dynamic property access within the Liquid scope.

src/OrchardCore/OrchardCore.Liquid.Abstractions · high confidence

The Liquid display management module now explicitly registers its core services, including the view parser, filter providers (such as sanitize\_html and supported\_cultures), and configuration options for Fluid parsing. This change centralizes the setup of Liquid-specific features like function allowance and tag helpers, ensuring they are available when the module is initialized.

src/OrchardCore/OrchardCore.DisplayManagement.Liquid/Extensions · high confidence

The Lucene search implementation has been extracted into a new OrchardCore.Lucene.Core module, establishing a dedicated core for Lucene-specific indexing and querying services. This change introduces support for sorting search results by multiple fields simultaneously, allowing more complex result ordering. Additionally, search responses now include the total hit count, providing users with accurate result set sizes rather than just the paginated subset. The module also registers a comprehensive set of query providers (such as Boolean, Fuzzy, Match, and Range) and filter providers, along with specific permissions for managing Lucene indexes and querying the API.

src/OrchardCore/OrchardCore.Lucene.Core · high confidence

The Lucene search implementation has been moved from the Search module into a new core library (OrchardCore.Lucene.Core), making the Lucene provider available as a foundational service rather than a module-specific feature. This change introduces core services for managing Lucene indices (LuceneIndexManager), handling queries (LuceneQuerySource, LuceneQueryHandler), and persisting indexing state to the filesystem (LuceneIndexingState), while also adding new lifecycle events (DocumentsAddedOrUpdated, DocumentsDeleted) to the document indexing handler interface.

src/OrchardCore/OrchardCore.Lucene.Core/Services · high confidence

The Lucene search provider has been extracted from the Search module into a standalone OrchardCore.Lucene.Core module. This change introduces new core components for Lucene-based indexing, including handlers for configuring content index profiles and index mappings, as well as model classes for Lucene-specific settings, query metadata, and index maps. Users relying on Lucene for search functionality will now interact with this dedicated core module rather than the general Search module.

src/OrchardCore/OrchardCore.Lucene.Core/Handlers, src/OrchardCore/OrchardCore.Lucene.Core/Models · high confidence

The OrchardCore.Media.Abstractions package has been restructured to support new media capabilities, introducing the IChunkFileUploadService interface to handle large file uploads in segments and purge temporary files. Security and access controls are enhanced via the IMediaTokenService for signed query strings, the IMediaNameNormalizerService for SEO-friendly slugification (with transliteration options), and the IUserAssetFolderNameProvider for organizing user assets. Configuration is centralized in MediaOptions, which now exposes settings for restricted file extensions, chunk upload limits, CDN base URLs, and cache behaviors, while new interfaces like IMediaFileStore and IMediaFileStoreCache define the underlying storage and caching contracts.

src/OrchardCore/OrchardCore.Media.Abstractions · high confidence

The JSON serialization infrastructure has been replaced with the modern System.Text.Json library, introducing new configuration classes (DocumentJsonSerializerOptions, JsonDerivedTypesOptions) and a centralized options holder (JOptions). This change brings several behavioral improvements: it now supports deserializing strings to numeric values, handles TimeSpan and DateTime types via dedicated converters, includes a fallback mechanism for polymorphic abstract types to prevent exceptions, and allows comments in JSON recipes. Additionally, enum values are now serialized as strings by default.

src/OrchardCore/OrchardCore.Abstractions/Json · high confidence

The OrchardCore.Mvc.Web sample project has been updated to use the .NET 6 minimal hosting model, replacing the previous Startup class pattern with a concise Program.cs entry point. This change simplifies the application's startup configuration by directly registering OrchardCore with MVC support and configuring middleware in a single file. Additionally, the default layout view has been upgraded to use Bootstrap 5.3.2 for the UI, and the default logging configuration has been adjusted to suppress verbose output by setting the default log level to Warning.

src/OrchardCore.Mvc.Web · high confidence

Razor Pages in Orchard Core modules are now gated by feature availability and organized by area, ensuring that pages are only served when their defining feature is enabled. The new \ModularPageApplicationModelProvider\ checks if a page's area corresponds to an enabled feature and returns a 404 if not, while \ModularPageRazorPagesOptionsSetup\ configures conventions to serve application module pages from the root and restricts access during setup. Additionally, \PageConventionCollectionExtensions\ provides helpers to add folder routes for both admin and non-admin areas, and \PageEndpointComparerPolicy\ ensures consistent endpoint matching priority.

src/OrchardCore/OrchardCore.Mvc.Core/RazorPages · high confidence

The NLog logging module now correctly identifies the current tenant in log output via a new \orchard-tenant-name\ layout renderer, falling back to "None" when no shell context is active. Additionally, the \UseNLogHost\ and \UseNLogWeb\ extension methods automatically resolve the NLog configuration directory using the \ORCHARD\_APP\_DATA\ environment variable or the default app data path, ensuring log files are written to the correct location.

src/OrchardCore/OrchardCore.Logging.NLog · high confidence

The security infrastructure now includes a dedicated ApiAuthenticationHandler that delegates authentication to a configured scheme, ensuring proper HTTP status codes (401/403) and RFC-compliant WWW-Authenticate headers for API requests by disabling HTML error page conversion. Additionally, a DefaultPermissionGrantingService has been introduced to check implied permissions recursively, and the DI registration ensures unique permission names are validated at startup.

src/OrchardCore/OrchardCore.Infrastructure/Security · high confidence

The GraphQL module now exposes configuration options to hide content types and fields, and to collapse content parts in the schema. Administrators can mark specific content types as hidden so they do not appear in GraphQL queries, and can hide individual fields to prevent them from being exposed. Additionally, content parts can be collapsed to simplify the schema structure, reducing the number of visible fields for complex content types.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Options · high confidence

The local locking mechanism for the current tenant has been replaced with a new LocalLock implementation that manages named semaphores with explicit reference counting. This change fixes a previous issue where semaphores could leak by ensuring they are disposed when their reference count reaches zero, and introduces support for TimeSpan.MaxValue as a valid expiration value (treated as indefinite locking). The new component implements IDistributedLock and ILocalLock, providing AcquireLockAsync, TryAcquireLockAsync, and IsLockAcquiredAsync methods, while internally handling semaphore lifecycle and timeout scenarios to prevent resource exhaustion.

src/OrchardCore/OrchardCore/Locking · high confidence

The ShellDescriptorManager now implements IShellDescriptorManager to manage shell descriptors stored in the database, handling feature loading, serial number updates, and event notifications. This implementation is registered as a scoped service via the new AddDataStorage extension method, which also configures host-level services for loading site settings from the file system.

src/OrchardCore/OrchardCore.Infrastructure/Shell · high confidence

This change introduces a comprehensive set of custom JSON converters and polymorphic handling mechanisms within the OrchardCore.Abstractions serialization layer. It adds specific converters for DateTime, TimeSpan, PathString, and dynamic objects to ensure consistent serialization formats. Furthermore, it implements a resilient polymorphic deserialization system (via ResilientPolymorphicJsonConverter and PolymorphicJsonTypeInfoResolver) that gracefully handles unrecognized type discriminators by falling back to a placeholder type instead of throwing exceptions, thereby improving stability when features are disabled or types evolve.

src/OrchardCore/OrchardCore.Abstractions/Json/Serialization · high confidence

This change introduces a new set of interfaces and attributes in OrchardCore.Abstractions to refine how features are discovered, built, and associated with code types. The new FeatureTypeDiscoveryAttribute allows developers to control type-to-feature mapping, including options to skip extension assignment or enforce single-feature registration. The IFeatureBuilderEvents interface and FeaturesProviderBase class provide lifecycle hooks (Building and Built) during feature construction, enabling better ordering and dependency management. Additionally, ITypeFeatureProvider and IFeatureInfo are defined to manage the mapping between dependent types and features, supporting scenarios like data migration assignment and type harvesting. These abstractions lay the groundwork for more robust feature dependency resolution and state management.

src/OrchardCore/OrchardCore.Abstractions/Extensions/Features · high confidence

The OrchardCore.Setup.Abstractions module now exposes a dedicated Services folder containing core interfaces and models for managing application initialization. This includes the ISetupService interface, which allows retrieving available setup recipes and executing tenant setup processes asynchronously, and the ISetupUserIdGenerator interface for creating unique identifiers during setup. Additionally, the SetupContext class is introduced to encapsulate setup information such as shell settings, enabled features, the selected recipe, and any errors encountered, providing a structured way to pass configuration data through the setup workflow.

src/OrchardCore/OrchardCore.Setup.Abstractions/Services · high confidence

The admin interface now exposes configurable options for the top bar, allowing users to control the visibility of the theme toggler (enabled by default), the menu filter, the 'New' menu, and titles in the top bar. This is supported by the introduction of a new \Navbar\ entity model to structure the navigation component.

src/OrchardCore/OrchardCore.Admin.Abstractions/Models · high confidence

The system now indexes content items using a new \ContentItemIndex\ record, enabling faster queries based on content type, owner, author, and display text. This change introduces explicit length limits (255 characters) for content type, owner, author, and display text fields, with the index provider automatically truncating values that exceed these limits to prevent database errors. Additionally, the index now includes the \DisplayText\ field, allowing users to search and filter content by its display name, and the database schema has been updated with appropriate indexes to support these new query patterns.

src/OrchardCore/OrchardCore.ContentManagement/Records · high confidence

The OrchardCore.Data.Abstractions package introduces a new set of types to standardize database configuration and validation. A new \IDbConnectionValidator\ interface and associated \DbConnectionValidatorContext\/\DbConnectionValidatorResult\ types allow the system to validate database connectivity and certificate trust before allowing a tenant to be added or set up, providing specific feedback for issues like invalid connections or untrusted SSL certificates. The package also defines \DatabaseProvider\ and \DatabaseProviderValue\ classes to explicitly manage supported database providers (MySql, Postgres, SqlConnection, Sqlite) and their metadata. Additionally, \DatabaseTableOptions\ and \ShellSettingsExtensions\ expose configuration for document table names, table name separators, and identity column sizes, while \ServiceCollectionExtensions\ provides a method to register these provider details. The \IDataMigrationManager\ interface is also present, defining the contract for managing feature database migrations.

src/OrchardCore/OrchardCore.Data.Abstractions · high confidence

This change introduces a new entity abstraction layer in OrchardCore.Infrastructure.Abstractions. It adds a comprehensive set of lifecycle context classes (Creating, Created, Initializing, Initialized, Loading, Loaded, Validating, Validated, Updating, Updated, Deleting, Deleted) and a ModelHandlerBase to manage model events. It also defines the IEntity interface with a JsonObject-based Properties bag and provides EntityExtensions with new methods (GetOrCreate, TryGet, Put, Remove, Alter, Has) for managing entity properties, while marking the legacy As\<T\> method as obsolete to encourage the use of the new, more consistent API.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Entities · high confidence

This change introduces the core abstractions for the extension system, including interfaces for extension and manifest information (IExtensionInfo, IManifestInfo), extension management (IExtensionManager), and dependency/priority strategies. It also adds a new configuration class, DocumentJsonSerializerOptionsConfiguration, which sets up the JSON serializer with a ResilientPolymorphicJsonConverterFactory and PolymorphicJsonTypeInfoResolver to prevent exceptions when serializing polymorphic abstract types, while reusing known converter instances.

src/OrchardCore/OrchardCore.Abstractions/Extensions · high confidence

The MVC core module now uses a new set of components to handle Razor views and routing in a multi-tenant environment. This includes custom file providers (ApplicationViewFileProvider, ModuleProjectRazorFileProvider) to serve views from both the application and module projects, a shared view compiler provider to optimize compilation across tenants, and a modular application model provider to handle area-based routing and controller filtering. Additionally, a custom file version provider (ShellFileVersionProvider) is introduced to manage static file versioning across tenants, and the startup configuration has been updated to support these new providers while maintaining backward compatibility with deprecated .NET 10 Razor runtime compilation options.

src/OrchardCore/OrchardCore.Mvc.Core · high confidence

The system now includes a new \DefaultPermissionService\ and \IPermissionService\ interface to manage permissions, replacing or augmenting previous mechanisms. This change introduces \IPermissionProvider\ for modules to enumerate available permissions and default stereotypes, along with \PermissionProviderExtensions\ to allow looking up permissions by name. A new \AddPermissionProvider\ extension method simplifies registering these providers in the dependency injection container. The \Permission\ class now supports security-critical flags and implied-by relationships, and \PermissionStereotype\ allows grouping permissions for role assignment.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Security/Permissions · high confidence

The search module now exposes a new abstraction layer in OrchardCore.Search.Abstractions, introducing ISearchService and ISearchHandler interfaces to decouple search logic from specific providers. This change enables registering multiple search services (such as Azure AI Search and Elasticsearch) via a keyed DI extension, allowing the system to resolve all ISearchService instances. Users benefit from enhanced search capabilities including content item highlights in SearchResult, a dedicated SearchContext for handling search operations, and centralized permissions for managing search settings.

src/OrchardCore/OrchardCore.Search.Abstractions · high confidence

The shell configuration layer now uses a dedicated \IShellConfiguration\ interface and \ShellConfiguration\ implementation that lazily builds tenant settings from application and site-specific sources. To ensure compatibility with Linux OS file systems, configuration keys using underscores are automatically resolved to their dot-notation equivalents (e.g., \OrchardCore\_Media\_Azure\ falls back to \OrchardCore.Media.Azure\), preventing lookup failures on case-sensitive or path-separator-sensitive systems. Additionally, new extension methods allow configuration sections to be converted to \JsonNode\ objects for easier programmatic access.

src/OrchardCore/OrchardCore.Abstractions/Shell/Configuration · high confidence

The shell descriptor system now includes new model classes to better track tenant features. \ShellDescriptor\ holds a snapshot of enabled and installed features, while \ShellFeature\ represents individual features with an ID and an \AlwaysEnabled\ flag. A new \InstalledShellFeature\ class extends \ShellFeature\ to include a \SerialNumber\, allowing the system to record the version of the descriptor when a feature was installed. These models support the shell's composition strategy by providing detailed metadata about feature states.

src/OrchardCore/OrchardCore.Abstractions/Shell/Descriptor/Models · high confidence

The site settings infrastructure now supports configurable caching behavior via a new \CacheMode\ enum (FromConfiguration, Enabled, DebugEnabled, Disabled) and exposes it on the \ISite\ interface. To improve consistency and performance, the legacy \As\<T\>()\ method is obsolete and replaced by \GetOrCreate\<T\>()\ and \TryGet\<T\>()\ on \ISite\, with corresponding extension methods added to \ISiteService\ for synchronous and asynchronous retrieval of custom settings.

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/Settings · high confidence

The Taxonomies.Core module now uses a new DefaultContentsTaxonomyListQueryService to retrieve content items associated with a taxonomy term, replacing the previous implementation. This service supports pagination via a Pager and allows external components to modify the query results through the new IContentsTaxonomyListFilter interface, enabling custom filtering logic for taxonomy-based content lists.

src/OrchardCore/OrchardCore.Taxonomies.Core · high confidence

The content display subsystem now uses new generic base classes, ContentPartDisplayDriver\<TPart\> and ContentFieldDisplayDriver\<TField\>, which replace the previous non-generic drivers. These drivers automatically generate and cache shape alternates for content parts and fields based on content type, part/field names, display modes, and editors, improving template targeting precision and rendering performance. Driver registration is now configured via ContentDisplayOptions and resolved through dedicated ContentPartDisplayDriverResolver and ContentFieldDisplayDriverResolver services, allowing developers to register display drivers for specific parts and fields with optional display mode or editor predicates.

src/OrchardCore/OrchardCore.ContentManagement.Display/ContentDisplay · high confidence

The OrchardCore.Users.Abstractions module now exposes core contracts and configuration options for the user system. It introduces the IUser interface and SerializableClaim/ClaimsPrincipalExtensions to support claim serialization, while UserOptions allows administrators to customize the URL paths for login, logoff, change password, external logins, and two-factor authentication. Additionally, UserRateLimiterPolicyNames defines specific rate-limiting policy identifiers for password authentication, recovery, registration, and two-factor flows.

src/OrchardCore/OrchardCore.Users.Abstractions · high confidence

The notification index has been updated to include the notification's text body in its searchable content. Previously, only the summary was indexed; the new implementation extracts the \TextBody\ from the notification's body info, appends it to the summary, strips HTML tags, and truncates the result to a defined length. This allows users to find notifications by searching within the full text of the message, not just the summary.

src/OrchardCore/OrchardCore.Notifications.Core/Indexes · high confidence

The media module now uses NetVips instead of ImageSharp.Web for on-demand image resizing and transformation. This change introduces a new abstraction layer (IImageProcessingEngine) and updates the supported output formats: BMP and TGA are no longer supported and will fall back to JPEG, while PNG, GIF, WebP, and JPEG remain available. The processing pipeline now relies on engine-agnostic commands and a dedicated resized-image cache interface, ensuring consistent content-type and extension handling across the media system.

src/OrchardCore/OrchardCore.Media.Abstractions/Processing, src/OrchardCore/OrchardCore.Media.Core/Properties · high confidence

The OpenID Connect abstraction layer now exposes additional capabilities for managing application identities and permissions. The IOpenIdApplicationStore interface has been expanded to include methods for retrieving and setting roles (GetRolesAsync, SetRolesAsync, ListInRoleAsync) and for resolving physical identifiers (FindByPhysicalIdAsync, GetPhysicalIdAsync). Similar physical ID resolution methods (FindByPhysicalIdAsync, GetPhysicalIdAsync) have been added to the authorization, scope, and token store interfaces, enabling implementations to map between logical identifiers and underlying storage keys.

src/OrchardCore/OrchardCore.OpenId.Core/Abstractions/Stores · high confidence

The OpenID module's manager interfaces (IOpenIdApplicationManager, IOpenIdAuthorizationManager, IOpenIdScopeManager, and IOpenIdTokenManager) have been updated to align with the OpenIddict 3.0 migration. These interfaces now extend OpenIddict's specific manager interfaces and expose methods for managing physical IDs and roles, ensuring that services depending on these abstractions can correctly interact with the updated OpenIddict core options at runtime.

src/OrchardCore/OrchardCore.OpenId.Core/Abstractions/Managers · high confidence

The OpenID module's database schema has been migrated to use YesSql collections, separating data for applications, authorizations, scopes, and tokens into distinct collections. This change introduces specific index tables (including reduce index tables for efficient counting) and enforces a 48-character length limit on identifier columns like ApplicationId and TokenId to ensure compatibility with MySQL index length constraints. Users will see their OpenID data organized into these new collection-based structures upon upgrading.

src/OrchardCore/OrchardCore.OpenId.Core/YesSql/Migrations · high confidence

The OpenID Core service managers (Application, Authorization, Scope, and Token) now expose methods to find entities and retrieve identifiers using a 'physical' ID, allowing the system to work with underlying storage identifiers that differ from the OpenIddict logical ID. Additionally, the Application manager introduces native role support: if the configured store implements the Orchard-specific role interfaces, roles are stored and queried directly; otherwise, roles are persisted as a JSON array in the untyped properties bag, ensuring compatibility with non-Orchard OpenID stores.

src/OrchardCore/OrchardCore.OpenId.Core/Services · high confidence

The OpenID module's YesSql storage layer has been updated to align with OpenIddict 7.0. This change introduces new entity models for applications, authorizations, scopes, and tokens, and replaces the previous YesSql store implementations with versions that implement the OpenIddict 7.0 store interfaces. For users, this ensures compatibility with the latest OpenIddict features and APIs while maintaining the existing YesSql-based persistence strategy.

src/OrchardCore/OrchardCore.OpenId.Core/YesSql/Stores · high confidence

The OpenID module has been migrated to OpenIddict 7.0, introducing new extension methods in OpenIdExtensions.cs to configure the underlying infrastructure. This includes registering Orchard-specific data migrations, replacing OpenIddict managers and stores with YesSql-backed implementations, and adding index providers for applications, authorizations, scopes, and tokens. The changes ensure compatibility with OpenIddict 7.0's internal service registration changes by manually registering typed managers and proxy delegates, while also configuring the YesSql store to enforce case-sensitive filtering where necessary.

src/OrchardCore/OrchardCore.OpenId.Core/Extensions · high confidence

The CMS and MVC project templates (Web and Module) have been updated to target .NET 10.0, replacing previous framework versions. The CMS Web template also introduces a new logger selection option (NLog, Serilog, or None) to configure logging during project generation, while the CMS Module template adds a parameter to optionally scaffold a complete Content Part (including driver, handler, and settings) alongside the base module structure.

src/Templates · high confidence

The module now includes a custom implementation of the HttpClient factory pattern (TenantHttpClientFactory) that tracks HttpMessageHandler lifetimes per tenant. This introduces new internal classes (ActiveHandlerTrackingEntry, ExpiredHandlerTrackingEntry, LifetimeTrackingHttpMessageHandler, NonCapturingTimer, ValueStopwatch) to manage handler expiration and cleanup via timers, ensuring that handlers are disposed only when they are no longer referenced, which helps prevent memory leaks in multi-tenant scenarios.

src/OrchardCore/OrchardCore/Modules/Overrides · high confidence

The ReCaptcha module now supports configuring site keys, secret keys, and API URIs through the site settings UI, while still allowing defaults to be set via appsettings.json or environment variables. The new ReCaptchaSettingsConfiguration ensures that site-specific settings are applied only if they haven't already been configured at the application level, providing a flexible hierarchy for ReCaptcha configuration.

src/OrchardCore/OrchardCore.ReCaptcha.Core/Configuration · high confidence

The deployment abstraction layer has been refactored to support a more robust and extensible deployment plan structure. The \DeploymentPlan\ model now uses a \long\ for its \Id\ and initializes its \DeploymentSteps\ list using collection expressions. A new \DeploymentSourceBase\<TStep\>\ abstract class simplifies the implementation of custom deployment sources by handling type-safe step processing. The \DeploymentStep\ class now includes a \Category\ property for UI filtering, and a new \UnknownDeploymentStep\ class preserves raw JSON data for steps whose types are no longer registered, preventing deserialization crashes. Service registration is streamlined via new \AddDeployment\ extension methods that handle sources, steps, and display drivers, while \DeploymentPlanResult\ now explicitly manages recipe metadata and file building.

src/OrchardCore/OrchardCore.Deployment.Abstractions · high confidence

The shape placement engine has been refactored to support complex UI layouts. The placement location string format now includes delimiters for Tabs (\#), Cards (%), and Columns (\|), allowing shapes to be organized into nested groups. A new fluent PlacementLocationBuilder API enables developers to construct these placements programmatically. Additionally, the shape table manager now uses frozen dictionaries for improved performance and caches shape descriptors statically to reduce allocations across tenants.

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors · high confidence

The OrchardCore.Redis.Abstractions package now defines the core interfaces and configuration models required to share a single Redis instance across multiple tenants. This includes the IRedisDatabaseFactory for creating shared database connections, the IRedisService interface which exposes the connection multiplexer and an InstancePrefix for namespacing, and the RedisOptions class that allows users to specify the connection configuration and the prefix string.

src/OrchardCore/OrchardCore.Redis.Abstractions · high confidence

The setup core services have been reorganized into a dedicated 'Services' folder, introducing a new ServiceCollectionExtensions class to register tenant-level setup services (SetupService, SetupUserIdGenerator) and moving the core SetupService and SetupUserIdGenerator implementations to this new location. This change improves code organization and maintainability without altering the external API or behavior of the setup process.

src/OrchardCore/OrchardCore.Setup.Core · high confidence

The content management handler subsystem has been restructured to support granular field-level processing alongside existing part-level handling. A new \ContentFieldHandlerResolver\ has been added to resolve and invoke handlers specific to individual content fields, allowing for field-level validation and logic. The \ContentPartHandlerCoordinator\ now coordinates both part and field handlers across all content lifecycle events (such as Activating, Creating, Loading, Validating, and Publishing), ensuring that field handlers are invoked in parallel with part handlers. Additionally, a new \UpdateContentsHandler\ centralizes the management of content item metadata, automatically setting the Owner, Author, CreatedUtc, ModifiedUtc, and PublishedUtc timestamps based on the current HTTP context and clock, ensuring consistent ownership and versioning data across creation, updates, and publishing workflows.

src/OrchardCore/OrchardCore.ContentManagement/Handlers · high confidence

The role management infrastructure has been restructured to support a dedicated system role provider and cleaner API usage. A new \DefaultSystemRoleNameProvider\ implements \ISystemRoleNameProvider\ to manage system roles (such as Administrator) via a frozen set, enabling the \RoleService\ to distinguish system roles from user-defined ones using \IsSystemRoleAsync\ and \IsAdminRoleAsync\. The previous \GetRoleNamesAsync\ method on \IRoleService\ is now deprecated in favor of the new \GetRolesAsync\ method, which returns full role objects, while a new extension method \RoleServiceExtensions.GetRoleNamesAsync\ provides the legacy string-based functionality for backward compatibility. Additionally, a \NullRoleStore\ has been introduced to handle scenarios where role storage is not required.

src/OrchardCore/OrchardCore.Roles.Core/Services · high confidence

The user management module now centralizes permission definitions in a new \UsersPermissions\ class, with the legacy \CommonPermissions\ class marked as obsolete to avoid cross-module references. This refactoring introduces granular, dynamic permissions for role-based user management (e.g., editing or deleting users within specific roles). Additionally, the \UserManagerExtensions\ now automatically updates the security stamp when roles are removed or claims are changed, ensuring that existing authentication sessions are invalidated to reflect these privilege changes immediately.

src/OrchardCore/OrchardCore.Users.Core · high confidence

The OrchardCore.Feeds.Abstractions module has been updated to use an asynchronous-first design for its core interfaces. IFeedBuilder.ProcessAsync now returns a Task\<XDocument\> instead of a synchronous result, and IFeedItemBuilder.PopulateAsync and IFeedQuery.ExecuteAsync are now asynchronous operations. Additionally, the provider interfaces (IFeedBuilderProvider and IFeedQueryProvider) have been updated to support async matching where applicable, and a new FeedBuilderExtensions class provides a helper method for adding properties to feed items.

src/OrchardCore/OrchardCore.Feeds.Abstractions · high confidence

The YesSql data access layer has been refactored to improve reliability and configurability. A new DbConnectionValidator now checks database connectivity and schema existence before allowing tenant setup, preventing errors from invalid connections or missing tables. SQLite database names are now configurable via settings, and the default cache mode has been set to Default. The system now uses System.Text.Json for content serialization instead of Newtonsoft.Json, with options configurable through the IoC container. Additionally, new services like DbConnectionAccessor and TableNameConventionFactory provide better control over connection creation and table naming conventions.

src/OrchardCore/OrchardCore.Data.YesSql · high confidence

The OrchardCore.Data.YesSql.Abstractions package has been restructured to provide cleaner abstractions for database migrations and indexing. A new DataMigration base class and corresponding extension methods now handle the reflection-based execution of Create and UpdateFrom steps, allowing developers to define migrations with standard static or async methods. The package introduces IScopedIndexProvider and associated DI extensions (AddIndexProvider, AddScopedIndexProvider) to support index providers that require scoped service resolution. Additionally, YesSql configuration is now centralized in YesSqlOptions, exposing settings such as IsolationLevel (defaulting to ReadCommitted), QueryGatingEnabled, and EnableThreadSafetyChecks, while DefaultTableNameConvention and ITableNameConventionFactory allow for customizable table naming strategies.

src/OrchardCore/OrchardCore.Data.YesSql.Abstractions · high confidence

The admin menu now uses a refined scoring algorithm to determine which menu items are highlighted as selected. The system computes a stable hash for each item and scores it based on how many leading path segments match the current request, giving higher priority to routes with more shared context (such as specific content item IDs) over broader ancestors. This ensures that the most specific matching menu item is marked as active, resolving issues with double-selected menus or incorrect root state.

src/OrchardCore/OrchardCore.Navigation.Core · high confidence

The content items admin list now uses a new extensible filtering architecture. A dedicated model binder parses the 'q' query string into a filter model, which is processed by pluggable filter providers (IContentsAdminListFilterProvider) and parsers (IContentsAdminListFilterParser). This allows third-party modules to inject custom query rules (such as the new Taxonomy filter) into the admin list without modifying core code. Additionally, a custom JSON output formatter ensures content items are serialized correctly using the system's configured document serializer options.

src/OrchardCore/OrchardCore.Contents.Core/Services · high confidence

The content management handler system has been restructured to provide finer control over content operations. A new \ContentValidateResult\ class and \Fail\ extension methods on \ValidateContentContext\ allow handlers to report specific validation errors. Cancellation capabilities have been added to \CreateContentContext\ and \PublishContentContext\, enabling handlers to abort creation or publishing. The \RemoveContentContext\ now includes a \RemoveContentReason\ enum (Deletion, NewVersion) and a \Cancel\ property to distinguish between item deletion and version replacement scenarios. Additionally, base handler classes (\ContentHandlerBase\, \ContentPartHandler\, \ContentFieldHandler\) and their corresponding interfaces have been updated to support these new context types and lifecycle events.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers · high confidence

The content management subsystem has been restructured to improve performance and maintainability. A new cache context provider ensures content definition caches are properly invalidated when definitions change. The content definition manager now utilizes memory caching for type and part definitions, while the default content manager introduces a session-based recall mechanism to avoid redundant database queries for published items. Additionally, dedicated factories for content parts and fields have been introduced to optimize type activation and registration, and a new compiled query streamlines fetching published content items by ID.

src/OrchardCore/OrchardCore.ContentManagement · high confidence

The content type metadata models in the ContentManagement.Abstractions layer have been restructured to use a unified \ContentDefinition\ base class with a generic \GetSettings\<T\>()\ method, replacing direct property access for settings. This change introduces extension methods for \ContentTypeDefinition\, \ContentTypePartDefinition\, and \ContentPartFieldDefinition\ to simplify retrieving display names, descriptions, editors, and display modes from their respective settings. Additionally, new options classes (\ContentTypeDefinitionOptions\, \ContentTypeDefinitionDriverOptions\) and a \StereotypeDescription\ model have been added to allow configuring the visibility of content type settings in the UI based on stereotypes or specific content types.

src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Metadata/Models · high confidence

The display management system has been refactored to use new, strongly-typed context classes (BuildDisplayContext, BuildEditorContext, UpdateEditorContext) that inherit from a common BuildShapeContext, replacing the previous dynamic or loosely-typed approaches. This change introduces a generic DisplayDriver\<TModel\> base class that enforces type safety for model handling and simplifies the driver API by automatically managing HTML field prefixes and model type checks via CanHandleModel. For users, this means display drivers are now more robust and easier to implement, with better compile-time guarantees and cleaner code structure, while maintaining backward compatibility through the generic constraints.

src/OrchardCore/OrchardCore.DisplayManagement/Handlers · high confidence

The email module's permission definitions have been moved into a dedicated EmailPermissions class to reduce module coupling, with the original Permissions class now delegating to it and marking the old static permission as obsolete. Additionally, service registration logic has been consolidated into ServiceCollectionExtensions, providing explicit methods to register core email services and configure custom email providers.

src/OrchardCore/OrchardCore.Email.Core · high confidence

The email sending infrastructure in OrchardCore.Email.Core has been refactored to introduce a pluggable provider model and built-in message validation. A new DefaultEmailProviderResolver now dynamically selects email providers based on configuration, allowing administrators to switch or add providers without code changes. The DefaultEmailService now returns a Result object indicating success or failure, providing clearer feedback on send outcomes. Additionally, an EmailMessageValidator automatically checks sender and recipient addresses for validity before sending, preventing invalid emails from being dispatched.

src/OrchardCore/OrchardCore.Email.Core/Services · high confidence

The extension loading mechanism has been refactored to improve reliability and performance. A new \DependencyOrdering\ class now handles feature ordering using a graph-based algorithm that respects both structural dependencies and explicit Before/After hints, ensuring features load in the correct sequence. The \ExtensionManager\ has been optimized to use frozen dictionaries for better memory efficiency and thread safety. Additionally, a new \DocumentSystemTextJsonOutputFormatter\ has been introduced to properly handle JSON serialization for document and entity types in MVC responses, configured via \MvcOptionsConfiguration\.

src/OrchardCore/OrchardCore/Extensions · high confidence

The feature extension system has been refactored to improve performance and control over feature activation. A new FeatureHash class now caches a hash of all enabled features in memory, speeding up checks that depend on the current feature set. The FeatureInfo model now supports an EnabledByDependencyOnly flag, allowing features to be automatically enabled or disabled based solely on their dependencies rather than explicit user configuration. Additionally, the TypeFeatureProvider has been updated to enforce that types are assigned to only a single feature, preventing conflicts where a type might be registered by multiple startup classes.

src/OrchardCore/OrchardCore/Extensions/Features · high confidence

The manifest attributes in OrchardCore.Abstractions (FeatureAttribute, ModuleAttribute, ModuleMarkerAttribute, ModuleNameAttribute, ModuleAssetAttribute) have been refactored to improve code clarity and maintainability. This includes moving manifest attributes to specific files, converting to file-scope namespaces, and updating the code to use language keywords instead of framework type names for type references. The FeatureAttribute now supports an 'enabledByDependencyOnly' flag to allow features to be auto-enabled or disabled based on dependencies. The ModuleAttribute extends FeatureAttribute to provide module-specific functionality while maintaining feature semantics. ManifestConstants now defines the Orchard Core version as 3.0.1.

src/OrchardCore/OrchardCore.Abstractions/Modules/Manifest · medium confidence

The shape rendering system in the DisplayManagement views layer has been refactored to improve performance and flexibility. A new \IDisplayResult\ interface and \CombinedResult\ class allow multiple display results to be composed and applied asynchronously. The \ShapeResult\ class now supports fluent configuration for shape placement (including specific locations for different display types) and introduces a \RenderWhen\ capability for conditional rendering. Additionally, \ShapeViewModel\ and its generic counterpart \ShapeViewModel\<T\>\ have been updated to include a \Properties\ dictionary for arbitrary metadata and optimized item sorting, providing a more robust foundation for shape building and templating.

src/OrchardCore/OrchardCore.DisplayManagement/Views · high confidence

The shell builder infrastructure has been restructured to improve how tenant service containers are composed and how services are tracked to their originating features. A new \CompositionStrategy\ now handles the assembly of the \ShellBlueprint\, ensuring that features marked as \DefaultTenantOnly\ are correctly skipped for non-default tenants and that startup types are properly mapped. The \ShellContainerFactory\ now utilizes a \FeatureAwareServiceCollection\ to wrap the tenant's service collection, allowing every registered service descriptor to be explicitly associated with the \IFeatureInfo\ that added it. This feature-tracking data is then used to populate the \ITypeFeatureProvider\, enabling more accurate type-to-feature resolution. Additionally, a \StartupBaseMock\ class was introduced to wrap legacy raw startup classes, allowing them to be treated uniformly with \IStartup\ implementations during the container creation process.

src/OrchardCore/OrchardCore/Shell/Builders · high confidence

The theme management system has been restructured to use a priority-based selection model. A new IThemeSelector interface allows multiple components to propose themes with specific priorities, while the ThemeManager resolves the highest-priority valid theme for the current request. This change introduces a dedicated ThemeLayout Razor page that explicitly renders the layout shape with the view body in the Content zone, replacing the previous implicit layout handling. Additionally, extension methods were added to IThemeManager to simplify retrieving the shape table for the active theme.

src/OrchardCore/OrchardCore.DisplayManagement/Theming · high confidence

The zone rendering logic in the Display Management module has been updated to support structured grouping of shapes into Tabs, Cards, and Columns within ContentZones. This change introduces a new FlatPositionComparer to handle precise sorting of shape positions, including support for terminal sentinels (start/end) and numeric ordering. Additionally, zone shape alternates are now cached for performance, and the zone holding mechanism has been refactored to use lazy initialization via ZoneOnDemand, reducing allocations and improving efficiency when accessing zones.

src/OrchardCore/OrchardCore.DisplayManagement/Zones · high confidence

The media module now enforces a more granular permission model, introducing distinct View permissions (ViewMedia, ViewRootMedia, ViewOthersMedia, ViewOwnMedia) that are separate from Manage permissions, allowing administrators to grant read-only access to media folders without permitting modifications. Additionally, the local media cache now safely mirrors remote storage paths (such as Azure Blob Storage) by escaping NTFS-invalid characters (like colons) and handling reserved device names, ensuring that files from remote stores can be cached locally without file system errors.

src/OrchardCore/OrchardCore.Media.Core · high confidence

The JSON node abstraction layer in OrchardCore.Abstractions now relies on the JsonPath.Net library for evaluating JSONPath queries, reversing a previous attempt to use a custom implementation. Additionally, this update restores and implements JSON merge functionality for arrays and objects (JArray, JObject, JNode, JValue), allowing users to merge JSON content with configurable array handling strategies (Concat, Union, Replace, Merge) and null value handling, mirroring the behavior previously available via Newtonsoft.Json.

src/OrchardCore/OrchardCore.Abstractions/Json/Nodes · high confidence

The admin interface no longer depends on jQuery for the select picker component, which has been replaced with a jQuery-free implementation. This change reduces the overall JavaScript footprint in the admin UI and aligns with the project's broader effort to minimize jQuery usage in favor of modern, framework-agnostic alternatives.

src/OrchardCore.Modules · high confidence

The core rule evaluation interfaces (IRuleService, IConditionResolver, IConditionOperatorResolver, and IConditionIdGenerator) have been relocated from the OrchardCore.Rules.Abstractions.Services namespace to OrchardCore.Rules.Services. This change affects how these services are referenced and resolved within the Rules module, requiring updates to any code that explicitly depends on the previous namespace location.

src/OrchardCore/OrchardCore.Rules.Abstractions/Services · high confidence

The Queries module now includes a dedicated permissions class defining the 'ManageSqlQueries' permission, which is marked as security critical to ensure proper access control for SQL query management. Additionally, a new migration helper has been added to support the transition of query documents, ensuring data integrity during upgrades by handling the migration of existing query data into the new structure.

src/OrchardCore/OrchardCore.Queries.Core · high confidence

When a user account is disabled, the system now automatically updates the user's security stamp. This ensures that existing authentication cookies and tokens become invalid immediately upon disablement, preventing any further access with stale credentials.

src/OrchardCore/OrchardCore.Users.Core/Handlers · high confidence

The MVC view location strategy has been updated to allow modules to share Razor views and ViewComponent templates with other modules. New location expanders scan enabled modules for shared content in the \Views/Shared\ and \Pages/Shared\ directories, making these resources available to the entire application rather than being restricted to the module that defines them.

src/OrchardCore/OrchardCore.Mvc.Core/LocationExpander · high confidence

The shell builder now provides a \CreateChildContainer\ extension method that automatically clones service registrations from the host into a new tenant-specific container. This method intelligently handles singleton services by either sharing non-disposable instances via factory delegates or registering immediate instance clones for disposable singletons, ensuring proper lifecycle management. It also supports keyed services and explicitly excludes \IStartupFilter\ registrations to prevent middleware from being re-added to the tenant pipeline.

src/OrchardCore/OrchardCore/Shell/Builders/Extensions · high confidence

AssemblyInfo.cs files have been added to multiple OrchardCore modules (including ContentManagement, ContentTypes, Data, Deployment, Indexing, and ResourceManagement) to explicitly define assembly metadata such as product names, GUIDs, and COM visibility settings. This ensures consistent metadata configuration across the platform's core abstractions and core libraries.

(repo-wide) · high confidence

The OrchardCore.Cms.Web project has been restructured to follow a modern, minimal-ASP.NET template pattern. The entry point is now Program.cs, which uses the generic host builder and integrates NLog for logging via a new NLog.config file. Development and production logging levels are explicitly defined in appsettings.json and appsettings.Development.json. Launch settings have been updated to use a 'Kestrel' profile with HTTPS enabled by default, and a new openapi-generation-setup.recipe.json has been added to facilitate API documentation generation during initial tenant setup.

src/OrchardCore.Cms.Web · high confidence

GraphQL queries for content items now enforce fine-grained permissions before returning data. The new ContentItemFilters component checks user permissions (ViewContent and ViewOwnContent) against content type definitions during the query phase, ensuring users only see items they are authorized to view. Additionally, a post-query filter provides a fallback security check to prevent improper disclosure. The ContentItemQuery resolver also validates permissions for individual item lookups, returning null for unauthorized access.

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries · high confidence

This change introduces support for .NET 10 keyed services and asynchronous initialization within the tenant container. It adds a \ClonedSingletonDescriptor\ and updates \ServiceDescriptorExtensions\ to handle keyed service resolution, ensuring correct implementation type and instance retrieval for both keyed and standard descriptors. Additionally, it provides extension methods to register delegates that run asynchronously immediately after a tenant container is created via \IServiceCollection.Initialize\, while marking the previous \IAsyncConfigureOptions\ and related async configuration methods as obsolete in favor of synchronous alternatives.

src/OrchardCore/OrchardCore.Abstractions/Shell/Builders/Extensions · high confidence

Orchard Core now supports live updates for email configuration without requiring a full application restart. This change introduces a signal-based invalidation mechanism that allows the standard IOptionsMonitor to observe changes to email options in real-time. The implementation includes a new IOptionsUpdateNotifier interface and a DefaultOptionsUpdateNotifier that defers invalidation signals until the current shell scope commits successfully, ensuring consistency. This enables features like dynamic email settings adjustments to take effect immediately for subsequent operations.

src/OrchardCore/OrchardCore.Abstractions/Options, src/OrchardCore/OrchardCore/Options · high confidence

Theme extensions that declare explicit sub-features via module manifests but do not define their own main feature now correctly register a synthetic main feature. This ensures the extension is recognized as a theme (IsTheme returns true) and allows base themes to properly declare dependencies on their child extensions, fixing issues where theme extensions were not appearing or functioning correctly.

src/OrchardCore/OrchardCore.DisplayManagement/Events · high confidence

When a tenant is removed, the system now actively drops the associated database tables instead of leaving them behind. This is achieved by introducing a new \ShellDbTablesRemovingHandler\ that replays the tenant's migrations in a read-only mode to identify all tables created by that tenant, and then executes a transaction to drop them. For SQLite tenants, the entire database file is deleted to ensure a clean slate, while other database providers use standard SQL drop commands.

src/OrchardCore/OrchardCore.Data.YesSql/Removing · high confidence

The built-in TheAdmin theme has been completely rewritten to use modern tooling and a newer UI framework. JavaScript logic (menu, notifications, preferences) is now written in TypeScript and bundled via Parcel, replacing the previous jQuery-based scripts. The styling has been migrated to SCSS and upgraded to Bootstrap 5, introducing a redesigned left sidebar with persistent user preferences (compact/expanded state) saved to local storage, a new client-side confirmation modal system, and a dedicated admin menu filter shortcut (Ctrl+Shift+F).

src/OrchardCore.Themes · high confidence

The ThemeAttribute class in the display management manifest has been updated to include an \enabledByDependencyOnly\ parameter in its constructors. This allows theme features to be automatically enabled or disabled based on their dependencies, rather than requiring manual activation, aligning with the new \EnabledByDependencyOnly\ flag introduced for features.

src/OrchardCore/OrchardCore.DisplayManagement/Manifest · high confidence

The notification system in the Messages zone has been updated to allow alerts to automatically disappear after a specified duration via the new DismissalMilliseconds property on NotifyContext. Additionally, the system now prevents duplicate notifications from being displayed by comparing entries using a dedicated comparer, ensuring a cleaner user experience.

src/OrchardCore/OrchardCore.DisplayManagement/Notify · high confidence

The OrchardCore.Abstractions assembly now explicitly exposes its internal members to four specific assemblies: OrchardCore.Data.YesSql, OrchardCore.ContentManagement.GraphQL, OrchardCore.DisplayManagement, and OrchardCore.DynamicCache. This change modifies the internal API surface, allowing these specific modules to access previously hidden implementation details within the abstractions layer.

src/OrchardCore/OrchardCore.Abstractions/Properties · high confidence

The core user management services have been rewritten to leverage ASP.NET Core Identity, replacing the previous custom implementation. This introduces a new UserStore implementing standard Identity interfaces (such as IUserPasswordStore and IUserEmailStore) and adds dedicated services for configuring token providers (email confirmation, password reset, change email) and handling two-factor authentication requirements. Administrators will notice that user authentication flows, including login and registration, now rely on the Identity framework's built-in mechanisms for security stamps, lockouts, and claim generation.

src/OrchardCore/OrchardCore.Users.Core/Services · high confidence

The workflow activity abstraction has been restructured to support a more granular lifecycle. The base Activity class now exposes dedicated lifecycle hooks for workflow restarts (OnWorkflowRestartingAsync, OnWorkflowRestartedAsync) and resumption (OnWorkflowResumingAsync, OnWorkflowResumedAsync), in addition to existing start and execution events. The execution model has been updated to use a new ActivityExecutionResult class with explicit 'Empty' and 'Halted' states, and the outcome helper methods have been simplified and renamed (e.g., Outcomes to Outcome). Additionally, property storage now uses System.Text.Json.Nodes.JsonNode instead of Newtonsoft.Json JToken, and a new ActivityViewModel generic class has been added to support view model binding for activities.

src/OrchardCore/OrchardCore.Workflows.Abstractions/Activities · high confidence

The OpenID Connect module now uses YesSql indexes to support efficient querying of application, authorization, scope, and token data. New index providers define how these entities are stored and retrieved, including specific reduce indexes for tracking redirect URIs, logout URIs, roles, and resources.

src/OrchardCore/OrchardCore.OpenId.Core/YesSql/Indexes · high confidence

This change introduces the core model, service, and settings for the HtmlBodyPart in OrchardCore.Html.Core to ensure HTML content is properly sanitized. The HtmlDisplayService now explicitly calls the IHtmlSanitizerService when the sanitizeHtml flag is true, addressing the reported issue where HTML sanitization was broken. The HtmlBodyPartSettings class provides a default configuration to enable HTML sanitization, ensuring that user-provided HTML is cleaned before display.

src/OrchardCore/OrchardCore.Html.Core · high confidence

The DataLocalization module now includes a null localizer implementation that safely handles translation requests when the feature is not enabled. This prevents the admin dashboard from crashing in environments where the DataLocalization module is disabled, ensuring a stable user experience regardless of the module's activation state.

src/OrchardCore/OrchardCore/Localization/Data · high confidence

The QueriesDocument model now stores its queries in a Dictionary that ignores case when looking up keys. This prevents issues where query names might be accessed or stored with different capitalizations, ensuring consistent behavior regardless of how the query name is cased.

src/OrchardCore/OrchardCore.Queries.Core/Models · high confidence

Added tests for Azure AI Search module configuration and vector search behavior; Added tests for Azure Email module options monitoring and client caching; Added tests for HTTPS settings migration; Added tests for Liquid encrypt/decrypt, transliterate, and slugify filters; Added tests for ReCaptcha options monitoring; Added tests for SMS provider options monitoring; Added tests for Security Headers middleware and extension methods; Added tests for Sub-Resource Integrity (SRI) validation; Added tests for granular settings permissions and shape rendering options monitoring; Added tests for the Rate Limits module; Added unit tests for Audit Trail DateTime parsing; Added unit tests for AutoSetup middleware behavior; Added unit tests for AutoroutePartHandler validation logic; Added unit tests for Azure Media module validation and configuration; Added unit tests for Content Fields and Spatial settings deserialization; Added unit tests for Data Localization services; Added unit tests for Elasticsearch ContentPickerField settings deserialization; Added unit tests for Markdown module services and filters; Added unit tests for OpenID module controllers and recipe steps; Added unit tests for RedisCacheWrapper disposal behavior; Added unit tests for Setup Controller and TimeZone Select List Provider; Added unit tests for SignalR backplane startup and configuration; Added unit tests for Taxonomy field settings serialization; Added unit tests for Twitter OAuth signature generation; Added unit tests for manifest attribute constructors; Added unit tests for module static file providers and utility extensions; Added unit tests for scripting global methods; Added unit tests for tenant management and validation; Added unit tests for the Email workflow task; Added unit tests for the Meta Conversions API service; Added unit tests for the OrchardCore.Users module; Expanded test coverage for OrchardCore.Media module.

The project now uses a centralized Directory.Packages.props file to manage NuGet package versions, ensuring consistent dependency resolution across all modules. Additionally, new npm package.json files have been added for the Assets Manager and Bloom scripts, introducing modern build tooling with dependencies like Parcel, Vite, Vue 3, and Monaco Editor to streamline asset compilation and development workflows.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 51 → 51 (+0.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 53 → 53 (-0.2)
• Architecture 73 → 72 (-0.5)
• Maturity 75 → 75 (+0.1)
• Readiness 56 → 54 (-2.0)
• Security 82 → 76 (-6.5)
• Event-Driven 100 → 100 (+0.0)
• Accessibility 40 → 41 (+1.2)
• Performance 76 → 76 (+0.0)

• (anonymous) (cognitive 20) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/table/trumbowyg.table.js)
• (anonymous) (cognitive 29) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/table/trumbowyg.table.js)
• BarePragmaDisable (src/OrchardCore.Modules/OrchardCore.Navigation/PagerShapesTableProvider.cs)
• Boundary-crossing change coupling: LocalizationEntries.cs ↔ AutorouteEntries.cs (src/OrchardCore.Modules/OrchardCore.ContentLocalization/Services/LocalizationEntries.cs)
• Bounded contexts not declared
• Change coupling: AccountController.cs ↔ RegistrationSettings.cs (src/OrchardCore.Modules/OrchardCore.Users/Controllers/AccountController.cs)
• Change coupling: EmailTask.cs ↔ EmailTaskViewModel.cs (src/OrchardCore.Modules/OrchardCore.Email/Workflows/Activities/EmailTask.cs)
• Change coupling: OrchardRazorHelperExtensions.cs ↔ ImageResizeTagHelper.cs (src/OrchardCore.Modules/OrchardCore.Media/Razor/OrchardRazorHelperExtensions.cs)
• Change coupling: ScheduledArchivingBackgroundTask.cs ↔ ScheduledPublishingBackgroundTask.cs (src/OrchardCore.Modules/OrchardCore.ArchiveLater/Services/ScheduledArchivingBackgroundTask.cs)
• Change coupling: ServiceCollectionExtensions.cs ↔ AzureAISearchIndexManager.cs (src/OrchardCore/OrchardCore.AzureAI.Core/Extensions/ServiceCollectionExtensions.cs)
• ClassTooLong: ShapeFactoryGenerator (src/OrchardCore/OrchardCore.SourceGenerators/ShapeFactoryGenerator.cs)
• CommentedOutCode (src/OrchardCore.Modules/OrchardCore.Contents/ViewModels/PublishContentViewModel.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• CommentedOutCode (test/OrchardCore.Abstractions.Tests/Modules/Manifest/ModuleMarkerAttributeTests.cs)
• …and 273 more

• (anonymous) (cognitive 18) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/pasteembed/trumbowyg.pasteembed.js)
• (anonymous) (cognitive 201) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/table/trumbowyg.table.js)
• (anonymous) (cognitive 21) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/giphy/trumbowyg.giphy.js)
• (anonymous) (cognitive 21) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/resizimg/trumbowyg.resizimg.js)
• (anonymous) (cognitive 23) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/history/trumbowyg.history.js)
• (anonymous) (cognitive 24) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/colors/trumbowyg.colors.js)
• (anonymous) (cognitive 24) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/preformatted/trumbowyg.preformatted.js)
• (anonymous) (cognitive 26) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/upload/trumbowyg.upload.js)
• (anonymous) (cognitive 33) (.scripts/assets-manager/min.mjs)
• (anonymous) (cyclomatic 143) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/table/trumbowyg.table.js)
• (anonymous) (cyclomatic 17) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/giphy/trumbowyg.giphy.js)
• (anonymous) (cyclomatic 18) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/preformatted/trumbowyg.preformatted.js)
• (anonymous) (cyclomatic 19) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/colors/trumbowyg.colors.js)
• (anonymous) (cyclomatic 19) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/upload/trumbowyg.upload.js)
• (anonymous) (cyclomatic 20) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/resizimg/trumbowyg.resizimg.js)
• (anonymous) (cyclomatic 22) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/trumbowyg/plugins/history/trumbowyg.history.js)
• (anonymous)::addProperListeners (cognitive 18) (src/OrchardCore.Modules/OrchardCore.Forms/Assets/js/form-visibility-rules.js)
• (anonymous)::getActiveClientFilters (cognitive 18) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/js/list-management.js)
• (anonymous)::getOptions (cognitive 54) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/js/list-management.js)
• (anonymous)::getOptions (cyclomatic 56) (src/OrchardCore.Modules/OrchardCore.Resources/Assets/js/list-management.js)
• …and 815 more

• 159 commits — 135 feature/other, 24 fixes

• src/OrchardCore.Modules — 70 commits
• (root) — 27 commits
• src/docs — 24 commits
• src/OrchardCore — 17 commits
• .github/workflows — 10 commits
• src/OrchardCore.Themes — 3 commits
• test/OrchardCore.Tests — 3 commits
• .agents/skills — 1 commit
• .github/ISSUE_TEMPLATE — 1 commit
• src/OrchardCore.Cms.Web — 1 commit
• test/OrchardCore.Benchmarks — 1 commit
• test/OrchardCore.Tests.Functional — 1 commit

• fix: #19664: Fix: rename static field to follow naming convention. (#19739)
• fix: Fix 'This class is deprecated. Use FileSizeHelper instead.' build error (Lombiq Technologies: OCORE-288) (#19833)
• fix: Fix Data Localization when Admin Menu is disabled (#19844)
• fix: Fix First-time Contributor Welcome workflow (Lombiq Technologies: OCORE-289) (#19861)
• fix: Fix Media Gallery SignalR Subscribe/UnsubscribePath console errors (#19751)
• fix: Fix Media Gallery uploads landing in wrong folder (#14317) (#19749)
• fix: Fix Media Picker rename dialog, real-time updates, and kebab menu hit targets (#19809)
• fix: Fix Null Reference Exception in UserEventHandler in AuditTrail (#19669)
• fix: Fix Permissions-Policy header serialization (comma separator, parenthesize quoted origins) (#19732)
• fix: Fix RequireFeatures shape providers leaking across shells (#19763)
• fix: Fix SEO image URLs when serving media from a CDN (#19813)
• fix: Fix authorization bypass in MoveMediaListEndpoint (#19923)
• fix: Fix broken HTML sanitization (Lombiq Technologies: OCORE-286) (#19787)
• fix: Fix build warnings not failing the CI build (Lombiq Technologies: OCORE-285) (#19722)
• fix: Fix default content filter term restoration (#19793)
• fix: Fix deleting a widget from a widget list (#19716)
• fix: Fix flaky functional tests and skip unresolved TaxonomyHierarchy flake to green up main (#19901)
• fix: Fix incorrect and incompete authorization behavior in ContentItemFilters (Lombiq Technologies: OCORE-283) (#19705)
• fix: Fix menu authorization semantics (#19742)
• fix: Fix missing folder-scoped authorization in GetTusFileInfoEndpoint (#19925)
• …and 139 more

• Unchanged — 40 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

OrchardCMS/OrchardCore 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.