@relvehq/agent-ready 0.0.0-stage → 0.3.0

package/dist/wp/relve-agent-ready/includes/class-relve-ar-response.php

@@ -0,0 +1,226 @@
+<?php
+/**
+ * Response: headers, ETag / 304, Cache-Control, token estimate.
+ *
+ * PHP port of @relvehq/agent-ready core/respond.ts and the adapters' header
+ * choices. build() is pure (an array in, an array out) so it is unit-tested;
+ * send() writes it with header() and echo.
+ *
+ * @package Relve_Agent_Ready
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+/**
+ * Builds and sends Markdown / llms.txt / 404 responses.
+ */
+class Relve_AR_Response {
+
+	const MARKDOWN_CONTENT_TYPE = 'text/markdown; charset=utf-8';
+	const TEXT_CONTENT_TYPE     = 'text/plain; charset=utf-8';
+
+	/** `.md`, `?format=md` and llms.txt: their own URLs, safe for shared caches. */
+	const CACHE_CONTROL = 'public, s-maxage=300, stale-while-revalidate=86400';
+
+	/** Negotiated by Accept on the page's own URL: never in a shared cache. */
+	const NEGOTIATED_CACHE_CONTROL = 'private, max-age=300';
+
+	/**
+	 * Cache-Control for a request that asked via $via.
+	 *
+	 * @param string $via suffix|query|accept|llms.
+	 * @return string
+	 */
+	public static function cache_control_for( $via ) {
+		return 'accept' === $via ? self::NEGOTIATED_CACHE_CONTROL : self::CACHE_CONTROL;
+	}
+
+	/**
+	 * Rough token count, as the package: ceil(length / 4), where length is
+	 * the JavaScript string length (UTF-16 code units).
+	 *
+	 * @param string $text Text.
+	 * @return int
+	 */
+	public static function estimate_tokens( $text ) {
+		return (int) ceil( self::utf16_length( $text ) / 4 );
+	}
+
+	/**
+	 * Length in UTF-16 code units (what JavaScript's .length counts).
+	 *
+	 * @param string $text UTF-8 text.
+	 * @return int
+	 */
+	public static function utf16_length( $text ) {
+		$text  = (string) $text;
+		$chars = preg_match_all( '/./su', $text );
+		if ( false === $chars ) {
+			return strlen( $text ); // Not valid UTF-8: count bytes.
+		}
+		$astral = preg_match_all( '/[\x{10000}-\x{10FFFF}]/u', $text );
+		return $chars + (int) $astral;
+	}
+
+	/**
+	 * Strong ETag: first 32 hex chars of SHA-256(body).
+	 *
+	 * @param string $body Body.
+	 * @return string
+	 */
+	public static function etag_for( $body ) {
+		return '"' . substr( hash( 'sha256', (string) $body ), 0, 32 ) . '"';
+	}
+
+	/**
+	 * ETag for a body. A `generated_at:` front-matter line is left out of the
+	 * hash (it changes every time) and the ETag is then weak, as the package.
+	 *
+	 * @param string $body Body.
+	 * @return string
+	 */
+	public static function etag_for_body( $body ) {
+		$stable = preg_replace( '/^generated_at:.*\n?/m', '', (string) $body, 1 );
+		return $stable === $body ? self::etag_for( $body ) : 'W/' . self::etag_for( $stable );
+	}
+
+	/**
+	 * RFC 9110 weak comparison; "*" matches any current representation.
+	 *
+	 * @param string|null $header If-None-Match value.
+	 * @param string      $etag   Our ETag.
+	 * @return bool
+	 */
+	public static function if_none_match_hits( $header, $etag ) {
+		if ( ! is_string( $header ) || '' === $header ) {
+			return false;
+		}
+		$bare = preg_replace( '#^W/#', '', $etag );
+		foreach ( explode( ',', $header ) as $raw ) {
+			$t = trim( $raw );
+			if ( '*' === $t || preg_replace( '#^W/#', '', $t ) === $bare ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Build a Markdown (or llms.txt) response.
+	 *
+	 * @param string $body Body.
+	 * @param array  $args {
+	 *     @type string      $method        GET or HEAD.
+	 *     @type string|null $if_none_match If-None-Match header.
+	 *     @type string|null $canonical     Absolute canonical URL; null leaves Link out.
+	 *     @type string      $cache_control Cache-Control.
+	 *     @type string      $content_type  Content-Type (default text/markdown).
+	 *     @type string      $source        x-agent-ready-source value.
+	 *     @type bool        $noindex       Send X-Robots-Tag: noindex (default true).
+	 *     @type int|null    $tokens        Token count (default: estimated from body).
+	 * }
+	 * @return array { status: int, headers: array<string,string>, body: string }
+	 */
+	public static function build( $body, $args ) {
+		$args = array_merge(
+			array(
+				'method'        => 'GET',
+				'if_none_match' => null,
+				'canonical'     => null,
+				'cache_control' => self::CACHE_CONTROL,
+				'content_type'  => self::MARKDOWN_CONTENT_TYPE,
+				'source'        => 'native',
+				'noindex'       => true,
+				'tokens'        => null,
+			),
+			(array) $args
+		);
+		$body   = (string) $body;
+		$etag   = self::etag_for_body( $body );
+		$tokens = null === $args['tokens'] ? self::estimate_tokens( $body ) : (int) $args['tokens'];
+
+		$headers = array( 'Content-Type' => $args['content_type'] );
+		$headers['Vary'] = 'Accept';
+		if ( $args['canonical'] ) {
+			$headers['Link'] = '<' . $args['canonical'] . '>; rel="canonical"';
+		}
+		if ( $args['noindex'] ) {
+			$headers['X-Robots-Tag'] = 'noindex';
+		}
+		$headers['x-markdown-tokens']    = (string) $tokens;
+		$headers['Cache-Control']        = $args['cache_control'];
+		$headers['ETag']                 = $etag;
+		$headers['x-agent-ready-source'] = $args['source'];
+
+		if ( self::if_none_match_hits( $args['if_none_match'], $etag ) ) {
+			unset( $headers['Content-Type'] );
+			return array(
+				'status'  => 304,
+				'headers' => $headers,
+				'body'    => '',
+			);
+		}
+		$headers['Content-Length'] = (string) strlen( $body );
+		return array(
+			'status'  => 200,
+			'headers' => $headers,
+			'body'    => 'HEAD' === strtoupper( (string) $args['method'] ) ? '' : $body,
+		);
+	}
+
+	/**
+	 * A plain-text error (the 404 for `.md` / `?format=md` with nothing to serve).
+	 *
+	 * @param int         $status    Status code.
+	 * @param string      $method    GET or HEAD.
+	 * @param string|null $canonical Canonical URL of the page, if known.
+	 * @return array
+	 */
+	public static function plain( $status, $method = 'GET', $canonical = null ) {
+		$body    = "No Markdown version of this page is available.\n";
+		$headers = array(
+			'Content-Type'  => self::TEXT_CONTENT_TYPE,
+			'Cache-Control' => 'no-store',
+			'Vary'          => 'Accept',
+			'X-Robots-Tag'  => 'noindex',
+		);
+		if ( $canonical ) {
+			$headers['Link'] = '<' . $canonical . '>; rel="canonical"';
+		}
+		$headers['Content-Length'] = (string) strlen( $body );
+		return array(
+			'status'  => (int) $status,
+			'headers' => $headers,
+			'body'    => 'HEAD' === strtoupper( (string) $method ) ? '' : $body,
+		);
+	}
+
+	/**
+	 * Write a built response. Removes headers WordPress already queued that
+	 * do not belong on Markdown (HTML Link headers, no-cache from nocache_headers()).
+	 * The caller exits afterwards.
+	 *
+	 * @param array $response From build() or plain().
+	 * @return void
+	 */
+	public static function send( $response ) {
+		if ( ! headers_sent() ) {
+			foreach ( array( 'Link', 'X-Pingback', 'Expires', 'Pragma', 'Last-Modified', 'Cache-Control', 'Content-Type', 'X-Robots-Tag' ) as $name ) {
+				header_remove( $name );
+			}
+			if ( function_exists( 'status_header' ) ) {
+				status_header( $response['status'] );
+			} else {
+				http_response_code( $response['status'] );
+			}
+			foreach ( $response['headers'] as $name => $value ) {
+				header( $name . ': ' . $value, true );
+			}
+		}
+		if ( '' !== $response['body'] ) {
+			echo $response['body']; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- text/markdown or text/plain body, never HTML.
+		}
+	}
+}

package/dist/wp/relve-agent-ready/includes/class-relve-ar-router.php

@@ -0,0 +1,421 @@
+<?php
+/**
+ * Router: when to answer with Markdown, and with what.
+ *
+ *   do_parse_request (filter, priority 1), before WordPress parses the URL:
+ *     - detect the request (Relve_AR_Negotiation::detect): `.md` suffix,
+ *       `?format=md`, Accept, or llms.txt; GET/HEAD only
+ *     - llms.txt: answered right here
+ *     - excluded path: `.md` / `?format=md` get a plain 404, Accept goes on
+ *     - `.md`: REQUEST_URI is rewritten without the suffix, so WordPress
+ *       resolves the post as usual (no rewrite rules involved, works with any
+ *       permalink structure and never reaches WordPress's 404 for ".md")
+ *   template_redirect (priority 1), after the main query, before
+ *   redirect_canonical:
+ *     - a published, public, non-password post/page of an enabled type, the
+ *       posts front page or a category / tag / author archive -> Markdown
+ *       (a stored refined file first, else built from WordPress data)
+ *     - anything else: Accept requests carry on untouched; `.md` and
+ *       `?format=md` get a plain-text 404
+ *
+ * Nothing at all happens while the "Enabled" setting is off.
+ *
+ * @package Relve_Agent_Ready
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+/**
+ * Front-end request handling.
+ */
+class Relve_AR_Router {
+
+	/** Detection for the current request, set in do_parse_request. @var array|null */
+	private static $detection = null;
+
+	/** Settings for the current request. @var array|null */
+	private static $settings = null;
+
+	/**
+	 * Register hooks.
+	 *
+	 * @return void
+	 */
+	public static function init() {
+		add_filter( 'do_parse_request', array( __CLASS__, 'on_parse_request' ), 1, 1 );
+		add_action( 'template_redirect', array( __CLASS__, 'on_template_redirect' ), 1 );
+		add_filter( 'rocket_cache_reject_uri', array( __CLASS__, 'rocket_reject_uri' ) );
+	}
+
+	// ── paths ─────────────────────────────────────────────────────────────
+
+	/**
+	 * Path of home_url() without trailing slash: "" or e.g. "/blog".
+	 *
+	 * @return string
+	 */
+	public static function home_path() {
+		$path = (string) wp_parse_url( home_url(), PHP_URL_PATH );
+		return rtrim( $path, '/' );
+	}
+
+	/**
+	 * scheme://host[:port] of home_url().
+	 *
+	 * @return string
+	 */
+	public static function home_origin() {
+		$p = wp_parse_url( home_url() );
+		if ( ! is_array( $p ) || empty( $p['host'] ) ) {
+			return '';
+		}
+		return ( isset( $p['scheme'] ) ? $p['scheme'] : 'https' ) . '://' . $p['host'] . ( isset( $p['port'] ) ? ':' . $p['port'] : '' );
+	}
+
+	/**
+	 * Static prefix of the permalink structure ("/blog" for
+	 * "/blog/%postname%/"), "" when there is none.
+	 *
+	 * @return string
+	 */
+	public static function permalink_prefix() {
+		global $wp_rewrite;
+		$front = ( $wp_rewrite && isset( $wp_rewrite->front ) ) ? (string) $wp_rewrite->front : '/';
+		if ( false !== strpos( $front, '%' ) ) {
+			return '';
+		}
+		$front = rtrim( $front, '/' );
+		return null === Relve_AR_Negotiation::normalize_path( '' === $front ? '/' : $front ) ? '' : $front;
+	}
+
+	/**
+	 * Paths llms.txt is answered at: "<home path>/llms.txt", plus
+	 * "<home path><permalink prefix>/llms.txt" when posts live under a static
+	 * prefix such as "/blog" (a site whose home is the root but whose blog is
+	 * routed to WordPress under /blog). Empty when the plugin should not
+	 * answer llms.txt.
+	 *
+	 * @param array $settings Settings.
+	 * @return string[]
+	 */
+	public static function llms_paths( $settings ) {
+		if ( ! Relve_AR_Llms::should_serve( $settings['llms_mode'], Relve_AR_Llms::yoast_serves(), Relve_AR_Llms::physical_file_exists() ) ) {
+			return array();
+		}
+		$home  = self::home_path();
+		$paths = array( $home . '/llms.txt' );
+		$pre   = self::permalink_prefix();
+		if ( '' !== $pre ) {
+			$paths[] = $home . $pre . '/llms.txt';
+		}
+		return array_values( array_unique( $paths ) );
+	}
+
+	// ── hooks ─────────────────────────────────────────────────────────────
+
+	/**
+	 * do_parse_request: detect, answer llms.txt, strip ".md" for WordPress.
+	 *
+	 * @param bool $do Whether WordPress should parse the request.
+	 * @return bool
+	 */
+	public static function on_parse_request( $do ) {
+		self::$detection = null;
+		if ( ! $do || is_admin() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) ) {
+			return $do;
+		}
+		$settings = Relve_AR_Settings::get();
+		if ( ! $settings['enabled'] ) {
+			return $do;
+		}
+		$method = isset( $_SERVER['REQUEST_METHOD'] ) ? strtoupper( sanitize_text_field( wp_unslash( $_SERVER['REQUEST_METHOD'] ) ) ) : 'GET';
+		if ( 'GET' !== $method && 'HEAD' !== $method ) {
+			return $do;
+		}
+		$uri    = isset( $_SERVER['REQUEST_URI'] ) ? wp_unslash( $_SERVER['REQUEST_URI'] ) : '/'; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- only matched, never output.
+		$accept = isset( $_SERVER['HTTP_ACCEPT'] ) ? wp_unslash( $_SERVER['HTTP_ACCEPT'] ) : ''; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- only parsed.
+		$home   = self::home_path();
+
+		$d = Relve_AR_Negotiation::detect( $method, (string) $uri, (string) $accept, $home, self::llms_paths( $settings ) );
+		if ( ! $d['markdown'] ) {
+			return $do;
+		}
+
+		if ( $d['llms'] ) {
+			self::serve_llms( $settings, $method );
+			exit;
+		}
+
+		if ( Relve_AR_Negotiation::is_excluded( $d['path'], $settings['excluded'], $home ) ) {
+			if ( 'accept' === $d['via'] ) {
+				return $do;
+			}
+			self::no_page_cache();
+			Relve_AR_Response::send( Relve_AR_Response::plain( 404, $method ) );
+			exit;
+		}
+
+		if ( 'suffix' === $d['via'] && null !== $d['uri'] ) {
+			$_SERVER['REQUEST_URI'] = wp_slash( $d['uri'] );
+			if ( ! empty( $_SERVER['PATH_INFO'] ) ) {
+				$_SERVER['PATH_INFO'] = self::strip_md_from_path_info( wp_unslash( $_SERVER['PATH_INFO'] ) ); // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
+			}
+		}
+
+		self::$detection = $d;
+		self::$settings  = $settings;
+		return $do;
+	}
+
+	/**
+	 * PATH_INFO without a trailing ".md" (some servers set it).
+	 *
+	 * @param string $path_info PATH_INFO.
+	 * @return string
+	 */
+	private static function strip_md_from_path_info( $path_info ) {
+		$lower = strtolower( $path_info );
+		if ( '/index.md' === substr( $lower, -9 ) ) {
+			return substr( $path_info, 0, -8 );
+		}
+		if ( '.md' === substr( $lower, -3 ) ) {
+			return substr( $path_info, 0, -3 );
+		}
+		return $path_info;
+	}
+
+	/**
+	 * template_redirect: serve the Markdown, or step aside.
+	 *
+	 * @return void
+	 */
+	public static function on_template_redirect() {
+		if ( null === self::$detection ) {
+			return;
+		}
+		$d        = self::$detection;
+		$settings = self::$settings;
+		$method   = isset( $_SERVER['REQUEST_METHOD'] ) ? strtoupper( sanitize_text_field( wp_unslash( $_SERVER['REQUEST_METHOD'] ) ) ) : 'GET';
+		$inm      = isset( $_SERVER['HTTP_IF_NONE_MATCH'] ) ? wp_unslash( $_SERVER['HTTP_IF_NONE_MATCH'] ) : null; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- compared only.
+		$negotiated = ( 'accept' === $d['via'] );
+
+		$target = self::resolve_target( $settings );
+		if ( null === $target ) {
+			if ( $negotiated ) {
+				return; // WordPress serves its normal response.
+			}
+			self::no_page_cache();
+			Relve_AR_Response::send( Relve_AR_Response::plain( 404, $method ) );
+			exit;
+		}
+
+		try {
+			$source = 'native';
+			$store  = new Relve_AR_Store();
+			$stored = $store->get( $d['path'], self::home_path() );
+			if ( null !== $stored ) {
+				$source = 'stored';
+				$body   = Relve_AR_Markdown_Builder::for_stored( $stored, $target['canonical'], isset( $target['post'] ) ? $target['post'] : null, $target['title'] );
+			} elseif ( 'post' === $target['kind'] ) {
+				$body = Relve_AR_Markdown_Builder::for_post( $target['post'], $target['canonical'] );
+			} else {
+				$body = Relve_AR_Markdown_Builder::for_archive( $target['kind'], $target['id'], $target['canonical'] );
+			}
+		} catch ( Throwable $e ) {
+			$body = null;
+		}
+		if ( null === $body ) {
+			if ( $negotiated ) {
+				return; // An agent asking by Accept is never worse off than a browser.
+			}
+			self::no_page_cache();
+			Relve_AR_Response::send( Relve_AR_Response::plain( 500, $method ) );
+			exit;
+		}
+
+		self::no_page_cache();
+		Relve_AR_Response::send(
+			Relve_AR_Response::build(
+				$body,
+				array(
+					'method'        => $method,
+					'if_none_match' => $inm,
+					'canonical'     => $target['canonical'],
+					'cache_control' => Relve_AR_Response::cache_control_for( $d['via'] ),
+					'source'        => $source,
+				)
+			)
+		);
+		exit;
+	}
+
+	/**
+	 * What the main query resolved to, if it is something we serve.
+	 *
+	 * @param array $settings Settings.
+	 * @return array|null { kind: post|home|category|post_tag|author, post?, id, canonical, title }
+	 */
+	public static function resolve_target( $settings ) {
+		if ( is_404() || is_feed() || is_search() || is_preview() || is_embed() || is_robots() || is_trackback() || is_attachment() ) {
+			return null;
+		}
+		$types = (array) $settings['post_types'];
+		if ( is_singular() ) {
+			$post = get_queried_object();
+			if ( ! self::servable_post( $post, $types ) ) {
+				return null;
+			}
+			$canonical = get_permalink( $post );
+			if ( ! $canonical ) {
+				return null;
+			}
+			return array(
+				'kind'      => 'post',
+				'post'      => $post,
+				'id'        => $post->ID,
+				'canonical' => $canonical,
+				'title'     => '',
+			);
+		}
+		if ( ! in_array( 'post', $types, true ) ) {
+			return null; // Lists of posts need posts enabled.
+		}
+		if ( is_home() ) {
+			$page      = (int) get_option( 'page_for_posts' );
+			$canonical = ( 'page' === get_option( 'show_on_front' ) && $page ) ? get_permalink( $page ) : home_url( '/' );
+			return array(
+				'kind'      => 'home',
+				'id'        => 0,
+				'canonical' => $canonical,
+				'title'     => html_entity_decode( get_bloginfo( 'name' ), ENT_QUOTES, 'UTF-8' ),
+			);
+		}
+		if ( is_category() || is_tag() ) {
+			$term = get_queried_object();
+			if ( ! $term || ! isset( $term->term_id ) ) {
+				return null;
+			}
+			$link = get_term_link( $term );
+			if ( is_wp_error( $link ) ) {
+				return null;
+			}
+			return array(
+				'kind'      => is_category() ? 'category' : 'post_tag',
+				'id'        => (int) $term->term_id,
+				'canonical' => $link,
+				'title'     => html_entity_decode( $term->name, ENT_QUOTES, 'UTF-8' ),
+			);
+		}
+		if ( is_author() ) {
+			$user = get_queried_object();
+			if ( ! $user || ! isset( $user->ID ) ) {
+				return null;
+			}
+			return array(
+				'kind'      => 'author',
+				'id'        => (int) $user->ID,
+				'canonical' => get_author_posts_url( $user->ID ),
+				'title'     => html_entity_decode( (string) $user->display_name, ENT_QUOTES, 'UTF-8' ),
+			);
+		}
+		return null;
+	}
+
+	/**
+	 * Published, public, not password-protected, of an enabled type.
+	 *
+	 * @param mixed    $post  Queried object.
+	 * @param string[] $types Enabled post types.
+	 * @return bool
+	 */
+	public static function servable_post( $post, $types ) {
+		if ( ! ( $post instanceof WP_Post ) ) {
+			return false;
+		}
+		if ( 'publish' !== $post->post_status || '' !== (string) $post->post_password ) {
+			return false;
+		}
+		if ( ! in_array( $post->post_type, (array) $types, true ) || ! is_post_type_viewable( $post->post_type ) ) {
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Answer llms.txt.
+	 *
+	 * @param array  $settings Settings.
+	 * @param string $method   GET or HEAD.
+	 * @return void
+	 */
+	private static function serve_llms( $settings, $method ) {
+		$inm  = isset( $_SERVER['HTTP_IF_NONE_MATCH'] ) ? wp_unslash( $_SERVER['HTTP_IF_NONE_MATCH'] ) : null; // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- compared only.
+		$body = Relve_AR_Llms::generate( $settings );
+		self::no_page_cache();
+		Relve_AR_Response::send(
+			Relve_AR_Response::build(
+				$body,
+				array(
+					'method'        => $method,
+					'if_none_match' => $inm,
+					'canonical'     => null, // llms.txt is meant to be found and read.
+					'noindex'       => false,
+					'content_type'  => Relve_AR_Response::TEXT_CONTENT_TYPE,
+					'cache_control' => Relve_AR_Response::cache_control_for( 'llms' ),
+					'source'        => 'llms',
+				)
+			)
+		);
+	}
+
+	// ── caches ────────────────────────────────────────────────────────────
+
+	/**
+	 * Tell page caches not to store this response as the page.
+	 *
+	 * @return void
+	 */
+	public static function no_page_cache() {
+		if ( ! defined( 'DONOTCACHEPAGE' ) ) {
+			define( 'DONOTCACHEPAGE', true ); // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedConstantFound -- shared page-cache convention.
+		}
+		add_filter( 'do_rocket_generate_caching_files', '__return_false', 999 );
+		do_action( 'litespeed_control_set_nocache', 'relve-agent-ready: markdown response' ); // phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- LiteSpeed Cache's hook.
+	}
+
+	/**
+	 * WP Rocket: never cache ".md" URLs or llms.txt.
+	 *
+	 * @param mixed $uris Reject patterns.
+	 * @return array
+	 */
+	public static function rocket_reject_uri( $uris ) {
+		$uris   = is_array( $uris ) ? $uris : array();
+		$uris[] = '/(.+)\.md';
+		$uris[] = '/(.*)llms\.txt';
+		return array_values( array_unique( $uris ) );
+	}
+
+	/**
+	 * Regenerate WP Rocket's config so the reject list is current.
+	 *
+	 * @return void
+	 */
+	public static function refresh_rocket() {
+		if ( function_exists( 'rocket_generate_config_file' ) ) {
+			rocket_generate_config_file();
+		}
+	}
+
+	/**
+	 * Reset per-request state (tests).
+	 *
+	 * @return void
+	 */
+	public static function reset() {
+		self::$detection = null;
+		self::$settings  = null;
+	}
+}