v7.5.1.1

Author: saad-siddique

languages/uncanny-automator.pot

@@ -1368,7 +1368,10 @@ protected function create_url_agent_context( string $page_url ): Agent_Context {
 	public function get_launcher_html( WP_REST_Request $request ) {
 		unset( $request );
 
-		if ( ! $this->get_uncanny_agent_setting( Admin_Settings_Uncanny_Agent_General::ENABLED_KEY ) ) {
+		if (
+			! $this->get_uncanny_agent_setting( Admin_Settings_Uncanny_Agent_General::ENABLED_KEY )
+			|| ! $this->should_render_surface( 'admin_launcher' )
+		) {
 			return rest_ensure_response(
 				array(
 					'html' => '',

readme.txt

@@ -1,6 +1,6 @@
 <?php
 /**
- * Page Builder host availability use case.
+ * Page Builder new-page policy use case.
  *
  * @package Uncanny_Automator
  */
@@ -9,35 +9,54 @@
 
 namespace Uncanny_Automator\App\Application\Page_Builder;
 
+use Uncanny_Automator\App\Feature_State\Application\Get_Feature_State;
+use Uncanny_Automator\App\Feature_State\Domain\Feature_State;
+
 /**
- * Decides if the host can load Page Builder.
+ * Decides if users can start new Page Builder pages.
  *
  * @since 7.5
  */
 final class Can_Load_Page_Builder {
 
 	/**
-	 * Availability port.
+	 * Feature-state query.
 	 *
-	 * @var Page_Builder_Availability_Port
+	 * @var Get_Feature_State|null
 	 */
-	private $availability;
+	private $feature_state;
 
 	/**
 	 * Create the use case.
 	 *
-	 * @param Page_Builder_Availability_Port $availability Availability port.
+	 * The legacy availability port is still accepted so existing integrations do
+	 * not fatal, but it is no longer a policy source.
+	 *
+	 * @param Get_Feature_State|Page_Builder_Availability_Port $feature_state Feature-state query or deprecated availability port.
 	 */
-	public function __construct( Page_Builder_Availability_Port $availability ) {
-		$this->availability = $availability;
+	public function __construct( $feature_state ) {
+		if ( $feature_state instanceof Get_Feature_State ) {
+			$this->feature_state = $feature_state;
+			return;
+		}
+
+		if ( $feature_state instanceof Page_Builder_Availability_Port ) {
+			// Retain construction compatibility without treating the obsolete port
+			// as policy evidence. Composition belongs at the Infrastructure edge.
+			$this->feature_state = null;
+			return;
+		}
+
+		throw new \InvalidArgumentException( 'Page Builder requires the Automator feature-state query.' );
 	}
 
 	/**
-	 * Check if Page Builder can load.
+	 * Check if users can start new Page Builder pages.
 	 *
 	 * @return bool
 	 */
 	public function execute(): bool {
-		return $this->availability->is_available();
+		return $this->feature_state instanceof Get_Feature_State
+			&& $this->feature_state->execute()->is_visible( Feature_State::PAGE_BUILDER_MENU );
 	}
 }

src/app/Application/Mcp/Mcp_Client.php

@@ -10,9 +10,10 @@
 namespace Uncanny_Automator\App\Application\Page_Builder;
 
 /**
- * Supplies the host decision that permits Page Builder.
+ * Supplies the legacy host decision that permitted Page Builder.
  *
  * @since 7.5
+ * @deprecated 7.5.1.1 Use Get_Feature_State with PAGE_BUILDER_MENU.
  */
 interface Page_Builder_Availability_Port {
 

src/app/Application/Page_Builder/Can_Load_Page_Builder.php

@@ -12,9 +12,7 @@
 
 namespace Uncanny_Automator\App\Application;
 
-use Uncanny_Automator\App\Application\Page_Builder\Can_Load_Page_Builder;
 use Uncanny_Automator\App\Components\Page_Builder\Module;
-use Uncanny_Automator\App\Infrastructure\Page_Builder\Page_Builder_Availability;
 use Uncanny_Automator\App\Recipe_Builder\Field\Services\Field_Sanitizer_Legacy_Hooks;
 
 /**
@@ -38,7 +36,7 @@ class Services_Bootstrap {
 	 */
 	public function init(): void {
 		$this->register_field_hooks();
-		( new Module( new Can_Load_Page_Builder( new Page_Builder_Availability() ) ) )->register();
+		( new Module() )->register();
 	}
 
 	/**

src/app/Application/Page_Builder/Page_Builder_Availability_Port.php

@@ -63,22 +63,26 @@ class Module {
 	 */
 	private $compatibility;
 
-	/**
-	 * Page Builder availability use case.
-	 *
-	 * @var Can_Load_Page_Builder
-	 */
-	private $can_load_page_builder;
-
 	/**
 	 * Constructor.
 	 *
-	 * @param Can_Load_Page_Builder $can_load_page_builder Availability use case.
-	 * @param Compatibility|null    $compatibility         Compatibility policy.
+	 * The former Can_Load_Page_Builder argument remains accepted for binary
+	 * compatibility, but presentation policy no longer controls runtime boot.
+	 *
+	 * @param Can_Load_Page_Builder|Compatibility|null $legacy_gate_or_compatibility Deprecated gate or compatibility policy.
+	 * @param Compatibility|null                       $compatibility               Compatibility policy.
 	 */
-	public function __construct( Can_Load_Page_Builder $can_load_page_builder, ?Compatibility $compatibility = null ) {
-		$this->can_load_page_builder = $can_load_page_builder;
-		$this->compatibility         = $compatibility ?? new Compatibility();
+	public function __construct( $legacy_gate_or_compatibility = null, ?Compatibility $compatibility = null ) {
+		if ( $legacy_gate_or_compatibility instanceof Compatibility ) {
+			$this->compatibility = $legacy_gate_or_compatibility;
+			return;
+		}
+
+		if ( null !== $legacy_gate_or_compatibility && ! $legacy_gate_or_compatibility instanceof Can_Load_Page_Builder ) {
+			throw new \InvalidArgumentException( 'The Page Builder host received an unsupported dependency.' );
+		}
+
+		$this->compatibility = $compatibility ?? new Compatibility();
 	}
 
 	/**
@@ -100,17 +104,17 @@ public function register(): void {
 	 */
 	public function boot(): void {
 		try {
-			if ( ! $this->can_load_page_builder->execute() ) {
-				return;
-			}
-
+			// Feature policy controls new-page affordances, never runtime ownership.
+			// Existing editors and published pages must survive a policy transition.
 			$compatibility = $this->compatibility->check( $this->environment() );
 			if ( 'ready' !== $compatibility['status'] ) {
 				$this->set_status( $compatibility['status'], $compatibility['detail'] );
 				return;
 			}
 
-			define( 'AUTOMATOR_PAGE_BUILDER_OWNS_RUNTIME', true );
+			if ( ! defined( 'AUTOMATOR_PAGE_BUILDER_OWNS_RUNTIME' ) ) {
+				define( 'AUTOMATOR_PAGE_BUILDER_OWNS_RUNTIME', true );
+			}
 
 			if ( ! defined( 'AUTOMATOR_PAGE_BUILDER_MODULE_VERSION' ) ) {
 				define( 'AUTOMATOR_PAGE_BUILDER_MODULE_VERSION', self::MODULE_VERSION );

src/app/Application/Services_Bootstrap.php

@@ -0,0 +1,58 @@
+<?php
+/**
+ * Get the current Automator feature state.
+ *
+ * @package Uncanny_Automator
+ * @since 7.5.1.1
+ */
+
+declare(strict_types=1);
+
+namespace Uncanny_Automator\App\Feature_State\Application;
+
+use Uncanny_Automator\App\Feature_State\Domain\Feature_State;
+use Uncanny_Automator\App\Feature_State\Domain\Feature_State_Policy;
+use Uncanny_Automator\App\Feature_State\Ports\Policy_State_Port;
+
+/**
+ * Application query for the request-wide feature visibility decision.
+ *
+ * Consumers ask this use case instead of reading licenses themselves. One
+ * request therefore gets one coherent snapshot across settings, menus, Agent
+ * presentation, and Setup Wizard, regardless of which consumer asks first.
+ */
+final class Get_Feature_State {
+
+	private Policy_State_Port $policy_states;
+	private ?Feature_State $memoized_state = null;
+
+	/**
+	 * @param Policy_State_Port $policy_states Current policy-state provider.
+	 */
+	public function __construct( Policy_State_Port $policy_states ) {
+		$this->policy_states = $policy_states;
+	}
+
+	/**
+	 * Get a memoized feature state, hiding every feature when resolution fails.
+	 *
+	 * @return Feature_State
+	 */
+	public function execute(): Feature_State {
+		if ( null !== $this->memoized_state ) {
+			return $this->memoized_state;
+		}
+
+		try {
+			$this->memoized_state = Feature_State_Policy::evaluate( $this->policy_states->get_state() );
+		} catch ( \Throwable $error ) {
+			// Technical unavailability is separate from the 15 business rows. We keep
+			// it out of Policy_State and give every consumer the same memoized
+			// all-hidden snapshot, avoiding retries and mixed UI within one request.
+			unset( $error );
+			$this->memoized_state = Feature_State::all_hidden();
+		}
+
+		return $this->memoized_state;
+	}
+}

src/app/Components/Page_Builder/Module.php

@@ -0,0 +1,113 @@
+<?php
+/**
+ * Automator allocation facts used by the feature policy.
+ *
+ * @package Uncanny_Automator
+ * @since 7.5.1.1
+ */
+
+declare(strict_types=1);
+
+namespace Uncanny_Automator\App\Feature_State\Domain;
+
+/**
+ * Reduces a validated allocation ledger to policy-relevant observations.
+ */
+final class Allocation_Facts {
+
+	private int $active_allocations;
+	private int $used_allocations;
+	private int $expired_allocations;
+	private Pending_First_Use_Allocation $pending_first_use_allocation;
+
+	/**
+	 * @param int $active_allocations  Active allocation rows.
+	 * @param int $used_allocations    Fully used allocation rows.
+	 * @param int $expired_allocations Expired allocation rows.
+	 * @param Pending_First_Use_Allocation|null $pending_first_use_allocation Pending grant eligibility.
+	 */
+	private function __construct(
+		int $active_allocations,
+		int $used_allocations,
+		int $expired_allocations,
+		?Pending_First_Use_Allocation $pending_first_use_allocation
+	) {
+		if (
+			$active_allocations < 0
+			|| $used_allocations < 0
+			|| $expired_allocations < 0
+		) {
+			throw new \InvalidArgumentException( 'The allocation facts contain impossible row counts.' );
+		}
+
+		$this->active_allocations           = $active_allocations;
+		$this->used_allocations             = $used_allocations;
+		$this->expired_allocations          = $expired_allocations;
+		$this->pending_first_use_allocation = $pending_first_use_allocation ?? Pending_First_Use_Allocation::none();
+
+		if (
+			! $this->pending_first_use_allocation->is_none()
+			&& ( $active_allocations > 0 || $used_allocations > 0 || $expired_allocations > 0 )
+		) {
+			throw new \InvalidArgumentException( 'A pending first-use allocation cannot accompany observed allocation rows.' );
+		}
+	}
+
+	/**
+	 * Create facts observed from one successful allocation response.
+	 *
+	 * @param int $active_allocations  Active allocation rows.
+	 * @param int $used_allocations    Fully used allocation rows.
+	 * @param int $expired_allocations Expired allocation rows.
+	 * @param Pending_First_Use_Allocation|null $pending_first_use_allocation Pending grant eligibility.
+	 *
+	 * @return self
+	 */
+	public static function observed(
+		int $active_allocations,
+		int $used_allocations,
+		int $expired_allocations,
+		?Pending_First_Use_Allocation $pending_first_use_allocation = null
+	): self {
+		return new self(
+			$active_allocations,
+			$used_allocations,
+			$expired_allocations,
+			$pending_first_use_allocation
+		);
+	}
+
+	/**
+	 * Get the independently observed pending-grant fact.
+	 *
+	 * @return Pending_First_Use_Allocation
+	 */
+	public function pending_first_use_allocation(): Pending_First_Use_Allocation {
+		return $this->pending_first_use_allocation;
+	}
+
+	/**
+	 * Resolve the allocation vocabulary represented by the observations.
+	 *
+	 * @return Allocation_State
+	 */
+	public function state(): Allocation_State {
+		// MCP accounting classifies every allocation at one observation time.
+		// Active takes precedence because the account can also contain old history.
+		if ( $this->active_allocations > 0 ) {
+			return Allocation_State::valid_allocation();
+		}
+
+		if ( 0 === $this->used_allocations && 0 === $this->expired_allocations ) {
+			return Allocation_State::never_had_allocation();
+		}
+
+		// Expiry has precedence over full use when the remaining collection has
+		// both states. Policy_State decides which license types support that state.
+		if ( $this->expired_allocations > 0 ) {
+			return Allocation_State::expired_allocation();
+		}
+
+		return Allocation_State::used_100_percent_allocation();
+	}
+}