← All changes | includes/seo/class-schema-management-system.php +818 -89 2.0.0 → 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'] ?? [];
		@@ -1039,8 +1259,47 @@
1039	1259	return home_url('/wp-content/plugins/thinkrank/assets/images/default-logo.jpg');
1040	1260	}
1041	1261
1042	1262	/**
	1263	+ * Schema keys outside the shared config defaults.
	1264	+ *
	1265	+ * @since 2.0.1
	1266	+ *
	1267	+ * @return string[]
	1268	+ */
	1269	+ protected function additional_setting_keys(): array {
	1270	+ return [
	1271	+ 'enable_article_schema', 'enable_product_schema',
	1272	+ 'enable_faq_schema', 'enable_howto_schema',
	1273	+ ];
	1274	+ }
	1275	+
	1276	+ /**
	1277	+ * Per-entity schema fields are an open set.
	1278	+ *
	1279	+ * Each schema type the UI can edit contributes its own field family —
	1280	+ * organization_*, person_*, website_*, business_*, software_*, howto_* —
	1281	+ * and a new type adds another. The families this manager owns are matched
	1282	+ * rather than enumerated, so adding a form does not silently start
	1283	+ * dropping its fields (#452).
	1284	+ *
	1285	+ * @since 2.0.1
	1286	+ *
	1287	+ * @return string[]
	1288	+ */
	1289	+ protected function dynamic_setting_key_patterns(): array {
	1290	+ return [
	1291	+ '/^organization_[a-z0-9_]+$/',
	1292	+ '/^person_[a-z0-9_]+$/',
	1293	+ '/^website_[a-z0-9_]+$/',
	1294	+ '/^business_[a-z0-9_]+$/',
	1295	+ '/^software_[a-z0-9_]+$/',
	1296	+ '/^howto_[a-z0-9_]+$/',
	1297	+ '/^product_[a-z0-9_]+$/',
	1298	+ ];
	1299	+ }
	1300	+
	1301	+ /**
1043	1302	* Get default settings for a context type (implements interface)
1044	1303	*
1045	1304	* @since 1.0.0
1046	1305	*
		@@ -1086,9 +1345,9 @@
1086	1345	$this->cache_manager->invalidate_all_cache();
1087	1346	}
1088	1347
1089	1348	// AUTO-DEPLOY: Automatically regenerate and deploy schema when settings change
1090		- if ($success && !empty($settings['auto_deploy'])) {
	1349	+ if ($success && self::should_auto_deploy($settings, $this->get_settings($context_type, $context_id))) {
1091	1350	$this->auto_deploy_schema_on_settings_change($context_type, $context_id, $settings);
1092	1351	}
1093	1352
1094	1353	return $success;
		@@ -1093,9 +1352,35 @@
1093	1352
1094	1353	return $success;
1095	1354	}
1096	1355
	1356	+
1097	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	+ /**
1098	1383	* Auto-deploy schema when settings change
1099	1384	*
1100	1385	* Automatically regenerates and deploys schema markup when organization or other
1101	1386	* schema settings are modified, ensuring the frontend output stays in sync.
		@@ -1132,38 +1417,59 @@
1132	1417	if ($this->has_person_settings_changed($settings)) {
1133	1418	$schema_types_to_regenerate[] = 'Person';
1134	1419	}
1135	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	+
1136	1437	// If no schema types need regeneration, return early
1137	1438	if (empty($schema_types_to_regenerate)) {
1138	1439	return;
1139	1440	}
1140	1441
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		- );
	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	+ );
1150	1452
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		- );
	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];
1158	1460	}
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	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	+ }
1166	1472	}
1167	1473	}
1168	1474
1169	1475	/**
		@@ -1201,9 +1507,15 @@
1201	1507	* @param array $settings Updated settings
1202	1508	* @return bool True if website settings changed
1203	1509	*/
1204	1510	private function has_website_settings_changed(array $settings): bool {
1205		- $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	+ ];
1206	1518
1207	1519	foreach ($website_keys as $key) {
1208	1520	if (isset($settings[$key])) {
1209	1521	return true;
		@@ -1221,11 +1533,20 @@
1221	1533	* @param array $settings Updated settings
1222	1534	* @return bool True if business settings changed
1223	1535	*/
1224	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().
1225	1543	$business_keys = [
1226		- 'business_name', 'business_type', 'business_address', 'business_phone',
1227		- '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',
1228	1549	];
1229	1550
1230	1551	foreach ($business_keys as $key) {
1231	1552	if (isset($settings[$key])) {
		@@ -1269,8 +1590,29 @@
1269	1590	$detected_types = [];
1270	1591
1271	1592	switch ($context_type) {
1272	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	+
1273	1615	$detected_types = ['Organization'];
1274	1616	// Check if it's a local business
1275	1617	if ($this->is_local_business()) {
1276	1618	$detected_types[] = 'LocalBusiness';
		@@ -1333,20 +1675,35 @@
1333	1675	} elseif ($context_id && in_array($context_type, ['post', 'page', 'product'], true)) {
1334	1676	// Post/page/product data
1335	1677	$post = get_post($context_id);
1336	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	+
1337	1690	$content_data = [
1338	1691	'title' => $post->post_title,
1339	1692	'url' => get_permalink($post->ID),
1340		- '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),
1341	1694	'content' => $post->post_content,
1342	1695	'author' => [
1343	1696	'name' => get_the_author_meta('display_name', $post->post_author),
1344	1697	'url' => get_author_posts_url($post->post_author)
1345	1698	],
1346		- 'date' => $post->post_date,
1347		- 'modified' => $post->post_modified,
1348		- '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,
1349	1706	'focus_keywords' => Focus_Keywords::get($post->ID),
1350	1707	'business_data' => $this->get_business_data_from_local_seo(),
1351	1708	'site_data' => $this->get_site_data_for_schema(),
1352	1709	'social_data' => $this->get_social_data_for_schema()
		@@ -1440,10 +1797,16 @@
1440	1797	global $wpdb;
1441	1798
1442	1799	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1443	1800
1444		- // First, delete all existing schemas for this context to ensure clean storage
1445		- $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);
1446	1809
1447	1810	foreach ($generation['generated_schemas'] as $schema_type => $schema_data) {
1448	1811	// Prepare schema data with validation status embedded
1449	1812	$schema_data_with_validation = $schema_data;
		@@ -1459,9 +1822,13 @@
1459	1822	'context_id' => $context_id,
1460	1823	'schema_type' => $schema_type,
1461	1824	'schema_data' => wp_json_encode($schema_data_with_validation),
1462	1825	'validation_status' => $generation['validation_results'][$schema_type]['is_valid'] ? 'valid' : 'invalid',
1463		- '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
1464	1831	];
1465	1832
1466	1833	// Insert new schema (existing ones were already deleted)
1467	1834	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema insertion requires direct database access
		@@ -1729,12 +2096,10 @@
1729	2096
1730	2097	/**
1731	2098	* Get deployed schemas for frontend integration
1732	2099	*
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
	2100	+ * Returns the newest active, deployed row of each schema type for the
	2101	+ * context. Results are cached per context (see Schema_Cache_Manager).
1737	2102	*
1738	2103	* @since 1.0.0
1739	2104	*
1740	2105	* @param string $context_type Context type
		@@ -1757,47 +2122,59 @@
1757	2122
1758	2123	// Use existing seo_schema table
1759	2124	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1760	2125
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)
	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];
1763	2140	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		- );
	2141	+ $context_where = 's.context_id IS NULL';
1778	2142	} 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		- );
	2143	+ $context_where = 's.context_id = %d';
	2144	+ $args[] = $context_id;
1794	2145	}
1795	2146
1796		- if (empty($deployed_schemas)) {
1797		- return [];
1798		- }
	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	+ );
1799	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	+
	2171	+ // Deliberately no early return on an empty result: it has to reach the
	2172	+ // cache write below. Most URLs have no deployed schema, so gating the
	2173	+ // write on a non-empty result made the majority of front-end requests
	2174	+ // permanent cache misses, re-running the query on every pageview (#392).
	2175	+ $deployed_schemas = $deployed_schemas ?: [];
	2176	+
1800	2177	// Process schemas for return
1801	2178	$processed_schemas = [];
1802	2179	foreach ($deployed_schemas as $deployed_schema) {
1803	2180	$schema_data = json_decode($deployed_schema['schema_data'], true);
		@@ -1808,8 +2185,26 @@
1808	2185	if (isset($schema_data['_validation'])) {
1809	2186	unset($schema_data['_validation']);
1810	2187	}
1811	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	+
1812	2207	$processed_schemas[$schema_type] = [
1813	2208	'data' => $schema_data,
1814	2209	'method' => 'json_ld', // Default method
1815	2210	'type' => $schema_type
		@@ -1816,10 +2211,13 @@
1816	2211	];
1817	2212	}
1818	2213	}
1819	2214
1820		- // CACHE LAYER: Store result in cache for future requests
1821		- if ($this->cache_manager && !empty($processed_schemas)) {
	2215	+ // CACHE LAYER: Store result in cache for future requests — including
	2216	+ // an empty one. Cache_Manager::set() wraps the payload in a metadata
	2217	+ // envelope, so an empty result is still stored as a truthy value and
	2218	+ // reads back as a hit rather than a miss (#392).
	2219	+ if ($this->cache_manager) {
1822	2220	$cache_key = $this->cache_manager->generate_deployed_schemas_key($context_type, $context_id);
1823	2221	$this->cache_manager->set($cache_key, $processed_schemas);
1824	2222	}
1825	2223
		@@ -1826,8 +2224,233 @@
1826	2224	return $processed_schemas;
1827	2225	}
1828	2226
1829	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	+ /**
1830	2453	* Clean up duplicate schemas in database
1831	2454	*
1832	2455	* @since 1.0.0
1833	2456	*
		@@ -1879,28 +2502,131 @@
1879	2502	}
1880	2503
1881	2504	return $deleted ?: 0;
1882	2505	}
	2506	+
1883	2507	/**
1884		- * Delete all existing schemas for a context before storing new ones
	2508	+ * Deactivate deployed schema rows for the given types.
1885	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	+ *
1886	2600	* @since 1.0.0
1887	2601	*
1888	2602	* @param string $context_type Context type
1889	2603	* @param int|null $context_id Context ID
	2604	+ * @param string[] $schema_types Optional. Limit the delete to these types.
1890	2605	* @return int Number of schemas deleted
1891	2606	*/
1892		- 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 {
1893	2608	global $wpdb;
1894	2609
1895	2610	$table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1896	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	+
1897	2622	if (null === $context_id) {
1898	2623	// Delete all schemas for NULL context_id
1899	2624	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1900	2625	$sql = sprintf(
1901		- 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL',
1902		- $table_name
	2626	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL%s',
	2627	+ $table_name,
	2628	+ $type_clause
1903	2629	);
1904	2630	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1905	2631	$deleted = $wpdb->query(
1906	2632	$wpdb->prepare(
		@@ -1905,9 +2631,9 @@
1905	2631	$deleted = $wpdb->query(
1906	2632	$wpdb->prepare(
1907	2633	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1908	2634	$sql,
1909		- $context_type
	2635	+ array_merge([$context_type], $type_values)
1910	2636	)
1911	2637	);
1912	2638	} else {
1913	2639	// Delete all schemas for specific context_id
		@@ -1912,10 +2638,11 @@
1912	2638	} else {
1913	2639	// Delete all schemas for specific context_id
1914	2640	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1915	2641	$sql = sprintf(
1916		- 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d',
1917		- $table_name
	2642	+ 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d%s',
	2643	+ $table_name,
	2644	+ $type_clause
1918	2645	);
1919	2646	// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1920	2647	$deleted = $wpdb->query(
1921	2648	$wpdb->prepare(
		@@ -1920,10 +2647,9 @@
1920	2647	$deleted = $wpdb->query(
1921	2648	$wpdb->prepare(
1922	2649	// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1923	2650	$sql,
1924		- $context_type,
1925		- $context_id
	2651	+ array_merge([$context_type, $context_id], $type_values)
1926	2652	)
1927	2653	);
1928	2654	}
1929	2655
		@@ -2007,8 +2733,11 @@
2007	2733	'site_url' => home_url(),
2008	2734	'admin_email' => get_option('admin_email'),
2009	2735	'language' => get_locale(),
2010	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'] ?? '',
2011	2740	'founded_date' => $site_identity_settings['founded_date'] ?? '',
2012	2741	'founder_name' => $site_identity_settings['founder_name'] ?? '',
2013	2742	'company_type' => $site_identity_settings['company_type'] ?? 'Organization',
2014	2743	// Site Identity assets