← All changes | includes/seo/class-schema-management-system.php +771 -88 2.0.0 → 2.12.0 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
		@@ -574,8 +756,24 @@
574	756
575	757	// Determine deployment method
576	758	$deployment['deployment_method'] = $this->determine_deployment_method($options);
577	759
	760	+ // When the caller owns the whole context — the user pressing Deploy, where
	761	+ // the payload is exactly what the preview showed — anything not in that
	762	+ // payload should come off the page (#464). Incremental callers such as
	763	+ // auto_deploy_schema_on_settings_change() pass only the types they
	764	+ // regenerated, so they must NOT retire the rest.
	765	+ if (!empty($options['authoritative'])) {
	766	+ $deployment['retired_schemas'] = $this->retire_schema_types(
	767	+ $context_type,
	768	+ $context_id,
	769	+ array_diff(
	770	+ array_keys($this->get_deployed_schemas($context_type, $context_id)),
	771	+ array_keys($schema_data)
	772	+ )
	773	+ );
	774	+ }
	775	+
578	776	// Deploy each schema
579	777	foreach ($schema_data as $schema_type => $schema) {
580	778	$deploy_result = $this->deploy_single_schema($schema, $schema_type, $deployment['deployment_method'], $context_type, $context_id);
581	779	$deployment['deployed_schemas'][$schema_type] = $deploy_result;
		@@ -661,9 +859,9 @@
661	859	}
662	860
663	861	return [
664	862	'validation_passed' => true,
665		- 'message' => __('Schema deployed and verified on the front end', 'thinkrank'),
	863	+ 'message' => __('Schema deployed and read back from storage', 'thinkrank'),
666	864	'missing_types' => []
667	865	];
668	866	}
669	867
		@@ -783,9 +981,11 @@
783	981	'validation_results' => [],
784	982	'rich_snippets_preview' => [],
785	983	'performance_data' => [],
786	984	'recommendations' => [],
787		- 'enabled' => true
	985	+ // Report the real setting. Hardcoding true here told every consumer
	986	+ // the feature was on even when the master switch was off (#461).
	987	+ 'enabled' => (bool) ($settings['enabled'] ?? true)
788	988	];
789	989
790	990	// Get enabled schema types
791	991	$enabled_types = $settings['enabled_schema_types'] ?? [];
		@@ -1039,8 +1239,47 @@
1039	1239	return home_url('/wp-content/plugins/thinkrank/assets/images/default-logo.jpg');
1040	1240	}
1041	1241
1042	1242	/**
	1243	+ * Schema keys outside the shared config defaults.
	1244	+ *
	1245	+ * @since 2.0.1
	1246	+ *
	1247	+ * @return string[]
	1248	+ */
	1249	+ protected function additional_setting_keys(): array {
	1250	+ return [
	1251	+ 'enable_article_schema', 'enable_product_schema',
	1252	+ 'enable_faq_schema', 'enable_howto_schema',
	1253	+ ];
	1254	+ }
	1255	+
	1256	+ /**
	1257	+ * Per-entity schema fields are an open set.
	1258	+ *
	1259	+ * Each schema type the UI can edit contributes its own field family —
	1260	+ * organization_*, person_*, website_*, business_*, software_*, howto_* —
	1261	+ * and a new type adds another. The families this manager owns are matched
	1262	+ * rather than enumerated, so adding a form does not silently start
	1263	+ * dropping its fields (#452).
	1264	+ *
	1265	+ * @since 2.0.1
	1266	+ *
	1267	+ * @return string[]
	1268	+ */
	1269	+ protected function dynamic_setting_key_patterns(): array {
	1270	+ return [
	1271	+ '/^organization_[a-z0-9_]+$/',
	1272	+ '/^person_[a-z0-9_]+$/',
	1273	+ '/^website_[a-z0-9_]+$/',
	1274	+ '/^business_[a-z0-9_]+$/',
	1275	+ '/^software_[a-z0-9_]+$/',
	1276	+ '/^howto_[a-z0-9_]+$/',
	1277	+ '/^product_[a-z0-9_]+$/',
	1278	+ ];
	1279	+ }
	1280	+
	1281	+ /**
1043	1282	* Get default settings for a context type (implements interface)
1044	1283	*
1045	1284	* @since 1.0.0
1046	1285	*
		@@ -1132,38 +1371,59 @@
1132	1371	if ($this->has_person_settings_changed($settings)) {
1133	1372	$schema_types_to_regenerate[] = 'Person';
1134	1373	}
1135	1374
	1375	+ // Honour the user's Schema Types selection. Without this the payload
	1376	+ // shape alone decided what shipped, so every save deployed all four
	1377	+ // types — including ones the user had explicitly deselected (#461).
	1378	+ // An empty selection means "auto", so only filter when one is set.
	1379	+ $enabled_types = $settings['enabled_schema_types'] ?? $this->get_settings($context_type, $context_id)['enabled_schema_types'] ?? [];
	1380	+
	1381	+ if (!empty($enabled_types) && is_array($enabled_types)) {
	1382	+ $schema_types_to_regenerate = array_values(
	1383	+ array_intersect($schema_types_to_regenerate, $enabled_types)
	1384	+ );
	1385	+ }
	1386	+
	1387	+ // Types that were deployed but are no longer wanted must come back off
	1388	+ // the page — deployment used to be additive-only (#464).
	1389	+ $this->retire_unselected_schema_types($context_type, $context_id, $enabled_types);
	1390	+
1136	1391	// If no schema types need regeneration, return early
1137	1392	if (empty($schema_types_to_regenerate)) {
1138	1393	return;
1139	1394	}
1140	1395
1141		- // Generate and deploy each schema type
1142		- foreach ($schema_types_to_regenerate as $schema_type) {
1143		- try {
1144		- // Generate schema using generate_schema_markup
1145		- $generation_result = $this->generate_schema_markup(
1146		- $context_type,
1147		- $context_id,
1148		- [$schema_type]
1149		- );
	1396	+ // Generate every affected type in ONE call. Generating them one at a
	1397	+ // time re-entered store_schema_data() per type, and each pass replaced
	1398	+ // the rows written by the previous one, so only the last type survived
	1399	+ // (#454). One batch also means one delete and one cache flush.
	1400	+ try {
	1401	+ $generation_result = $this->generate_schema_markup(
	1402	+ $context_type,
	1403	+ $context_id,
	1404	+ $schema_types_to_regenerate
	1405	+ );
1150	1406
1151		- // Deploy if generation was successful
1152		- if (!empty($generation_result['generated_schemas'][$schema_type]) && $generation_result['deployment_ready']) {
1153		- $this->deploy_schema_markup(
1154		- $context_type,
1155		- $context_id,
1156		- [$schema_type => $generation_result['generated_schemas'][$schema_type]]
1157		- );
	1407	+ $deployable = [];
	1408	+ foreach ($schema_types_to_regenerate as $schema_type) {
	1409	+ // Only deploy what validated — see #470.
	1410	+ if (!empty($generation_result['generated_schemas'][$schema_type])
	1411	+ && !empty($generation_result['validation_results'][$schema_type]['is_valid'])
	1412	+ ) {
	1413	+ $deployable[$schema_type] = $generation_result['generated_schemas'][$schema_type];
1158	1414	}
1159		- } catch (\Exception $e) {
1160		- // Log error but don't fail the settings save
1161		- if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
1162		- // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
1163		- error_log('ThinkRank: Auto-deploy failed for ' . $schema_type . ': ' . $e->getMessage());
1164		- }
1165	1415	}
	1416	+
	1417	+ if (!empty($deployable)) {
	1418	+ $this->deploy_schema_markup($context_type, $context_id, $deployable);
	1419	+ }
	1420	+ } catch (\Exception $e) {
	1421	+ // Log error but don't fail the settings save
	1422	+ if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
	1423	+ // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
	1424	+ error_log('ThinkRank: Auto-deploy failed for ' . implode(', ', $schema_types_to_regenerate) . ': ' . $e->getMessage());
	1425	+ }
1166	1426	}
1167	1427	}
1168	1428
1169	1429	/**
		@@ -1201,9 +1461,15 @@
1201	1461	* @param array $settings Updated settings
1202	1462	* @return bool True if website settings changed
1203	1463	*/
1204	1464	private function has_website_settings_changed(array $settings): bool {
1205		- $website_keys = ['site_name', 'site_description', 'site_url'];
	1465	+ // These are the keys the Website tab actually stores. It previously
	1466	+ // looked for site_name/site_description/site_url, which belong to Site
	1467	+ // Identity and never appear in a schema settings payload — so WebSite
	1468	+ // schema never auto-deployed no matter what was edited (#455).
	1469	+ $website_keys = [
	1470	+ 'website_name', 'website_url', 'website_description', 'website_author',
	1471	+ ];
1206	1472
1207	1473	foreach ($website_keys as $key) {
1208	1474	if (isset($settings[$key])) {
1209	1475	return true;
		@@ -1221,11 +1487,20 @@
1221	1487	* @param array $settings Updated settings
1222	1488	* @return bool True if business settings changed
1223	1489	*/
1224	1490	private function has_business_settings_changed(array $settings): bool {
	1491	+ // Only the keys this manager actually stores. business_name/address/
	1492	+ // phone/hours live in the site_identity category and never reach a
	1493	+ // schema settings save, so keying off them meant LocalBusiness never
	1494	+ // auto-deployed (#455). Edits to those fields refresh LocalBusiness
	1495	+ // through the Site Identity save path instead — see
	1496	+ // refresh_schema_for_foreign_settings().
1225	1497	$business_keys = [
1226		- 'business_name', 'business_type', 'business_address', 'business_phone',
1227		- 'business_hours', 'business_price_range'
	1498	+ 'enable_local_business',
	1499	+ 'business_price_range',
	1500	+ 'business_geo_latitude',
	1501	+ 'business_geo_longitude',
	1502	+ 'business_opening_hours',
1228	1503	];
1229	1504
1230	1505	foreach ($business_keys as $key) {
1231	1506	if (isset($settings[$key])) {
		@@ -1269,8 +1544,29 @@
1269	1544	$detected_types = [];
1270	1545
1271	1546	switch ($context_type) {
1272	1547	case 'site':
	1548	+ // The admin's Schema Types selection is the answer to "what
	1549	+ // does this site need"; detection is only the fallback for an
	1550	+ // install that has not chosen yet (#456).
	1551	+ $settings = $this->get_settings($context_type, $context_id);
	1552	+ $enabled = array_values(array_filter(
	1553	+ array_map('strval', (array) ($settings['enabled_schema_types'] ?? [])),
	1554	+ 'strlen'
	1555	+ ));
	1556	+
	1557	+ // Drop stale names the factory no longer registers rather than
	1558	+ // handing them to the builder to silently skip.
	1559	+ $enabled = array_values(array_filter(
	1560	+ $enabled,
	1561	+ fn($type) => isset($this->schema_types[$type])
	1562	+ ));
	1563	+
	1564	+ if (!empty($enabled)) {
	1565	+ $detected_types = $enabled;
	1566	+ break;
	1567	+ }
	1568	+
1273	1569	$detected_types = ['Organization'];
1274	1570	// Check if it's a local business
1275	1571	if ($this->is_local_business()) {
1276	1572	$detected_types[] = 'LocalBusiness';
		@@ -1333,20 +1629,35 @@
1333	1629	} elseif ($context_id && in_array($context_type, ['post', 'page', 'product'], true)) {
1334	1630	// Post/page/product data
1335	1631	$post = get_post($context_id);
1336	1632	if ($post) {
	1633	+ // Resolve the featured image's URL to its ID here, where the ID
	1634	+ // is in hand, so the schema builder does not query for an
	1635	+ // attachment it was just given (#847). Offered as a hint rather
	1636	+ // than asserted: `post_thumbnail_url` can swap the URL for one
	1637	+ // the featured image does not own.
	1638	+ $thumbnail_url = get_the_post_thumbnail_url($post->ID, 'full');
	1639	+
	1640	+ if ($thumbnail_url) {
	1641	+ Attachment_Lookup::id_from_url((string) $thumbnail_url, (int) get_post_thumbnail_id($post->ID));
	1642	+ }
	1643	+
1337	1644	$content_data = [
1338	1645	'title' => $post->post_title,
1339	1646	'url' => get_permalink($post->ID),
1340		- 'excerpt' => $post->post_excerpt ?: wp_trim_words($post->post_content, 30),
	1647	+ 'excerpt' => $post->post_excerpt ?: \ThinkRank\Core\Seo_Text::trim_words($post->post_content, 30),
1341	1648	'content' => $post->post_content,
1342	1649	'author' => [
1343	1650	'name' => get_the_author_meta('display_name', $post->post_author),
1344	1651	'url' => get_author_posts_url($post->post_author)
1345	1652	],
1346		- 'date' => $post->post_date,
1347		- 'modified' => $post->post_modified,
1348		- 'image' => get_the_post_thumbnail_url($post->ID, 'full'),
	1653	+ // ISO 8601 with offset. post_date/post_modified are raw
	1654	+ // MySQL columns in site-local time with no timezone, which
	1655	+ // Google rejects as "Invalid value in field datePublished"
	1656	+ // and drops the Article rich result (#465).
	1657	+ 'date' => get_the_date('c', $post),
	1658	+ 'modified' => get_the_modified_date('c', $post),
	1659	+ 'image' => $thumbnail_url,
1349	1660	'focus_keywords' => Focus_Keywords::get($post->ID),
1350	1661	'business_data' => $this->get_business_data_from_local_seo(),
1351	1662	'site_data' => $this->get_site_data_for_schema(),
1352	1663	'social_data' => $this->get_social_data_for_schema()
		@@ -1440,10 +1751,16 @@
1440	1751	global $wpdb;
1441	1752
1442	1753	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1443	1754
1444		- // First, delete all existing schemas for this context to ensure clean storage
1445		- $this->delete_existing_schemas($context_type, $context_id);
	1755	+ // Replace only the types in this batch. Clearing the whole context
	1756	+ // destroyed types the caller never asked about — and callers do
	1757	+ // regenerate a subset, one type at a time (#454).
	1758	+ $generated_types = array_keys($generation['generated_schemas'] ?? []);
	1759	+ if (empty($generated_types)) {
	1760	+ return false;
	1761	+ }
	1762	+ $this->delete_existing_schemas($context_type, $context_id, $generated_types);
1446	1763
1447	1764	foreach ($generation['generated_schemas'] as $schema_type => $schema_data) {
1448	1765	// Prepare schema data with validation status embedded
1449	1766	$schema_data_with_validation = $schema_data;
		@@ -1459,9 +1776,13 @@
1459	1776	'context_id' => $context_id,
1460	1777	'schema_type' => $schema_type,
1461	1778	'schema_data' => wp_json_encode($schema_data_with_validation),
1462	1779	'validation_status' => $generation['validation_results'][$schema_type]['is_valid'] ? 'valid' : 'invalid',
1463		- 'is_active' => $generation['deployment_ready'] ? 1 : 0
	1780	+ // Per-type, not batch-wide. deployment_ready is only true when
	1781	+ // EVERY type in the batch validated, so one invalid type (a site
	1782	+ // with no Business Info makes LocalBusiness invalid) deactivated
	1783	+ // all the valid ones alongside it (#470).
	1784	+ 'is_active' => !empty($generation['validation_results'][$schema_type]['is_valid']) ? 1 : 0
1464	1785	];
1465	1786
1466	1787	// Insert new schema (existing ones were already deleted)
1467	1788	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema insertion requires direct database access
		@@ -1729,12 +2050,10 @@
1729	2050
1730	2051	/**
1731	2052	* Get deployed schemas for frontend integration
1732	2053	*
1733		- * PERFORMANCE OPTIMIZED: This method now uses:
1734		- * 1. Schema caching layer (90% reduction in database queries)
1735		- * 2. Window function approach instead of correlated subquery (80-90% query performance improvement)
1736		- * 3. Composite index: idx_context_schema_active
	2054	+ * Returns the newest active, deployed row of each schema type for the
	2055	+ * context. Results are cached per context (see Schema_Cache_Manager).
1737	2056	*
1738	2057	* @since 1.0.0
1739	2058	*
1740	2059	* @param string $context_type Context type
		@@ -1757,47 +2076,59 @@
1757	2076
1758	2077	// Use existing seo_schema table
1759	2078	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1760	2079
1761		- // OPTIMIZED QUERY: Use window function approach to eliminate correlated subquery
1762		- // This leverages the new composite index: idx_context_schema_active (context_type, schema_type, is_active, created_at DESC)
	2080	+ // The newest row per type used to be picked with ROW_NUMBER() OVER
	2081	+ // (PARTITION BY schema_type ...). Window functions need MySQL 8.0 /
	2082	+ // MariaDB 10.2, and WordPress still runs on MySQL 5.7, where that is
	2083	+ // a syntax error on every page view and no deployed schema is ever
	2084	+ // output. A row is the newest of its type when no other row of the
	2085	+ // same context and type outranks it, so NOT EXISTS keeps the
	2086	+ // greatest-per-group in the database, and schema_data — JSON, and
	2087	+ // large — is only transferred for the rows that are output.
	2088	+ //
	2089	+ // `<=>` is NULL-safe equality: the site context stores context_id
	2090	+ // as NULL, and `n.context_id = s.context_id` is never true for it.
	2091	+ // schema_id breaks a same-second tie, which the window function
	2092	+ // left to chance.
	2093	+ $args = [$context_type];
1763	2094	if (null === $context_id) {
1764		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1765		- $sql = sprintf(
1766		- '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',
1767		- $table_name
1768		- );
1769		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1770		- $deployed_schemas = $wpdb->get_results(
1771		- $wpdb->prepare(
1772		- // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1773		- $sql,
1774		- $context_type
1775		- ),
1776		- ARRAY_A
1777		- );
	2095	+ $context_where = 's.context_id IS NULL';
1778	2096	} else {
1779		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1780		- $sql = sprintf(
1781		- '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',
1782		- $table_name
1783		- );
1784		- // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1785		- $deployed_schemas = $wpdb->get_results(
1786		- $wpdb->prepare(
1787		- // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1788		- $sql,
1789		- $context_type,
1790		- $context_id
1791		- ),
1792		- ARRAY_A
1793		- );
	2097	+ $context_where = 's.context_id = %d';
	2098	+ $args[] = $context_id;
1794	2099	}
1795	2100
1796		- if (empty($deployed_schemas)) {
1797		- return [];
1798		- }
	2101	+ $sql = sprintf(
	2102	+ 'SELECT s.schema_type, s.schema_data FROM %1$s s'
	2103	+ . ' WHERE s.context_type = %%s AND %2$s AND s.is_active = 1 AND s.validation_status IN (\'deployed\', \'valid\')'
	2104	+ . ' AND NOT EXISTS ('
	2105	+ . 'SELECT 1 FROM %1$s n'
	2106	+ . ' WHERE n.context_type = s.context_type AND n.context_id <=> s.context_id AND n.schema_type = s.schema_type'
	2107	+ . ' AND n.is_active = 1 AND n.validation_status IN (\'deployed\', \'valid\')'
	2108	+ . ' AND (n.created_at > s.created_at OR (n.created_at = s.created_at AND n.schema_id > s.schema_id))'
	2109	+ . ')'
	2110	+ . ' ORDER BY s.schema_type',
	2111	+ $table_name,
	2112	+ $context_where
	2113	+ );
1799	2114
	2115	+ // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
	2116	+ $deployed_schemas = $wpdb->get_results(
	2117	+ $wpdb->prepare(
	2118	+ // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
	2119	+ $sql,
	2120	+ ...$args
	2121	+ ),
	2122	+ ARRAY_A
	2123	+ );
	2124	+
	2125	+ // Deliberately no early return on an empty result: it has to reach the
	2126	+ // cache write below. Most URLs have no deployed schema, so gating the
	2127	+ // write on a non-empty result made the majority of front-end requests
	2128	+ // permanent cache misses, re-running the query on every pageview (#392).
	2129	+ $deployed_schemas = $deployed_schemas ?: [];
	2130	+
1800	2131	// Process schemas for return
1801	2132	$processed_schemas = [];
1802	2133	foreach ($deployed_schemas as $deployed_schema) {
1803	2134	$schema_data = json_decode($deployed_schema['schema_data'], true);
		@@ -1808,8 +2139,26 @@
1808	2139	if (isset($schema_data['_validation'])) {
1809	2140	unset($schema_data['_validation']);
1810	2141	}
1811	2142
	2143	+ // Deployed schema is a snapshot, so rows written before #465
	2144	+ // still carry raw MySQL datetimes. Normalise on read so the
	2145	+ // fix reaches existing sites without a migration.
	2146	+ $schema_data = $this->normalize_stored_schema($schema_data);
	2147	+
	2148	+ // The permalink was frozen at deploy time, so schema deployed
	2149	+ // while a post was a draft advertised "?p=123" as both url and
	2150	+ // mainEntityOfPage forever — contradicting the node's own @id
	2151	+ // and the canonical (#470). Resolve it live instead.
	2152	+ $schema_data = $this->refresh_schema_permalink($schema_data, $context_type, $context_id);
	2153	+
	2154	+ // schema.org types `sameAs`, `url`, `logo` and `image` as URLs,
	2155	+ // but the form stored whatever was typed, so free text entered
	2156	+ // in a social-profile field shipped as a sameAs member and made
	2157	+ // the whole entity invalid (#480). Drop bad values on read, so
	2158	+ // existing sites stop emitting them without a migration.
	2159	+ $schema_data = $this->filter_entity_urls($schema_data);
	2160	+
1812	2161	$processed_schemas[$schema_type] = [
1813	2162	'data' => $schema_data,
1814	2163	'method' => 'json_ld', // Default method
1815	2164	'type' => $schema_type
		@@ -1816,10 +2165,13 @@
1816	2165	];
1817	2166	}
1818	2167	}
1819	2168
1820		- // CACHE LAYER: Store result in cache for future requests
1821		- if ($this->cache_manager && !empty($processed_schemas)) {
	2169	+ // CACHE LAYER: Store result in cache for future requests — including
	2170	+ // an empty one. Cache_Manager::set() wraps the payload in a metadata
	2171	+ // envelope, so an empty result is still stored as a truthy value and
	2172	+ // reads back as a hit rather than a miss (#392).
	2173	+ if ($this->cache_manager) {
1822	2174	$cache_key = $this->cache_manager->generate_deployed_schemas_key($context_type, $context_id);
1823	2175	$this->cache_manager->set($cache_key, $processed_schemas);
1824	2176	}
1825	2177
		@@ -1826,8 +2178,233 @@
1826	2178	return $processed_schemas;
1827	2179	}
1828	2180
1829	2181	/**
	2182	+ * Properties schema.org defines as URLs.
	2183	+ *
	2184	+ * @since 2.0.2
	2185	+ * @var string[]
	2186	+ */
	2187	+ private const URL_PROPERTIES = ['sameAs', 'url', 'logo', 'image'];
	2188	+
	2189	+ /**
	2190	+ * Whether a value is a URL safe to publish in structured data.
	2191	+ *
	2192	+ * @since 2.0.2
	2193	+ *
	2194	+ * @param mixed $url Candidate value.
	2195	+ * @return bool
	2196	+ */
	2197	+ private function is_publishable_url($url): bool {
	2198	+ if (!is_string($url) || '' === trim($url)) {
	2199	+ return false;
	2200	+ }
	2201	+
	2202	+ if (!filter_var($url, FILTER_VALIDATE_URL)) {
	2203	+ return false;
	2204	+ }
	2205	+
	2206	+ $scheme = wp_parse_url($url, PHP_URL_SCHEME);
	2207	+
	2208	+ return in_array(strtolower((string) $scheme), ['http', 'https'], true);
	2209	+ }
	2210	+
	2211	+ /**
	2212	+ * Drop values that are not URLs from URL-typed properties.
	2213	+ *
	2214	+ * An absent property is valid; one holding free text is not, and it can
	2215	+ * invalidate the entity around it. Nested objects (`logo` and `image` are
	2216	+ * frequently ImageObjects) are walked so a bad `url` inside one is caught
	2217	+ * too. A property left with nothing is removed rather than emitted empty.
	2218	+ *
	2219	+ * @since 2.0.2
	2220	+ *
	2221	+ * @param array $schema Decoded schema data.
	2222	+ * @return array Schema carrying only publishable URLs.
	2223	+ */
	2224	+ private function filter_entity_urls(array $schema): array {
	2225	+ foreach ($schema as $key => $value) {
	2226	+ if (is_array($value) && !in_array($key, self::URL_PROPERTIES, true)) {
	2227	+ $schema[$key] = $this->filter_entity_urls($value);
	2228	+ continue;
	2229	+ }
	2230	+
	2231	+ if (!in_array($key, self::URL_PROPERTIES, true)) {
	2232	+ continue;
	2233	+ }
	2234	+
	2235	+ // A nested object (ImageObject and friends) carries its own url.
	2236	+ if (is_array($value) && isset($value['@type'])) {
	2237	+ $schema[$key] = $this->filter_entity_urls($value);
	2238	+ continue;
	2239	+ }
	2240	+
	2241	+ if (is_array($value)) {
	2242	+ $kept = [];
	2243	+
	2244	+ foreach ($value as $item) {
	2245	+ if (is_array($item)) {
	2246	+ $kept[] = $this->filter_entity_urls($item);
	2247	+ } elseif ($this->is_publishable_url($item)) {
	2248	+ $kept[] = $item;
	2249	+ }
	2250	+ }
	2251	+
	2252	+ if ([] === $kept) {
	2253	+ unset($schema[$key]);
	2254	+ } else {
	2255	+ $schema[$key] = array_values($kept);
	2256	+ }
	2257	+
	2258	+ continue;
	2259	+ }
	2260	+
	2261	+ if (!$this->is_publishable_url($value)) {
	2262	+ unset($schema[$key]);
	2263	+ }
	2264	+ }
	2265	+
	2266	+ return $schema;
	2267	+ }
	2268	+
	2269	+ /**
	2270	+ * Schema types whose `url` identifies the entity, not the page.
	2271	+ *
	2272	+ * On a Person or an Organization, `url` is that entity's own website, so
	2273	+ * overwriting it with the permalink of whichever post the schema happens to
	2274	+ * be deployed on is simply wrong. It also breaks graph assembly: the site
	2275	+ * identity emits the same entity with its real `url`, and once the two
	2276	+ * copies disagree they can no longer be recognised as one entity (#479).
	2277	+ *
	2278	+ * @since 2.0.2
	2279	+ * @var string[]
	2280	+ */
	2281	+ private const ENTITY_URL_TYPES = ['Person', 'Organization', 'LocalBusiness'];
	2282	+
	2283	+ /**
	2284	+ * Replace a stored permalink snapshot with the post's live permalink.
	2285	+ *
	2286	+ * Only touches `url` and `mainEntityOfPage`, and only for post-like
	2287	+ * contexts where a permalink actually exists. Identity entities are
	2288	+ * exempt from the `url` rewrite — see self::ENTITY_URL_TYPES.
	2289	+ *
	2290	+ * @since 1.16.0
	2291	+ *
	2292	+ * @param array $schema Decoded schema data.
	2293	+ * @param string $context_type Context type.
	2294	+ * @param int|null $context_id Context ID.
	2295	+ * @return array Schema with a current permalink.
	2296	+ */
	2297	+ private function refresh_schema_permalink(array $schema, string $context_type, ?int $context_id): array {
	2298	+ if ('site' === $context_type || empty($context_id)) {
	2299	+ return $schema;
	2300	+ }
	2301	+
	2302	+ $permalink = get_permalink($context_id);
	2303	+
	2304	+ if (!$permalink) {
	2305	+ return $schema;
	2306	+ }
	2307	+
	2308	+ $type = $schema['@type'] ?? '';
	2309	+ $type = is_array($type) ? reset($type) : $type;
	2310	+ // A LocalBusiness is deployed under the subtype the site chose, so the
	2311	+ // exemption has to cover every subtype, not only the literal root.
	2312	+ $is_entity = in_array((string) $type, self::ENTITY_URL_TYPES, true)
	2313	+ || \ThinkRank\Config\Local_Business_Types_Config::is_local_business($type);
	2314	+
	2315	+ if (isset($schema['url']) && !$is_entity) {
	2316	+ $schema['url'] = $permalink;
	2317	+ }
	2318	+
	2319	+ if (isset($schema['mainEntityOfPage'])) {
	2320	+ if (is_array($schema['mainEntityOfPage'])) {
	2321	+ if (isset($schema['mainEntityOfPage']['@id'])) {
	2322	+ $schema['mainEntityOfPage']['@id'] = $permalink;
	2323	+ }
	2324	+ } else {
	2325	+ $schema['mainEntityOfPage'] = $permalink;
	2326	+ }
	2327	+ }
	2328	+
	2329	+ return $schema;
	2330	+ }
	2331	+
	2332	+ /**
	2333	+ * Normalise properties that stored snapshots may hold in a stale format.
	2334	+ *
	2335	+ * Deployed schema is written once and read forever, so a formatting fix in
	2336	+ * the builder never reaches rows already on disk. Correcting on read means
	2337	+ * existing sites benefit without a migration.
	2338	+ *
	2339	+ * Covers non-ISO-8601 dates (#465) and WP locales in inLanguage, which must
	2340	+ * be a BCP-47 tag — en-US, not en_US (#473). Walks nested nodes so values
	2341	+ * inside author/publisher/@graph entries are covered too.
	2342	+ *
	2343	+ * Also decodes HTML entities in plain-text properties. Schema_Builder
	2344	+ * stored the block editor's `&amp;` as-is until 2.10.0, and nothing
	2345	+ * decodes JSON-LD downstream, so every deployed node built from post text
	2346	+ * published the entity literally.
	2347	+ *
	2348	+ * @since 1.16.0
	2349	+ * @since 2.10.0 Decodes entities in plain-text properties.
	2350	+ *
	2351	+ * @param array $schema Decoded schema data.
	2352	+ * @return array Normalised schema.
	2353	+ */
	2354	+ private function normalize_stored_schema(array $schema): array {
	2355	+ static $date_keys = [
	2356	+ 'datePublished', 'dateModified', 'dateCreated', 'uploadDate',
	2357	+ 'startDate', 'endDate', 'validFrom', 'validThrough', 'expires',
	2358	+ ];
	2359	+
	2360	+ // Plain text in schema.org. Answer/HowToStep `text` is deliberately
	2361	+ // absent: Google reads Answer.text as HTML, where an entity is correct
	2362	+ // and decoding `&lt;` would turn escaped text into live markup.
	2363	+ static $text_keys = [
	2364	+ 'name', 'headline', 'alternativeHeadline', 'description',
	2365	+ 'reviewBody', 'about', 'abstract', 'caption',
	2366	+ ];
	2367	+
	2368	+ foreach ($schema as $key => $value) {
	2369	+ if (is_array($value)) {
	2370	+ $schema[$key] = $this->normalize_stored_schema($value);
	2371	+ continue;
	2372	+ }
	2373	+
	2374	+ if ('inLanguage' === $key && is_string($value) && '' !== $value) {
	2375	+ $schema[$key] = str_replace('_', '-', $value);
	2376	+ continue;
	2377	+ }
	2378	+
	2379	+ // Decode only: a snapshot already truncated with an ellipsis must
	2380	+ // keep it, which the full Seo_Text::normalize_schema_text() would
	2381	+ // strip as an excerpt marker.
	2382	+ if (in_array($key, $text_keys, true) && is_string($value) && '' !== $value) {
	2383	+ $schema[$key] = \ThinkRank\Core\Seo_Text::decode_schema_entities($value);
	2384	+ continue;
	2385	+ }
	2386	+
	2387	+ if (!in_array($key, $date_keys, true) || !is_string($value) || '' === $value) {
	2388	+ continue;
	2389	+ }
	2390	+
	2391	+ // Already ISO 8601 — leave it alone.
	2392	+ if (preg_match('/^\d{4}-\d{2}-\d{2}T/', $value)) {
	2393	+ continue;
	2394	+ }
	2395	+
	2396	+ $timestamp = strtotime($value);
	2397	+
	2398	+ if (false !== $timestamp) {
	2399	+ $schema[$key] = (string) wp_date('c', $timestamp);
	2400	+ }
	2401	+ }
	2402	+
	2403	+ return $schema;
	2404	+ }
	2405	+
	2406	+ /**
1830	2407	* Clean up duplicate schemas in database
1831	2408	*
1832	2409	* @since 1.0.0
1833	2410	*
		@@ -1879,28 +2456,131 @@
1879	2456	}
1880	2457
1881	2458	return $deleted ?: 0;
1882	2459	}
	2460	+
1883	2461	/**
1884		- * Delete all existing schemas for a context before storing new ones
	2462	+ * Deactivate deployed schema rows for the given types.
1885	2463	*
	2464	+ * Deployment was insert-only, so anything ever deployed to a context stayed
	2465	+ * on the page forever — switching a post's schema type left the old one live
	2466	+ * and deactivating a saved schema did nothing (#464). Rows are deactivated
	2467	+ * rather than deleted so a later redeploy can revive them and so there is a
	2468	+ * trail of what was published.
	2469	+ *
	2470	+ * @since 1.16.0
	2471	+ *
	2472	+ * @param string $context_type Context type.
	2473	+ * @param int|null $context_id Context ID.
	2474	+ * @param string[] $schema_types Types to retire.
	2475	+ * @return int Number of rows deactivated.
	2476	+ */
	2477	+ private function retire_schema_types(string $context_type, ?int $context_id, array $schema_types): int {
	2478	+ $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
	2479	+
	2480	+ if (empty($schema_types)) {
	2481	+ return 0;
	2482	+ }
	2483	+
	2484	+ global $wpdb;
	2485	+
	2486	+ $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
	2487	+ $placeholders = implode(', ', array_fill(0, count($schema_types), '%s'));
	2488	+
	2489	+ if (null === $context_id) {
	2490	+ $sql = sprintf(
	2491	+ 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id IS NULL AND schema_type IN (%s)',
	2492	+ $table_name,
	2493	+ $placeholders
	2494	+ );
	2495	+ $args = array_merge([$context_type], $schema_types);
	2496	+ } else {
	2497	+ $sql = sprintf(
	2498	+ 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id = %%d AND schema_type IN (%s)',
	2499	+ $table_name,
	2500	+ $placeholders
	2501	+ );
	2502	+ $args = array_merge([$context_type, $context_id], $schema_types);
	2503	+ }
	2504	+
	2505	+ // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Retiring deployed schema rows requires direct database access.
	2506	+ $updated = $wpdb->query(
	2507	+ $wpdb->prepare(
	2508	+ // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is built from an internal table name and generated placeholders.
	2509	+ $sql,
	2510	+ $args
	2511	+ )
	2512	+ );
	2513	+
	2514	+ if ($updated && $this->cache_manager) {
	2515	+ $this->cache_manager->invalidate_context_cache($context_type, $context_id);
	2516	+ }
	2517	+
	2518	+ return (int) ($updated ?: 0);
	2519	+ }
	2520	+
	2521	+ /**
	2522	+ * Retire deployed types that are no longer in the user's Schema Types selection.
	2523	+ *
	2524	+ * An empty selection means "auto-detect", so nothing is retired in that case.
	2525	+ *
	2526	+ * @since 1.16.0
	2527	+ *
	2528	+ * @param string $context_type Context type.
	2529	+ * @param int|null $context_id Context ID.
	2530	+ * @param array $enabled_types The user's selected types.
	2531	+ * @return int Number of rows deactivated.
	2532	+ */
	2533	+ private function retire_unselected_schema_types(string $context_type, ?int $context_id, array $enabled_types): int {
	2534	+ if (empty($enabled_types)) {
	2535	+ return 0;
	2536	+ }
	2537	+
	2538	+ $deployed = array_keys($this->get_deployed_schemas($context_type, $context_id));
	2539	+ $stale = array_diff($deployed, $enabled_types);
	2540	+
	2541	+ return $this->retire_schema_types($context_type, $context_id, $stale);
	2542	+ }
	2543	+
	2544	+ /**
	2545	+ * Delete stored schemas for a context before storing new ones.
	2546	+ *
	2547	+ * `$schema_types` scopes the delete to the types actually being rewritten.
	2548	+ * Without it this wiped every type in the context, which silently destroyed
	2549	+ * deployed schema whenever a caller regenerated a subset — and
	2550	+ * auto_deploy_schema_on_settings_change() regenerates one type at a time
	2551	+ * (#454). Passing an empty array keeps the original clear-the-context
	2552	+ * behaviour for callers that genuinely rewrite everything.
	2553	+ *
1886	2554	* @since 1.0.0
1887	2555	*
1888	2556	* @param string $context_type Context type
1889	2557	* @param int|null $context_id Context ID
	2558	+ * @param string[] $schema_types Optional. Limit the delete to these types.
1890	2559	* @return int Number of schemas deleted
1891	2560	*/
1892		- private function delete_existing_schemas(string $context_type, ?int $context_id): int {
	2561	+ private function delete_existing_schemas(string $context_type, ?int $context_id, array $schema_types = []): int {
1893	2562	global $wpdb;
1894	2563
1895	2564	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1896	2565
	2566	+ // Build an optional `AND schema_type IN (…)` clause with one prepared
	2567	+ // placeholder per type, so the scoping cannot be injected through.
	2568	+ $type_clause = '';
	2569	+ $type_values = [];
	2570	+ $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
	2571	+ if (!empty($schema_types)) {
	2572	+ $type_clause = ' AND schema_type IN (' . implode(', ', array_fill(0, count($schema_types), '%s')) . ')';
	2573	+ $type_values = $schema_types;
	2574	+ }
	2575	+
1897	2576	if (null === $context_id) {
1898	2577	// Delete all schemas for NULL context_id
1899	2578	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1900	2579	$sql = sprintf(
1901		- 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL',
1902		- $table_name
	2580	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL%s',
	2581	+ $table_name,
	2582	+ $type_clause
1903	2583	);
1904	2584	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1905	2585	$deleted = $wpdb->query(
1906	2586	$wpdb->prepare(
		@@ -1905,9 +2585,9 @@
1905	2585	$deleted = $wpdb->query(
1906	2586	$wpdb->prepare(
1907	2587	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1908	2588	$sql,
1909		- $context_type
	2589	+ array_merge([$context_type], $type_values)
1910	2590	)
1911	2591	);
1912	2592	} else {
1913	2593	// Delete all schemas for specific context_id
		@@ -1912,10 +2592,11 @@
1912	2592	} else {
1913	2593	// Delete all schemas for specific context_id
1914	2594	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1915	2595	$sql = sprintf(
1916		- 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d',
1917		- $table_name
	2596	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d%s',
	2597	+ $table_name,
	2598	+ $type_clause
1918	2599	);
1919	2600	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1920	2601	$deleted = $wpdb->query(
1921	2602	$wpdb->prepare(
		@@ -1920,10 +2601,9 @@
1920	2601	$deleted = $wpdb->query(
1921	2602	$wpdb->prepare(
1922	2603	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1923	2604	$sql,
1924		- $context_type,
1925		- $context_id
	2605	+ array_merge([$context_type, $context_id], $type_values)
1926	2606	)
1927	2607	);
1928	2608	}
1929	2609
		@@ -2007,8 +2687,11 @@
2007	2687	'site_url' => home_url(),
2008	2688	'admin_email' => get_option('admin_email'),
2009	2689	'language' => get_locale(),
2010	2690	'timezone' => get_option('timezone_string'),
	2691	+ // Read by populate_website_schema(), so the deployed WebSite node
	2692	+ // carries the same alternateName as the default one (#692).
	2693	+ 'alternate_name' => $site_identity_settings['alternate_name'] ?? '',
2011	2694	'founded_date' => $site_identity_settings['founded_date'] ?? '',
2012	2695	'founder_name' => $site_identity_settings['founder_name'] ?? '',
2013	2696	'company_type' => $site_identity_settings['company_type'] ?? 'Organization',
2014	2697	// Site Identity assets