Skip to content

Release notes for Pollora, the Laravel framework for WordPress: every stable and pre-release version of pollora/framework, newest first.

Pollora's version numbers follow the Laravel release it is built on. The skeleton (pollora/pollora) is tagged with the same number as the framework it ships. Releases are also published on GitHub.

13.40.x

v13.40.2

· Added, Fixed

Added

  • pollora:theme:activate: makes a theme the active WordPress theme, given by its directory name, and refuses to run when WordPress is not fully loaded

Fixed

  • pollora new no longer ends in an error after the theme is built. On a first install pollora:make:theme runs in the process that has just installed WordPress, which is only partly loaded (SHORTINIT): switch_theme() failed there with Call to undefined function wp_set_template_globals(). The theme was left active, but the install exited with code 1 and never showed its success message. The theme is now activated by a fresh pollora:theme:activate process; if that fails, the install carries on and prints the wp theme activate <name> to run afterwards. v13.40.1 fixed the same cause for the plugins the theme requires (Pollora/pollora#274)

v13.40.1

· Added, Fixed

Added

  • pollora:plugin:activate: activates WordPress plugins, given as paths relative to the plugins directory (woocommerce/woocommerce.php), and refuses to run when WordPress is not fully loaded

Fixed

  • pollora new no longer crashes when a theme template requires a WordPress plugin and you activate it (arsort(): Argument #1 ($array) must be of type array, null given). The E-commerce template (pollora/theme-apiary) always hit it: it requires WooCommerce. On a first install pollora:make:theme runs in the process that has just installed WordPress, which is only partly loaded (SHORTINIT), and activate_plugin() failed there before the theme build and the theme activation. The plugins are now activated by a fresh pollora:plugin:activate process, where WordPress loads completely and the activation hooks run. If that process fails, the install carries on and prints the wp plugin activate <slug> to run afterwards (Pollora/pollora#274)

v13.40.0

· Changed

Changed

  • The framework requires Laravel 13.40 (illuminate/* ^13.40)

13.39.x

v13.39.3

· Changed

Changed

  • pollora/wp-rest 2.0 is accepted, and composer update installs it: a REST route that declares no permission is refused (rest_forbidden, 401 for a visitor, 403 for a logged-in user), where it used to stay public. Before updating, declare permissionCallback: Everyone::class on the routes that are public on purpose, or a permission such as IsLoggedIn. To keep the old behaviour for a while, return false from the pollora/wp-rest/private_by_default filter: WordPress then tells, with WP_DEBUG, which route to fix. To stay on the previous version, require "pollora/wp-rest": "^0.2" (there is no 1.x). The framework accepts ^0.1 || ^0.2 || ^1.0 || ^2.0
  • The development files (.harness.json, AGENTS.md, api-surface.json, composer-dependency-analyser.php, .gitignore) are kept out of the distribution archive, and pollora/harness is required at ^0.1.15

v13.39.2

· Added, Changed

Added

  • wordpress.sessions: Route::wp() routes no longer have to start a Laravel session. Routes declared in routes/web.php inherit the web group, so every anonymous request to a Route::wp() route started a session (a row in sessions, the <app>_session and XSRF-TOKEN cookies). With 'sessions' => false in config/wordpress.php, those routes drop StartSession, ShareErrorsFromSession and the CSRF middleware (PreventRequestForgery, which ValidateCsrfToken extends), and csrf_token(), old() and flash data have nothing to read from there. The default is true: nothing changes for an existing site. Laravel-native routes keep the full web group, and the template hierarchy fallback is not affected

Changed

  • pollora/entity is required at ^2.0 (it was ^1.2): entity 2.0 only raises its PHP requirement to 8.3, which the framework already requires
  • nwidart/laravel-modules is required at ^13.2 (it was ^13.0). Its 13.2.0 release changes how a custom stubs.path is enabled and how a custom paths.generator.* entry without a namespace gets its namespace; a project on the default configuration needs no change
  • The development tooling moves up: @commitlint/cli and @commitlint/config-conventional 21 (they need Node 22.12 or later; the repository’s rules still apply), prettier 3.9.10, and, for the end-to-end suite, @playwright/test 1.64.1 and @wordpress/e2e-test-utils-playwright 3.1.0, both pinned as before. lint-staged is removed, with its configuration: it was configured but no git hook ever ran it (the only hook is commit-msg)
  • Dependabot ignores the major versions of @types/node in tests/e2e: the suite runs on Node 22
  • The development dependency pollora/harness is required at ^0.1.13

v13.39.1

· Changed, Fixed

Changed

  • WP Rocket moved to its own package, pollora/wp-rocket. Install it if the project runs WP Rocket: composer require pollora/wp-rocket. The framework no longer registers WpRocketServiceProvider, which kept WP Rocket from writing its rules into .htaccess and from setting WP_CACHE (both off unless wordpress.wprocket.generate_htaccess / set_cache_constant say otherwise). Without the package, an active WP Rocket does both on its own. The old class name Pollora\ThirdParty\WpRocket\WpRocketServiceProvider still resolves once the package is installed, and wordpress.wprocket is unchanged
  • pollora:doctor and Site Health check that WP Rocket, when active, has its Pollora integration installed; pollora/wp-rocket is suggested in composer.json
  • pollora/colt ^11.0 (it was ^10.0.1): Colt 11 requires PHP 8.3, declares strict types and adds return types to its public methods, so a model that extends one of Colt’s and overrides a method must be compatible. pollora/block-bindings is required as ^0.2 (it needs Colt 11) and pollora/query as ^2.0 || ^3.0 (3.0 only raises its PHP requirement to 8.3)
  • laravel/prompts is updated to ^0.3.26
  • Dependabot watches the npm lock files (/ and tests/e2e) and opens its pull requests, security updates included, against develop: a security update used to target main, which broke the Gitflow

Fixed

  • The end-to-end test of the module list no longer fails when WordPress shows its own warning notice, as it does while a core update is available
  • tests/e2e/package-lock.json is refreshed with npm audit fix (zod 4.6.7, puppeteer-core 25.16.0 and their dependencies) to fix known vulnerabilities in these development dependencies
  • fast-uri is updated to 3.1.9 in package-lock.json and tests/e2e/package-lock.json to fix known vulnerabilities in these development dependencies

v13.39.0

· Added, Changed, Fixed

Added

  • pollora:doctor and Site Health check that WooCommerce, when active, has its Pollora integration installed: it warns, and gives composer require pollora/woocommerce, when it does not
  • pollora/woocommerce is suggested in composer.json

Changed

  • The framework requires Laravel 13.39 (illuminate/* ^13.39)
  • WooCommerce moved to its own package, pollora/woocommerce. Install it if the project runs WooCommerce: composer require pollora/woocommerce. The framework no longer ships the integration (Pollora\ThirdParty\WooCommerce, the WooCommerce events in Pollora\Events\WordPress\Plugins\WooCommerce, the shop/product/cart… Route::wp() conditions in wordpress.plugin_conditions): without the package a WooCommerce shop loses its Blade templates, those conditions, the Coming Soon page and the events, with no error. The package keeps the old class names working, aliased to Pollora\WooCommerce\…, until the next major release; a project’s own wordpress.plugin_conditions still win, and the wordpress.plugin_conditions.woocommerce defaults stay in config/wordpress.php until the next major release. The core now names no third-party plugin (ARCH-05), so that rule no longer needs its seven nosemgrep notes
  • The Pollora harness (pollora/harness) checks the repository, and a failing gate blocks a merge: composer qa runs the style, static analysis, Rector, tests and architecture rules, dependency policy and analysis, security patterns (bare exceptions, unserialize() calls, third-party plugin references in the core), audit, public surface and ratchet gates, and api-surface.json records the public surface (attributes, hooks, configuration keys, commands). Nothing changes at run time
  • The harness’s dependency analysis (ARCH-07) blocks: composer-dependency-analyser.php scans src/ and tests/ and lists, with its reason, each package the code names without requiring it (Laravel’s components, Symfony and PSR libraries, PHP extensions) and each requirement it does not name (patches, the helper loader, the Bedrock autoloader)
  • Theme setup errors, the languages API, a WordPress query run before WordPress is loaded and the legacy mysql_connect() call throw named exceptions (ThemeSetupException, LanguageApiException, WordPressNotLoadedException, UnsupportedDatabaseCallException, all RuntimeExceptions) instead of a bare RuntimeException; an unknown plugin throws PluginException::notFound() (an Exception, as before). The messages keep their beginning and say what to check
  • A media disk that is missing, has no Flysystem driver, or has no URL throws the named MediaDiskException (a RuntimeException, so a catch (RuntimeException) keeps working; the messages keep their beginning and now say how to fix it) instead of a bare RuntimeException
  • Module errors throw named exceptions instead of a bare RuntimeException or Exception: ModuleStateException (a module cannot be switched or its state written) and ModuleComponentException (a component fails to initialise in debug mode) extend RuntimeException, and the downloader’s failures are now ModuleException (an Exception, as before). The messages keep their beginning, and now say what to check
  • The domain layer no longer calls WordPress or imports the Infrastructure layer (harness rules ARCH-01 and ARCH-02). Theme menus, sidebars and image sizes are registered through ThemeFeatureRegistrarInterface, the theme URI filters resolve through ContentUrlResolverInterface and ThemeAssetUrlResolverInterface, the dashboard reads WordPress through WordPressEnvironmentInterface, AbstractTaxonomy translates its default labels through LabelTranslatorInterface, and WooCommerceService asks WooCommerceEnvironmentInterface about the child theme. Each port is bound to a WordPress adapter by its module’s service provider; behaviour and public signatures are unchanged
  • pollora/wp-rest ^0.2 is accepted: a REST route without a permission stays public and now calls _doing_it_wrong(), outside REST responses. Declare permissionCallback: Everyone::class for a route that is public on purpose, or return true from the pollora/wp_rest/private_by_default filter to refuse such routes today

Fixed

  • The tests run with the lowest dependencies on PHP 8.3 and later: antecedent/patchwork 2.2 is required in development, as older versions break PHPUnit’s code
  • filter_input() reads the plugins to delete with FILTER_UNSAFE_RAW, the same filter as FILTER_DEFAULT, which PHP 8.5 deprecates

13.38.x

v13.38.1

· Fixed, Added

Fixed

  • An APP_URL without a scheme (APP_URL=pollora.test, written by hand in .env) no longer breaks the site: every Artisan command failed with Undefined array key "host", and /wp-admin/ answered a 404 because WordPress built its URLs relative to the current path. The value is read as http://pollora.test for WP_HOME, WP_SITEURL, the cookie path and the console host (#518)

  • The home page of a site served by Valet or Herd no longer redirects to itself. Both run the site through their own server.php, which includes public/index.php, so SCRIPT_FILENAME is not the front controller. Pollora took the request for a WordPress entry point and sent it to the home URL, in an endless loop. A front controller PHP has included now counts as Laravel serving the request

  • /cms/wp-admin/, the address pollora:install prints for the admin, answered a 404 under Valet and Herd, which hand every URL that is not a file to the front controller. A request for a public/ directory that holds an index.php is now sent to that file

Added

  • Site Health reports an error when the web server serves .env: MAMP, Apache or nginx pointed at the project folder instead of public/ expose the application key and the database password, and answer the site with a 404. The check requests /.env and says to point the document root to public/
  • pollora:doctor warns when APP_URL has no scheme, and gives the value to write

v13.38.0

· Fixed, Changed

Fixed

  • The setup (pollora:env:setup, pollora:install) accepts an empty database password. A local MySQL with root and no password, the default with Homebrew, MAMP and many Docker images, was refused with “Database password is required” and had to be written into .env by hand. The connection test that follows still decides whether the empty password works, and DB_PASSWORD= is written as an empty value (#515)

Changed

  • The framework requires Laravel 13.38 (illuminate/* ^13.38)

13.37.x

v13.37.1

· Changed

Changed

  • The framework requires Laravel 13.37 (illuminate/* ^13.37), the release its version number follows. v13.37.0 still accepted 13.36

v13.37.0

· Added, Fixed, Changed

Added

  • Media, anchor of a cover: ImageSize::add('portrait')->cover(400, 500, Anchor::Top) keeps the top of the image instead of its centre (Pollora\Media\Domain\Enums\Anchor, the nine positions of add_image_size()). It never changes the dimensions of the size, changes the name of the files and the version of a service URL, becomes a gravity in the imgproxy preset, and is refused by Bunny, which pollora:media:thumbs:export and pollora:doctor report. It comes with pollora/media 0.8
  • Media, sizes made by a service: media.thumbnails.driver (MEDIA_THUMBNAILS_DRIVER) takes bunny (photo.jpg?class=card, an image class of Bunny Optimizer) or imgproxy (a URL signed with HMAC-SHA256 that names a preset, imgproxy 4.0.x in presets-only mode) besides pollora. No file is made and no fallback route is registered; a private media never goes to the service. php artisan pollora:media:thumbs:export --driver=bunny|imgproxy declares one class or preset per size and per extra width (Bunny: merged by name, a dry run unless --execute; imgproxy: the configuration to give it, without the key or the salt), and pollora:doctor reports a driver that cannot be used. See media.thumbnails.bunny and media.thumbnails.imgproxy in config/media.php
  • Media, sizes made on demand: a declared size that is not eager() is made the first time its URL is asked for, at the exact path of the URL, and served as a file afterwards (Cache-Control: public, max-age=31536000, immutable, never a redirect); the name, the signature and the extension are checked before anything is made, and media.thumbnails limits the cost per server (sizes at the same time, biggest original, wait before a size that exists is served instead). pollora:doctor reports a .htaccess in the uploads folder that stops the fallback
  • Media, image sizes: an ImageSize facade declares the sizes your design uses, ImageSize::add('card')->cover(600, 400)->webp(75), with cover(), scale(), contain(), webp(), avif(), original(), widths(), eager() and upscale(). The file of a size is named photo-card-600x400-{signature}.webp (an HMAC of the original and of the size, made with the application key), so changing a size changes its name, and the URL, width, height and srcset of a size are worked out from the metadata of the original, never from the disk. The sizes WordPress registers itself, including a theme’s config/images.php, are left as they are. pollora:media:thumbs:warm makes the missing files for the images already uploaded, pollora:media:thumbs:prune deletes the files of a size that was changed or removed, and pollora:doctor reports a declaration that cannot make a size or a format the server cannot write
  • Media, private files: a media flagged private (the _pollora_media_private meta, or the pollora/media/is_private filter) is served through a signed URL that expires (media.private.expiry) on its URL, its sizes and its srcset; a public media keeps its plain URL and the disk is never asked to tell them apart. pollora:media:visibility {id} --private|--public changes every file of a media on the disk, pollora:media:files {id} lists them, and the module’s actions reach Laravel as MediaStored, MediaDeleted and MediaVisibilityChanged events. The URL is signed by the Laravel disk (temporaryUrl()), and pollora:doctor warns of private media on a disk that cannot sign
  • Media, images: the sizes a media does not need at once can be generated after the upload (media.async_thumbnails): thumbnail and medium come with the upload, the rest in an asynchronous action that runs on the queue, Action Scheduler or WP-Cron, and WordPress serves the nearest size meanwhile. An upload of an image with nine sizes no longer reads the original back, nor asks the disk for the size of each file, and the personal data export works on any disk (its archive is built locally, copied to the disk and deleted from it when it expires). Both WordPress image editors, GD and Imagick, work as they are
  • The media library can live on any Laravel disk (local, S3, R2, Scaleway…) behind two settings, media.disk and media.url (config/media.php, MEDIA_DISK, MEDIA_URL). The storage is pollora/media; the framework keeps the connector: MediaServiceProvider (the Flysystem driver of the disk, the URL of the disk when media.url is empty), pollora:media:status, pollora:media:migrate (copy between disks, --replace-urls for the database, dry run unless --execute) and a check of pollora:doctor (the disk takes a file; no media left in the local uploads folder). WordPress’s own file functions follow through a pollora:// stream wrapper and the upload_dir filter, so Gutenberg, ACF, Meta Box, WooCommerce and imports need no adaptation; a media URL is media.url and a relative path, never asked to the disk. With no media.disk, nothing changes: WordPress keeps public/content/uploads
  • A Role facade declares roles and capabilities the fluent way, besides #[Role] and #[ModifyRole]: Role::make('event_manager', 'Event manager')->inherits('author')->grantsPostType(Event::class, Access::Editor)->grants('export_attendees')->without('publish_posts'), Role::modify('editor') and Role::capabilitySet(EventCap::class). The names are those of the attributes and of their arguments, and the same code checks both, so a mistake is refused with the same reason, naming the call (Role::make('x') at file:line). There is nothing to register: the declarations are checked when WordPress builds its roles. It comes with pollora/roles 0.2

Fixed

  • Media, edited images: the eager() sizes of an image cropped, rotated, flipped or restored in the media library are made, as at upload. WordPress saves the metadata of an edited image without wp_generate_attachment_metadata, so on a disk served without fallback every size of an edited image was a broken image until thumbs warm. It comes with pollora/media 0.7.1

Changed

  • RoleServiceProvider binds RoleRegistry with its RoleDefinitionBuilder and adds RoleDeclarer, the service the facade forwards to

13.36.x

v13.36.1

· Added, Changed

Added

  • Block Bindings live in their own package, pollora/block-bindings, which the framework requires: the resolver, the source builder and registry, BindingContext, the four sources Pollora ships (pollora/post-meta, pollora/term-meta, pollora/author-meta, pollora/option), BlockBindingDiscovery, the WordPress adapters, the editor data and script (block-bindings.js ships with the package) and the preview route, with their tests. Class names do not change. The framework keeps what needs Laravel: BlockBindingServiceProvider, config/block-bindings.php, the Laravel implementations of the package’s contracts (LaravelMethodInvoker, LaravelBindingEvents, LaravelPostFinder), pollora:binding:list, pollora:make:binding and the pollora:doctor check
  • Roles and capabilities live in their own package, pollora/roles, which the framework requires: RoleDefinitionBuilder, RoleRegistry, RoleCompiler, PostTypeCapabilityMap, the capability readers, the WordPress adapters (stored roles, WP_Roles injection, label translation, role usage) and RoleDiscovery, with their tests. Class names do not change. The framework keeps the Laravel side: RoleServiceProvider, the role middleware, the @role directive, the HasRoles bridge ($user->can(), @can), the pollora:roles:* commands and the pollora:doctor check
  • Typed meta lives in its own package, pollora/meta, which the framework requires: MetaAccessor (of(), schemas(), schemaFor(), extend()), the fluent MetaRecord, the schema builder and repository, MetaAuditor, MetaUiDrivers, the value caster, the WordPress adapters, MetaDiscovery and MetaUiDriverConformance, with their tests. Class names do not change. The framework keeps what needs Laravel: MetaServiceProvider, the Meta facade and HasTypedMeta, the Laravel validator (LaravelMetaValidator), the pollora:meta:* commands and the pollora:doctor check
  • The asset classes live in their own package, pollora/assets, which the framework requires: AssetManager, AssetContainer, AssetEnqueuer (Asset::add()->container()->useVite()), AssetFile, the record and the wp-admin notice of a missing build. Class names do not change. The package also resolves Vite builds without Laravel, for a classic theme, a plugin or a Bedrock site. The framework keeps what needs Laravel: the service provider, the Asset facade, ViteManager (Laravel’s Vite, where ASSET_URL, a CDN and the application URL keep applying), RootAssetManager and the Laravel implementations of the package’s three contracts (ViteManagerFactory, RuntimeContext, PublicPath)

Changed

  • Accepts pollora/query 2.0 alongside 1.x (^1.0 || ^2.0, up from ^1.0): the package now covers every WordPress query class, with terminal methods (first(), ids(), count(), exists()) and the documentation of each builder. Class names and the three existing facades do not change. composer update takes 2.0, and a project that needs 1.x requires pollora/query ^1.0 itself. A few fixes in 2.0 change the result of a query that used to run: where() followed by orWhere() groups the earlier clauses ((a AND b) OR c), DateQuery::inclusive() now takes effect, dates use a 24-hour clock, and an invalid fields(), userPermission() or orderBy() direction throws a QueryException instead of being ignored. The package’s upgrading guide lists them
  • The asset classes that left for the package no longer reach for Laravel: AssetEnqueuer receives the hook services, the Vite factory, the runtime and a PSR-3 logger instead of resolving them from the container, AssetFile is resolved through a resolver the provider sets (AssetFile::resolveUsing()), and AssetManager, MissingBuilds and MissingBuildNotice take their public directory, logger and project root as arguments. The rendered HTML of a Pollora site is unchanged, in build and while Vite runs hot
  • An AssetEnqueuer destroyed after its application, as in a test, no longer throws while it reports a failure of its deferred enqueue
  • The typed meta classes that will leave for pollora/meta no longer reach for Laravel: MetaUiDrivers and MetaAccessor::extend() take a PSR-11 ContainerInterface (the Laravel container is one, a driver closure receives the same object), and the key of a data object’s property is derived by Pollora\Attributes\Support\Naming instead of Str::snake(). What needs Laravel moved to Pollora\Meta\Infrastructure\Laravel: MetaServiceProvider, LaravelMetaValidator, TypedMetaCheck, MetaListCommand and MetaAuditCommand. The rendered pages, the REST responses and the output of the pollora:meta:*, pollora:binding:list, pollora:roles:* and pollora:doctor commands of a Pollora site are unchanged
  • The roles classes that will leave for pollora/roles no longer reach for Laravel: the label of a #[Role] without one comes from Naming::headline() (the same words as Str::headline()) and Naming::classBasename(). What needs Laravel moved to Pollora\Role\Infrastructure\Laravel: RoleServiceProvider, the role middleware EnsureUserHasRole, the @role directive RoleDirective, the RolesCheck of pollora:doctor and the pollora:roles:* and pollora:make:role commands with their stubs. Roles, capabilities and command outputs of a Pollora site are unchanged
  • The Block Bindings classes that will leave for pollora/block-bindings no longer reach for Laravel: the resolver takes a PSR-11 container, and three contracts carry what Laravel did for it, MethodInvokerInterface (the method of a #[BlockBinding] source gets the services its typed parameters name; LaravelMethodInvoker calls through Laravel’s container, ReflectionMethodInvoker by reflection) BindingEventsInterface (BindingResolved reaches Laravel’s dispatcher through LaravelBindingEvents) and PostFinderInterface (BindingContext::post() loads the framework’s Pollora\Models\Post through LaravelPostFinder, Colt’s Post without it, and is typed as Colt’s Post, which the framework’s extends). The options a project lists in block-bindings.options reach OptionSource and the editor data as an array, read from the config by the provider. Labels and names come from Naming, as Str writes them. What needs Laravel moved to Pollora\BlockBinding\Infrastructure\Laravel: the provider, the doctor check, pollora:binding:list and pollora:make:binding with their stub. Pages, REST responses and command outputs of a Pollora site are unchanged

v13.36.0

· Added, Changed, Deprecated, Removed, Fixed

Added

  • Discovery lives in its own package, pollora/discovery, which the framework requires: the engine, its contracts, DiscoveryManager, the cache and the #[SkipDiscovery] attribute, with their tests and benchmarks. Class names do not change. The framework keeps what needs Laravel: the service provider, discovery:run / discovery:clear, DiscoveryRegistrar, ServiceProviderDiscovery, the Laravel adapters, and HasConfiguringSupport, which builds post types and taxonomies
  • Discovery can run without Laravel’s application, the first step towards pollora/discovery: new DiscoveryEngine() works with no argument. Two contracts let an environment plug in — InstanceResolverInterface builds the classes discovery needs (Laravel’s container in a Pollora application, ReflectionInstanceResolver otherwise) and DiscoveryRegistrarInterface adds the environment’s discoveries before each run (DiscoveryRegistrar keeps scanning the container’s *Discovery bindings). Psr16DiscoverCacheDriver caches scans in any PSR-16 cache
  • Post type and taxonomy attributes say what they register: each implements ConfiguresArguments, a pure function that returns the registration arguments with its own contribution (#[HasArchive('library')] sets has_archive, #[Labels] merges into the generated labels), and the method attributes (#[AdminCol], #[RegisterMetaBoxCb], #[MetaBoxCb], #[MetaBoxSanitizeCb], #[UpdateCountCallback]) implement ConfiguresArgumentsWithMethod, the discovery handing them the method as a callback. The Pollora\Attributes namespace no longer reaches Laravel or a framework service, which an architecture test keeps: the first step towards pollora/attributes, a package to declare attributes without the framework
  • The attributes live in their own package, pollora/attributes, which the framework requires: every attribute and its contracts, with the value types they take (Every, Interval, Access, Control, BindingFieldType). Class names do not change. The framework keeps the two deprecated bases, PostTypeAttribute and TaxonomyAttribute, and the code that reads the attributes
  • REST routes live in their own package, pollora/wp-rest, which the framework requires: WpRestDiscovery, the route registrar, the permissions (IsLoggedIn, IsAdmin, Can) and Pollora\Support\WpGlobals. Class names do not change. The framework keeps WpRestAttributeServiceProvider
  • WP-CLI commands live in their own package, pollora/wp-cli, which the framework requires: WpCliDiscovery, WpCliService, the WP-CLI adapters and WordpressCommand. Class names do not change. The framework keeps WpCliServiceProvider and pollora:make:wp-cli
  • Scheduling lives in its own package, pollora/schedule, which the framework requires: one engine behind #[Schedule] and a fluent API (Schedule::event(), Schedule::once(), cancel(), next(), events()), WP-Cron as the default driver, and Schedule::fake() for tests. ScheduleDiscovery keeps its class name and moves there, with the same hook names and schedule keys. The framework gives the engine its container, so the classes passed to call() get their dependencies, and keeps the bridge to Laravel’s scheduler (use_laravel_scheduler)
  • config/schedule.php (publishable with the pollora-schedule tag) chooses the scheduling driver, wp-cron (the default) or action-scheduler, by POLLORA_SCHEDULE_DRIVER, and lists the hooks that stay on WP-Cron whatever the driver. The cron option now indexes every driver’s events, so wp_next_scheduled(), Site Health and WP Crontrol see the ones Action Scheduler keeps, and WP-Cron never runs them. Changing the driver moves nothing by itself
  • pollora:schedule:list shows the scheduled events with their type, frequency and driver (--type, --driver, --site, --network, --json), read from the cron option with no query to a driver; an event on WP-Cron on purpose reads (protected) or (fallback), one a former driver keeps reads (to migrate). pollora:schedule:migrate moves the pending events from one driver to another (--from, --to, --dry-run), in both directions and safe to run again
  • pollora:doctor, Site Health and an administration notice report a driver that does not exist or is not available (events stay on WP-Cron), and the events a former driver still keeps, with the command that moves them
  • The laravel scheduling driver (POLLORA_SCHEDULE_DRIVER=laravel): every event is a job delayed until it is due, in the application’s queue (database, Redis or Horizon, SQS), and a worker runs it. There is no table of Pollora’s own and no schedule:run: the cron option is the record of what is scheduled, and cancelling an event takes its entry out of it. A job runs only if the entry still exists with its identifier and time, so a cancelled, moved or duplicated job stops; a recurring event queues its next occurrence once it ran or failed for good, never in the past. config/schedule.php gains laravel.connection, queue, max_delay (a job due later than the connection allows, 900 seconds on SQS, wakes and waits again) and late_after. On a multisite network the queue is shared, with one worker, and each job runs in the site that scheduled it
  • Lost jobs (a flushed Redis, a purged queue) are found again: at most every five minutes, as a request ends and under a lock, and with php artisan pollora:schedule:recover (--network, --dry-run), an event more than late_after seconds (600) past its time is queued again with the same identifier, so it never runs twice. pollora:doctor and Site Health report late events (no worker), a queue connection that is sync or null, and a scheduled event that failed for good in the last week

Changed

  • Requires Laravel 13.36: illuminate/* ^13.35 → ^13.36. The framework version tracks Laravel’s, so this release is v13.36.0

  • DiscoveryEngine, DiscoveryCacheManager, InstancePool and ReflectionCache take their dependencies instead of reaching for app() and config(); reading structure-discoverer.cache moved to LaravelDiscoveryCacheManagerFactory. DiscoveryRegistrar::registerFromContainer() is now registerInto(). These are infrastructure classes, outside the public contracts (Pollora\Discovery\Domain\*), which do not change

  • One DiscoveryCacheManager is shared by the engine and the pollora:doctor discovery cache check, which built its own

  • The discovery benchmarks measure memory as PHP allocates it, from a reset peak: they read 2 MB whatever the load

  • #[WpRestRoute\Method] no longer registers its route: WpRestRouteRegistrar, in the WpRest module, does, with the same arguments, permissions and request injection. Default slugs, meta keys and command names come from Pollora\Attributes\Support\Naming, which gives the same results as Str::kebab() and Str::snake(); Pollora\Support\Slug uses it

  • The WpRest module no longer reaches for Laravel’s application, the first step towards pollora/wp-rest: custom HandlesAttributes attributes receive the PSR-11 container given to WpRestDiscovery, and WpRestAttributableWrapper takes the controller instance instead of building it. An architecture test keeps the module to the attributes, discovery, PSR contracts and WordPress

  • The WpCli module no longer reaches for Laravel’s application, the first step towards pollora/wp-cli: WpCliDiscovery builds commands through the discovery’s instance pool instead of resolve(). Its service provider and pollora:make:wp-cli stay in the framework; an architecture test keeps the rest to the attributes, discovery, PSR logging and WP-CLI

  • #[Schedule], which runs on WP-Cron alone, no longer reaches for Laravel, the first step towards pollora/schedule: ScheduleDiscovery derives default hook names itself, with the same results as Str::snake() (a parity test keeps them), so hooks already scheduled keep their name. The bridge to Laravel’s scheduler (use_laravel_scheduler) stays in the framework

  • Asynchronous actions queue through the WP-Cron and Action Scheduler drivers of pollora/schedule, with pollora/hook 2.0: ->async(), #[Async], Async::fake(), via() and their options do not change, and work already queued runs once the upgrade is in. Async\Drivers\WpCronDriver and ActionSchedulerDriver are gone with no alias; the framework never used them, and the queue driver is unchanged

Deprecated

  • DiscoveryCacheInterface and LaravelDiscoveryCache, removed in 15.0: nothing reads this cache, scans are cached by the Spatie driver given to DiscoveryCacheManager
  • Pollora\Attributes\PostType\PostTypeAttribute and Pollora\Attributes\Taxonomy\TaxonomyAttribute, removed in 15.0: no built-in attribute extends them any more; implement ConfiguresArguments

Removed

  • The Laravel scheduling bridge, with no replacement under the same name: wordpress.use_laravel_scheduler, Pollora\Schedule\Scheduler, SchedulerInterface, Events\* (AbstractEvent, SingleEvent, RecurringEvent), Jobs\JobDispatcher, RegisterSchedulerFiltersUseCase, the pre_schedule_event, pre_option_cron and related filters it installed, and the wp_events table. Setting the option no longer does anything. To keep WP-Cron events on Laravel’s queue, set POLLORA_SCHEDULE_DRIVER=laravel and run a worker (php artisan queue:work) in place of schedule:run; events that sat in wp_events are not moved (let #[Schedule] and your own code schedule them again, then drop the table: DROP TABLE <prefix>wp_events, with the prefix of your database connection). pollora:doctor no longer reads the option
  • handle() on #[Action], #[Filter], #[WpRestRoute] and #[WpRestRoute\Method], and Hook no longer implements HandlesAttributes: HookDiscovery and WpRestDiscovery register hooks and routes themselves. Only the bug below reached Action::handle(), and WpRestRoute::handle() wrote to a read-only wrapper

Fixed

  • A queued asynchronous action runs even when the request that runs it registers no hook: the framework listens to pollora/async/run at boot instead of waiting for an Action to be built. Before, a handler registered only in the request that queued it was never run, and Action Scheduler marked it failed (“no callbacks are registered”)
  • wp_get_environment_type() follows APP_ENV instead of reading production on every site (#443): local gives local, dev, development and testing give development, staging gives staging, anything else production. A WP_ENVIRONMENT_TYPE environment variable, a wordpress.constants.WP_ENVIRONMENT_TYPE value or a constant defined earlier still wins. WordPress 7.1 turns pings (incoming and outgoing pingbacks and trackbacks) off outside production, so they are off on a site with APP_ENV=local or staging: add_filter('wp_should_disable_pings_for_environment', '__return_false') brings them back
  • pollora:doctor no longer counts as overdue WP-Cron events the ones Action Scheduler keeps: the cron option indexes them too, with a driver key
  • A public #[Action] or #[Filter] method in a #[PostType] or #[Taxonomy] class is registered once: the post type and taxonomy discoveries also handed it to Action::handle(), which registered it a second time on the discovery’s configuration object, so the page firing that hook failed with call_user_func(): Argument #1 ($callback) must be a valid callback, class Pollora\PostType\Infrastructure\Services\PostTypeConfiguration does not have a method …
  • A REST controller declared with #[WpRestRoute] gets its constructor dependencies: it is resolved through the discovery’s instance pool (Laravel’s container in a Pollora application) instead of new with no argument, so a controller with a required dependency answered every request with Trying to invoke non static method … without an object

13.35.x

v13.35.6

· Fixed

Fixed

  • composer create-project pollora/pollora without a database finishes: pollora:install, run by the skeleton’s post-create-project-cmd, stopped with “Application environment is not configured. Aborting.” and exit code 1. Run by a Composer script, it now says which settings to fill and what to run, and exits 0; run by hand or in a deployment, it still fails, with the same hints (pollora#78)

v13.35.5

· Fixed

Fixed

  • A page template declared in the theme’s config/templates.php is rendered by its Blade view: WordPress puts the template slug first in the page hierarchy without extension (landing), which Pollora looked up as a file named landing instead of landing.blade.php, so page.blade.php answered (pollora#159)
  • Before the database is configured, the WordPress fallback route answers 503 instead of 500 (Call to undefined function wp_using_themes()): with APP_DEBUG, a “Pollora is not set up yet” page names the missing settings (DB_CONNECTION=mysql, DB_HOST, DB_DATABASE, DB_USERNAME, DB_PASSWORD) and the commands to run (pollora:env:setup, pollora:install, pollora:doctor); without it, the application’s or Laravel’s 503 page. Laravel routes keep working (pollora#78)
  • composer create-project pollora/pollora without a database no longer ends with a failing script (“Database name is required”): Composer runs pollora:env:setup without a terminal, which the command now treats as non-interactive, printing the settings to fill and the commands to run (pollora#78)
  • A theme, plugin or module whose Vite build is missing (npm absent, a failed build, public/build deleted) no longer takes the whole site down: every request, wp-login.php and wp-admin included, answered 500 Vite manifest not found because blocks resolve their scripts while WordPress boots. A container with neither a hot file nor a manifest now gives no asset URLs (blocks register without scripts, Asset::url() gives an empty string), the missing build is logged once per request and an admin notice names the manifest and the commands to run (npm run build, pollora:doctor) (pollora#79)

v13.35.4

· Fixed

Fixed

  • Update checks for modules installed by Composer ask the project’s repositories in Composer’s order and move on when one does not serve the package (401, 403, 404), Packagist last: a private composer repository listed first (SatisPress, paid plugins) answered for every package and a module from Packagist read “source did not answer” (#448). A repository’s exclude is honoured next to only, "packagist.org": false keeps Packagist out, and wpackagist.org is no longer taken for Packagist

v13.35.3

· Added, Changed, Fixed, Removed

Added

  • pollora:make:module Crm creates a lean module from the new Pollora/module-default template: classes discovered in app/ (an example hooks class, no service provider), resources/views/blocks, and a Vite build through @pollora/vite-config into public/build/module/<kebab>. Each Laravel layer is one flag away: --provider, --routes (implies --provider), --api (implies --routes), --config, --database, --tests, or --full; --no-assets for a PHP-only module. The module is enabled, composer dump-autoload merges its composer.json, and npm builds it (--no-enable, --no-npm). --repository and --repo-version pick another template; --offline, or a failed download, uses the copy bundled with the framework
  • module:make writes the same lean module, offline, unless the project’s config/modules.php sets paths or stubs (nwidart/laravel-modules’ own published file; Pollora’s, from --tag=pollora-modules, does not): the framework turns off nwidart/laravel-modules’ stock folders, files and classes and writes its bundled template once the module is created
  • Every enabled module with a vite.config.* gets its module.<kebab> asset container, so Asset::add(...)->container('module.crm') works without a provider of its own; it was set up only for modules with blocks
  • pollora:make:block recognises a vite.config.js built on @pollora/vite-config, which builds blocks already, instead of warning that it does not match the Pollora pattern
  • Module activation connectors: whether a Laravel module is enabled comes from a connector, through nwidart/laravel-modules’ activator ('activator' => 'pollora'), so module:enable, module:disable and everything reading app('modules') keep working. json (default) reads and writes modules_statuses.json as nwidart does; database keeps a JSON map in the non-autoloaded pollora_modules WordPress option, read with Laravel’s connection before WordPress loads (never unserialized) and written with update_option() once it has, falling back on json while the options table does not exist; config reads connectors.config.states or MODULES_ENABLED / MODULES_DISABLED, read-only. A project connector implements ModuleStateConnector and is declared in connectors.<name>.class, or given to ModuleConnectors::extend() in bootstrap/app.php
  • modules.locked.enabled / modules.locked.disabled (MODULES_LOCKED_ENABLED / MODULES_LOCKED_DISABLED) force a module’s state over any connector; switching a locked module throws ModuleLockedException
  • A switch clears nwidart’s provider manifest and the discovery cache, and fires ModuleEnabled / ModuleDisabled (module, source admin or console, WordPress user)
  • config/modules.php, published with php artisan vendor:publish --tag=pollora-modules: nwidart reads its activator while it registers, before any provider of the application, so the connector is chosen in this file, not from a provider
  • pollora:module:connector [connector] [--import] shows where module states live and copies them into another connector before the configuration points to it
  • pollora:doctor and Site Health check module activation (module-activation): the database connector reading its fallback, a module the states list but the disk no longer has, a state file that cannot be written while Plugins › Modules is the way to switch, a configuration or route cache written before the last switch, and MODULES_* settings ignored because config/modules.php is not published
  • pollora:module:frontend Crm gives an existing module the template’s frontend build (package.json and vite.config.js on @pollora/vite-config, resources/assets/app.{js,css}), keeping a .bak of each file it replaces; the builds check recognises the Vite config of nwidart’s stock module:make (public/build-<lower>, where Pollora never looks) and points to it
  • Plugins › Modules (plugins.php?page=pollora-modules, linked as “Modules (n)” among the plugin views): every module with its description, path, state (enabled, disabled, locked) and where the state lives, with Enable / Disable per row and as bulk actions. Switches need activate_plugins (modules.admin.capability), are nonce-protected, go through nwidart’s Module::enable() / disable() and say the change applies from the next request. A locked module has no switch; MODULES_ADMIN_TOGGLE=false turns every switch off. With the JSON file, the view warns that the next deployment resets it and each switch asks for confirmation; when the file cannot be written, switches are off and the view explains how to change states
  • Tools › Pollora’s Modules card and pollora:status say where module states are stored, and the card links to the Modules view
  • Update checks for modules installed by Composer: a module whose path is a Composer package’s install path (placed in Modules/ by the skeleton’s installer-paths rule, or scanned in vendor/) carries that package’s version, whatever its type; a local module has none and is never checked. The latest release comes from the repository the project’s composer.json declares for it — a composer repository (Private Packagist, Satis: {url}/p2/{package}.json), a GitHub vcs repository (latest release, else highest tag; MODULES_GITHUB_TOKEN for a private one), or Packagist — is cached per package for 12 hours (1 hour when the source does not answer), and is fetched by a daily WP-Cron task or pollora:module:outdated, never during a front-end request. Plugins › Modules shows “1.3.0 · 1.4.0 available” with the composer update command, Site Health tests “Pollora modules are up to date”, and pollora:status (--json too) gives each module’s version and latest; a dev-* build is never reported outdated
  • pollora:make:block --module=<name> creates a block in a module’s resources/views/blocks, named after the module in kebab case (blocks-demo/hero), like the seven generators that already took --module
  • AnsweringTemplate says which template the hierarchy answered a request with: template file, conditional tag, Blade view, whether it fell back to index. It stays empty when Route::wp() or a Laravel route answered, and works without WP_DEBUG, unlike the template marker
  • Pollora\WordPress\Events\WordPressBooting is dispatched right before wp-settings.php loads: the last moment to set something up before WordPress builds its globals. Listen to it from a provider’s register()
  • DiscoveryCacheManager::scans() says, for each location, whether its structures came from this process, the persistent cache or a scan, with time and count. A cold and a warm persistent cache used to both count as a miss
  • Pollora\BlockBinding\Domain\Events\BindingResolved is dispatched for each block binding resolved, with its source, field, post, time and whether the cache answered; only when something listens
  • AssetManager::containers() lists every asset container by name: the theme’s, plugins’, modules’

Changed

  • Requires pollora/hook ^1.5, for AbstractHook::all() (every registration made through Action and Filter) and the pollora/async/dispatched action, which debugging tools read

Fixed

  • Tools › Pollora and pollora:status reported 0 modules when one module.json had no priority: nwidart’s getPriority() is typed string and threw
  • Tools › Pollora and pollora:status showed every module as disabled: nwidart keys allEnabled() by lower-case name, which the module’s own name never matched
  • Generators with --module wrote into Modules/<Studly> under the Modules\<Studly> namespace whatever the module declared: they now take the path where nwidart/laravel-modules found the module and the namespace its composer.json maps onto app/ (or src/), so a module under Module\BlocksDemo\ gets classes it can autoload

Removed

  • The framework’s Modules/config/modules.php, merged into modules after nwidart/laravel-modules’ own config and so never applied (its module path pointed at the themes directory)

v13.35.2

· Added, Fixed

Added

  • Asynchronous actions in the framework (pollora/hook 1.4): Action::add(...)->async() can queue handlers as Laravel jobs. The queue driver dispatches a RunAsyncAction job on hooks.async.queue.connection (the default connection when null) and on the action’s onQueue() or hooks.async.queue.queue. auto, the default, tries the Laravel queue first once HOOKS_ASYNC_CONNECTION names the connection a worker runs (without a worker, jobs would never run, so the queue is opt-in), then Action Scheduler, then WP-Cron; a sync or null connection is always skipped. via('queue') and HOOKS_ASYNC_DRIVER=queue use the default connection. The job is tried once: retries are new jobs queued after the backoff, and the last failure lands in the failed jobs table. It also clears WordPress’s in-memory cache before each handler, since a worker lives across jobs
  • config/hooks.php, published with php artisan vendor:publish --tag=pollora-hooks: default driver (HOOKS_ASYNC_DRIVER, sync in a developer’s .env runs every handler at once), attempts, backoff, as_user, queue connection and name
  • #[Async], next to #[Action], makes a method asynchronous with the options of ->async() as named parameters: delay, via, onQueue, unique (true or the lock duration), tries, backoff, asUser, capture and when (public methods of the class), keepMissing, except. On a class it applies to every #[Action] method, and a method’s own #[Async] replaces it. A declaration that cannot be honoured (a hook in except the method does not declare, a missing or non-public capture/when method, invalid attempts, backoff or lock) is logged and the action runs synchronously; #[Async] on a #[Filter] or without #[Action] is logged
  • pollora:doctor and Site Health check asynchronous actions (async-actions): an ignored #[Async] (now kept, not only logged), an unavailable default driver (every handler then runs in the request) or via() driver, a HOOKS_ASYNC_CONNECTION that is undefined or sync/null, WP-Cron events overdue for an hour while WP-Cron or Action Scheduler is in use (Pollora sets DISABLE_WP_CRON: a system cron must request wp-cron.php), jobs of a database queue waiting 15 minutes for a worker, and payloads or unique locks the daily recovery task left behind
  • pollora:make:action --async generates the method with #[Async] and its import, in a new class or added to an existing one
  • pollora:async:list lists the asynchronous actions (hook, priority, handler, driver, delay, attempts and backoff, unique lock, queue, as user), which drivers are available in this request, and the default driver with where it comes from (HOOKS_ASYNC_DRIVER, the POLLORA_ASYNC_DRIVER constant, the pollora/hook/async_driver filter, or auto and the drivers it tries); --json for scripts
  • Async handlers in the framework: debug mode follows app.debug, incidents go to the Laravel log, closures are signed with the application key, Eloquent models travel by class and key and are reloaded at execution, and parameters typed with a service are resolved from the container

Fixed

  • pollora:make:action and pollora:make:filter were registered as pollora:make:action {name} and pollora:make:filter {name}: the console reached them by prefix, but Artisan::call('pollora:make:action') did not find them
  • The method generated for a hook with separators read handleSavepost for save_post: it is now handleSavePost
  • Errors met while registering hooks discovered by attribute went to no logger: HookDiscovery now receives the application’s logger
  • Login screen: the language switcher’s label (“Language” and its icon, shown when a second language is installed) sat at the left edge of the window, far from its dropdown. The card style given to the login form also reached the switcher’s form and made it a full-width block; it is an inline block again, as in WordPress’s own sheet
  • Login screen: the rules for the buttons were written .pollora-login .wp-core-ui …, but both classes are on <body>, so they never matched. The language switcher’s button kept wp-admin’s blue instead of the theme’s primary colour, and the submit button kept WordPress’s button-large padding

v13.35.1

· Security, Removed, Fixed, Changed

Security

  • WordPress 7.1.3 is a security release (seven fixes, among them a stored XSS on the Comments screen and a second-order SQL injection in the WXR export). The skeleton installs it from v13.35.1; an existing project runs composer update johnpbloch/wordpress johnpbloch/wordpress-core. Pollora’s core patch still applies

Removed

  • Editor and tool files no longer tracked: .cursor/ and .windsurf/ rules from 2025 (superseded by CLAUDE.md and Nectar), a .claude/ plan, a 2023 .php-cs-fixer.cache, and the unused StyleCI and Code Climate configurations (style is checked by Pint in CI, coverage by Codecov)

Fixed

  • pollora:make:plugin no longer copies the template’s bin/ (its packaging script and tests) into the new plugin, as pollora:make:theme already did
  • A plugin that answers from template_redirect and includes the theme’s query template itself (include get_query_template('404'), WooCommerce’s Review Order page) printed the Blade source of the view: the {type}_template filters now hand back a loader that renders it while template_redirect runs (#419)
  • template_redirect ran before the application’s providers had booted — WordPress is loaded from a provider’s boot, the theme’s providers boot after it — so a view rendered from it lacked the theme’s view composers and shared data. It now runs once every provider has booted, still before routing, and pollora_loaded after it (#419)
  • Trackbacks answered 500: wp-trackback.php was required from a method, where it found no $wp and loaded WordPress a second time (#419)

Changed

  • README: the organization’s banner and badges (CI instead of Codecov), installation first, the newer features listed (typed meta, roles, blocks and Block Bindings, pollora:doctor), and the type coverage check under Testing

v13.35.0

· Added, Changed

Added

  • pollora:doctor and Site Health check every Block Binding written in the templates, template parts and patterns of the theme, the Pollora plugins and the modules: a source that is not registered, a field the source does not have, a meta no #[Meta] declares, a meta or an option the source may not show (not in REST, protected, not public, not listed in block-bindings.options), an attribute WordPress does not bind for that block, and a block.json whose pollora.bindings lacks render or lists an undeclared attribute. Each of these left the block with its saved content, silently. Content stored in the database is not read
  • pollora:doctor and Site Health check typed meta: a #[Meta] declaration discovery refused (until now only logged, its meta never registered), a post type or taxonomy named by #[PostMeta]/#[TermMeta] that does not exist, meta marked showInRest on a post type or taxonomy that is not in REST, and stored values that cannot be read as their type (sampled: they read as the default)
  • pollora:doctor and Site Health check roles: users still carrying a role removed from the code (named, with the users), a default_role naming a role that no longer exists (new users get no capability), capabilities given to users one by one outside the declared roles, and what the role declarations could not apply (until now only logged)
  • pollora:roles:list (--json): every WordPress role with its origin (declared by a class, modified by one, or stored), its number of capabilities and of users
  • pollora:roles:show {role} (--json, a slug or a #[Role] class): the effective capabilities of a role, each with where it comes from (inherited, granted by the class, by #[ModifyRole], by the super roles), and the capabilities the code removes
  • pollora:roles:prune (--reassign=, --force): takes roles removed from the code off the users who still carry them (WordPress’s remove_role() ignores a role it no longer knows, so through remove_cap()), gives the users left with no role the --reassign one, and deletes the copies of removed roles a plugin wrote back to the database. Shows the changes unless --force; refuses to leave a user with no role
  • pollora:roles:import {role} (--inherits=, --class=, --theme, --plugin, --module): generates a #[Role] class from a role stored in the database (add_role(), a role editor plugin); with --inherits, only the differences (#[Grants], #[Without]). Sensitive capabilities get allowSensitive: true and a note; capabilities stored as denied are listed and left out. Refuses core roles (use #[ModifyRole]) and roles the code already declares
  • pollora:roles:dump (--force): writes the roles as the code makes them into the {prefix}user_roles option, for tools that read the database without loading the site; what it writes is marked, so a role later removed from the code is still removed. Shows the changes unless --force
  • pollora:meta:list (--json): every typed meta by class, with the object it belongs to, its key, type and options; exits with 1 when discovery refused a declaration
  • pollora:meta:audit (--limit, --json): reads the stored values of every typed meta and names those that cannot be read as their type (a property whose type changed, a value written outside the meta API), with the objects concerned — exits with 1 then, for CI against a copy of production; and lists the keys stored on the project’s own post types and taxonomies that no #[Meta] declares, such as the old key of a renamed property
  • pollora:binding:list (--json): the Pollora binding sources, what each one offers (fields, the meta it may show by post type or taxonomy, the listed options), and the blocks whose attributes WordPress lets bind
  • In debug mode, a Block Bindings field slower than 50 ms is logged as a warning, with its source, its field and its post: every bound block of the page waits for it

Changed

  • Requires Laravel 13.35 (illuminate/* ^13.35)

13.34.x

v13.34.6

· Added

Added

  • Block Bindings sources declared in PHP (experimental): a class marked #[BlockBinding('acme/event')] is registered with register_block_bindings_source(), each public method marked #[BindingField] being a field a block chooses with "args": {"field": "remaining_seats"} (an __invoke() source receives every call). A field receives a BindingContext — the post or term of the block context, right in a query loop, the arguments, the bound attribute, post() and meta(Event::class) for typed meta — and any dependency the container resolves. Every source answers through one resolver, so none can forget its checks: nothing of a post the visitor cannot see (unpublished, password, read_post) or of a non-public term, text escaped where WordPress writes it as HTML, url fields sanitized, an HtmlString filtered like post content, a field that throws logged and the block keeping its content (thrown in debug mode), each value computed once per request. A declaration WordPress would reject or leave silently empty (name, missing or unsupported return type, field declared twice) is reported at discovery. pollora:make:binding generates a source
  • A server-rendered block becomes bindable by listing attributes under pollora.bindings in its block.json: the attributes are added to block_bindings_supported_attributes_{block} and the Blade view receives the bound value in $attributes. A block without render, or an attribute the block does not declare, is reported
  • Block Bindings sources for typed meta, formatted by their declared type: pollora/post-meta and pollora/term-meta (a term from the block context or the queried term) read a #[Meta] exposed in REST under a key that is not protected, as core/post-meta does; pollora/author-meta reads a user meta marked #[Meta(public: true)] only; pollora/option reads the options listed in block-bindings.options (none by default). A date shows in the site’s format and language (format for another), a number with the site’s separators (decimals), a boolean as Yes/No (true, false for other words), an enum by its label(), an array as a list, format: raw gives the stored value (a date in ISO 8601) and fallback the text of an empty meta
  • The editor side of Pollora’s binding sources: the block’s “Attributes” panel offers the fields of every #[BlockBinding] class (only on the post types it names) and, for pollora/post-meta, term-meta and author-meta, the meta of the post type being edited that the source may show (an attachment also to number attributes, for an image ID); pollora/option offers the listed options. A bound block shows its value in the editor, computed on the server by the same resolver as the page, escaped the same way and formatted in the site’s language whatever the user’s, through POST /wp-json/pollora/v1/block-bindings/resolve: one request for the blocks waiting for a value, allowed to who can edit the post (edit_posts without one). The values are read-only; the field’s label shows while a value loads or when there is none. The script is resources/js/block-bindings.js, printed inline after wp-blocks with no build
  • #[Meta(media: true)] on an int property marks an attachment ID: bound to an image, it gives the URL (size), the alternative text, the title or the caption depending on the attribute; its input control is Media. #[Meta(public: true)] marks a meta anyone may see

v13.34.5

· Added

Added

  • Input fields for typed meta, through a contract (experimental): #[Meta(control: Control::Color, group: 'Profile', hints: ['acf' => [...]])] describes the field in neutral terms, a control being derived from the type otherwise (Text, RichText with sanitize: 'wp_kses_post', Number, Toggle, DateTime, Select). A package implements MetaUiDriver and registers it with Meta::extend('acf', AcfDriver::class); the project picks it in meta.ui (none by default), and the driver receives each schema on init, with only the meta it supports. Meta::schemas(), Meta::schemaFor('post', 'event'), the MetaSchemasRegistered event, and MetaUiDriverConformance::check($driver) for driver authors. The framework names no field plugin
  • Arrays and data objects as typed meta: an array property declares its item type with items: 'int' (or a class) or a @var list<string> docblock, and is stored as one serialized array or, with single: false, one row per item (whereMeta() then matches a model by one of its items). A class with public typed properties (scalars, dates, backed enums) is stored as an array, never as a PHP object, and read back as an instance; absent, it reads as an instance with its own defaults. REST publishes items and properties schemas, so WordPress refuses an item or a property of the wrong type; strings inside are sanitized like a string meta
  • Typed meta: a post type declared with #[PostType] gets custom-fields support when one of its #[Meta] has showInRest: true, without which WordPress leaves meta out of its REST responses. A post type targeted by #[PostMeta] is left as it is
  • Typed meta validation: #[Meta(rules: ['min:0', 'max:5000'])] checks a value with Laravel’s validator, the type rule implied (integer for an int, so max compares numbers). A write from PHP (Meta::of()->set(), a model attribute) throws a MetaValidationException naming the meta; a REST write to a post, term, user or comment answers 400 with the message of the rule (params → meta.<key>) before anything is stored. Writes through WordPress’s own functions (update_post_meta()) are only sanitized
  • Typed meta for every object (experimental): #[PostMeta('product')] or #[PostMeta(['post', 'page'])] for post types the project does not declare, #[TermMeta('category')], #[UserMeta] and #[CommentMeta] (every comment type: WordPress has no per-type comment meta). Meta::of() reads and writes them by object ID; a key two classes declare for the same objects is refused at discovery
  • Typed meta on the Eloquent models (experimental): Pollora\Models\Post, Page, Term, User and Comment read the #[Meta] their object carries as attributes, with their PHP type ($event->capacity, or by key $event->sold_out), check a write at once and store it through update_metadata() when the model is saved; whereMeta('capacity', '>=', 100) compares numbers as numbers. A post model with protected $postType = 'event' is bound to its post type at discovery, so Post::find() returns it. A class known to carry typed meta stops eager loading the meta relation and primes WordPress’s meta cache once per collection (one query instead of the relation); other models and undeclared keys keep Colt’s behaviour
  • Roles in Laravel (experimental), a role being named by its slug or by the class of a #[Role]: hasRole(), assignRole(), removeRole() and roles() on Pollora\Models\User (trait HasRoles; writes go through WP_User, an unknown role is refused); the role: route middleware (role:event_manager,editor, or EnsureUserHasRole::using(EventManager::class)), which refuses with a 403 a user who has none of the roles, an alias the application already uses being kept; @role accepts role classes (@role(EventManager::class)) and keeps the behaviour of Sage Directives’ @role for slugs
  • REST permission Can for #[WpRestRoute] and #[Method]: permissionCallback: new Can('edit_posts'), a #[CapabilitySet] enum case, or new Can('edit_post', parameter: 'id') to check a meta capability on the object in the request. permissionCallback now accepts a Permission instance as well as a class name; a refusal answers 401 to a guest and 403 to a logged-in user
  • Translated role labels: #[Role(…, textDomain: 'my-theme')] translates the label with that domain wherever WordPress shows role names (translate_user_role(): users list, role dropdowns). Translation happens when the admin displays the role, through gettext_with_context_default, so no translation is loaded early; a label WordPress already translates is left alone

v13.34.4

· Added, Fixed, Changed, Removed

Added

  • Typed meta (experimental): a public typed property of a #[PostType] or #[Taxonomy] class marked #[Meta] is registered with register_meta() — type, default, sanitization, REST schema (dates as date-time, enums as enum), capability as auth_callback, revisions. Meta::of(Event::class, $postId) reads each meta with its PHP type (int, float, bool, string, dates, backed enums) and writes through WordPress’s meta API (->fill([...])->save()). A declaration WordPress cannot register (union or array type, no default, protected key in REST without a capability, a key declared twice) is reported at discovery with the class and property named. The API may change before it is declared stable
  • Roles declared in code (experimental): #[Role('event_manager', inherits: 'author')] with #[Grants], #[Without], #[GrantsPostType(Event::class, Access::Editor)] and #[GrantsTaxonomy]; #[ModifyRole('editor')] for roles the project does not own; #[CapabilitySet] enums for the project’s own capabilities; pollora:make:role. Roles are injected into WordPress on wp_roles_init, never written to the database: the code is the only source of truth, a role or a capability removed from the code is gone even after a plugin wrote the roles back. The roles in roles.super_roles (administrator) receive every declared capability, so a post type with #[CapabilityType] no longer disappears from the admin. Sensitive capabilities need allowSensitive: true; a core role cannot be redeclared, a super role cannot be inherited from

Fixed

  • WordPress capabilities answer Laravel’s authorization again: $user->can('edit_posts'), Gate::allows('edit_post', $post), @can and the can: middleware. The Gate::after() bridge to user_can() was only added when WordPress was already loaded, which it never is when providers register, so every WordPress capability was denied. The bridge now converts the Gate’s user (Pollora\Models\User, WP_User or ID) and Eloquent model arguments for user_can(), and Pollora\Models\User uses Laravel’s Authorizable (can(), cannot()). Abilities defined with Gate::define() and policies keep priority (#390)

Changed

  • Dependency minimums: pollora/ajax, pollora/hook, pollora/option ^1.1, laravel/prompts ^0.3.24 (#394)
  • Discoveries also receive the enums that carry attributes (needed by #[CapabilitySet]); enums without attributes are still skipped

Removed

  • src/Theme/Infrastructure/Services/Directives.php: @usercan, @template and @gravityform were never registered (the file was loaded nowhere, and @usercan called a User::current() that does not exist). Use @can for capabilities

v13.34.3

· Fixed

Fixed

  • Each discovered item is applied once per request. The engine applied every discovery again for each scanned location and module engine (5 times per request on a typical project), with all the items found so far: each #[Schedule] task had 5 callbacks on its cron hook and ran 5 times per cron run, each #[WpRestRoute] route exposed 5 identical endpoints, cron_schedules and init collected duplicate closures. Measured on a project with WooCommerce: apply() time per request 6.6 ms → 2.6 ms, 80 fewer hook callbacks; registered post types, taxonomies, REST routes, cron events, WP-CLI commands and rendered pages unchanged (#386)

v13.34.2

· Security, Fixed

Security

  • pollora/colt ^10.0.1: meta and option values are unserialized without allowing classes, so a tampered value can no longer instantiate PHP objects (Pollora/colt#1)
  • The api_plugins bootstrap reads active_plugins with unserialize() restricted to no classes: a tampered option can no longer instantiate PHP objects (#382)

Fixed

  • saveMeta() and createMeta() on Pollora\Models go through update_metadata() / add_metadata() when WordPress is loaded: sanitize callbacks, meta hooks and object cache invalidation now apply, and get_post_meta() no longer returns the previous value under a persistent object cache (Pollora/colt#1)
  • $post->acf, $term->acf and $user->acf no longer end in a fatal error: Colt’s ACF trait referenced a class that was never shipped (Pollora/colt#1)

v13.34.1

· Removed, Fixed

Removed

  • The use_default_wp_theme_directory key of config/wordpress.php. Nothing ever read it: setting it to true changed nothing, and themes always live in themes/ (#297)

Fixed

  • Under WordPress 7, a classic theme’s block styles and global-styles were printed at the bottom of every page, after the content they style — a flash of unstyled content on slow connections — and the head kept two empty placeholders. WordPress loads those styles on demand at wp_footer, then moves them back into the head through its template enhancement output buffer, which only starts when template-loader.php includes a template: a Blade page includes none. A WordPressTemplateEnhancement middleware now plays the buffer’s part on the response — wp_template_enhancement_output_buffer_started before the view renders, the wp_template_enhancement_output_buffer filter and wp_finalized_template_enhancement_output_buffer on the HTML — for Route::wp() routes and the template hierarchy, so any plugin built on that filter sees Pollora’s pages too. A plain Laravel route that prints wp_head()/wp_footer() can add the middleware itself
  • pollora:install without a terminal — --no-interaction, CI, or pollora new driving it — stopped on “Site title is required” unless every option was passed: the prompts it could not show were still required. It now fills what is missing with a working local site — the project name as title (the first label of the APP_URL host: under DDEV the directory is always html), admin at admin@<APP_URL host>, a generated password shown once (also with --install), en_US, not indexed — and keeps every option it is given
  • pollora:status and the dashboard reported a post type or taxonomy under a slug derived from its class name, ignoring the attribute: #[PostType('synthese-presse')] class SyntheseDePresse was listed as synthese-de-presse, a post type that does not exist, and its plural label was ignored too. Both read the attribute now, through PostType::resolveSlug() / Taxonomy::resolveSlug(), the rule discovery registers with, so they cannot disagree again (#298)

v13.34.0

· Fixed

The first stable release since v13.4.4, on Laravel 13.34. It gathers every change from v13.32.0-beta to v13.34.0-beta.2 below; coming from 13.4, read those entries, or run Nectar’s upgrade-pollora-v13-32 prompt (full comparison).

Fixed

  • A plugin with neither app/ nor src/ — one that only ships blocks, which need no class — was discovered from its root, node_modules included: 2 to 7 seconds on every request in debug mode, measured on a blocks-only plugin with a Vite build. Its other top-level directories are scanned instead, never node_modules, vendor, bower_components, build, dist, public, resources, assets, languages, lang or a hidden directory

v13.34.0-beta.2

Pre-release · Added, Fixed, Changed

Added

  • pollora:doctor: checks a project for the failures that stay silent — the site renders, the command exits 0 — and prints, under each, the command that fixes it. Each check comes from a failure met in practice: WordPress core not patched or __() not Pollora’s; patches.lock.json missing or older than the framework’s patches; .env names Pollora does not read (DB_NAME, WP_HOME…) or MySQL settings on a sqlite connection; configuration or routes cached outside production; classes missing from the discovery cache; for the theme, every Pollora plugin and every enabled module: a build missing, written to another folder than Pollora reads, or a hot file pointing at a dev server that is stopped or not exposed, a directory symlinked under another name, %theme_*%/%plugin_*% placeholders or .stub files left from a copied template, blocks still in the legacy resources/blocks; pattern files WordPress never registers or has not cached; Route::wp() routes answering in place of a block theme’s templates. --json for scripts; exits 1 on an error
  • The same checks in WordPress’s Site Health (Tools › Site Health), with a “Pollora” badge, plus one that only a web request can make: every block of the theme, the Pollora plugins and the modules is registered. That is the boot a visitor gets — blocks were once registered under WP-CLI but not over HTTP, which a console check would have passed

Fixed

  • Deleting a navigation menu (wp menu delete, or the Menus screen) raised a TypeError once the menu was already gone: delete_nav_menu is the delete_{$taxonomy} hook, which passes the term ID first, and the listener expected a WP_Term. MenuDeleted now receives the menu WordPress copied before deleting it
  • While Vite ran hot, its client was enqueued with WordPress’s version appended (@vite/client?ver=7.1.2). The modules Vite serves import /@vite/client by its bare URL, so the browser loaded the client twice, as two modules with two HMR connections. It is enqueued with no version, like the entries (regression from v13.34.0-beta)
  • On a branch install (dev-develop, 13.x-dev), Site Health and the admin notice announced “Pollora 13.4.4 is available”: version_compare() ranks a branch name below every release. A development build is no longer compared with releases — Site Health says it is one, the notice stays silent — and the dashboard, the admin menu badge and pollora:status share that one rule, which they each duplicated and missed 13.x-dev. Site Health’s info tab now labels the compared version “Latest stable version”, since pre-releases are not counted

Changed

  • pollora:make:theme activates the generated theme only where the site needs one. A site with no usable theme — a first install — gets it without a question; a site that already has one keeps it unless the answer is “yes”, now the default “no”, so --no-interaction never replaces a working theme. --activate and --no-activate settle it without asking, and pollora:install passes --activate. Activation goes through switch_theme(), which fires switch_theme and after_switch_theme; the options were written directly before, so those hooks never ran

v13.34.0-beta

Pre-release · Added, Fixed, Changed

The framework’s version tracks Laravel’s: this beta requires Laravel 13.34.

Added

  • A third pollora:make:theme template, Magazine (magazine → pollora/theme-buzz): a Full Site Editing block theme whose templates, parts and patterns are edited in the Site Editor, next to default and ecommerce. The missing-theme page and admin notice list it too

Fixed

  • A Vite script was printed before WordPress’s import map, which Firefox and Safari then ignore: any WordPress script module on the page — the navigation block’s, the search block’s, the image lightbox’s — failed on @wordpress/interactivity was a bare specifier, so the block did nothing. Chromium tolerates the order, which hid it. In a classic theme the import map is always in the footer, so any theme with a Vite script in the head was affected as soon as an author inserted such a block. The Vite client of the dev server had the same problem
  • A block theme’s own 404.html answered with HTTP 200. WordPress core resolves it to wp-includes/template-canvas.php, which is never a Blade view, so it always rendered through FrontendController’s raw-PHP-template branch — the only branch that never looked at is_404(). Measured on a fresh block theme: right content, wrong status
  • A real 404 lost its error404 body class, and every page served by the template hierarchy carried a meaningless one built from its path (any-no-such-page). The WordPressBodyClass middleware was meant for Laravel routes, which WordPress’s own resolution calls a 404, but it only ran on WordPress routes — the {any} fallback included — where WordPress’s verdict is the right one. So it did the opposite of its job on both sides: a Laravel route (Route::get('/dashboard/{tab}')) kept error404, is_404() true and a “Page not found” title over its 200 response

Changed

  • Requires Laravel 13.34: illuminate/* ^13.34 (was ^13.32). Measured on laravel/framework v13.34.0: the full suite, Pint, PHPStan and Rector pass unchanged
  • The WordPressBodyClass middleware is replaced by a RouteMatched listener, ApplyApplicationRouteContext, which runs on every route: a route WordPress answers (Route::wp() and the template-hierarchy fallback, both flagged isWordPressRoute()) keeps WordPress’s classes and verdict untouched; any other route has is_404() cleared and its URI segments added as body classes (dashboard tab-settings). A middleware could not do this — Laravel routes are not given the WordPress middleware stack
  • On the front end and in the admin, a Vite script is enqueued as a WordPress script module (wp_enqueue_script_module), so WordPress places it after its import map, as it does its own modules: in the head of a block theme (the footer with loadInFooter()), always in the footer of a classic theme. What a module cannot take — dependencies(), localize(), inline() — goes on a classic companion script, {handle}-data, which runs before the module. The editor, login screen and Customizer are unchanged

13.32.x

v13.32.0-beta.9

Pre-release · Added, Fixed, Changed, Removed

Added

  • <InnerBlocks /> in a block’s render.blade.php: the block’s inner blocks are edited in place in the editor, inside the rendered template, and printed in place of the tag on the page, in a div carrying the tag’s class (pollora-inner-blocks by default). The tag takes Gutenberg’s inner blocks options — allowedBlocks, template, templateLock, orientation… — as attributes, JSON for arrays and objects. Modelled on ACF’s <InnerBlocks />. A render.php template gets it too
  • The block editor runtime window.pollora.blocks (script handle pollora-block-editor, a dependency of the editor script of every block with a render template): bladeEdit(metadata) previews the template through the core block-renderer route and makes its <InnerBlocks /> editable; save stores the inner blocks. Shipped inline, as nothing under vendor/ has a public URL
  • $isPreview in a block template: true while it renders for the editor’s preview
  • develop is aliased to 13.x-dev (extra.branch-alias). Without it, dev-develop satisfied no version constraint: a project on dev-develop could not install a package requiring pollora/framework ^13.0 — pollora/nectar 1.1 does — without an inline alias of its own

Fixed

  • pollora:make:block --inner-blocks made a dynamic block whose inner blocks were neither editable in its preview, saved in the post, nor printed by its template. It now writes <InnerBlocks /> in render.blade.php
  • TemplateMarker’s documentation no longer says every response goes through template_include: responses from Route::wp() and Laravel routes bypass it and carry no marker, as the hierarchy browser tests assert
  • “Validate Changelog” no longer fails the pull request of every release. It required a non-empty [Unreleased] on any pull request to main, which a release from develop or release/* has emptied into the version’s section by construction; it now checks hotfixes only

Changed

  • pollora:make:block generates dynamic blocks on the runtime: edit.jsx is window.pollora.blocks.bladeEdit(metadata) instead of ServerSideRender, save is window.pollora.blocks.save instead of () => null, and @wordpress/server-side-render is no longer added to package.json. Blocks made before keep working
  • The framework no longer declares the wpackagist repository, from which it required nothing. Composer still fetched its metadata on every install, so a wpackagist network error failed the build — measured: the nightly of 2026-09-27 failed “Code Quality” on curl error 56 from wpackagist.org
  • The installed package no longer carries the test suite, the CI workflows and the tooling configs: .gitattributes leaves them out of the archive Composer installs. The browser tests stay reachable by cloning the repository, which is how theme CI fetches them

Removed

  • get, a grep output committed by mistake

v13.32.0-beta.8

Pre-release · Added

No change to the framework’s code: this beta ships the browser test suite that now guards it, 73 tests per browser.

Added

  • Browser tests of the template hierarchy. Two fixture themes: one has a template for every case, the other index.blade.php alone. Each URL is read in the framework’s template marker, in the template’s own output and in the HTTP status: front-page, home, page-{slug}, page-{id}, a custom page template, page, single, single-{type}, archive-{type}, archive, taxonomy-{tax}-{term}, taxonomy-{tax}, category-{slug}, tag, author-{nicename}, date, search, and 404 with a 404 status; a Blade view over a PHP template of the same name; Route::wp() and Laravel routes over the hierarchy. With index alone every case falls back to it, and an unknown URL still answers 404. Replayed: without the 404 view, or with the marker disabled, the suite fails
  • Browser tests of the framework’s features, through a fixture plugin that declares each by attribute and checks it by its effect: #[Filter] and #[Action], a #[PostType] (REST type, archive, admin menu), #[WpRestRoute] (a public route; an IsAdmin one that refuses a visitor and answers an administrator), #[Ajax] for visitors and logged-in users, a script enqueued through the Asset facade, every script and stylesheet of the home page loading with nothing over plain http://, get_theme_file_uri() giving the active theme’s built entry a URL that answers, no server path in the page a visitor gets, the theme’s menu locations and login screen, and __() sending a text domain to WordPress’s catalogues and replacements to Laravel. Replayed: with the v13.32.0-beta.6 theme URI fix undone, or with WordPress’s side of __() disabled, the suite fails
  • The browser tests run in Firefox and WebKit as well as Chromium every night, and on a manual run of the workflow (E2E_BROWSERS). Pull requests keep Chromium alone. The schedule runs from main, so it starts with this release

v13.32.0-beta.7

Pre-release · Fixed, Changed

Fixed

  • pollora:make:block refuses a theme or plugin that cannot build a block, and says why. A plugin made without assets has neither package.json nor vite.config.js: the block was written anyway, could not be built, and the npm install the command advised walked up to the site’s own package.json and installed there. It now stops before writing anything and names the missing files
  • pollora:make:plugin --asset includes the asset files. The option takes a value, so the bare flag read as null, which the defaults applied without a terminal turned into false: --asset alone left the assets out. --asset=false still leaves them out, and the other options keep their defaults
  • A block title holding a quote (--title="Owner's Hero") no longer breaks the JavaScript pollora:make:block writes. render.blade.php escaped it; edit.jsx and save.jsx printed it raw inside a single-quoted string, so the block failed to build
  • A block’s editor script depends on every WordPress script its code imports. BlockRegistrar gave each editor script a fixed list — wp-blocks, wp-element, wp-block-editor, wp-i18n — while @roots/vite-plugin turns every @wordpress/* import into a global and records the matching handles in editor.deps.json. A block importing @wordpress/components or @wordpress/server-side-render worked only when something else happened to load that script. The handles in the build’s editor.deps.json are now added to the defaults; in dev mode, which has no build, the defaults stand
  • Blocks shipped by themes, plugins and modules exist in the block editor, on the page and in the REST API. They were registered by a BlocksServiceProvider of the module’s own, and over HTTP no shape of that provider works: WordPress is loaded, and init has fired, before theme and plugin providers boot, so the provider pollora:make:block wrote — hooking init from boot() — was never called, and a REST request is answered before those providers boot at all. Blocks existed in WP-CLI only, which is where they had been checked. Measured on a fresh install: theme-default’s hero and call-to-action were missing from the editor and from /wp/v2/block-types. The framework now registers every module’s resources/views/blocks (and the former resources/blocks) itself on init, from a hook set while it boots — before WordPress loads — and creates the asset container of a Laravel module that ships blocks. pollora:make:block no longer writes a provider. A BlocksServiceProvider kept from an earlier release is harmless: a block WordPress already holds is skipped. Covered by browser tests that insert each block in the editor, reload it, and find it on the published page
  • Themes and plugins keep working on a site whose autoloader was dumped with --classmap-authoritative. Their namespaces (Theme\…, Plugin\…) were added at runtime to Composer’s root loader, and an authoritative loader answers from its classmap alone: it never looked at them, so every front-end page answered 404 (Class "Theme\Apiary\Walkers\MenuPrimary" not found) while wp-login.php still worked. Module namespaces now live in a class loader of their own, registered after Composer’s, and shared by the theme and plugin autoloaders under the ModuleAutoloader::CLASS_LOADER container key. It has no vendor directory, so it stays out of ClassLoader::getRegisteredLoaders() and cannot move Application::inferBasePath(). Measured on a live site in both modes: pages, the PHPUnit and HTTP suites, and the theme sweep all pass. The root loader is no longer bound to Composer\Autoload\ClassLoader in the container as a side effect
  • php artisan test, and anything else that asks Laravel for its base path, no longer resolves it to a plugin’s directory. ModuleAutoloader::register() registered the root Composer loader again although it was already active, and Composer answers that by moving it to the end of ClassLoader::getRegisteredLoaders() — behind the loader of any plugin shipping its own vendor/, such as Query Monitor. Application::inferBasePath() reads the first entry of that list, so on such a site 38 of 40 of its PHPUnit tests failed opening plugins/query-monitor/bootstrap/app.php. Composer’s InstalledVersions::getRootPackage() read the same list and reported the plugin as the root package, over HTTP, in artisan and in WP-CLI. Namespaces added with addPsr4() take effect on an active loader, so the loader is now only registered when it is not already. The bug dates back to June 2025 and shipped in v13.4.4
  • patches/mockery-php84-nullable.patch is back on main, byte for byte as v13.4.4 shipped it. The v13.4.x line declares that patch by the URL refs/heads/main/patches/mockery-php84-nullable.patch, and a released composer.json cannot change; removing the file from main on 2026-09-17 made the URL answer 404, and composer-patches v1 skips a patch it cannot fetch with only a warning — so every v13.4.x install since went without it. Nothing on the 13.32 line references the file: its patch URLs are pinned to commits
  • The patches this package asks its consumers to apply are pinned to the commit that produced them, instead of being served from refs/heads/main. A released composer.json cannot be changed, so a branch URL moves under every version already published: removing mockery-php84-nullable.patch from main on 2026-09-17 turned it into a 404 for every v13.4.x install, which composer-patches v1 skips with only a warning. With composer-patches v2 a moved patch is worse — its checksum no longer matches patches.lock.json and the install fails. A Patches CI job now proves each URL pins a commit in the branch’s history whose file matches the working tree. Versions already released keep the URLs they shipped with
  • Generators write a theme’s, plugin’s or module’s classes where its autoloader reads them. The autoloaders map a namespace onto app/ when it exists and onto src/ otherwise — one directory, never both — while every --plugin, --theme and --module generator wrote into app/ unconditionally. On a target keeping its classes in src/, that was worse than one misplaced file: creating app/ flipped the autoloader and discovery over to it, and every class already in src/ stopped being loaded. They now resolve the directory with the autoloaders’ own precedence, and a target with neither still gets app/
  • The BlocksServiceProvider the scaffolder writes registers its blocks on init, which is when WordPress accepts block registrations at all. It called registerDirectory() straight from boot(), and providers boot before WordPress has defined register_block_type() — BlockRegistrar answers that by returning immediately, with no error and no notice, so the blocks simply never existed. theme-default hit this, shipped v1.4.0 with it, and fixed its own copy by hand; the stub that writes every other provider kept the broken shape, so each new theme and plugin was born with the bug
  • pollora:make:block writes the BlocksServiceProvider when the target has none. A blocks directory that is not empty was taken as proof that the infrastructure was in place, and it usually is — but blocks registered by something else live there too, and none of them needs the provider that registers Vite-built blocks. In a target like theme-apiary, whose only shipped block is an ACF one, every block ever scaffolded was written to disk, built by Vite, and registered by nobody: nothing failed, nothing reached the log, and the block simply never appeared in the editor — permanently, since the directory only gets less empty. Measured on a live site, then pinned end to end in the theme’s CI. Only the provider is created; the npm dependencies and the initial Vite patch still belong to a genuinely first block
  • composer install and composer update no longer fail on a Pollora site that has no terminal. pollora:env:setup runs from composer’s post-autoload-dump hook, so it fires inside container builds, deployments and CI; when the database was not reachable it reached for Laravel Prompts, which throws where there is nothing to prompt, and composer exited 1 reporting a prompting problem rather than a database one. Nothing in that command is a gate — pollora:install is what refuses to continue without a database — so with no terminal it now names what is wrong, names the command to run once the database is up, and lets composer finish

Changed

  • The block editor shows what the page shows for a block made by pollora:make:block. A dynamic block’s edit.jsx renders render.blade.php through ServerSideRender for the block’s current attributes, and a static block’s mirrors the markup save.jsx writes; both used to show a placeholder (”… – Block Editor”) the page never displayed. A block with --inner-blocks keeps the InnerBlocks editor, which a server render cannot provide. @wordpress/server-side-render joins the npm dependencies added with a first block. Checked in a browser: the preview holds the rendered text, and the old stub fails the same test
  • cweagans/composer-patches moves from ^1.7 to ^2.0. It is the plugin that applies the WordPress l10n patch — renaming WordPress’s __() to __wp() so Laravel’s helper can have the name — on every Pollora site. Measured before merging: on a fresh install, v2 resolves the framework’s patch as a dependency patch and applies it, and the skeleton’s check that WordPress core carries it passes. Two things change for a project. v2 writes a patches.lock.json recording each patch’s sha256, and on a machine without the patch cached it downloads the patch again and fails with HashMismatchException when the file no longer matches — so a patch served from a moving URL can break fresh installs of a project that locked an earlier version. And the skeleton’s enable-patching option is no longer read: v1.7.3 checked it and defaulted to off, v2 resolves dependency patches unconditionally
  • The commit-hook tooling is declared where it belongs. @commitlint/cli, @commitlint/config-conventional, husky, lint-staged and prettier sat under dependencies rather than devDependencies, so every advisory in their tree was reported against this repository at runtime scope — ten high-severity alerts describing packages no Pollora site has ever loaded. Nothing installs differently: npm ci installs devDependencies by default, and the commit hook was checked after the move
  • Every open npm advisory clears: fast-uri moves to 3.1.8 and js-yaml to 4.3.2, past the 3.1.6 and 4.3.2 that patch them. npm audit goes from 2 high-severity vulnerabilities to 0
  • The contribution guide documents the pull request title convention. CI validates the title of every pull request against the conventional commit format, and rejected one said only that the check had failed — a rule enforced on a first contribution and published nowhere. The allowed types are listed, along with the fact that Validate Changelog only runs on release pull requests into main and never concerns a contribution to develop

v13.32.0-beta.6

Pre-release · Fixed

Fixed

  • get_theme_file_uri() answers the URL the build gave a theme file, instead of an empty string. It returned '' for every path there is — measured on a live site, on the front end as much as on wp-login.php. WordPress hands the theme_file_uri filter both the URL it built and the file it was asked for; the file was thrown away and rebuilt by subtracting get_stylesheet_directory_uri() from the URL, then handed to the asset resolver, which prefixes the container’s own root a second time. resources/assets/app.js was looked up as resources/assets/resources/assets/app.js, never found, and the failure was logged and swallowed — one line in laravel.log per call. Both spellings now resolve: the path from the theme root a caller would write, and the path relative to the container root the manifest is keyed on. A theme’s own directory is not web-served on a Pollora project — measured, /themes/… and /content/themes/… both 404 while /build/theme/… serves — so the build is the only address a theme file has. Anything the build does not know about is handed back untouched rather than emptied
  • The server’s filesystem path no longer reaches the public HTML. get_theme_root_uri() can only turn a theme root into a URL when it sits under WP_CONTENT_DIR; a Pollora project registers its themes at the project root, and for a root it cannot map WordPress returns the path verbatim — so get_stylesheet_directory_uri() answered /var/www/html/themes/apiary, and WordPress’s speculative-loading rules printed it into the <head> of every front-end page. Measured: one occurrence per page before, zero after. Only an answer that is not a URL is replaced, so a project keeping its themes under content is untouched

v13.32.0-beta.5

Pre-release · Added, Changed, Fixed

Added

  • The login screen wears the theme’s design, from the theme’s own theme.json. WordPress loads the theme on wp-login.php but emits none of its design there — measured: zero occurrences of wp--preset--color in the HTML of a login screen — so every site logs in through the same grey form whatever it looks like elsewhere. A theme that ships a config/login.php now gets its colours, radii and typography printed on login_head, its own logo above the form, and its home page behind that logo instead of wordpress.org. Nothing is duplicated: the design stays in theme.json, and restyling a theme restyles its login screen. Sign-in, lost password, reset, register and the confirm-admin-email prompt are all covered, being one screen as far as login_head is concerned. Strictly opt-in — a theme with no config/login.php gets WordPress’s screen, byte for byte, so upgrading the framework never changes the page people sign in through. See Theming → Login screen
  • pollora/login/palette, pollora/login/logo, pollora/login/styles and pollora/login/credit filters, for a module or a plugin to take over any part of the login screen without touching the theme
  • Discovery says so when one location takes more than 250ms to scan, naming the location, the time and how many structures it found. The cost above was absorbed in complete silence for as long as it existed — no log line, no notice, nothing that measured it. Debug mode only: with the cache on, the cost is paid once

Changed

  • A theme’s config/login.php is loaded on init, like menus.php, sidebars.php and templates.php, so __() works in it. WordPress fires init through wp-load.php before wp-login.php fires login_init, so the config is in place well before anything reads it

Fixed

  • Attribute discovery no longer walks a plugin’s node_modules. Themes and modules have always been scanned at app/, falling back to src/ — the two directories the autoloader maps Plugin\{Name}\ onto — while plugins were scanned at their root, which is where node_modules/ lands as soon as a plugin has a Vite build. Symfony’s Finder enumerates every file before filtering by extension, so the walk costs everything and the extension check costs nothing: measured on a demo plugin with a block build, 69,741 files walked on every request to reach the three PHP files the plugin owns — 1,691 ms against 1 ms for the same directory without node_modules. It also discovered five WordPress core classes shipped inside @wordpress/style-engine and handed them to the discovery pipeline, which is its own kind of wrong. With APP_DEBUG on, discovery keeps no cache, so a site paid this on every request: the home page of a site with one such plugin went from 3.0s to 0.78s, and from 691MB of peak memory to 37MB under Blackfire. A plugin shipping neither app/ nor src/ is still scanned at its root, so one keeping its classes at the top level is unaffected

v13.32.0-beta.4

Pre-release · Added, Fixed

Added

  • Every page says which template answered it, as an HTML comment on wp_head, whenever WP_DEBUG is on. WordPress offers no way to see which template rendered a request short of reading the code and guessing, and a Blade hierarchy on top makes the guess harder — several files could plausibly have answered, and which one did is the whole question when a page comes back wrong. Themes had started marking their own views by hand, one at a time, and drifting: theme-apiary marks most of its templates and not its front page. This is derived from the template the request actually resolved to, so it cannot be forgotten, and it reaches every theme without one of its own. A comment changes no markup and no styling; nothing at all is emitted in production, and the path is relative to the project so it never says where the site lives on disk

Fixed

  • A failed starter download says what happened instead of raising a TypeError. make:theme and make:plugin fetch their template from GitHub and, when that fails, fall back to copying one bundled with the framework — except none is bundled: neither src/Theme/stubs/ nor src/Plugin/stubs/ exists. getTemplatePath() declared string and returned realpath()’s false, so a transient network failure surfaced as getTemplatePath(): Return value must be of type string, false returned, naming a method the user has never heard of and saying nothing about the download. Measured on CI the first time GitHub did not serve an archive. Both commands now fail with a sentence that names the cause
  • A REST controller declaring WP_REST_Request $request receives it. Handler arguments were built from the route parameters alone, so that type hint had get_param('request') looked up — no route declares a parameter by that name — and the method was invoked with null, fatalling on a TypeError before a line of it ran. Every endpoint whose handler asked for the request answered 500. A parameter type-hinted WP_REST_Request now gets the request; everything else still comes from the route, and builtin types are left alone since they name route values
  • WordPress’s own entry points answer their real status again. wp-login.php, wp-links-opml.php and the rest are run directly by PHP, with Pollora loaded along the way through wp-config.php; it resolved the URL as a content request anyway, and /cms/wp-login.php matches the attachment rewrite rule [^/]+/([^/]+)/?$. No such attachment exists, so WordPress sent a 404 header — and then rendered a perfectly good login form underneath it. The query now runs only when Laravel’s front controller is the script being executed, which covers any entry point WordPress or a project adds later without naming it. pollora_loaded still fires either way
  • /cms/ no longer answers with the source of a Blade template. The WordPress installation root is served by WordPress’s own index.php, whose template-loader.php includes whatever the template hierarchy hands it — and Pollora puts Blade sources in that hierarchy, since it renders them through Laravel. PHP printed one verbatim, directives and all. A front-end request that reaches that loader has bypassed Laravel and was looking for the site, so it is redirected to the home URL
  • make:theme and make:plugin download the highest version of a starter, not whichever tag GitHub listed first. That order follows what was pushed most recently, so a fix tagged on an older line — 1.2.1 published after 1.4.0 — would have been handed to everyone scaffolding, a downgrade with nothing to notice it by. Tags are now compared as versions, pre-releases lose to any stable version so tagging a beta does not push it onto people who asked for nothing in particular, and a tag that is not a version at all is left out of the comparison rather than winning it. A repository whose tags follow some other scheme keeps its previous behaviour. The request also asks for 100 tags instead of the default 30, which could leave the highest version on an unread second page

v13.32.0-beta.3

Pre-release · Fixed

Fixed

  • The block editor now shows the theme’s own styles, so a block looks in the back office much like it does on the front. Both default themes declare editor-styles support, but that support only tells WordPress how to treat the styles it is handed — it loads none, and nothing named any: theme assets are registered with toFrontend(), leaving the editor with theme.json’s variables and none of the rules built from them. The theme’s built stylesheets are read from its Vite manifest and passed to add_editor_style(), which is what reaches inside the editor iframe; enqueueing on enqueue_block_editor_assets lands in the admin page around it instead. Any theme declaring the support gets this, with no change of its own
  • Multisite is usable again. Bootstrap::rewriteNetworkUrl() is hooked to the network_site_url filter, which WordPress applies with a $scheme of null whenever no explicit scheme is requested — the common case — while the method declared a non-nullable string $scheme. Every request fatalled as soon as MULTISITE was enabled, the admin included. $path and $scheme now carry defaults matching the filter’s own signature; single-site installs never reach this path (#296)
  • pollora:install no longer leaves a site whose articles answer 404. It set the permalink structure and flushed, but the rule set WordPress can build mid-install is incomplete — taxonomies and post types are not all registered at that point — so flushing stored exactly that, and every single-post URL 404’d until something flushed again later. The option is dropped instead, letting WordPress rebuild it on the first request. This is the same reasoning completeWebInstall() already applied to the WordPress web installer; that hook is registered only outside the console, so the command-line install never went through it. Measured on a fresh install: 404 on an article before, 200 after
  • The missing-theme guidance page now reaches the case it was written for. It was wired only onto the exception handler, catching the View [home] not found that view() used to throw; since the skeleton stopped declaring WordPress routes the template hierarchy decides, nothing calls view(), nothing throws, and a site with no theme answered a bare 404 instead — the crash the page exists to replace, wearing a different status code. The request is now taken over on template_redirect, which WordPress fires before any template is chosen and which runWp() reaches before Laravel routes, alongside the existing handling for robots, favicons, feeds and trackbacks. The exception path stays for anything still routing through view(), and its registration no longer sits behind a guard that could skip the hook. The admin, AJAX and REST keep their normal responses: the admin is where the user goes to fix this
  • Blade templates now outrank the PHP stubs at a theme’s root. The root holds the files WordPress needs to consider the theme valid — index.php in particular, which ships as “Silence is golden” — and was registered as a view path ahead of resources/views, so locate() ranked its index.php above resources/views/index.blade.php. Every request the template hierarchy could not match to a more specific template (archives, search, custom post types, any single view without its own template) rendered that stub: HTTP 200 with an empty body and no error anywhere. Blade and PHP candidates are now collected separately so every Blade one wins, and view paths are registered in the order they are declared. A classic PHP template with no Blade equivalent is still used
  • Installing WordPress on a URL where a site already answers no longer dies with Class "WP_Http_Cookie" not found. wp_install() calls wp_remote_get() on the site URL and WP_Http builds a WP_Http_Cookie for every Set-Cookie header it gets back, but the install bootstrap loaded only part of the HTTP stack. It now loads the classes wp-settings.php loads, in its order. This affected reinstalls, migrations, and taking a domain back
  • wordpress.org no longer offers updates for the themes the project scaffolds. WordPress sends every installed theme to its update API keyed by the directory name, so a theme whose name matches a published slug is offered that unrelated theme — default, which pollora:install generates, matches one, and accepting the offer replaced the project’s theme with a download of the theme published there in 2005. Offers aimed at a theme in the project’s themes directory are moved to no_update. The Update URI header does not cover this on its own: WordPress consults the matching update_themes_{$hostname} filter only when wordpress.org returned nothing for that theme
  • A site installed through the WordPress web installer no longer answers 404 on every category, tag and date archive. The rewrite rules WordPress stores during its own install are incomplete — taxonomies and post types are not all registered at that point — and nothing regenerated them afterwards. The option is now dropped on wp_install, where the migrations already run, so WordPress rebuilds the rules on a later request
  • wp-admin no longer reports the active theme as missing while the front end renders it. get_stylesheet_directory() goes through the theme_root filter Pollora sets, but wp_get_theme() computes the root itself and no filter applies there. Registering Pollora’s themes directory replaced $wp_theme_directories instead of appending to it, and get_raw_theme_root() answers a hardcoded /themes whenever a single directory is registered, which wp_get_theme() then resolves against WP_CONTENT_DIR. WordPress’s own themes directory is kept alongside Pollora’s, and the stylesheet_root and template_root options now hold the directory containing the themes rather than the active theme’s own directory, which was one level too deep
  • A site installed through the WordPress web installer explains what to do instead of crashing. That path never runs pollora:install, so themes/ stays empty while the stylesheet option already points at WP_DEFAULT_THEME, and every front-end request died on View [home] not found. A missing view on a front-end request now renders a page naming the two theme templates and the command that scaffolds them, and wp-admin carries the same warning. It applies only while the site has no theme at all, so a headless install keeps working and a theme missing a single template still surfaces its real error

v13.32.0-beta.2

Pre-release · Added, Changed, Deprecated, Fixed, Removed

Added

  • pollora.dev as the project website and documentation: homepage and support.docs in composer.json (shown on Packagist), homepage in package.json, the README, and a Documentation link in the Pollora admin dashboard header
  • Gutenberg blocks render with Blade: a block.json "render": "file:./render.blade.php" renders through the view factory with $attributes, $content and $block, Blade components included. pollora:make:block now creates dynamic Blade blocks by default — their markup is not stored in post_content, so changing it never invalidates existing content — and --static creates a block with save.jsx
  • BlockRegistrar::registerDirectory() and registerBlock() accept an optional basePath, the Vite project root the asset entry points are resolved from; it defaults to the closest directory holding a vite.config file, or else the one containing resources/

Changed

  • Blocks live in resources/views/blocks/{slug} instead of resources/blocks/{slug}, next to the Blade views, for pollora:make:block, its BlocksServiceProvider stub and the Vite entries it generates. See Migrating from resources/blocks
  • pollora:make:block limits Vite full reloads under resources/views to Blade files: laravel-vite-plugin’s refreshPaths and a resources/views/** glob would reload the page on every block JSX change instead of hot-replacing it
  • BREAKING for custom BlockRegistrarInterface implementations: both methods gained the optional ?string $basePath = null parameter
  • Relicensed under MIT, like the other Pollora packages: composer.json and the README declared GPL-2.0-or-later, and the only license files were the 0BSD/WTFPL texts inherited from the original WordPress integration by Jordan Doyle, now credited in the README
  • Development against WordPress 7.1 stubs (php-stubs/wordpress-stubs ^7.1); patches/wordpress-stubs.patch regenerated for them and reduced to the __() → __wp() rename. Its wp_mail() hunk no longer matched the stubs (WordPress added an $embeds parameter) and renamed a function nothing overrides
  • mockery/mockery ^1.6.11 in development

Deprecated

  • Blocks in resources/blocks are still registered, with a notice in the log, until Pollora v15. A theme or plugin blocks directory scans both locations, and a block present in both is taken from resources/views/blocks
  • pollora:make:block --dynamic, now the default

Fixed

  • A block render file outside the block directory is no longer included: WordPress built its own render callback from block.json whenever Pollora’s check rejected the path
  • Blocks built with vite build get their view script and stylesheets again: the Vite entries generated by pollora:make:block only listed each block’s index script, so viewScript, style and editorStyle were missing from the production manifest. Running the command again in a configured theme or plugin rewrites the entries
  • pollora:make:block adds wordpressPlugin() to the Vite plugins on first use: it imported the plugin, then skipped adding it because the name was already in the file
  • The Artisan commands renamed to the Laravel colon convention in v13.32.0-beta answer to their previous names again. The rename left no alias, so a project whose composer.json still ran pollora:env-setup in post-autoload-dump failed composer install right after upgrading. Kept as aliases: pollora:env-setup, pollora:make-theme, pollora:delete-theme, pollora:make-plugin, pollora:make-block, pollora:make-model, pollora:make-action, pollora:make-filter, pollora:make-posttype, pollora:make-taxonomy, pollora:make-wp-cli
  • pollora:install pointed to a non-existent wp:env-setup command when the database connection failed
  • Asset containers no longer share one Vite configuration. Each ViteManager reconfigured Laravel’s Vite singleton in place, so the last container set up — typically the theme — imposed its hot file on every other one: with the theme on npm run dev and a plugin built for production, the plugin’s assets resolved as built but were enqueued as hot, and the block editor crashed with forceFullUrl(): Argument #1 ($path) must be of type string, array given. The getAssetUrls macro likewise read the build directory of the last manager registered instead of its own, and the Vite client tag was rendered from the unconfigured singleton
  • pollora:install completes without interaction (--no-interaction, CI, piped stdin). It called pollora:make:theme without a name, which failed with Not enough arguments (missing: "name") after WordPress was installed; it now generates the default theme from pollora/theme-default — the theme WordPress activates on install — or the one named by the new --theme option
  • pollora:install runs its migrations with --force and fails when they fail. In production, migrate asks for confirmation and cancels when it cannot prompt, yet the install reported Migration completed successfully: a non-interactive production install left the sessions and cache tables missing and every page answered 500
  • Commands using PromptsForMissingOption (pollora:make:theme, pollora:make:plugin) apply their prompt defaults when they cannot prompt, instead of leaving the options empty: a theme generated without interaction had a style.css with no author, URI, description or version

Removed

  • patches/mockery-php84-nullable.patch — Mockery fixed the PHP 8.4 implicit nullable deprecations upstream, so the patch no longer applied and printed Could not apply patch! on every composer install, including in projects built on the skeleton. patches/wordpress-core.patch stays: it is what lets pollora/helper-overrider declare __()

v13.32.0-beta

Pre-release · Added, Changed, Fixed, Removed

Pollora now follows Laravel’s version numbers: this release requires Laravel 13.32.

Added

  • Translation diagnostics in pollora:status and the admin dashboard — reports whether the __() override is the one actually installed, alongside the WordPress and Laravel locales. laravel/framework declares __() behind the same function_exists() guard as pollora/helper-overrider and Composer emits autoload.files in dependency order, so whichever loads first wins; when Laravel wins nothing errors, WordPress catalogues simply stop resolving and every core, theme and plugin string silently renders untranslated. Detection compares the file declaring __() against the one declaring pollora_translation_resolver() — they ship in the same helpers.php, so matching paths prove the package won the race whatever the install layout
  • WordPress Abilities API support through the new pollora/abilities package (requires WordPress 6.9)
    • Ability facade for fluent declaration: Ability::define('acme/get-posts')->description(…)->category(…)->can(…)->using(…)
    • #[Ability] attribute on classes implementing AbilityHandler, discovered automatically
    • Ability::category() for the categories abilities file under, declared for you when an ability names one nobody registered
    • Behaviour annotations (reads/creates/updates/deletes) published to AI clients as readOnlyHint, destructiveHint and idempotentHint
    • Typed SchemaBuilder for input and output JSON Schema, and a defensive Input reader
    • Permission checks receive the same input as the body, allowing per-object capability checks; they default to refusing
  • #[SkipDiscovery] attribute to exclude classes from the discovery engine
    • Classes annotated with #[SkipDiscovery] are completely invisible to all discoveries — no reflection loaded, no attributes scanned
    • except parameter for selective exclusion: #[SkipDiscovery(except: [HookDiscovery::class])] skips all discoveries except the listed ones
  • Publishable config/discovery.php with skip_classes and skip_paths arrays for config-level exclusions (third-party packages, vendor classes)
  • DiscoveryRegistrar — automatically registers Discovery classes from the service container, eliminating manual addDiscovery() calls in ServiceProviders
  • pollora_register() helper with ModuleType enum for simplified theme/plugin registration
    • Themes: pollora_register(ModuleType::Theme) — 3 lines in functions.php, auto-detects theme name and path
    • Plugins: pollora_register(ModuleType::Plugin, 'my-plugin', __DIR__) — replaces manual PluginRegistrar wiring
  • #[Ajax] attribute for declarative AJAX action registration with security-by-default
  • Discovery system performance benchmark suite (tests/Benchmark/) with realistic attribute complexity and multi-location DDD scenarios
  • Public method caching in ReflectionCache::getPublicMethods() — avoids redundant getMethods(IS_PUBLIC) reflection calls

Changed

  • BREAKING: requires Laravel 13.32 (illuminate/* ^13.32). The framework version now tracks the Laravel release it targets, hence the jump from v13.4.3
  • BREAKING: Pollora\Services\Translater now requires its $domain argument. The old 'wordpress' default existed only to pair with the wordpress. key prefix that pollora/helper-overrider 1.2.0 removed — it prefixed every lookup as __('wordpress.'.$value) and relied on the resolver stripping it before the gettext call, so with 1.2.0 installed it silently returned values untranslated. Nothing in the framework used it (Sidebar and Menus both pass 'sidebars'/'menus' explicitly); pass __($value, 'default') if you want WordPress’s core catalogue. Two latent bugs went with it: the prefix was stripped with an unanchored str_replace(), so a value such as 'Go to menus.example' came back as 'Go to example', and translateItem() was typed string under declare(strict_types=1), so a wildcard translate(['*']) over a config array holding an int or bool raised a TypeError
  • BREAKING: Ajax module extracted to pollora/ajax package
  • BREAKING: Option module extracted to pollora/option package
  • BREAKING: Hook domain and adapters extracted to pollora/hook package
  • Domain layer paths restored for hexagonal architecture consistency
  • Public API types exposed for Theme and Option modules
  • All manual addDiscovery() calls removed from ServiceProviders — replaced by DiscoveryRegistrar auto-registration
  • Empty boot() methods removed from LaravelPluginModule and LaravelThemeModule (Rector RemoveParentDelegatingClassMethodRector)
  • Artisan command signatures renamed to Laravel colon convention (e.g. pollora:make:theme)
  • DiscoveryItems::all() optimized — replaced spread-in-loop with array_merge
  • Redundant reflection pre-loading removed from DiscoveryEngine

Fixed

  • WordPressHeaders middleware now respects the DONOTCACHEPAGE constant set by WooCommerce and compatible cache plugins, preventing public cache headers on cart, checkout, and account pages
  • __() no longer fatals on a translation with replacements whose key is absent from the current locale. __('Shipping :brand', ['brand' => 'Test']) raised TypeError: Cannot access offset of type array in isset or empty whenever Lang::has() answered no: the guard normalised only the empty array to the default text domain, so a non-empty replacement array travelled into WordPress’s translate() as the domain and reached isset($l10n[$domain]). It hit every __($key, [...]) call whose key was not in the locale’s catalogue — typically a site whose sources and language are both English, where no en_US.json exists at all, taking down every string with a placeholder. Requires pollora/helper-overrider 1.2, which routes on the caller’s intent — a string second argument is a WordPress text domain, a non-empty array is a Laravel call — instead of on whether Laravel happens to hold the key. The same release fixes an unguarded Lang::has() that raised A facade root has not been set. wherever __() runs before or without an application, a wordpress. prefix strip that rewrote the substring anywhere it appeared (__('Go to wordpress.org') returned Go to org), Laravel group keys returning an array to callers typed against WordPress’s string, and a missing base-language locale fallback that kept a fr_FR site from ever reading lang/fr.json
  • The Loop and Query facade aliases no longer crash a page that uses them. Both were still declared in extra.laravel.aliases after their facade classes had been deleted — Loop since 9a50cac (2026-04-21), Query since 9c0cb42 (2024-08-05). Laravel registers an alias without checking its target and only calls class_alias() the first time the short name is used, so the package installed and booted cleanly and then threw Class "Pollora\Support\Facades\Loop" not found on whichever page happened to call it. Present in every v13.4.x release. See the migration note below for what replaces Loop.
  • PluginManagerTest isolation — real Container with dynamic WP_PLUGIN_DIR replaces fragile ContainerInterface mock
  • WooCommerce hooks test updated for ComingSoonHandler dependency
  • PHPStan dead catches widened, redundant @return $this docblocks removed
  • OptionService namespace aligned with extracted package
  • GitHub releases are created again on tag push — the Deploy workflow lacked contents: write; suffixed tags (-beta, -rc.1) are now published as pre-releases

Removed

  • The Loop and Query entries in extra.laravel.aliases, whose facade classes no longer exist

Migrating from Loop

Loop:: was removed in 9a50cac as a breaking change, but the alias stayed behind and the removal was never written down — so a project only found out when a page 500’d. This is that note, late.

In Blade, the replacement is Sage Directives (log1x/sage-directives, registered by PolloraServiceProvider): @title, @content, @excerpt, @permalink, @published, @posts and the rest.

In PHP, Pollora\View\Loop was only ever a proxy over WordPress functions. The full mapping, read off the deleted source rather than reconstructed:

RemovedReplacement
Loop::id()get_the_ID()
Loop::title($post)get_the_title($post)
Loop::author()get_the_author()
Loop::authorMeta($field, $userId)get_the_author_meta($field, $userId)
Loop::content($moreText, $stripTeaser)apply_filters('the_content', get_the_content($moreText, $stripTeaser)), then str_replace(']]>', ']]&gt;', …)
Loop::excerpt($post)apply_filters('the_excerpt', get_the_excerpt($post))
Loop::thumbnail($size, $attr, $post)get_the_post_thumbnail($post, $size, $attr)
Loop::thumbnailUrl($size, $icon)wp_get_attachment_image_src(get_post_thumbnail_id(), $size, $icon)[0] ?? null
Loop::link($post, $leavename)get_permalink($post, $leavename)
Loop::category($id)get_the_category($id)
Loop::tags($id)get_the_tags($id) ?: []
Loop::terms($taxonomy, $post)get_the_terms($post, $taxonomy) ?: []
Loop::date($format, $post)get_the_date($format, $post)
Loop::postClass($class, $postId)'class="'.implode(' ', get_post_class($class, $postId)).'"'
Loop::nextPage($label, $maxPage)get_next_posts_link($label, $maxPage)
Loop::previousPage($label)get_previous_posts_link($label)
Loop::paginate($args)paginate_links($args)

Four of these are not straight renames, and a blind substitution breaks them:

  • thumbnail() and terms() reorder their arguments — the post moves from last to first — and both defaulted the post to the one in the loop.
  • postClass() returned a ready-made class="…" attribute string, where get_post_class() returns an array.
  • content() and excerpt() applied the_content / the_excerpt themselves; dropping the filter silently strips whatever other plugins add there.
  • tags() and terms() normalised false to an empty array.

Query:: has no replacement to document — the facade was already gone before v13, and the alias outlived it by two years.

  • Unfinished Admin Pages module
  • Manual addDiscovery() boot logic in HookServiceProvider, PostTypeServiceProvider, TaxonomyServiceProvider, WpRestAttributeServiceProvider, SchedulerDiscoveryServiceProvider
  • RegisterScheduleDiscoveryUseCase (superseded by DiscoveryRegistrar)