Changelog
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.
No release matches this version.
13.40.x
v13.40.2
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 newno longer ends in an error after the theme is built. On a first installpollora:make:themeruns in the process that has just installed WordPress, which is only partly loaded (SHORTINIT):switch_theme()failed there withCall 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 freshpollora:theme:activateprocess; if that fails, the install carries on and prints thewp 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
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 newno 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 installpollora:make:themeruns in the process that has just installed WordPress, which is only partly loaded (SHORTINIT), andactivate_plugin()failed there before the theme build and the theme activation. The plugins are now activated by a freshpollora:plugin:activateprocess, where WordPress loads completely and the activation hooks run. If that process fails, the install carries on and prints thewp plugin activate <slug>to run afterwards (Pollora/pollora#274)
v13.40.0
13.39.x
v13.39.3
Changed
pollora/wp-rest2.0 is accepted, andcomposer updateinstalls 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, declarepermissionCallback: Everyone::classon the routes that are public on purpose, or a permission such asIsLoggedIn. To keep the old behaviour for a while, returnfalsefrom thepollora/wp-rest/private_by_defaultfilter: WordPress then tells, withWP_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, andpollora/harnessis required at^0.1.15
v13.39.2
Added
wordpress.sessions:Route::wp()routes no longer have to start a Laravel session. Routes declared inroutes/web.phpinherit thewebgroup, so every anonymous request to aRoute::wp()route started a session (a row insessions, the<app>_sessionandXSRF-TOKENcookies). With'sessions' => falseinconfig/wordpress.php, those routes dropStartSession,ShareErrorsFromSessionand the CSRF middleware (PreventRequestForgery, whichValidateCsrfTokenextends), andcsrf_token(),old()and flash data have nothing to read from there. The default istrue: nothing changes for an existing site. Laravel-native routes keep the fullwebgroup, and the template hierarchy fallback is not affected
Changed
pollora/entityis required at^2.0(it was^1.2): entity 2.0 only raises its PHP requirement to 8.3, which the framework already requiresnwidart/laravel-modulesis required at^13.2(it was^13.0). Its 13.2.0 release changes how a customstubs.pathis enabled and how a custompaths.generator.*entry without anamespacegets its namespace; a project on the default configuration needs no change- The development tooling moves up:
@commitlint/cliand@commitlint/config-conventional21 (they need Node 22.12 or later; the repository’s rules still apply),prettier3.9.10, and, for the end-to-end suite,@playwright/test1.64.1 and@wordpress/e2e-test-utils-playwright3.1.0, both pinned as before.lint-stagedis removed, with its configuration: it was configured but no git hook ever ran it (the only hook iscommit-msg) - Dependabot ignores the major versions of
@types/nodeintests/e2e: the suite runs on Node 22 - The development dependency
pollora/harnessis required at^0.1.13
v13.39.1
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 registersWpRocketServiceProvider, which kept WP Rocket from writing its rules into.htaccessand from settingWP_CACHE(both off unlesswordpress.wprocket.generate_htaccess/set_cache_constantsay otherwise). Without the package, an active WP Rocket does both on its own. The old class namePollora\ThirdParty\WpRocket\WpRocketServiceProviderstill resolves once the package is installed, andwordpress.wprocketis unchanged pollora:doctorand Site Health check that WP Rocket, when active, has its Pollora integration installed;pollora/wp-rocketis suggested incomposer.jsonpollora/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-bindingsis required as^0.2(it needs Colt 11) andpollora/queryas^2.0 || ^3.0(3.0 only raises its PHP requirement to 8.3)laravel/promptsis updated to^0.3.26- Dependabot watches the npm lock files (
/andtests/e2e) and opens its pull requests, security updates included, againstdevelop: a security update used to targetmain, 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.jsonis refreshed withnpm audit fix(zod4.6.7,puppeteer-core25.16.0 and their dependencies) to fix known vulnerabilities in these development dependenciesfast-uriis updated to 3.1.9 inpackage-lock.jsonandtests/e2e/package-lock.jsonto fix known vulnerabilities in these development dependencies
v13.39.0
Added
pollora:doctorand Site Health check that WooCommerce, when active, has its Pollora integration installed: it warns, and givescomposer require pollora/woocommerce, when it does notpollora/woocommerceis suggested incomposer.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 inPollora\Events\WordPress\Plugins\WooCommerce, theshop/product/cart…Route::wp()conditions inwordpress.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 toPollora\WooCommerce\…, until the next major release; a project’s ownwordpress.plugin_conditionsstill win, and thewordpress.plugin_conditions.woocommercedefaults stay inconfig/wordpress.phpuntil the next major release. The core now names no third-party plugin (ARCH-05), so that rule no longer needs its sevennosemgrepnotes - The Pollora harness (
pollora/harness) checks the repository, and a failing gate blocks a merge:composer qaruns 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, andapi-surface.jsonrecords the public surface (attributes, hooks, configuration keys, commands). Nothing changes at run time - The harness’s dependency analysis (ARCH-07) blocks:
composer-dependency-analyser.phpscanssrc/andtests/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, allRuntimeExceptions) instead of a bareRuntimeException; an unknown plugin throwsPluginException::notFound()(anException, 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(aRuntimeException, so acatch (RuntimeException)keeps working; the messages keep their beginning and now say how to fix it) instead of a bareRuntimeException - Module errors throw named exceptions instead of a bare
RuntimeExceptionorException:ModuleStateException(a module cannot be switched or its state written) andModuleComponentException(a component fails to initialise in debug mode) extendRuntimeException, and the downloader’s failures are nowModuleException(anException, 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 throughContentUrlResolverInterfaceandThemeAssetUrlResolverInterface, the dashboard reads WordPress throughWordPressEnvironmentInterface,AbstractTaxonomytranslates its default labels throughLabelTranslatorInterface, andWooCommerceServiceasksWooCommerceEnvironmentInterfaceabout 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. DeclarepermissionCallback: Everyone::classfor a route that is public on purpose, or returntruefrom thepollora/wp_rest/private_by_defaultfilter to refuse such routes today
Fixed
- The tests run with the lowest dependencies on PHP 8.3 and later:
antecedent/patchwork2.2 is required in development, as older versions break PHPUnit’s code filter_input()reads the plugins to delete withFILTER_UNSAFE_RAW, the same filter asFILTER_DEFAULT, which PHP 8.5 deprecates
13.38.x
v13.38.1
Fixed
-
An
APP_URLwithout a scheme (APP_URL=pollora.test, written by hand in.env) no longer breaks the site: every Artisan command failed withUndefined array key "host", and/wp-admin/answered a 404 because WordPress built its URLs relative to the current path. The value is read ashttp://pollora.testforWP_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 includespublic/index.php, soSCRIPT_FILENAMEis 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 addresspollora:installprints 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 apublic/directory that holds anindex.phpis 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 ofpublic/expose the application key and the database password, and answer the site with a 404. The check requests/.envand says to point the document root topublic/ pollora:doctorwarns whenAPP_URLhas no scheme, and gives the value to write
v13.38.0
Fixed
- The setup (
pollora:env:setup,pollora:install) accepts an empty database password. A local MySQL withrootand no password, the default with Homebrew, MAMP and many Docker images, was refused with “Database password is required” and had to be written into.envby hand. The connection test that follows still decides whether the empty password works, andDB_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
- 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
- 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 ofadd_image_size()). It never changes the dimensions of the size, changes the name of the files and the version of a service URL, becomes agravityin the imgproxy preset, and is refused by Bunny, whichpollora:media:thumbs:exportandpollora:doctorreport. It comes withpollora/media0.8 - Media, sizes made by a service:
media.thumbnails.driver(MEDIA_THUMBNAILS_DRIVER) takesbunny(photo.jpg?class=card, an image class of Bunny Optimizer) orimgproxy(a URL signed with HMAC-SHA256 that names a preset, imgproxy 4.0.x in presets-only mode) besidespollora. 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|imgproxydeclares 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), andpollora:doctorreports a driver that cannot be used. Seemedia.thumbnails.bunnyandmedia.thumbnails.imgproxyinconfig/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, andmedia.thumbnailslimits the cost per server (sizes at the same time, biggest original, wait before a size that exists is served instead).pollora:doctorreports a.htaccessin the uploads folder that stops the fallback - Media, image sizes: an
ImageSizefacade declares the sizes your design uses,ImageSize::add('card')->cover(600, 400)->webp(75), withcover(),scale(),contain(),webp(),avif(),original(),widths(),eager()andupscale(). The file of a size is namedphoto-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 andsrcsetof a size are worked out from the metadata of the original, never from the disk. The sizes WordPress registers itself, including a theme’sconfig/images.php, are left as they are.pollora:media:thumbs:warmmakes the missing files for the images already uploaded,pollora:media:thumbs:prunedeletes the files of a size that was changed or removed, andpollora:doctorreports a declaration that cannot make a size or a format the server cannot write - Media, private files: a media flagged private (the
_pollora_media_privatemeta, or thepollora/media/is_privatefilter) is served through a signed URL that expires (media.private.expiry) on its URL, its sizes and itssrcset; a public media keeps its plain URL and the disk is never asked to tell them apart.pollora:media:visibility {id} --private|--publicchanges every file of a media on the disk,pollora:media:files {id}lists them, and the module’s actions reach Laravel asMediaStored,MediaDeletedandMediaVisibilityChangedevents. The URL is signed by the Laravel disk (temporaryUrl()), andpollora:doctorwarns 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):thumbnailandmediumcome 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.diskandmedia.url(config/media.php,MEDIA_DISK,MEDIA_URL). The storage ispollora/media; the framework keeps the connector:MediaServiceProvider(the Flysystem driver of the disk, the URL of the disk whenmedia.urlis empty),pollora:media:status,pollora:media:migrate(copy between disks,--replace-urlsfor the database, dry run unless--execute) and a check ofpollora:doctor(the disk takes a file; no media left in the local uploads folder). WordPress’s own file functions follow through apollora://stream wrapper and theupload_dirfilter, so Gutenberg, ACF, Meta Box, WooCommerce and imports need no adaptation; a media URL ismedia.urland a relative path, never asked to the disk. With nomedia.disk, nothing changes: WordPress keepspublic/content/uploads - A
Rolefacade 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')andRole::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 withpollora/roles0.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 withoutwp_generate_attachment_metadata, so on a disk served without fallback every size of an edited image was a broken image untilthumbs warm. It comes withpollora/media0.7.1
Changed
RoleServiceProviderbindsRoleRegistrywith itsRoleDefinitionBuilderand addsRoleDeclarer, the service the facade forwards to
13.36.x
v13.36.1
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.jsships 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:bindingand thepollora:doctorcheck - 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_Rolesinjection, label translation, role usage) andRoleDiscovery, with their tests. Class names do not change. The framework keeps the Laravel side:RoleServiceProvider, therolemiddleware, the@roledirective, theHasRolesbridge ($user->can(),@can), thepollora:roles:*commands and thepollora:doctorcheck - Typed meta lives in its own package,
pollora/meta, which the framework requires:MetaAccessor(of(),schemas(),schemaFor(),extend()), the fluentMetaRecord, the schema builder and repository,MetaAuditor,MetaUiDrivers, the value caster, the WordPress adapters,MetaDiscoveryandMetaUiDriverConformance, with their tests. Class names do not change. The framework keeps what needs Laravel:MetaServiceProvider, theMetafacade andHasTypedMeta, the Laravel validator (LaravelMetaValidator), thepollora:meta:*commands and thepollora:doctorcheck - 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, theAssetfacade,ViteManager(Laravel’s Vite, whereASSET_URL, a CDN and the application URL keep applying),RootAssetManagerand the Laravel implementations of the package’s three contracts (ViteManagerFactory,RuntimeContext,PublicPath)
Changed
- Accepts
pollora/query2.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 updatetakes 2.0, and a project that needs 1.x requirespollora/query^1.0itself. A few fixes in 2.0 change the result of a query that used to run:where()followed byorWhere()groups the earlier clauses ((a AND b) OR c),DateQuery::inclusive()now takes effect, dates use a 24-hour clock, and an invalidfields(),userPermission()ororderBy()direction throws aQueryExceptioninstead of being ignored. The package’s upgrading guide lists them - The asset classes that left for the package no longer reach for Laravel:
AssetEnqueuerreceives the hook services, the Vite factory, the runtime and a PSR-3 logger instead of resolving them from the container,AssetFileis resolved through a resolver the provider sets (AssetFile::resolveUsing()), andAssetManager,MissingBuildsandMissingBuildNoticetake 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
AssetEnqueuerdestroyed 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/metano longer reach for Laravel:MetaUiDriversandMetaAccessor::extend()take a PSR-11ContainerInterface(the Laravel container is one, a driver closure receives the same object), and the key of a data object’s property is derived byPollora\Attributes\Support\Naminginstead ofStr::snake(). What needs Laravel moved toPollora\Meta\Infrastructure\Laravel:MetaServiceProvider,LaravelMetaValidator,TypedMetaCheck,MetaListCommandandMetaAuditCommand. The rendered pages, the REST responses and the output of thepollora:meta:*,pollora:binding:list,pollora:roles:*andpollora:doctorcommands of a Pollora site are unchanged - The roles classes that will leave for
pollora/rolesno longer reach for Laravel: the label of a#[Role]without one comes fromNaming::headline()(the same words asStr::headline()) andNaming::classBasename(). What needs Laravel moved toPollora\Role\Infrastructure\Laravel:RoleServiceProvider, therolemiddlewareEnsureUserHasRole, the@roledirectiveRoleDirective, theRolesCheckofpollora:doctorand thepollora:roles:*andpollora:make:rolecommands with their stubs. Roles, capabilities and command outputs of a Pollora site are unchanged - The Block Bindings classes that will leave for
pollora/block-bindingsno 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;LaravelMethodInvokercalls through Laravel’s container,ReflectionMethodInvokerby reflection)BindingEventsInterface(BindingResolvedreaches Laravel’s dispatcher throughLaravelBindingEvents) andPostFinderInterface(BindingContext::post()loads the framework’sPollora\Models\PostthroughLaravelPostFinder, Colt’sPostwithout it, and is typed as Colt’sPost, which the framework’s extends). The options a project lists inblock-bindings.optionsreachOptionSourceand the editor data as an array, read from the config by the provider. Labels and names come fromNaming, asStrwrites them. What needs Laravel moved toPollora\BlockBinding\Infrastructure\Laravel: the provider, the doctor check,pollora:binding:listandpollora:make:bindingwith their stub. Pages, REST responses and command outputs of a Pollora site are unchanged
v13.36.0
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, andHasConfiguringSupport, 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 —InstanceResolverInterfacebuilds the classes discovery needs (Laravel’s container in a Pollora application,ReflectionInstanceResolverotherwise) andDiscoveryRegistrarInterfaceadds the environment’s discoveries before each run (DiscoveryRegistrarkeeps scanning the container’s*Discoverybindings).Psr16DiscoverCacheDrivercaches 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')]setshas_archive,#[Labels]merges into the generated labels), and the method attributes (#[AdminCol],#[RegisterMetaBoxCb],#[MetaBoxCb],#[MetaBoxSanitizeCb],#[UpdateCountCallback]) implementConfiguresArgumentsWithMethod, the discovery handing them the method as a callback. ThePollora\Attributesnamespace no longer reaches Laravel or a framework service, which an architecture test keeps: the first step towardspollora/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,PostTypeAttributeandTaxonomyAttribute, 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) andPollora\Support\WpGlobals. Class names do not change. The framework keepsWpRestAttributeServiceProvider - WP-CLI commands live in their own package,
pollora/wp-cli, which the framework requires:WpCliDiscovery,WpCliService, the WP-CLI adapters andWordpressCommand. Class names do not change. The framework keepsWpCliServiceProviderandpollora: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, andSchedule::fake()for tests.ScheduleDiscoverykeeps 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 tocall()get their dependencies, and keeps the bridge to Laravel’s scheduler (use_laravel_scheduler) config/schedule.php(publishable with thepollora-scheduletag) chooses the scheduling driver,wp-cron(the default) oraction-scheduler, byPOLLORA_SCHEDULE_DRIVER, and lists the hooks that stay on WP-Cron whatever the driver. Thecronoption now indexes every driver’s events, sowp_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 itselfpollora:schedule:listshows the scheduled events with their type, frequency and driver (--type,--driver,--site,--network,--json), read from thecronoption 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:migratemoves the pending events from one driver to another (--from,--to,--dry-run), in both directions and safe to run againpollora: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
laravelscheduling 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 noschedule:run: thecronoption 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.phpgainslaravel.connection,queue,max_delay(a job due later than the connection allows, 900 seconds on SQS, wakes and waits again) andlate_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 thanlate_afterseconds (600) past its time is queued again with the same identifier, so it never runs twice.pollora:doctorand Site Health report late events (no worker), a queue connection that issyncornull, 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,InstancePoolandReflectionCachetake their dependencies instead of reaching forapp()andconfig(); readingstructure-discoverer.cachemoved toLaravelDiscoveryCacheManagerFactory.DiscoveryRegistrar::registerFromContainer()is nowregisterInto(). These are infrastructure classes, outside the public contracts (Pollora\Discovery\Domain\*), which do not change -
One
DiscoveryCacheManageris shared by the engine and thepollora:doctordiscovery 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 fromPollora\Attributes\Support\Naming, which gives the same results asStr::kebab()andStr::snake();Pollora\Support\Sluguses it -
The WpRest module no longer reaches for Laravel’s application, the first step towards
pollora/wp-rest: customHandlesAttributesattributes receive the PSR-11 container given toWpRestDiscovery, andWpRestAttributableWrappertakes 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:WpCliDiscoverybuilds commands through the discovery’s instance pool instead ofresolve(). Its service provider andpollora:make:wp-clistay 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 towardspollora/schedule:ScheduleDiscoveryderives default hook names itself, with the same results asStr::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, withpollora/hook2.0:->async(),#[Async],Async::fake(),via()and their options do not change, and work already queued runs once the upgrade is in.Async\Drivers\WpCronDriverandActionSchedulerDriverare gone with no alias; the framework never used them, and thequeuedriver is unchanged
Deprecated
DiscoveryCacheInterfaceandLaravelDiscoveryCache, removed in 15.0: nothing reads this cache, scans are cached by the Spatie driver given toDiscoveryCacheManagerPollora\Attributes\PostType\PostTypeAttributeandPollora\Attributes\Taxonomy\TaxonomyAttribute, removed in 15.0: no built-in attribute extends them any more; implementConfiguresArguments
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, thepre_schedule_event,pre_option_cronand related filters it installed, and thewp_eventstable. Setting the option no longer does anything. To keep WP-Cron events on Laravel’s queue, setPOLLORA_SCHEDULE_DRIVER=laraveland run a worker (php artisan queue:work) in place ofschedule:run; events that sat inwp_eventsare 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:doctorno longer reads the option handle()on#[Action],#[Filter],#[WpRestRoute]and#[WpRestRoute\Method], andHookno longer implementsHandlesAttributes:HookDiscoveryandWpRestDiscoveryregister hooks and routes themselves. Only the bug below reachedAction::handle(), andWpRestRoute::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/runat boot instead of waiting for anActionto 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()followsAPP_ENVinstead of readingproductionon every site (#443):localgiveslocal,dev,developmentandtestinggivedevelopment,staginggivesstaging, anything elseproduction. AWP_ENVIRONMENT_TYPEenvironment variable, awordpress.constants.WP_ENVIRONMENT_TYPEvalue or a constant defined earlier still wins. WordPress 7.1 turns pings (incoming and outgoing pingbacks and trackbacks) off outsideproduction, so they are off on a site withAPP_ENV=localorstaging:add_filter('wp_should_disable_pings_for_environment', '__return_false')brings them backpollora:doctorno longer counts as overdue WP-Cron events the ones Action Scheduler keeps: thecronoption indexes them too, with adriverkey- A public
#[Action]or#[Filter]method in a#[PostType]or#[Taxonomy]class is registered once: the post type and taxonomy discoveries also handed it toAction::handle(), which registered it a second time on the discovery’s configuration object, so the page firing that hook failed withcall_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 ofnewwith no argument, so a controller with a required dependency answered every request withTrying to invoke non static method … without an object
13.35.x
v13.35.6
Fixed
composer create-project pollora/pollorawithout a database finishes:pollora:install, run by the skeleton’spost-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
- A page template declared in the theme’s
config/templates.phpis 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 namedlandinginstead oflanding.blade.php, sopage.blade.phpanswered (pollora#159) - Before the database is configured, the WordPress fallback route answers 503 instead of 500 (
Call to undefined function wp_using_themes()): withAPP_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/pollorawithout a database no longer ends with a failing script (“Database name is required”): Composer runspollora:env:setupwithout 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/builddeleted) no longer takes the whole site down: every request,wp-login.phpand wp-admin included, answered 500Vite manifest not foundbecause 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
- 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
composerrepository listed first (SatisPress, paid plugins) answered for every package and a module from Packagist read “source did not answer” (#448). A repository’sexcludeis honoured next toonly,"packagist.org": falsekeeps Packagist out, andwpackagist.orgis no longer taken for Packagist
v13.35.3
Added
pollora:make:module Crmcreates a lean module from the new Pollora/module-default template: classes discovered inapp/(an example hooks class, no service provider),resources/views/blocks, and a Vite build through@pollora/vite-configintopublic/build/module/<kebab>. Each Laravel layer is one flag away:--provider,--routes(implies--provider),--api(implies--routes),--config,--database,--tests, or--full;--no-assetsfor a PHP-only module. The module is enabled,composer dump-autoloadmerges itscomposer.json, and npm builds it (--no-enable,--no-npm).--repositoryand--repo-versionpick another template;--offline, or a failed download, uses the copy bundled with the frameworkmodule:makewrites the same lean module, offline, unless the project’sconfig/modules.phpsetspathsorstubs(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 itsmodule.<kebab>asset container, soAsset::add(...)->container('module.crm')works without a provider of its own; it was set up only for modules with blocks pollora:make:blockrecognises avite.config.jsbuilt 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'), somodule:enable,module:disableand everything readingapp('modules')keep working.json(default) reads and writesmodules_statuses.jsonas nwidart does;databasekeeps a JSON map in the non-autoloadedpollora_modulesWordPress option, read with Laravel’s connection before WordPress loads (never unserialized) and written withupdate_option()once it has, falling back onjsonwhile the options table does not exist;configreadsconnectors.config.statesorMODULES_ENABLED/MODULES_DISABLED, read-only. A project connector implementsModuleStateConnectorand is declared inconnectors.<name>.class, or given toModuleConnectors::extend()inbootstrap/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 throwsModuleLockedException- A switch clears nwidart’s provider manifest and the discovery cache, and fires
ModuleEnabled/ModuleDisabled(module, sourceadminorconsole, WordPress user) config/modules.php, published withphp 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 providerpollora:module:connector [connector] [--import]shows where module states live and copies them into another connector before the configuration points to itpollora:doctorand 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, andMODULES_*settings ignored becauseconfig/modules.phpis not publishedpollora:module:frontend Crmgives an existing module the template’s frontend build (package.jsonandvite.config.json@pollora/vite-config,resources/assets/app.{js,css}), keeping a.bakof each file it replaces; the builds check recognises the Vite config of nwidart’s stockmodule: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 needactivate_plugins(modules.admin.capability), are nonce-protected, go through nwidart’sModule::enable()/disable()and say the change applies from the next request. A locked module has no switch;MODULES_ADMIN_TOGGLE=falseturns 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:statussay 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’sinstaller-pathsrule, or scanned invendor/) 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’scomposer.jsondeclares for it — acomposerrepository (Private Packagist, Satis:{url}/p2/{package}.json), a GitHubvcsrepository (latest release, else highest tag;MODULES_GITHUB_TOKENfor 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 orpollora:module:outdated, never during a front-end request. Plugins › Modules shows “1.3.0 · 1.4.0 available” with thecomposer updatecommand, Site Health tests “Pollora modules are up to date”, andpollora:status(--jsontoo) gives each module’s version and latest; adev-*build is never reported outdated pollora:make:block --module=<name>creates a block in a module’sresources/views/blocks, named after the module in kebab case (blocks-demo/hero), like the seven generators that already took--moduleAnsweringTemplatesays which template the hierarchy answered a request with: template file, conditional tag, Blade view, whether it fell back toindex. It stays empty whenRoute::wp()or a Laravel route answered, and works withoutWP_DEBUG, unlike the template markerPollora\WordPress\Events\WordPressBootingis dispatched right beforewp-settings.phploads: the last moment to set something up before WordPress builds its globals. Listen to it from a provider’sregister()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 missPollora\BlockBinding\Domain\Events\BindingResolvedis dispatched for each block binding resolved, with its source, field, post, time and whether the cache answered; only when something listensAssetManager::containers()lists every asset container by name: the theme’s, plugins’, modules’
Changed
- Requires
pollora/hook^1.5, forAbstractHook::all()(every registration made throughActionandFilter) and thepollora/async/dispatchedaction, which debugging tools read
Fixed
- Tools › Pollora and
pollora:statusreported 0 modules when onemodule.jsonhad nopriority: nwidart’sgetPriority()is typedstringand threw - Tools › Pollora and
pollora:statusshowed every module as disabled: nwidart keysallEnabled()by lower-case name, which the module’s own name never matched - Generators with
--modulewrote intoModules/<Studly>under theModules\<Studly>namespace whatever the module declared: they now take the path where nwidart/laravel-modules found the module and the namespace itscomposer.jsonmaps ontoapp/(orsrc/), so a module underModule\BlocksDemo\gets classes it can autoload
Removed
- The framework’s
Modules/config/modules.php, merged intomodulesafter nwidart/laravel-modules’ own config and so never applied (its module path pointed at the themes directory)
v13.35.2
Added
- Asynchronous actions in the framework (pollora/hook 1.4):
Action::add(...)->async()can queue handlers as Laravel jobs. Thequeuedriver dispatches aRunAsyncActionjob onhooks.async.queue.connection(the default connection when null) and on the action’sonQueue()orhooks.async.queue.queue.auto, the default, tries the Laravel queue first onceHOOKS_ASYNC_CONNECTIONnames the connection a worker runs (without a worker, jobs would never run, so the queue is opt-in), then Action Scheduler, then WP-Cron; asyncornullconnection is always skipped.via('queue')andHOOKS_ASYNC_DRIVER=queueuse 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 withphp artisan vendor:publish --tag=pollora-hooks: default driver (HOOKS_ASYNC_DRIVER,syncin a developer’s.envruns 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(trueor the lock duration),tries,backoff,asUser,captureandwhen(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 inexceptthe method does not declare, a missing or non-publiccapture/whenmethod, invalid attempts, backoff or lock) is logged and the action runs synchronously;#[Async]on a#[Filter]or without#[Action]is loggedpollora:doctorand 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) orvia()driver, aHOOKS_ASYNC_CONNECTIONthat is undefined orsync/null, WP-Cron events overdue for an hour while WP-Cron or Action Scheduler is in use (Pollora setsDISABLE_WP_CRON: a system cron must requestwp-cron.php), jobs of a database queue waiting 15 minutes for a worker, and payloads or unique locks the daily recovery task left behindpollora:make:action --asyncgenerates the method with#[Async]and its import, in a new class or added to an existing onepollora:async:listlists 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, thePOLLORA_ASYNC_DRIVERconstant, thepollora/hook/async_driverfilter, orautoand the drivers it tries);--jsonfor 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:actionandpollora:make:filterwere registered aspollora:make:action {name}andpollora:make:filter {name}: the console reached them by prefix, butArtisan::call('pollora:make:action')did not find them- The method generated for a hook with separators read
handleSavepostforsave_post: it is nowhandleSavePost - Errors met while registering hooks discovered by attribute went to no logger:
HookDiscoverynow 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’sbutton-largepadding
v13.35.1
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 byCLAUDE.mdand 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:pluginno longer copies the template’sbin/(its packaging script and tests) into the new plugin, aspollora:make:themealready did- A plugin that answers from
template_redirectand 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}_templatefilters now hand back a loader that renders it whiletemplate_redirectruns (#419) template_redirectran 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, andpollora_loadedafter it (#419)- Trackbacks answered 500:
wp-trackback.phpwas required from a method, where it found no$wpand 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
pollora:doctorand 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, notpublic, not listed inblock-bindings.options), an attribute WordPress does not bind for that block, and ablock.jsonwhosepollora.bindingslacksrenderor lists an undeclared attribute. Each of these left the block with its saved content, silently. Content stored in the database is not readpollora:doctorand 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 markedshowInReston 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:doctorand Site Health check roles: users still carrying a role removed from the code (named, with the users), adefault_rolenaming 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 userspollora: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 removespollora:roles:prune(--reassign=,--force): takes roles removed from the code off the users who still carry them (WordPress’sremove_role()ignores a role it no longer knows, so throughremove_cap()), gives the users left with no role the--reassignone, 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 rolepollora: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 getallowSensitive: trueand a note; capabilities stored as denied are listed and left out. Refuses core roles (use#[ModifyRole]) and roles the code already declarespollora:roles:dump(--force): writes the roles as the code makes them into the{prefix}user_rolesoption, 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--forcepollora: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 declarationpollora: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 propertypollora: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
- Block Bindings sources declared in PHP (experimental): a class marked
#[BlockBinding('acme/event')]is registered withregister_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 aBindingContext— the post or term of the block context, right in a query loop, the arguments, the bound attribute,post()andmeta(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,urlfields sanitized, anHtmlStringfiltered 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:bindinggenerates a source - A server-rendered block becomes bindable by listing attributes under
pollora.bindingsin itsblock.json: the attributes are added toblock_bindings_supported_attributes_{block}and the Blade view receives the bound value in$attributes. A block withoutrender, or an attribute the block does not declare, is reported - Block Bindings sources for typed meta, formatted by their declared type:
pollora/post-metaandpollora/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, ascore/post-metadoes;pollora/author-metareads a user meta marked#[Meta(public: true)]only;pollora/optionreads the options listed inblock-bindings.options(none by default). A date shows in the site’s format and language (formatfor another), a number with the site’s separators (decimals), a boolean as Yes/No (true,falsefor other words), an enum by itslabel(), an array as a list,format: rawgives the stored value (a date in ISO 8601) andfallbackthe 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, forpollora/post-meta,term-metaandauthor-meta, the meta of the post type being edited that the source may show (an attachment also tonumberattributes, for an image ID);pollora/optionoffers 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, throughPOST /wp-json/pollora/v1/block-bindings/resolve: one request for the blocks waiting for a value, allowed to who can edit the post (edit_postswithout one). The values are read-only; the field’s label shows while a value loads or when there is none. The script isresources/js/block-bindings.js, printed inline afterwp-blockswith no build #[Meta(media: true)]on anintproperty 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 isMedia.#[Meta(public: true)]marks a meta anyone may see
v13.34.5
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,RichTextwithsanitize: 'wp_kses_post',Number,Toggle,DateTime,Select). A package implementsMetaUiDriverand registers it withMeta::extend('acf', AcfDriver::class); the project picks it inmeta.ui(none by default), and the driver receives each schema oninit, with only the meta it supports.Meta::schemas(),Meta::schemaFor('post', 'event'), theMetaSchemasRegisteredevent, andMetaUiDriverConformance::check($driver)for driver authors. The framework names no field plugin - Arrays and data objects as typed meta: an
arrayproperty declares its item type withitems: 'int'(or a class) or a@var list<string>docblock, and is stored as one serialized array or, withsingle: 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 publishesitemsandpropertiesschemas, 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]getscustom-fieldssupport when one of its#[Meta]hasshowInRest: true, without which WordPress leavesmetaout 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 (integerfor an int, somaxcompares numbers). A write from PHP (Meta::of()->set(), a model attribute) throws aMetaValidationExceptionnaming 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,UserandCommentread 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 throughupdate_metadata()when the model is saved;whereMeta('capacity', '>=', 100)compares numbers as numbers. A post model withprotected $postType = 'event'is bound to its post type at discovery, soPost::find()returns it. A class known to carry typed meta stops eager loading themetarelation 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()androles()onPollora\Models\User(traitHasRoles; writes go throughWP_User, an unknown role is refused); therole:route middleware (role:event_manager,editor, orEnsureUserHasRole::using(EventManager::class)), which refuses with a 403 a user who has none of the roles, an alias the application already uses being kept;@roleaccepts role classes (@role(EventManager::class)) and keeps the behaviour of Sage Directives’@rolefor slugs - REST permission
Canfor#[WpRestRoute]and#[Method]:permissionCallback: new Can('edit_posts'), a#[CapabilitySet]enum case, ornew Can('edit_post', parameter: 'id')to check a meta capability on the object in the request.permissionCallbacknow accepts aPermissioninstance 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, throughgettext_with_context_default, so no translation is loaded early; a label WordPress already translates is left alone
v13.34.4
Added
- Typed meta (experimental): a public typed property of a
#[PostType]or#[Taxonomy]class marked#[Meta]is registered withregister_meta()— type, default, sanitization, REST schema (dates asdate-time, enums asenum),capabilityasauth_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 onwp_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 inroles.super_roles(administrator) receive every declared capability, so a post type with#[CapabilityType]no longer disappears from the admin. Sensitive capabilities needallowSensitive: 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),@canand thecan:middleware. TheGate::after()bridge touser_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_Useror ID) and Eloquent model arguments foruser_can(), andPollora\Models\Useruses Laravel’sAuthorizable(can(),cannot()). Abilities defined withGate::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,@templateand@gravityformwere never registered (the file was loaded nowhere, and@usercancalled aUser::current()that does not exist). Use@canfor capabilities
v13.34.3
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_schedulesandinitcollected 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
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_pluginsbootstrap readsactive_pluginswithunserialize()restricted to no classes: a tampered option can no longer instantiate PHP objects (#382)
Fixed
saveMeta()andcreateMeta()onPollora\Modelsgo throughupdate_metadata()/add_metadata()when WordPress is loaded: sanitize callbacks, meta hooks and object cache invalidation now apply, andget_post_meta()no longer returns the previous value under a persistent object cache (Pollora/colt#1)$post->acf,$term->acfand$user->acfno longer end in a fatal error: Colt’s ACF trait referenced a class that was never shipped (Pollora/colt#1)
v13.34.1
Removed
- The
use_default_wp_theme_directorykey ofconfig/wordpress.php. Nothing ever read it: setting it totruechanged nothing, and themes always live inthemes/(#297)
Fixed
- Under WordPress 7, a classic theme’s block styles and
global-styleswere 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 atwp_footer, then moves them back into the head through its template enhancement output buffer, which only starts whentemplate-loader.phpincludes a template: a Blade page includes none. AWordPressTemplateEnhancementmiddleware now plays the buffer’s part on the response —wp_template_enhancement_output_buffer_startedbefore the view renders, thewp_template_enhancement_output_bufferfilter andwp_finalized_template_enhancement_output_bufferon the HTML — forRoute::wp()routes and the template hierarchy, so any plugin built on that filter sees Pollora’s pages too. A plain Laravel route that printswp_head()/wp_footer()can add the middleware itself pollora:installwithout a terminal —--no-interaction, CI, orpollora newdriving 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 theAPP_URLhost: under DDEV the directory is alwayshtml),adminatadmin@<APP_URL host>, a generated password shown once (also with--install),en_US, not indexed — and keeps every option it is givenpollora:statusand the dashboard reported a post type or taxonomy under a slug derived from its class name, ignoring the attribute:#[PostType('synthese-presse')] class SyntheseDePressewas listed assynthese-de-presse, a post type that does not exist, and itsplurallabel was ignored too. Both read the attribute now, throughPostType::resolveSlug()/Taxonomy::resolveSlug(), the rule discovery registers with, so they cannot disagree again (#298)
v13.34.0
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/norsrc/— one that only ships blocks, which need no class — was discovered from its root,node_modulesincluded: 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, nevernode_modules,vendor,bower_components,build,dist,public,resources,assets,languages,langor a hidden directory
v13.34.0-beta.2
Pre-release
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.jsonmissing or older than the framework’s patches;.envnames 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.stubfiles left from a copied template, blocks still in the legacyresources/blocks; pattern files WordPress never registers or has not cached;Route::wp()routes answering in place of a block theme’s templates.--jsonfor 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 aTypeErroronce the menu was already gone:delete_nav_menuis thedelete_{$taxonomy}hook, which passes the term ID first, and the listener expected aWP_Term.MenuDeletednow 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/clientby 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 andpollora:statusshare that one rule, which they each duplicated and missed13.x-dev. Site Health’s info tab now labels the compared version “Latest stable version”, since pre-releases are not counted
Changed
pollora:make:themeactivates 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-interactionnever replaces a working theme.--activateand--no-activatesettle it without asking, andpollora:installpasses--activate. Activation goes throughswitch_theme(), which firesswitch_themeandafter_switch_theme; the options were written directly before, so those hooks never ran
v13.34.0-beta
Pre-release
The framework’s version tracks Laravel’s: this beta requires Laravel 13.34.
Added
- A third
pollora:make:themetemplate, Magazine (magazine→pollora/theme-buzz): a Full Site Editing block theme whose templates, parts and patterns are edited in the Site Editor, next todefaultandecommerce. 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.htmlanswered with HTTP 200. WordPress core resolves it towp-includes/template-canvas.php, which is never a Blade view, so it always rendered throughFrontendController’s raw-PHP-template branch — the only branch that never looked atis_404(). Measured on a fresh block theme: right content, wrong status - A real 404 lost its
error404body class, and every page served by the template hierarchy carried a meaningless one built from its path (any-no-such-page). TheWordPressBodyClassmiddleware 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}')) kepterror404,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 onlaravel/frameworkv13.34.0: the full suite, Pint, PHPStan and Rector pass unchanged - The
WordPressBodyClassmiddleware is replaced by aRouteMatchedlistener,ApplyApplicationRouteContext, which runs on every route: a route WordPress answers (Route::wp()and the template-hierarchy fallback, both flaggedisWordPressRoute()) keeps WordPress’s classes and verdict untouched; any other route hasis_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 withloadInFooter()), 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
<InnerBlocks />in a block’srender.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 adivcarrying the tag’sclass(pollora-inner-blocksby 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 />. Arender.phptemplate gets it too- The block editor runtime
window.pollora.blocks(script handlepollora-block-editor, a dependency of the editor script of every block with arendertemplate):bladeEdit(metadata)previews the template through the core block-renderer route and makes its<InnerBlocks />editable;savestores the inner blocks. Shipped inline, as nothing undervendor/has a public URL $isPreviewin a block template: true while it renders for the editor’s previewdevelopis aliased to13.x-dev(extra.branch-alias). Without it,dev-developsatisfied no version constraint: a project ondev-developcould not install a package requiringpollora/framework^13.0—pollora/nectar1.1 does — without an inline alias of its own
Fixed
pollora:make:block --inner-blocksmade 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 />inrender.blade.phpTemplateMarker’s documentation no longer says every response goes throughtemplate_include: responses fromRoute::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 tomain, which a release fromdeveloporrelease/*has emptied into the version’s section by construction; it now checks hotfixes only
Changed
pollora:make:blockgenerates dynamic blocks on the runtime:edit.jsxiswindow.pollora.blocks.bladeEdit(metadata)instead ofServerSideRender,saveiswindow.pollora.blocks.saveinstead of() => null, and@wordpress/server-side-renderis no longer added topackage.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 56from wpackagist.org - The installed package no longer carries the test suite, the CI workflows and the tooling configs:
.gitattributesleaves 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
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.phpalone. 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, and404with a 404 status; a Blade view over a PHP template of the same name;Route::wp()and Laravel routes over the hierarchy. Withindexalone 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; anIsAdminone that refuses a visitor and answers an administrator),#[Ajax]for visitors and logged-in users, a script enqueued through theAssetfacade, every script and stylesheet of the home page loading with nothing over plainhttp://,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 frommain, so it starts with this release
v13.32.0-beta.7
Pre-release
Fixed
pollora:make:blockrefuses a theme or plugin that cannot build a block, and says why. A plugin made without assets has neitherpackage.jsonnorvite.config.js: the block was written anyway, could not be built, and thenpm installthe command advised walked up to the site’s ownpackage.jsonand installed there. It now stops before writing anything and names the missing filespollora:make:plugin --assetincludes the asset files. The option takes a value, so the bare flag read as null, which the defaults applied without a terminal turned intofalse:--assetalone left the assets out.--asset=falsestill leaves them out, and the other options keep their defaults- A block title holding a quote (
--title="Owner's Hero") no longer breaks the JavaScriptpollora:make:blockwrites.render.blade.phpescaped it;edit.jsxandsave.jsxprinted 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.
BlockRegistrargave each editor script a fixed list —wp-blocks,wp-element,wp-block-editor,wp-i18n— while@roots/vite-pluginturns every@wordpress/*import into a global and records the matching handles ineditor.deps.json. A block importing@wordpress/componentsor@wordpress/server-side-renderworked only when something else happened to load that script. The handles in the build’seditor.deps.jsonare 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
BlocksServiceProviderof the module’s own, and over HTTP no shape of that provider works: WordPress is loaded, andinithas fired, before theme and plugin providers boot, so the providerpollora:make:blockwrote — hookinginitfromboot()— 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’sheroandcall-to-actionwere missing from the editor and from/wp/v2/block-types. The framework now registers every module’sresources/views/blocks(and the formerresources/blocks) itself oninit, from a hook set while it boots — before WordPress loads — and creates the asset container of a Laravel module that ships blocks.pollora:make:blockno longer writes a provider. ABlocksServiceProviderkept 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) whilewp-login.phpstill 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 theModuleAutoloader::CLASS_LOADERcontainer key. It has no vendor directory, so it stays out ofClassLoader::getRegisteredLoaders()and cannot moveApplication::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 toComposer\Autoload\ClassLoaderin 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 ofClassLoader::getRegisteredLoaders()— behind the loader of any plugin shipping its ownvendor/, 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 openingplugins/query-monitor/bootstrap/app.php. Composer’sInstalledVersions::getRootPackage()read the same list and reported the plugin as the root package, over HTTP, in artisan and in WP-CLI. Namespaces added withaddPsr4()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.4patches/mockery-php84-nullable.patchis back onmain, byte for byte as v13.4.4 shipped it. The v13.4.x line declares that patch by the URLrefs/heads/main/patches/mockery-php84-nullable.patch, and a releasedcomposer.jsoncannot change; removing the file frommainon 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 releasedcomposer.jsoncannot be changed, so a branch URL moves under every version already published: removingmockery-php84-nullable.patchfrommainon 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 matchespatches.lock.jsonand 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 ontosrc/otherwise — one directory, never both — while every--plugin,--themeand--modulegenerator wrote intoapp/unconditionally. On a target keeping its classes insrc/, that was worse than one misplaced file: creatingapp/flipped the autoloader and discovery over to it, and every class already insrc/stopped being loaded. They now resolve the directory with the autoloaders’ own precedence, and a target with neither still getsapp/ - The
BlocksServiceProviderthe scaffolder writes registers its blocks oninit, which is when WordPress accepts block registrations at all. It calledregisterDirectory()straight fromboot(), and providers boot before WordPress has definedregister_block_type()—BlockRegistraranswers that by returning immediately, with no error and no notice, so the blocks simply never existed.theme-defaulthit 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:blockwrites theBlocksServiceProviderwhen 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 liketheme-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 blockcomposer installandcomposer updateno longer fail on a Pollora site that has no terminal.pollora:env:setupruns from composer’spost-autoload-dumphook, 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:installis 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’sedit.jsxrendersrender.blade.phpthroughServerSideRenderfor the block’s current attributes, and a static block’s mirrors the markupsave.jsxwrites; both used to show a placeholder (”… – Block Editor”) the page never displayed. A block with--inner-blockskeeps theInnerBlockseditor, which a server render cannot provide.@wordpress/server-side-renderjoins 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-patchesmoves from^1.7to^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 apatches.lock.jsonrecording each patch’s sha256, and on a machine without the patch cached it downloads the patch again and fails withHashMismatchExceptionwhen 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’senable-patchingoption 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-stagedandprettiersat underdependenciesrather thandevDependencies, 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 ciinstalls devDependencies by default, and the commit hook was checked after the move - Every open npm advisory clears:
fast-urimoves to 3.1.8 andjs-yamlto 4.3.2, past the 3.1.6 and 4.3.2 that patch them.npm auditgoes 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
mainand never concerns a contribution todevelop
v13.32.0-beta.6
Pre-release
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 thetheme_file_urifilter both the URL it built and the file it was asked for; the file was thrown away and rebuilt by subtractingget_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.jswas looked up asresources/assets/resources/assets/app.js, never found, and the failure was logged and swallowed — one line inlaravel.logper 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 underWP_CONTENT_DIR; a Pollora project registers its themes at the project root, and for a root it cannot map WordPress returns the path verbatim — soget_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
- The login screen wears the theme’s design, from the theme’s own theme.json. WordPress loads the theme on
wp-login.phpbut emits none of its design there — measured: zero occurrences ofwp--preset--colorin 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 aconfig/login.phpnow gets its colours, radii and typography printed onlogin_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 aslogin_headis concerned. Strictly opt-in — a theme with noconfig/login.phpgets 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/stylesandpollora/login/creditfilters, 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.phpis loaded oninit, likemenus.php,sidebars.phpandtemplates.php, so__()works in it. WordPress firesinitthroughwp-load.phpbeforewp-login.phpfireslogin_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 atapp/, falling back tosrc/— the two directories the autoloader mapsPlugin\{Name}\onto — while plugins were scanned at their root, which is wherenode_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 withoutnode_modules. It also discovered five WordPress core classes shipped inside@wordpress/style-engineand handed them to the discovery pipeline, which is its own kind of wrong. WithAPP_DEBUGon, 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 neitherapp/norsrc/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
- Every page says which template answered it, as an HTML comment on
wp_head, wheneverWP_DEBUGis 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:themeandmake:pluginfetch their template from GitHub and, when that fails, fall back to copying one bundled with the framework — except none is bundled: neithersrc/Theme/stubs/norsrc/Plugin/stubs/exists.getTemplatePath()declaredstringand returnedrealpath()’sfalse, so a transient network failure surfaced asgetTemplatePath(): 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 $requestreceives it. Handler arguments were built from the route parameters alone, so that type hint hadget_param('request')looked up — no route declares a parameter by that name — and the method was invoked withnull, fatalling on a TypeError before a line of it ran. Every endpoint whose handler asked for the request answered 500. A parameter type-hintedWP_REST_Requestnow 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.phpand the rest are run directly by PHP, with Pollora loaded along the way throughwp-config.php; it resolved the URL as a content request anyway, and/cms/wp-login.phpmatches 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_loadedstill fires either way /cms/no longer answers with the source of a Blade template. The WordPress installation root is served by WordPress’s ownindex.php, whosetemplate-loader.phpincludes 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 URLmake:themeandmake:plugindownload 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
- 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-stylessupport, 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 withtoFrontend(), 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 toadd_editor_style(), which is what reaches inside the editor iframe; enqueueing onenqueue_block_editor_assetslands 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 thenetwork_site_urlfilter, which WordPress applies with a$schemeofnullwhenever no explicit scheme is requested — the common case — while the method declared a non-nullablestring $scheme. Every request fatalled as soon asMULTISITEwas enabled, the admin included.$pathand$schemenow carry defaults matching the filter’s own signature; single-site installs never reach this path (#296) pollora:installno 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 reasoningcompleteWebInstall()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 foundthatview()used to throw; since the skeleton stopped declaring WordPress routes the template hierarchy decides, nothing callsview(), 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 ontemplate_redirect, which WordPress fires before any template is chosen and whichrunWp()reaches before Laravel routes, alongside the existing handling for robots, favicons, feeds and trackbacks. The exception path stays for anything still routing throughview(), 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.phpin particular, which ships as “Silence is golden” — and was registered as a view path ahead ofresources/views, solocate()ranked itsindex.phpaboveresources/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()callswp_remote_get()on the site URL andWP_Httpbuilds aWP_Http_Cookiefor everySet-Cookieheader it gets back, but the install bootstrap loaded only part of the HTTP stack. It now loads the classeswp-settings.phploads, 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, whichpollora:installgenerates, 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 tono_update. TheUpdate URIheader does not cover this on its own: WordPress consults the matchingupdate_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 thetheme_rootfilter Pollora sets, butwp_get_theme()computes the root itself and no filter applies there. Registering Pollora’s themes directory replaced$wp_theme_directoriesinstead of appending to it, andget_raw_theme_root()answers a hardcoded/themeswhenever a single directory is registered, whichwp_get_theme()then resolves againstWP_CONTENT_DIR. WordPress’s own themes directory is kept alongside Pollora’s, and thestylesheet_rootandtemplate_rootoptions 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, sothemes/stays empty while thestylesheetoption already points atWP_DEFAULT_THEME, and every front-end request died onView [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
- pollora.dev as the project website and documentation:
homepageandsupport.docsincomposer.json(shown on Packagist),homepageinpackage.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,$contentand$block, Blade components included.pollora:make:blocknow creates dynamic Blade blocks by default — their markup is not stored inpost_content, so changing it never invalidates existing content — and--staticcreates a block withsave.jsx BlockRegistrar::registerDirectory()andregisterBlock()accept an optionalbasePath, the Vite project root the asset entry points are resolved from; it defaults to the closest directory holding avite.configfile, or else the one containingresources/
Changed
- Blocks live in
resources/views/blocks/{slug}instead ofresources/blocks/{slug}, next to the Blade views, forpollora:make:block, itsBlocksServiceProviderstub and the Vite entries it generates. See Migrating fromresources/blocks pollora:make:blocklimits Vite full reloads underresources/viewsto Blade files: laravel-vite-plugin’srefreshPathsand aresources/views/**glob would reload the page on every block JSX change instead of hot-replacing it- BREAKING for custom
BlockRegistrarInterfaceimplementations: both methods gained the optional?string $basePath = nullparameter - Relicensed under MIT, like the other Pollora packages:
composer.jsonand the README declaredGPL-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.patchregenerated for them and reduced to the__()→__wp()rename. Itswp_mail()hunk no longer matched the stubs (WordPress added an$embedsparameter) and renamed a function nothing overrides mockery/mockery^1.6.11in development
Deprecated
- Blocks in
resources/blocksare 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 fromresources/views/blocks pollora:make:block --dynamic, now the default
Fixed
- A block
renderfile outside the block directory is no longer included: WordPress built its own render callback fromblock.jsonwhenever Pollora’s check rejected the path - Blocks built with
vite buildget their view script and stylesheets again: the Vite entries generated bypollora:make:blockonly listed each block’sindexscript, soviewScript,styleandeditorStylewere missing from the production manifest. Running the command again in a configured theme or plugin rewrites the entries pollora:make:blockaddswordpressPlugin()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.jsonstill ranpollora:env-setupinpost-autoload-dumpfailedcomposer installright 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:installpointed to a non-existentwp:env-setupcommand when the database connection failed- Asset containers no longer share one Vite configuration. Each
ViteManagerreconfigured Laravel’sVitesingleton in place, so the last container set up — typically the theme — imposed its hot file on every other one: with the theme onnpm run devand a plugin built for production, the plugin’s assets resolved as built but were enqueued as hot, and the block editor crashed withforceFullUrl(): Argument #1 ($path) must be of type string, array given. ThegetAssetUrlsmacro 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:installcompletes without interaction (--no-interaction, CI, piped stdin). It calledpollora:make:themewithout a name, which failed withNot enough arguments (missing: "name")after WordPress was installed; it now generates thedefaulttheme frompollora/theme-default— the theme WordPress activates on install — or the one named by the new--themeoptionpollora:installruns its migrations with--forceand fails when they fail. In production,migrateasks for confirmation and cancels when it cannot prompt, yet the install reportedMigration 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 astyle.csswith 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 printedCould not apply patch!on everycomposer install, including in projects built on the skeleton.patches/wordpress-core.patchstays: it is what letspollora/helper-overriderdeclare__()
v13.32.0-beta
Pre-release
Pollora now follows Laravel’s version numbers: this release requires Laravel 13.32.
Added
- Translation diagnostics in
pollora:statusand the admin dashboard — reports whether the__()override is the one actually installed, alongside the WordPress and Laravel locales.laravel/frameworkdeclares__()behind the samefunction_exists()guard aspollora/helper-overriderand Composer emitsautoload.filesin 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 declaringpollora_translation_resolver()— they ship in the samehelpers.php, so matching paths prove the package won the race whatever the install layout - WordPress Abilities API support through the new
pollora/abilitiespackage (requires WordPress 6.9)Abilityfacade for fluent declaration:Ability::define('acme/get-posts')->description(…)->category(…)->can(…)->using(…)#[Ability]attribute on classes implementingAbilityHandler, discovered automaticallyAbility::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 asreadOnlyHint,destructiveHintandidempotentHint - Typed
SchemaBuilderfor input and output JSON Schema, and a defensiveInputreader - 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 exceptparameter for selective exclusion:#[SkipDiscovery(except: [HookDiscovery::class])]skips all discoveries except the listed ones
- Classes annotated with
- Publishable
config/discovery.phpwithskip_classesandskip_pathsarrays for config-level exclusions (third-party packages, vendor classes) DiscoveryRegistrar— automatically registers Discovery classes from the service container, eliminating manualaddDiscovery()calls in ServiceProviderspollora_register()helper withModuleTypeenum for simplified theme/plugin registration- Themes:
pollora_register(ModuleType::Theme)— 3 lines infunctions.php, auto-detects theme name and path - Plugins:
pollora_register(ModuleType::Plugin, 'my-plugin', __DIR__)— replaces manualPluginRegistrarwiring
- Themes:
#[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 redundantgetMethods(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\Translaternow requires its$domainargument. The old'wordpress'default existed only to pair with thewordpress.key prefix thatpollora/helper-overrider1.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 (SidebarandMenusboth 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 unanchoredstr_replace(), so a value such as'Go to menus.example'came back as'Go to example', andtranslateItem()was typedstringunderdeclare(strict_types=1), so a wildcardtranslate(['*'])over a config array holding an int or bool raised aTypeError - BREAKING: Ajax module extracted to
pollora/ajaxpackage - BREAKING: Option module extracted to
pollora/optionpackage - BREAKING: Hook domain and adapters extracted to
pollora/hookpackage - 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 byDiscoveryRegistrarauto-registration - Empty
boot()methods removed fromLaravelPluginModuleandLaravelThemeModule(RectorRemoveParentDelegatingClassMethodRector) - Artisan command signatures renamed to Laravel colon convention (e.g.
pollora:make:theme) DiscoveryItems::all()optimized — replaced spread-in-loop witharray_merge- Redundant reflection pre-loading removed from
DiscoveryEngine
Fixed
WordPressHeadersmiddleware now respects theDONOTCACHEPAGEconstant 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'])raisedTypeError: Cannot access offset of type array in isset or emptywheneverLang::has()answered no: the guard normalised only the empty array to thedefaulttext domain, so a non-empty replacement array travelled into WordPress’stranslate()as the domain and reachedisset($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 noen_US.jsonexists at all, taking down every string with a placeholder. Requirespollora/helper-overrider1.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 unguardedLang::has()that raisedA facade root has not been set.wherever__()runs before or without an application, awordpress.prefix strip that rewrote the substring anywhere it appeared (__('Go to wordpress.org')returnedGo to org), Laravel group keys returning an array to callers typed against WordPress’sstring, and a missing base-language locale fallback that kept afr_FRsite from ever readinglang/fr.json- The
LoopandQueryfacade aliases no longer crash a page that uses them. Both were still declared inextra.laravel.aliasesafter their facade classes had been deleted —Loopsince9a50cac(2026-04-21),Querysince9c0cb42(2024-08-05). Laravel registers an alias without checking its target and only callsclass_alias()the first time the short name is used, so the package installed and booted cleanly and then threwClass "Pollora\Support\Facades\Loop" not foundon whichever page happened to call it. Present in every v13.4.x release. See the migration note below for what replacesLoop. PluginManagerTestisolation — realContainerwith dynamicWP_PLUGIN_DIRreplaces fragileContainerInterfacemock- WooCommerce hooks test updated for
ComingSoonHandlerdependency - PHPStan dead catches widened, redundant
@return $thisdocblocks removed OptionServicenamespace 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
LoopandQueryentries inextra.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:
| Removed | Replacement |
|---|---|
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(']]>', ']]>', …) |
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()andterms()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-madeclass="…"attribute string, whereget_post_class()returns an array.content()andexcerpt()appliedthe_content/the_excerptthemselves; dropping the filter silently strips whatever other plugins add there.tags()andterms()normalisedfalseto 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 byDiscoveryRegistrar)