← All changes | includes/seo/class-schema-management-system.php +770 -86 2.0.1 → 2.14.1 View file →

		@@ -167,8 +167,20 @@
167	167	'rich_snippets' => ['video', 'video_carousel'],
168	168	'context_types' => ['post', 'page'],
169	169	'priority' => 'medium'
170	170	],
	171	+ // Offered by the metabox dropdown and registered in Schema_Factory, but
	172	+ // absent here — generate_schema_markup() keys off this array, so a
	173	+ // Review request was silently skipped (#462).
	174	+ 'Review' => [
	175	+ 'name' => 'Review',
	176	+ 'description' => 'Reviews and ratings of a product, service or place',
	177	+ 'required_properties' => ['itemReviewed', 'reviewRating', 'author'],
	178	+ 'recommended_properties' => ['reviewBody', 'datePublished', 'publisher'],
	179	+ 'rich_snippets' => ['review', 'review_snippet'],
	180	+ 'context_types' => ['post', 'page'],
	181	+ 'priority' => 'medium'
	182	+ ],
171	183	'Recipe' => [
172	184	'name' => 'Recipe',
173	185	'description' => 'Cooking recipes and food preparation',
174	186	'required_properties' => ['name', 'image', 'author', 'datePublished', 'description', 'recipeIngredient', 'recipeInstructions'],
		@@ -189,13 +201,43 @@
189	201	'WebPage' => [
190	202	'name' => 'WebPage',
191	203	'description' => 'Individual web pages',
192	204	'required_properties' => ['name', 'url'],
	205	+ // 'post' as well as 'page': the per-page selector reaches this for
	206	+ // any post type, and a registry limited to 'page' silently produced
	207	+ // nothing for the rest (#624).
193	208	'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
194	209	'rich_snippets' => ['webpage', 'breadcrumb'],
195		- 'context_types' => ['page'],
	210	+ 'context_types' => ['page', 'post'],
196	211	'priority' => 'medium'
197	212	],
	213	+ 'AboutPage' => [
	214	+ 'name' => 'AboutPage',
	215	+ 'description' => 'A page describing the organisation or person behind the site',
	216	+ 'required_properties' => ['name', 'url'],
	217	+ 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
	218	+ 'rich_snippets' => ['webpage', 'breadcrumb'],
	219	+ 'context_types' => ['page', 'post'],
	220	+ 'priority' => 'medium'
	221	+ ],
	222	+ 'ContactPage' => [
	223	+ 'name' => 'ContactPage',
	224	+ 'description' => 'A page giving contact details',
	225	+ 'required_properties' => ['name', 'url'],
	226	+ 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
	227	+ 'rich_snippets' => ['webpage', 'breadcrumb'],
	228	+ 'context_types' => ['page', 'post'],
	229	+ 'priority' => 'medium'
	230	+ ],
	231	+ 'ProfilePage' => [
	232	+ 'name' => 'ProfilePage',
	233	+ 'description' => 'A page about a single person or organisation',
	234	+ 'required_properties' => ['name', 'url'],
	235	+ 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
	236	+ 'rich_snippets' => ['webpage', 'breadcrumb'],
	237	+ 'context_types' => ['page', 'post'],
	238	+ 'priority' => 'medium'
	239	+ ],
198	240	'FAQPage' => [
199	241	'name' => 'FAQPage',
200	242	'description' => 'Frequently Asked Questions pages',
201	243	'required_properties' => ['mainEntity'],
		@@ -309,8 +351,19 @@
309	351	*/
310	352	private ?Schema_Cache_Manager $cache_manager = null;
311	353
312	354	/**
	355	+ * Whether the foreign-settings listener has been registered this request.
	356	+ *
	357	+ * Static because `thinkrank_seo_settings_saved` is a global hook — one
	358	+ * listener serves every instance. See the constructor for why (#463).
	359	+ *
	360	+ * @since 1.16.0
	361	+ * @var bool
	362	+ */
	363	+ private static bool $foreign_settings_listener_registered = false;
	364	+
	365	+ /**
313	366	* Constructor
314	367	*
315	368	* @since 1.0.0
316	369	*/
		@@ -326,11 +379,117 @@
326	379	$this->initialize_schema_builder();
327	380
328	381	// Initialize Schema Cache Manager for performance optimization
329	382	$this->initialize_cache_manager();
	383	+
	384	+ // LocalBusiness and Organization both read Business Info, which Site
	385	+ // Identity owns. Without this, editing an address or phone number never
	386	+ // refreshed the deployed schema (#455).
	387	+ //
	388	+ // Registered at most once per request. WordPress keys callbacks by
	389	+ // object hash, so binding $this here added a fresh listener for every
	390	+ // instance — and this class is constructed from inside the very callback
	391	+ // it registers, which doubled the listener count on every settings save
	392	+ // (#463). The guard is static because the hook itself is global.
	393	+ if (!self::$foreign_settings_listener_registered) {
	394	+ self::$foreign_settings_listener_registered = true;
	395	+ add_action('thinkrank_seo_settings_saved', [$this, 'refresh_schema_for_foreign_settings'], 10, 4);
	396	+ }
330	397	}
331	398
332	399	/**
	400	+ * Regenerate schema when another manager saves settings this schema reads.
	401	+ *
	402	+ * Site Identity owns the Business Info fields that feed LocalBusiness and
	403	+ * the Organization address/contactPoint, so a save there has to refresh the
	404	+ * deployed schema even though no schema setting changed.
	405	+ *
	406	+ * @since 2.0.2
	407	+ *
	408	+ * @param string $manager_type Settings category that was saved.
	409	+ * @param array $settings Settings that were written.
	410	+ * @param string $context_type Context type.
	411	+ * @param int|null $context_id Context ID.
	412	+ * @return void
	413	+ */
	414	+ public function refresh_schema_for_foreign_settings(
	415	+ string $manager_type,
	416	+ array $settings,
	417	+ string $context_type,
	418	+ ?int $context_id
	419	+ ): void {
	420	+ if ('site_identity' !== $manager_type) {
	421	+ return;
	422	+ }
	423	+
	424	+ $business_keys = [
	425	+ 'business_name', 'business_type', 'business_address', 'business_city',
	426	+ 'business_state', 'business_postal_code', 'business_country',
	427	+ 'business_phone', 'business_email', 'business_hours',
	428	+ 'business_latitude', 'business_longitude', 'business_price_range',
	429	+ ];
	430	+
	431	+ // Which deployed types a Site Identity key can invalidate. The business
	432	+ // block feeds LocalBusiness and Organization; alternate_name feeds the
	433	+ // WebSite node, which had no entry here at all — so editing it left the
	434	+ // deployed schema showing the previous value until something else
	435	+ // happened to redeploy (#692).
	436	+ $refresh_types = [];
	437	+
	438	+ if (!empty(array_intersect_key($settings, array_flip($business_keys)))) {
	439	+ $refresh_types[] = 'LocalBusiness';
	440	+ $refresh_types[] = 'Organization';
	441	+ }
	442	+
	443	+ if (array_key_exists('alternate_name', $settings)) {
	444	+ $refresh_types[] = 'WebSite';
	445	+ }
	446	+
	447	+ if (empty($refresh_types)) {
	448	+ return;
	449	+ }
	450	+
	451	+ $schema_settings = $this->get_settings($context_type, $context_id);
	452	+ if (empty($schema_settings['auto_deploy'])) {
	453	+ return;
	454	+ }
	455	+
	456	+ // Only refresh types that are actually deployed, so this never adds a
	457	+ // type the admin did not enable.
	458	+ $deployed = array_keys((array) $this->get_deployed_schemas($context_type, $context_id));
	459	+ $affected = array_values(array_intersect($deployed, $refresh_types));
	460	+
	461	+ if (empty($affected)) {
	462	+ return;
	463	+ }
	464	+
	465	+ try {
	466	+ $generation = $this->generate_schema_markup($context_type, $context_id, $affected);
	467	+
	468	+ // Deploy the types that validated, not all-or-nothing. Gating on
	469	+ // deployment_ready meant one invalid type blocked every valid one
	470	+ // in the same batch (#470).
	471	+ $deployable = [];
	472	+ foreach ($affected as $type) {
	473	+ if (!empty($generation['generated_schemas'][$type])
	474	+ && !empty($generation['validation_results'][$type]['is_valid'])
	475	+ ) {
	476	+ $deployable[$type] = $generation['generated_schemas'][$type];
	477	+ }
	478	+ }
	479	+
	480	+ if (!empty($deployable)) {
	481	+ $this->deploy_schema_markup($context_type, $context_id, $deployable);
	482	+ }
	483	+ } catch (\Exception $e) {
	484	+ if (defined('WP_DEBUG') && WP_DEBUG) {
	485	+ // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
	486	+ error_log('ThinkRank: Business Info schema refresh failed: ' . $e->getMessage());
	487	+ }
	488	+ }
	489	+ }
	490	+
	491	+ /**
333	492	* Initialize Schema Builder
334	493	*
335	494	* @return void
336	495	*/
		@@ -356,10 +515,20 @@
356	515	require_once THINKRANK_PLUGIN_DIR . 'includes/seo/class-schema-cache-manager.php';
357	516	}
358	517
359	518	if (class_exists('ThinkRank\\SEO\\Schema_Cache_Manager')) {
360		- // Get cache duration from deployment config
	519	+ // Honour the stored cache_duration setting. It is exposed in
	520	+ // get_settings_schema() (min 300 / max 86400), validated, persisted
	521	+ // and surfaced through both abilities — but the cache manager was
	522	+ // always built from the hardcoded config value, so the setting had
	523	+ // no effect (#473). Falls back to the config default.
361	524	$cache_duration = $this->deployment_config['caching']['duration'] ?? 3600;
	525	+
	526	+ $stored = $this->get_settings('site', null)['cache_duration'] ?? null;
	527	+ if (is_numeric($stored) && (int) $stored > 0) {
	528	+ $cache_duration = (int) $stored;
	529	+ }
	530	+
362	531	$this->cache_manager = new Schema_Cache_Manager($cache_duration);
363	532	}
364	533	}
365	534
		@@ -367,12 +536,19 @@
367	536	* Generate schema markup with comprehensive content analysis integration
368	537	*
369	538	* @since 1.0.0
370	539	*
	540	+ * Generation is read-only by default. Persisting the result is opt-in via
	541	+ * `$options['persist']`, because this method is also reached from the
	542	+ * front-end read path (get_output_data()) and from GET routes — where a
	543	+ * DELETE + INSERT would destroy the admin's deployed rows and publish
	544	+ * types nobody deployed (#460).
	545	+ *
371	546	* @param string $context_type Context type
372	547	* @param int|null $context_id Context ID
373	548	* @param array $schema_types Schema types to generate
374		- * @param array $options Generation options
	549	+ * @param array $options Generation options. Pass `persist => true`
	550	+ * from explicit write paths only.
375	551	* @return array Comprehensive schema generation results
376	552	*/
377	553	public function generate_schema_markup(string $context_type, ?int $context_id, array $schema_types = [], array $options = []): array {
378	554	$generation = [
		@@ -443,10 +619,16 @@
443	619
444	620	// Check deployment readiness
445	621	$generation['deployment_ready'] = $this->check_deployment_readiness($generation['validation_results']);
446	622
447		- // Store schema data
448		- $this->store_schema_data($context_type, $context_id, $generation);
	623	+ // Persistence belongs to deployment, not generation. Every write path
	624	+ // (refresh_schema_for_foreign_settings(), auto_deploy_schema_on_settings_change(),
	625	+ // the deploy route) calls deploy_schema_markup() straight after generating,
	626	+ // so nothing needs to opt in today — the flag exists to keep this an
	627	+ // explicit decision rather than an accident.
	628	+ if (!empty($options['persist'])) {
	629	+ $this->store_schema_data($context_type, $context_id, $generation);
	630	+ }
449	631
450	632	return $generation;
451	633	}
452	634
		@@ -548,8 +730,27 @@
548	730	return $optimization;
549	731	}
550	732
551	733	/**
	734	+ * Deployed types an authoritative deploy takes off the page.
	735	+ *
	736	+ * Everything deployed that the payload left out, except the types the
	737	+ * caller sent but could not deploy: those failed validation, they were not
	738	+ * removed by the user, so their live copy stays. Retiring them took the
	739	+ * site's Organization down behind a success toast (#949).
	740	+ *
	741	+ * @since 2.14.1
	742	+ *
	743	+ * @param string[] $deployed Types deployed for the context now.
	744	+ * @param string[] $payload Types in this deploy.
	745	+ * @param string[] $retain_types Types sent but skipped by validation.
	746	+ * @return string[] Types to retire.
	747	+ */
	748	+ public static function types_to_retire(array $deployed, array $payload, array $retain_types = []): array {
	749	+ return array_values(array_diff($deployed, $payload, $retain_types));
	750	+ }
	751	+
	752	+ /**
552	753	* Deploy schema markup with automated implementation
553	754	*
554	755	* @since 1.0.0
555	756	*
		@@ -574,8 +775,25 @@
574	775
575	776	// Determine deployment method
576	777	$deployment['deployment_method'] = $this->determine_deployment_method($options);
577	778
	779	+ // When the caller owns the whole context — the user pressing Deploy, where
	780	+ // the payload is exactly what the preview showed — anything not in that
	781	+ // payload should come off the page (#464). Incremental callers such as
	782	+ // auto_deploy_schema_on_settings_change() pass only the types they
	783	+ // regenerated, so they must NOT retire the rest.
	784	+ if (!empty($options['authoritative'])) {
	785	+ $deployment['retired_schemas'] = $this->retire_schema_types(
	786	+ $context_type,
	787	+ $context_id,
	788	+ self::types_to_retire(
	789	+ array_keys($this->get_deployed_schemas($context_type, $context_id)),
	790	+ array_keys($schema_data),
	791	+ (array) ($options['retain_types'] ?? [])
	792	+ )
	793	+ );
	794	+ }
	795	+
578	796	// Deploy each schema
579	797	foreach ($schema_data as $schema_type => $schema) {
580	798	$deploy_result = $this->deploy_single_schema($schema, $schema_type, $deployment['deployment_method'], $context_type, $context_id);
581	799	$deployment['deployed_schemas'][$schema_type] = $deploy_result;
		@@ -661,9 +879,9 @@
661	879	}
662	880
663	881	return [
664	882	'validation_passed' => true,
665		- 'message' => __('Schema deployed and verified on the front end', 'thinkrank'),
	883	+ 'message' => __('Schema deployed and read back from storage', 'thinkrank'),
666	884	'missing_types' => []
667	885	];
668	886	}
669	887
		@@ -783,9 +1001,11 @@
783	1001	'validation_results' => [],
784	1002	'rich_snippets_preview' => [],
785	1003	'performance_data' => [],
786	1004	'recommendations' => [],
787		- 'enabled' => true
	1005	+ // Report the real setting. Hardcoding true here told every consumer
	1006	+ // the feature was on even when the master switch was off (#461).
	1007	+ 'enabled' => (bool) ($settings['enabled'] ?? true)
788	1008	];
789	1009
790	1010	// Get enabled schema types
791	1011	$enabled_types = $settings['enabled_schema_types'] ?? [];
		@@ -1125,9 +1345,9 @@
1125	1345	$this->cache_manager->invalidate_all_cache();
1126	1346	}
1127	1347
1128	1348	// AUTO-DEPLOY: Automatically regenerate and deploy schema when settings change
1129		- if ($success && !empty($settings['auto_deploy'])) {
	1349	+ if ($success && self::should_auto_deploy($settings, $this->get_settings($context_type, $context_id))) {
1130	1350	$this->auto_deploy_schema_on_settings_change($context_type, $context_id, $settings);
1131	1351	}
1132	1352
1133	1353	return $success;
		@@ -1132,9 +1352,35 @@
1132	1352
1133	1353	return $success;
1134	1354	}
1135	1355
	1356	+
1136	1357	/**
	1358	+ * Whether a save should redeploy the schema it changed.
	1359	+ *
	1360	+ * `auto_deploy` is a stored setting (on by default), not something a save
	1361	+ * restates. Reading it off the incoming patch meant a partial save — which
	1362	+ * is what the admin screen sends, one field at a time — skipped
	1363	+ * auto-deploy on a site that had it switched on, and the deployed snapshot
	1364	+ * the front end serves kept the name, logo and sameAs it was deployed
	1365	+ * with, however often the user saved (#904, the gate #12 left in place).
	1366	+ *
	1367	+ * A patch that does carry the key still wins, so a caller can deploy or
	1368	+ * hold deliberately.
	1369	+ *
	1370	+ * @param array $patch Settings being saved
	1371	+ * @param array $stored Settings as stored, after the save
	1372	+ * @return bool
	1373	+ */
	1374	+ public static function should_auto_deploy(array $patch, array $stored): bool {
	1375	+ if (array_key_exists('auto_deploy', $patch)) {
	1376	+ return !empty($patch['auto_deploy']);
	1377	+ }
	1378	+
	1379	+ return !empty($stored['auto_deploy']);
	1380	+ }
	1381	+
	1382	+ /**
1137	1383	* Auto-deploy schema when settings change
1138	1384	*
1139	1385	* Automatically regenerates and deploys schema markup when organization or other
1140	1386	* schema settings are modified, ensuring the frontend output stays in sync.
		@@ -1171,38 +1417,59 @@
1171	1417	if ($this->has_person_settings_changed($settings)) {
1172	1418	$schema_types_to_regenerate[] = 'Person';
1173	1419	}
1174	1420
	1421	+ // Honour the user's Schema Types selection. Without this the payload
	1422	+ // shape alone decided what shipped, so every save deployed all four
	1423	+ // types — including ones the user had explicitly deselected (#461).
	1424	+ // An empty selection means "auto", so only filter when one is set.
	1425	+ $enabled_types = $settings['enabled_schema_types'] ?? $this->get_settings($context_type, $context_id)['enabled_schema_types'] ?? [];
	1426	+
	1427	+ if (!empty($enabled_types) && is_array($enabled_types)) {
	1428	+ $schema_types_to_regenerate = array_values(
	1429	+ array_intersect($schema_types_to_regenerate, $enabled_types)
	1430	+ );
	1431	+ }
	1432	+
	1433	+ // Types that were deployed but are no longer wanted must come back off
	1434	+ // the page — deployment used to be additive-only (#464).
	1435	+ $this->retire_unselected_schema_types($context_type, $context_id, $enabled_types);
	1436	+
1175	1437	// If no schema types need regeneration, return early
1176	1438	if (empty($schema_types_to_regenerate)) {
1177	1439	return;
1178	1440	}
1179	1441
1180		- // Generate and deploy each schema type
1181		- foreach ($schema_types_to_regenerate as $schema_type) {
1182		- try {
1183		- // Generate schema using generate_schema_markup
1184		- $generation_result = $this->generate_schema_markup(
1185		- $context_type,
1186		- $context_id,
1187		- [$schema_type]
1188		- );
	1442	+ // Generate every affected type in ONE call. Generating them one at a
	1443	+ // time re-entered store_schema_data() per type, and each pass replaced
	1444	+ // the rows written by the previous one, so only the last type survived
	1445	+ // (#454). One batch also means one delete and one cache flush.
	1446	+ try {
	1447	+ $generation_result = $this->generate_schema_markup(
	1448	+ $context_type,
	1449	+ $context_id,
	1450	+ $schema_types_to_regenerate
	1451	+ );
1189	1452
1190		- // Deploy if generation was successful
1191		- if (!empty($generation_result['generated_schemas'][$schema_type]) && $generation_result['deployment_ready']) {
1192		- $this->deploy_schema_markup(
1193		- $context_type,
1194		- $context_id,
1195		- [$schema_type => $generation_result['generated_schemas'][$schema_type]]
1196		- );
	1453	+ $deployable = [];
	1454	+ foreach ($schema_types_to_regenerate as $schema_type) {
	1455	+ // Only deploy what validated — see #470.
	1456	+ if (!empty($generation_result['generated_schemas'][$schema_type])
	1457	+ && !empty($generation_result['validation_results'][$schema_type]['is_valid'])
	1458	+ ) {
	1459	+ $deployable[$schema_type] = $generation_result['generated_schemas'][$schema_type];
1197	1460	}
1198		- } catch (\Exception $e) {
1199		- // Log error but don't fail the settings save
1200		- if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
1201		- // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
1202		- error_log('ThinkRank: Auto-deploy failed for ' . $schema_type . ': ' . $e->getMessage());
1203		- }
1204	1461	}
	1462	+
	1463	+ if (!empty($deployable)) {
	1464	+ $this->deploy_schema_markup($context_type, $context_id, $deployable);
	1465	+ }
	1466	+ } catch (\Exception $e) {
	1467	+ // Log error but don't fail the settings save
	1468	+ if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
	1469	+ // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
	1470	+ error_log('ThinkRank: Auto-deploy failed for ' . implode(', ', $schema_types_to_regenerate) . ': ' . $e->getMessage());
	1471	+ }
1205	1472	}
1206	1473	}
1207	1474
1208	1475	/**
		@@ -1240,9 +1507,15 @@
1240	1507	* @param array $settings Updated settings
1241	1508	* @return bool True if website settings changed
1242	1509	*/
1243	1510	private function has_website_settings_changed(array $settings): bool {
1244		- $website_keys = ['site_name', 'site_description', 'site_url'];
	1511	+ // These are the keys the Website tab actually stores. It previously
	1512	+ // looked for site_name/site_description/site_url, which belong to Site
	1513	+ // Identity and never appear in a schema settings payload — so WebSite
	1514	+ // schema never auto-deployed no matter what was edited (#455).
	1515	+ $website_keys = [
	1516	+ 'website_name', 'website_url', 'website_description', 'website_author',
	1517	+ ];
1245	1518
1246	1519	foreach ($website_keys as $key) {
1247	1520	if (isset($settings[$key])) {
1248	1521	return true;
		@@ -1260,11 +1533,20 @@
1260	1533	* @param array $settings Updated settings
1261	1534	* @return bool True if business settings changed
1262	1535	*/
1263	1536	private function has_business_settings_changed(array $settings): bool {
	1537	+ // Only the keys this manager actually stores. business_name/address/
	1538	+ // phone/hours live in the site_identity category and never reach a
	1539	+ // schema settings save, so keying off them meant LocalBusiness never
	1540	+ // auto-deployed (#455). Edits to those fields refresh LocalBusiness
	1541	+ // through the Site Identity save path instead — see
	1542	+ // refresh_schema_for_foreign_settings().
1264	1543	$business_keys = [
1265		- 'business_name', 'business_type', 'business_address', 'business_phone',
1266		- 'business_hours', 'business_price_range'
	1544	+ 'enable_local_business',
	1545	+ 'business_price_range',
	1546	+ 'business_geo_latitude',
	1547	+ 'business_geo_longitude',
	1548	+ 'business_opening_hours',
1267	1549	];
1268	1550
1269	1551	foreach ($business_keys as $key) {
1270	1552	if (isset($settings[$key])) {
		@@ -1308,8 +1590,29 @@
1308	1590	$detected_types = [];
1309	1591
1310	1592	switch ($context_type) {
1311	1593	case 'site':
	1594	+ // The admin's Schema Types selection is the answer to "what
	1595	+ // does this site need"; detection is only the fallback for an
	1596	+ // install that has not chosen yet (#456).
	1597	+ $settings = $this->get_settings($context_type, $context_id);
	1598	+ $enabled = array_values(array_filter(
	1599	+ array_map('strval', (array) ($settings['enabled_schema_types'] ?? [])),
	1600	+ 'strlen'
	1601	+ ));
	1602	+
	1603	+ // Drop stale names the factory no longer registers rather than
	1604	+ // handing them to the builder to silently skip.
	1605	+ $enabled = array_values(array_filter(
	1606	+ $enabled,
	1607	+ fn($type) => isset($this->schema_types[$type])
	1608	+ ));
	1609	+
	1610	+ if (!empty($enabled)) {
	1611	+ $detected_types = $enabled;
	1612	+ break;
	1613	+ }
	1614	+
1312	1615	$detected_types = ['Organization'];
1313	1616	// Check if it's a local business
1314	1617	if ($this->is_local_business()) {
1315	1618	$detected_types[] = 'LocalBusiness';
		@@ -1372,20 +1675,35 @@
1372	1675	} elseif ($context_id && in_array($context_type, ['post', 'page', 'product'], true)) {
1373	1676	// Post/page/product data
1374	1677	$post = get_post($context_id);
1375	1678	if ($post) {
	1679	+ // Resolve the featured image's URL to its ID here, where the ID
	1680	+ // is in hand, so the schema builder does not query for an
	1681	+ // attachment it was just given (#847). Offered as a hint rather
	1682	+ // than asserted: `post_thumbnail_url` can swap the URL for one
	1683	+ // the featured image does not own.
	1684	+ $thumbnail_url = get_the_post_thumbnail_url($post->ID, 'full');
	1685	+
	1686	+ if ($thumbnail_url) {
	1687	+ Attachment_Lookup::id_from_url((string) $thumbnail_url, (int) get_post_thumbnail_id($post->ID));
	1688	+ }
	1689	+
1376	1690	$content_data = [
1377	1691	'title' => $post->post_title,
1378	1692	'url' => get_permalink($post->ID),
1379		- 'excerpt' => $post->post_excerpt ?: wp_trim_words($post->post_content, 30),
	1693	+ 'excerpt' => $post->post_excerpt ?: \ThinkRank\Core\Seo_Text::trim_words($post->post_content, 30),
1380	1694	'content' => $post->post_content,
1381	1695	'author' => [
1382	1696	'name' => get_the_author_meta('display_name', $post->post_author),
1383	1697	'url' => get_author_posts_url($post->post_author)
1384	1698	],
1385		- 'date' => $post->post_date,
1386		- 'modified' => $post->post_modified,
1387		- 'image' => get_the_post_thumbnail_url($post->ID, 'full'),
	1699	+ // ISO 8601 with offset. post_date/post_modified are raw
	1700	+ // MySQL columns in site-local time with no timezone, which
	1701	+ // Google rejects as "Invalid value in field datePublished"
	1702	+ // and drops the Article rich result (#465).
	1703	+ 'date' => get_the_date('c', $post),
	1704	+ 'modified' => get_the_modified_date('c', $post),
	1705	+ 'image' => $thumbnail_url,
1388	1706	'focus_keywords' => Focus_Keywords::get($post->ID),
1389	1707	'business_data' => $this->get_business_data_from_local_seo(),
1390	1708	'site_data' => $this->get_site_data_for_schema(),
1391	1709	'social_data' => $this->get_social_data_for_schema()
		@@ -1479,10 +1797,16 @@
1479	1797	global $wpdb;
1480	1798
1481	1799	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1482	1800
1483		- // First, delete all existing schemas for this context to ensure clean storage
1484		- $this->delete_existing_schemas($context_type, $context_id);
	1801	+ // Replace only the types in this batch. Clearing the whole context
	1802	+ // destroyed types the caller never asked about — and callers do
	1803	+ // regenerate a subset, one type at a time (#454).
	1804	+ $generated_types = array_keys($generation['generated_schemas'] ?? []);
	1805	+ if (empty($generated_types)) {
	1806	+ return false;
	1807	+ }
	1808	+ $this->delete_existing_schemas($context_type, $context_id, $generated_types);
1485	1809
1486	1810	foreach ($generation['generated_schemas'] as $schema_type => $schema_data) {
1487	1811	// Prepare schema data with validation status embedded
1488	1812	$schema_data_with_validation = $schema_data;
		@@ -1498,9 +1822,13 @@
1498	1822	'context_id' => $context_id,
1499	1823	'schema_type' => $schema_type,
1500	1824	'schema_data' => wp_json_encode($schema_data_with_validation),
1501	1825	'validation_status' => $generation['validation_results'][$schema_type]['is_valid'] ? 'valid' : 'invalid',
1502		- 'is_active' => $generation['deployment_ready'] ? 1 : 0
	1826	+ // Per-type, not batch-wide. deployment_ready is only true when
	1827	+ // EVERY type in the batch validated, so one invalid type (a site
	1828	+ // with no Business Info makes LocalBusiness invalid) deactivated
	1829	+ // all the valid ones alongside it (#470).
	1830	+ 'is_active' => !empty($generation['validation_results'][$schema_type]['is_valid']) ? 1 : 0
1503	1831	];
1504	1832
1505	1833	// Insert new schema (existing ones were already deleted)
1506	1834	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema insertion requires direct database access
		@@ -1768,12 +2096,10 @@
1768	2096
1769	2097	/**
1770	2098	* Get deployed schemas for frontend integration
1771	2099	*
1772		- * PERFORMANCE OPTIMIZED: This method now uses:
1773		- * 1. Schema caching layer (90% reduction in database queries)
1774		- * 2. Window function approach instead of correlated subquery (80-90% query performance improvement)
1775		- * 3. Composite index: idx_context_schema_active
	2100	+ * Returns the newest active, deployed row of each schema type for the
	2101	+ * context. Results are cached per context (see Schema_Cache_Manager).
1776	2102	*
1777	2103	* @since 1.0.0
1778	2104	*
1779	2105	* @param string $context_type Context type
		@@ -1796,48 +2122,57 @@
1796	2122
1797	2123	// Use existing seo_schema table
1798	2124	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1799	2125
1800		- // OPTIMIZED QUERY: Use window function approach to eliminate correlated subquery
1801		- // This leverages the new composite index: idx_context_schema_active (context_type, schema_type, is_active, created_at DESC)
	2126	+ // The newest row per type used to be picked with ROW_NUMBER() OVER
	2127	+ // (PARTITION BY schema_type ...). Window functions need MySQL 8.0 /
	2128	+ // MariaDB 10.2, and WordPress still runs on MySQL 5.7, where that is
	2129	+ // a syntax error on every page view and no deployed schema is ever
	2130	+ // output. A row is the newest of its type when no other row of the
	2131	+ // same context and type outranks it, so NOT EXISTS keeps the
	2132	+ // greatest-per-group in the database, and schema_data — JSON, and
	2133	+ // large — is only transferred for the rows that are output.
	2134	+ //
	2135	+ // `<=>` is NULL-safe equality: the site context stores context_id
	2136	+ // as NULL, and `n.context_id = s.context_id` is never true for it.
	2137	+ // schema_id breaks a same-second tie, which the window function
	2138	+ // left to chance.
	2139	+ $args = [$context_type];
1802	2140	if (null === $context_id) {
1803		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1804		- $sql = sprintf(
1805		- 'SELECT schema_type, schema_data FROM (SELECT schema_type, schema_data, ROW_NUMBER() OVER (PARTITION BY schema_type ORDER BY created_at DESC) as rn FROM %s WHERE context_type = %%s AND context_id IS NULL AND is_active = 1 AND validation_status IN (\'deployed\', \'valid\')) ranked WHERE rn = 1 ORDER BY schema_type',
1806		- $table_name
1807		- );
1808		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1809		- $deployed_schemas = $wpdb->get_results(
1810		- $wpdb->prepare(
1811		- // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1812		- $sql,
1813		- $context_type
1814		- ),
1815		- ARRAY_A
1816		- );
	2141	+ $context_where = 's.context_id IS NULL';
1817	2142	} else {
1818		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1819		- $sql = sprintf(
1820		- 'SELECT schema_type, schema_data FROM (SELECT schema_type, schema_data, ROW_NUMBER() OVER (PARTITION BY schema_type ORDER BY created_at DESC) as rn FROM %s WHERE context_type = %%s AND context_id = %%d AND is_active = 1 AND validation_status IN (\'deployed\', \'valid\')) ranked WHERE rn = 1 ORDER BY schema_type',
1821		- $table_name
1822		- );
1823		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1824		- $deployed_schemas = $wpdb->get_results(
1825		- $wpdb->prepare(
1826		- // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1827		- $sql,
1828		- $context_type,
1829		- $context_id
1830		- ),
1831		- ARRAY_A
1832		- );
	2143	+ $context_where = 's.context_id = %d';
	2144	+ $args[] = $context_id;
1833	2145	}
1834	2146
	2147	+ $sql = sprintf(
	2148	+ 'SELECT s.schema_type, s.schema_data FROM %1$s s'
	2149	+ . ' WHERE s.context_type = %%s AND %2$s AND s.is_active = 1 AND s.validation_status IN (\'deployed\', \'valid\')'
	2150	+ . ' AND NOT EXISTS ('
	2151	+ . 'SELECT 1 FROM %1$s n'
	2152	+ . ' WHERE n.context_type = s.context_type AND n.context_id <=> s.context_id AND n.schema_type = s.schema_type'
	2153	+ . ' AND n.is_active = 1 AND n.validation_status IN (\'deployed\', \'valid\')'
	2154	+ . ' AND (n.created_at > s.created_at OR (n.created_at = s.created_at AND n.schema_id > s.schema_id))'
	2155	+ . ')'
	2156	+ . ' ORDER BY s.schema_type',
	2157	+ $table_name,
	2158	+ $context_where
	2159	+ );
	2160	+
	2161	+ // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
	2162	+ $deployed_schemas = $wpdb->get_results(
	2163	+ $wpdb->prepare(
	2164	+ // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
	2165	+ $sql,
	2166	+ ...$args
	2167	+ ),
	2168	+ ARRAY_A
	2169	+ );
	2170	+
1835	2171	// Deliberately no early return on an empty result: it has to reach the
1836	2172	// cache write below. Most URLs have no deployed schema, so gating the
1837	2173	// write on a non-empty result made the majority of front-end requests
1838		- // permanent cache misses, re-running a ROW_NUMBER() OVER (PARTITION BY
1839		- // ...) query with two filesorts on every pageview (#392).
	2174	+ // permanent cache misses, re-running the query on every pageview (#392).
1840	2175	$deployed_schemas = $deployed_schemas ?: [];
1841	2176
1842	2177	// Process schemas for return
1843	2178	$processed_schemas = [];
		@@ -1850,8 +2185,26 @@
1850	2185	if (isset($schema_data['_validation'])) {
1851	2186	unset($schema_data['_validation']);
1852	2187	}
1853	2188
	2189	+ // Deployed schema is a snapshot, so rows written before #465
	2190	+ // still carry raw MySQL datetimes. Normalise on read so the
	2191	+ // fix reaches existing sites without a migration.
	2192	+ $schema_data = $this->normalize_stored_schema($schema_data);
	2193	+
	2194	+ // The permalink was frozen at deploy time, so schema deployed
	2195	+ // while a post was a draft advertised "?p=123" as both url and
	2196	+ // mainEntityOfPage forever — contradicting the node's own @id
	2197	+ // and the canonical (#470). Resolve it live instead.
	2198	+ $schema_data = $this->refresh_schema_permalink($schema_data, $context_type, $context_id);
	2199	+
	2200	+ // schema.org types `sameAs`, `url`, `logo` and `image` as URLs,
	2201	+ // but the form stored whatever was typed, so free text entered
	2202	+ // in a social-profile field shipped as a sameAs member and made
	2203	+ // the whole entity invalid (#480). Drop bad values on read, so
	2204	+ // existing sites stop emitting them without a migration.
	2205	+ $schema_data = $this->filter_entity_urls($schema_data);
	2206	+
1854	2207	$processed_schemas[$schema_type] = [
1855	2208	'data' => $schema_data,
1856	2209	'method' => 'json_ld', // Default method
1857	2210	'type' => $schema_type
		@@ -1871,8 +2224,233 @@
1871	2224	return $processed_schemas;
1872	2225	}
1873	2226
1874	2227	/**
	2228	+ * Properties schema.org defines as URLs.
	2229	+ *
	2230	+ * @since 2.0.2
	2231	+ * @var string[]
	2232	+ */
	2233	+ private const URL_PROPERTIES = ['sameAs', 'url', 'logo', 'image'];
	2234	+
	2235	+ /**
	2236	+ * Whether a value is a URL safe to publish in structured data.
	2237	+ *
	2238	+ * @since 2.0.2
	2239	+ *
	2240	+ * @param mixed $url Candidate value.
	2241	+ * @return bool
	2242	+ */
	2243	+ private function is_publishable_url($url): bool {
	2244	+ if (!is_string($url) || '' === trim($url)) {
	2245	+ return false;
	2246	+ }
	2247	+
	2248	+ if (!filter_var($url, FILTER_VALIDATE_URL)) {
	2249	+ return false;
	2250	+ }
	2251	+
	2252	+ $scheme = wp_parse_url($url, PHP_URL_SCHEME);
	2253	+
	2254	+ return in_array(strtolower((string) $scheme), ['http', 'https'], true);
	2255	+ }
	2256	+
	2257	+ /**
	2258	+ * Drop values that are not URLs from URL-typed properties.
	2259	+ *
	2260	+ * An absent property is valid; one holding free text is not, and it can
	2261	+ * invalidate the entity around it. Nested objects (`logo` and `image` are
	2262	+ * frequently ImageObjects) are walked so a bad `url` inside one is caught
	2263	+ * too. A property left with nothing is removed rather than emitted empty.
	2264	+ *
	2265	+ * @since 2.0.2
	2266	+ *
	2267	+ * @param array $schema Decoded schema data.
	2268	+ * @return array Schema carrying only publishable URLs.
	2269	+ */
	2270	+ private function filter_entity_urls(array $schema): array {
	2271	+ foreach ($schema as $key => $value) {
	2272	+ if (is_array($value) && !in_array($key, self::URL_PROPERTIES, true)) {
	2273	+ $schema[$key] = $this->filter_entity_urls($value);
	2274	+ continue;
	2275	+ }
	2276	+
	2277	+ if (!in_array($key, self::URL_PROPERTIES, true)) {
	2278	+ continue;
	2279	+ }
	2280	+
	2281	+ // A nested object (ImageObject and friends) carries its own url.
	2282	+ if (is_array($value) && isset($value['@type'])) {
	2283	+ $schema[$key] = $this->filter_entity_urls($value);
	2284	+ continue;
	2285	+ }
	2286	+
	2287	+ if (is_array($value)) {
	2288	+ $kept = [];
	2289	+
	2290	+ foreach ($value as $item) {
	2291	+ if (is_array($item)) {
	2292	+ $kept[] = $this->filter_entity_urls($item);
	2293	+ } elseif ($this->is_publishable_url($item)) {
	2294	+ $kept[] = $item;
	2295	+ }
	2296	+ }
	2297	+
	2298	+ if ([] === $kept) {
	2299	+ unset($schema[$key]);
	2300	+ } else {
	2301	+ $schema[$key] = array_values($kept);
	2302	+ }
	2303	+
	2304	+ continue;
	2305	+ }
	2306	+
	2307	+ if (!$this->is_publishable_url($value)) {
	2308	+ unset($schema[$key]);
	2309	+ }
	2310	+ }
	2311	+
	2312	+ return $schema;
	2313	+ }
	2314	+
	2315	+ /**
	2316	+ * Schema types whose `url` identifies the entity, not the page.
	2317	+ *
	2318	+ * On a Person or an Organization, `url` is that entity's own website, so
	2319	+ * overwriting it with the permalink of whichever post the schema happens to
	2320	+ * be deployed on is simply wrong. It also breaks graph assembly: the site
	2321	+ * identity emits the same entity with its real `url`, and once the two
	2322	+ * copies disagree they can no longer be recognised as one entity (#479).
	2323	+ *
	2324	+ * @since 2.0.2
	2325	+ * @var string[]
	2326	+ */
	2327	+ private const ENTITY_URL_TYPES = ['Person', 'Organization', 'LocalBusiness'];
	2328	+
	2329	+ /**
	2330	+ * Replace a stored permalink snapshot with the post's live permalink.
	2331	+ *
	2332	+ * Only touches `url` and `mainEntityOfPage`, and only for post-like
	2333	+ * contexts where a permalink actually exists. Identity entities are
	2334	+ * exempt from the `url` rewrite — see self::ENTITY_URL_TYPES.
	2335	+ *
	2336	+ * @since 1.16.0
	2337	+ *
	2338	+ * @param array $schema Decoded schema data.
	2339	+ * @param string $context_type Context type.
	2340	+ * @param int|null $context_id Context ID.
	2341	+ * @return array Schema with a current permalink.
	2342	+ */
	2343	+ private function refresh_schema_permalink(array $schema, string $context_type, ?int $context_id): array {
	2344	+ if ('site' === $context_type || empty($context_id)) {
	2345	+ return $schema;
	2346	+ }
	2347	+
	2348	+ $permalink = get_permalink($context_id);
	2349	+
	2350	+ if (!$permalink) {
	2351	+ return $schema;
	2352	+ }
	2353	+
	2354	+ $type = $schema['@type'] ?? '';
	2355	+ $type = is_array($type) ? reset($type) : $type;
	2356	+ // A LocalBusiness is deployed under the subtype the site chose, so the
	2357	+ // exemption has to cover every subtype, not only the literal root.
	2358	+ $is_entity = in_array((string) $type, self::ENTITY_URL_TYPES, true)
	2359	+ || \ThinkRank\Config\Local_Business_Types_Config::is_local_business($type);
	2360	+
	2361	+ if (isset($schema['url']) && !$is_entity) {
	2362	+ $schema['url'] = $permalink;
	2363	+ }
	2364	+
	2365	+ if (isset($schema['mainEntityOfPage'])) {
	2366	+ if (is_array($schema['mainEntityOfPage'])) {
	2367	+ if (isset($schema['mainEntityOfPage']['@id'])) {
	2368	+ $schema['mainEntityOfPage']['@id'] = $permalink;
	2369	+ }
	2370	+ } else {
	2371	+ $schema['mainEntityOfPage'] = $permalink;
	2372	+ }
	2373	+ }
	2374	+
	2375	+ return $schema;
	2376	+ }
	2377	+
	2378	+ /**
	2379	+ * Normalise properties that stored snapshots may hold in a stale format.
	2380	+ *
	2381	+ * Deployed schema is written once and read forever, so a formatting fix in
	2382	+ * the builder never reaches rows already on disk. Correcting on read means
	2383	+ * existing sites benefit without a migration.
	2384	+ *
	2385	+ * Covers non-ISO-8601 dates (#465) and WP locales in inLanguage, which must
	2386	+ * be a BCP-47 tag — en-US, not en_US (#473). Walks nested nodes so values
	2387	+ * inside author/publisher/@graph entries are covered too.
	2388	+ *
	2389	+ * Also decodes HTML entities in plain-text properties. Schema_Builder
	2390	+ * stored the block editor's `&amp;` as-is until 2.10.0, and nothing
	2391	+ * decodes JSON-LD downstream, so every deployed node built from post text
	2392	+ * published the entity literally.
	2393	+ *
	2394	+ * @since 1.16.0
	2395	+ * @since 2.10.0 Decodes entities in plain-text properties.
	2396	+ *
	2397	+ * @param array $schema Decoded schema data.
	2398	+ * @return array Normalised schema.
	2399	+ */
	2400	+ private function normalize_stored_schema(array $schema): array {
	2401	+ static $date_keys = [
	2402	+ 'datePublished', 'dateModified', 'dateCreated', 'uploadDate',
	2403	+ 'startDate', 'endDate', 'validFrom', 'validThrough', 'expires',
	2404	+ ];
	2405	+
	2406	+ // Plain text in schema.org. Answer/HowToStep `text` is deliberately
	2407	+ // absent: Google reads Answer.text as HTML, where an entity is correct
	2408	+ // and decoding `&lt;` would turn escaped text into live markup.
	2409	+ static $text_keys = [
	2410	+ 'name', 'headline', 'alternativeHeadline', 'description',
	2411	+ 'reviewBody', 'about', 'abstract', 'caption',
	2412	+ ];
	2413	+
	2414	+ foreach ($schema as $key => $value) {
	2415	+ if (is_array($value)) {
	2416	+ $schema[$key] = $this->normalize_stored_schema($value);
	2417	+ continue;
	2418	+ }
	2419	+
	2420	+ if ('inLanguage' === $key && is_string($value) && '' !== $value) {
	2421	+ $schema[$key] = str_replace('_', '-', $value);
	2422	+ continue;
	2423	+ }
	2424	+
	2425	+ // Decode only: a snapshot already truncated with an ellipsis must
	2426	+ // keep it, which the full Seo_Text::normalize_schema_text() would
	2427	+ // strip as an excerpt marker.
	2428	+ if (in_array($key, $text_keys, true) && is_string($value) && '' !== $value) {
	2429	+ $schema[$key] = \ThinkRank\Core\Seo_Text::decode_schema_entities($value);
	2430	+ continue;
	2431	+ }
	2432	+
	2433	+ if (!in_array($key, $date_keys, true) || !is_string($value) || '' === $value) {
	2434	+ continue;
	2435	+ }
	2436	+
	2437	+ // Already ISO 8601 — leave it alone.
	2438	+ if (preg_match('/^\d{4}-\d{2}-\d{2}T/', $value)) {
	2439	+ continue;
	2440	+ }
	2441	+
	2442	+ $timestamp = strtotime($value);
	2443	+
	2444	+ if (false !== $timestamp) {
	2445	+ $schema[$key] = (string) wp_date('c', $timestamp);
	2446	+ }
	2447	+ }
	2448	+
	2449	+ return $schema;
	2450	+ }
	2451	+
	2452	+ /**
1875	2453	* Clean up duplicate schemas in database
1876	2454	*
1877	2455	* @since 1.0.0
1878	2456	*
		@@ -1924,28 +2502,131 @@
1924	2502	}
1925	2503
1926	2504	return $deleted ?: 0;
1927	2505	}
	2506	+
1928	2507	/**
1929		- * Delete all existing schemas for a context before storing new ones
	2508	+ * Deactivate deployed schema rows for the given types.
1930	2509	*
	2510	+ * Deployment was insert-only, so anything ever deployed to a context stayed
	2511	+ * on the page forever — switching a post's schema type left the old one live
	2512	+ * and deactivating a saved schema did nothing (#464). Rows are deactivated
	2513	+ * rather than deleted so a later redeploy can revive them and so there is a
	2514	+ * trail of what was published.
	2515	+ *
	2516	+ * @since 1.16.0
	2517	+ *
	2518	+ * @param string $context_type Context type.
	2519	+ * @param int|null $context_id Context ID.
	2520	+ * @param string[] $schema_types Types to retire.
	2521	+ * @return int Number of rows deactivated.
	2522	+ */
	2523	+ private function retire_schema_types(string $context_type, ?int $context_id, array $schema_types): int {
	2524	+ $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
	2525	+
	2526	+ if (empty($schema_types)) {
	2527	+ return 0;
	2528	+ }
	2529	+
	2530	+ global $wpdb;
	2531	+
	2532	+ $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
	2533	+ $placeholders = implode(', ', array_fill(0, count($schema_types), '%s'));
	2534	+
	2535	+ if (null === $context_id) {
	2536	+ $sql = sprintf(
	2537	+ 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id IS NULL AND schema_type IN (%s)',
	2538	+ $table_name,
	2539	+ $placeholders
	2540	+ );
	2541	+ $args = array_merge([$context_type], $schema_types);
	2542	+ } else {
	2543	+ $sql = sprintf(
	2544	+ 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id = %%d AND schema_type IN (%s)',
	2545	+ $table_name,
	2546	+ $placeholders
	2547	+ );
	2548	+ $args = array_merge([$context_type, $context_id], $schema_types);
	2549	+ }
	2550	+
	2551	+ // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Retiring deployed schema rows requires direct database access.
	2552	+ $updated = $wpdb->query(
	2553	+ $wpdb->prepare(
	2554	+ // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is built from an internal table name and generated placeholders.
	2555	+ $sql,
	2556	+ $args
	2557	+ )
	2558	+ );
	2559	+
	2560	+ if ($updated && $this->cache_manager) {
	2561	+ $this->cache_manager->invalidate_context_cache($context_type, $context_id);
	2562	+ }
	2563	+
	2564	+ return (int) ($updated ?: 0);
	2565	+ }
	2566	+
	2567	+ /**
	2568	+ * Retire deployed types that are no longer in the user's Schema Types selection.
	2569	+ *
	2570	+ * An empty selection means "auto-detect", so nothing is retired in that case.
	2571	+ *
	2572	+ * @since 1.16.0
	2573	+ *
	2574	+ * @param string $context_type Context type.
	2575	+ * @param int|null $context_id Context ID.
	2576	+ * @param array $enabled_types The user's selected types.
	2577	+ * @return int Number of rows deactivated.
	2578	+ */
	2579	+ private function retire_unselected_schema_types(string $context_type, ?int $context_id, array $enabled_types): int {
	2580	+ if (empty($enabled_types)) {
	2581	+ return 0;
	2582	+ }
	2583	+
	2584	+ $deployed = array_keys($this->get_deployed_schemas($context_type, $context_id));
	2585	+ $stale = array_diff($deployed, $enabled_types);
	2586	+
	2587	+ return $this->retire_schema_types($context_type, $context_id, $stale);
	2588	+ }
	2589	+
	2590	+ /**
	2591	+ * Delete stored schemas for a context before storing new ones.
	2592	+ *
	2593	+ * `$schema_types` scopes the delete to the types actually being rewritten.
	2594	+ * Without it this wiped every type in the context, which silently destroyed
	2595	+ * deployed schema whenever a caller regenerated a subset — and
	2596	+ * auto_deploy_schema_on_settings_change() regenerates one type at a time
	2597	+ * (#454). Passing an empty array keeps the original clear-the-context
	2598	+ * behaviour for callers that genuinely rewrite everything.
	2599	+ *
1931	2600	* @since 1.0.0
1932	2601	*
1933	2602	* @param string $context_type Context type
1934	2603	* @param int|null $context_id Context ID
	2604	+ * @param string[] $schema_types Optional. Limit the delete to these types.
1935	2605	* @return int Number of schemas deleted
1936	2606	*/
1937		- private function delete_existing_schemas(string $context_type, ?int $context_id): int {
	2607	+ private function delete_existing_schemas(string $context_type, ?int $context_id, array $schema_types = []): int {
1938	2608	global $wpdb;
1939	2609
1940	2610	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1941	2611
	2612	+ // Build an optional `AND schema_type IN (…)` clause with one prepared
	2613	+ // placeholder per type, so the scoping cannot be injected through.
	2614	+ $type_clause = '';
	2615	+ $type_values = [];
	2616	+ $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
	2617	+ if (!empty($schema_types)) {
	2618	+ $type_clause = ' AND schema_type IN (' . implode(', ', array_fill(0, count($schema_types), '%s')) . ')';
	2619	+ $type_values = $schema_types;
	2620	+ }
	2621	+
1942	2622	if (null === $context_id) {
1943	2623	// Delete all schemas for NULL context_id
1944	2624	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1945	2625	$sql = sprintf(
1946		- 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL',
1947		- $table_name
	2626	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL%s',
	2627	+ $table_name,
	2628	+ $type_clause
1948	2629	);
1949	2630	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1950	2631	$deleted = $wpdb->query(
1951	2632	$wpdb->prepare(
		@@ -1950,9 +2631,9 @@
1950	2631	$deleted = $wpdb->query(
1951	2632	$wpdb->prepare(
1952	2633	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1953	2634	$sql,
1954		- $context_type
	2635	+ array_merge([$context_type], $type_values)
1955	2636	)
1956	2637	);
1957	2638	} else {
1958	2639	// Delete all schemas for specific context_id
		@@ -1957,10 +2638,11 @@
1957	2638	} else {
1958	2639	// Delete all schemas for specific context_id
1959	2640	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1960	2641	$sql = sprintf(
1961		- 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d',
1962		- $table_name
	2642	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d%s',
	2643	+ $table_name,
	2644	+ $type_clause
1963	2645	);
1964	2646	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1965	2647	$deleted = $wpdb->query(
1966	2648	$wpdb->prepare(
		@@ -1965,10 +2647,9 @@
1965	2647	$deleted = $wpdb->query(
1966	2648	$wpdb->prepare(
1967	2649	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1968	2650	$sql,
1969		- $context_type,
1970		- $context_id
	2651	+ array_merge([$context_type, $context_id], $type_values)
1971	2652	)
1972	2653	);
1973	2654	}
1974	2655
		@@ -2052,8 +2733,11 @@
2052	2733	'site_url' => home_url(),
2053	2734	'admin_email' => get_option('admin_email'),
2054	2735	'language' => get_locale(),
2055	2736	'timezone' => get_option('timezone_string'),
	2737	+ // Read by populate_website_schema(), so the deployed WebSite node
	2738	+ // carries the same alternateName as the default one (#692).
	2739	+ 'alternate_name' => $site_identity_settings['alternate_name'] ?? '',
2056	2740	'founded_date' => $site_identity_settings['founded_date'] ?? '',
2057	2741	'founder_name' => $site_identity_settings['founder_name'] ?? '',
2058	2742	'company_type' => $site_identity_settings['company_type'] ?? 'Organization',
2059	2743	// Site Identity assets