@wp-playground/wordpress 3.1.20 → 3.1.22

package/index.js

@@ -1,8 +1,2253 @@
-import { phpVars as $, joinPaths as s, dirname as y, basename as b, phpVar as d } from "@php-wasm/util";
-import { createMemoizedFetch as P, unzipFile as p } from "@wp-playground/common";
-import { logger as g } from "@php-wasm/logger";
-import { sandboxedSpawnHandlerFactory as T, PHPRequestHandler as E, PHP as v, setPhpIniEntries as S, writeFiles as f, withPHPIniValues as R } from "@php-wasm/universal";
-const m = `<?php
+import { isLegacyPHPVersion as w, setPhpIniEntries as P, withPHPIniValues as N, sandboxedSpawnHandlerFactory as F, PHPRequestHandler as C, PHP as q, writeFiles as b } from "@php-wasm/universal";
+import { joinPaths as _, phpVar as $, phpVars as A, dirname as W, basename as G } from "@php-wasm/util";
+import { unzipFile as m, createMemoizedFetch as M } from "@wp-playground/common";
+import { logger as h } from "@php-wasm/logger";
+async function S(e) {
+  await e.writeFile(
+    "/internal/shared/mu-plugins/0-playground.php",
+    `<?php
+
+		// Save WordPress environment information to a file.
+		// Named function (not a closure) so this file parses on PHP 5.2.
+		function playground_save_wp_env_info() {
+			if (defined('DB_ENGINE') && DB_ENGINE === 'sqlite') {
+				$db_info = array(
+					'type' => 'sqlite',
+					'path' => FQDB,
+					'driver_path' => defined('WP_MYSQL_ON_SQLITE_LOADER_PATH')
+						? WP_MYSQL_ON_SQLITE_LOADER_PATH
+						: dirname(SQLITE_MAIN_FILE) . '/wp-pdo-mysql-on-sqlite.php',
+				);
+			} else {
+				$db_info = array(
+					'type' => 'mysql',
+					// TODO: Save MySQL connection config.
+				);
+			}
+			$wp_env = array('db' => $db_info);
+			$wp_env_php = sprintf('<?php return %s;', var_export($wp_env, true));
+			$wp_env_file = '/internal/shared/wp-env.php';
+			if (!file_exists($wp_env_file) || file_get_contents($wp_env_file) !== $wp_env_php ) {
+				file_put_contents($wp_env_file, $wp_env_php);
+			}
+		}
+		add_action('wp_loaded', 'playground_save_wp_env_info');
+
+        // Needed because gethostbyname( 'wordpress.org' ) returns
+        // a private network IP address for some reason.
+        function playground_allowed_redirect_hosts( $deprecated = '' ) {
+            return array(
+                'wordpress.org',
+                'api.wordpress.org',
+                'downloads.wordpress.org',
+            );
+        }
+        add_filter( 'allowed_redirect_hosts', 'playground_allowed_redirect_hosts' );
+
+		/**
+		 * Prevents wp_http_validate_url() from universally failing.
+		 *
+		 * wp_http_validate_url() calls gethostbyname() to verify whether the host
+		 * is external. If it is internal, the URL validation fails and WordPress
+		 * refuses to make a request.
+		 *
+		 * However, in EMscripten, gethostbyname() returns a private network IP address.
+		 * This causes wp_http_validate_url() to return false for all URLs.
+		 *
+		 * This filter ensures that all URLs are considered external. In production
+		 * environments, this would be considered a security risk. However, Playground
+		 * already provides multiple code execution vectors as features (e.g. Blueprints).
+		 *
+		 * If someone wants to poke around local IP addresses, they already have multiple
+		 * tools at their disposal. Therefore, this is not a real security risk in context
+		 * of WordPress Playground or Playground CLI.
+		 */
+		add_filter('http_request_host_is_external', '__return_true');
+
+		// Support pretty permalinks
+        add_filter( 'got_url_rewrite', '__return_true' );
+
+		/**
+		 * Flush rewrite rules on the first real WordPress request.
+		 *
+		 * During boot, we set permalink_structure in the database
+		 * but can't flush rewrite rules at that point because WordPress
+		 * isn't fully bootstrapped — post types and taxonomies haven't
+		 * been registered yet, so the generated rules are incomplete.
+		 *
+		 * This hook fires on 'init' at a very late priority, after all
+		 * post types and taxonomies are registered. It checks if the
+		 * rewrite_rules option is empty (meaning rules were never
+		 * flushed) and if permalink_structure is set, then flushes once.
+		 * A flag file prevents repeated flushes on subsequent requests.
+		 */
+		function playground_maybe_flush_rewrite_rules() {
+			$flag = '/internal/shared/.rewrite-rules-flushed';
+			if (file_exists($flag)) {
+				return;
+			}
+			if (!function_exists('get_option')) {
+				return;
+			}
+			$structure = get_option('permalink_structure');
+			if (empty($structure)) {
+				return;
+			}
+			$rules = get_option('rewrite_rules');
+			if (!empty($rules)) {
+				@file_put_contents($flag, '1');
+				return;
+			}
+			global $wp_rewrite;
+			if (!isset($wp_rewrite) && class_exists('WP_Rewrite')) {
+				$wp_rewrite = new WP_Rewrite();
+			}
+			if (isset($wp_rewrite) && method_exists($wp_rewrite, 'flush_rules')) {
+				$wp_rewrite->flush_rules();
+			}
+			@file_put_contents($flag, '1');
+		}
+		add_action('init', 'playground_maybe_flush_rewrite_rules', 99999);
+
+        // Create the fonts directory if missing
+        if(!file_exists(WP_CONTENT_DIR . '/fonts')) {
+            mkdir(WP_CONTENT_DIR . '/fonts');
+        }
+
+        $log_file = WP_CONTENT_DIR . '/debug.log';
+        if ( defined( 'WP_DEBUG_LOG' ) && WP_DEBUG_LOG ) {
+            if ( is_string( WP_DEBUG_LOG ) ) {
+                $log_file = WP_DEBUG_LOG;
+            }
+            ini_set('error_log', $log_file);
+        } else {
+            ini_set('log_errors', '0');
+        }
+        define('ERROR_LOG_FILE', $log_file);
+        ?>`
+  ), await e.writeFile(
+    "/internal/shared/mu-plugins/sitemap-redirect.php",
+    `<?php
+		/**
+		 * Redirect sitemap.xml to wp-sitemap.xml for non-root installations.
+		 *
+		 * WordPress seems to only generate the sitemap.xml → wp-sitemap.xml rewrite
+		 * rule when installed at the domain root. This mu-plugin handles the
+		 * redirect for non-root installations.
+		 */
+		if (isset($_SERVER['REQUEST_URI'])) {
+			$site_url = site_url();
+			$parsed = parse_url($site_url);
+			$base_path = isset($parsed['path']) ? rtrim($parsed['path'], '/') : '';
+
+			$request_uri = $_SERVER['REQUEST_URI'];
+			if (
+				$request_uri === $base_path . '/sitemap.xml' ||
+				strpos($request_uri, $base_path . '/sitemap.xml?') === 0 ||
+				strpos($request_uri, $base_path . '/sitemap.xml/') === 0
+			) {
+				$query_string = strpos($request_uri, '?') !== false ? substr($request_uri, strpos($request_uri, '?')) : '';
+				header('Location: ' . $base_path . '/wp-sitemap.xml' . $query_string, true, 301);
+				exit;
+			}
+		}
+		`
+  ), await e.writeFile(
+    "/internal/shared/mu-plugins/inline-tinymce-content-css.php",
+    `<?php
+		function playground_inline_tinymce_content_css($settings) {
+			if (empty($settings['content_css'])) return $settings;
+			$css_urls = explode(',', $settings['content_css']);
+			$inline_css = '';
+			$doc_root = isset($_SERVER['DOCUMENT_ROOT'])
+				? $_SERVER['DOCUMENT_ROOT'] : '/wordpress';
+			foreach ($css_urls as $url) {
+				$url = trim($url);
+				if (!$url) continue;
+				$parsed = parse_url($url);
+				if (!isset($parsed['path'])) continue;
+				$path = preg_replace('#^/scope:[^/]+#', '', $parsed['path']);
+				$file = $doc_root . $path;
+				if (file_exists($file)) {
+					$inline_css .= @file_get_contents($file) . "\\n";
+				}
+			}
+			if ($inline_css !== '') {
+				if (!empty($settings['content_style'])) {
+					$inline_css = $settings['content_style'] . "\\n" . $inline_css;
+				}
+				$settings['content_style'] = $inline_css;
+				$settings['content_css'] = '';
+			}
+			return $settings;
+		}
+		add_filter('tiny_mce_before_init', 'playground_inline_tinymce_content_css');
+		`
+  );
+}
+function v(e) {
+  return `
+/**
+ * Loads the SQLite integration plugin before WordPress is loaded
+ * and without creating a drop-in "db.php" file.
+ *
+ * Technically, it creates a global $wpdb object whose only two
+ * purposes are to:
+ *
+ * * Exist – because the require_wp_db() WordPress function won't
+ *           connect to MySQL if $wpdb is already set.
+ * * Load the SQLite integration plugin the first time it's used
+ *   and replace the global $wpdb reference with the SQLite one.
+ *
+ * This lets Playground keep the WordPress installation clean and
+ * solves dillemas like:
+ *
+ * * Should we include db.php in Playground exports?
+ * * Should we remove db.php from Playground imports?
+ * * How should we treat stale db.php from long-lived OPFS sites?
+ *
+ * @see https://github.com/WordPress/wordpress-playground/discussions/1379 for
+ *      more context.
+ */
+class Playground_SQLite_Integration_Loader {
+	public function __call($name, $arguments) {
+		$this->load_sqlite_integration();
+		if($GLOBALS['wpdb'] === $this) {
+			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
+		}
+		return call_user_func_array(
+			array($GLOBALS['wpdb'], $name),
+			$arguments
+		);
+	}
+	public function __get($name) {
+		$this->load_sqlite_integration();
+		if($GLOBALS['wpdb'] === $this) {
+			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
+		}
+		return $GLOBALS['wpdb']->$name;
+	}
+	public function __set($name, $value) {
+		$this->load_sqlite_integration();
+		if($GLOBALS['wpdb'] === $this) {
+			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
+		}
+		$GLOBALS['wpdb']->$name = $value;
+	}
+    protected function load_sqlite_integration() {
+        ${e}
+    }
+}
+/**
+ * The Query Monitor plugin short-circuits in the CLI SAPI. However, in Playground,
+ * the SAPI is always "cli" at the moment. Let's set a constant to disable the CLI
+ * detection.
+ *
+ * @see https://github.com/WordPress/sqlite-database-integration/pull/212
+ * @see https://github.com/WordPress/sqlite-database-integration/pull/215
+ */
+define('QM_TESTS', true);
+$wpdb = $GLOBALS['wpdb'] = new Playground_SQLite_Integration_Loader();
+
+/**
+ * WordPress is capable of using a preloaded global $wpdb. However, if
+ * it cannot find the drop-in db.php plugin it still checks whether
+ * the mysqli_connect() function exists even though it's not used.
+ *
+ * What WordPress demands, Playground shall provide.
+ */
+`;
+}
+const H = `
+			if (function_exists('is_user_logged_in') && is_user_logged_in()) {
+				return;
+			}
+			if (headers_sent()) {
+				return;
+			}
+
+			// Legacy auto-login never redirects; it populates $_COOKIE
+			// in-process for the current request and relies on
+			// setcookie() / wp_set_auth_cookie() to persist across
+			// requests via HttpCookieStore.
+
+			// WP 2.5+
+			if (function_exists('wp_set_current_user') && function_exists('wp_set_auth_cookie')) {
+				$user = function_exists('get_user_by')
+					? get_user_by('login', $user_name)
+					: (function_exists('get_userdatabylogin')
+						? get_userdatabylogin($user_name) : null);
+				if (!$user) return;
+
+				wp_set_current_user($user->ID, $user->user_login);
+				// Populate $_COOKIE in-process so auth_redirect() and
+				// wp_verify_nonce() see the session for the remainder
+				// of this request; wp_set_auth_cookie() also emits
+				// Set-Cookie for subsequent requests.
+				wp_set_auth_cookie($user->ID);
+				if (function_exists('wp_generate_auth_cookie')) {
+					$_pg_exp = time() + 172800;
+					if (defined('AUTH_COOKIE'))
+						$_COOKIE[AUTH_COOKIE] = wp_generate_auth_cookie($user->ID, $_pg_exp, 'auth');
+					if (defined('SECURE_AUTH_COOKIE'))
+						$_COOKIE[SECURE_AUTH_COOKIE] = wp_generate_auth_cookie($user->ID, $_pg_exp, 'secure_auth');
+					if (defined('LOGGED_IN_COOKIE'))
+						$_COOKIE[LOGGED_IN_COOKIE] = wp_generate_auth_cookie($user->ID, $_pg_exp, 'logged_in');
+				}
+				return;
+			}
+
+			// WP 1.5–2.4
+			if (defined('USER_COOKIE') && defined('PASS_COOKIE')) {
+				$_pg_pass_cookie = md5(md5('password'));
+				$_COOKIE[USER_COOKIE] = $user_name;
+				$_COOKIE[PASS_COOKIE] = $_pg_pass_cookie;
+				if (!headers_sent()) {
+					$_pg_exp = time() + 172800;
+					setcookie(USER_COOKIE, $user_name, $_pg_exp, '/');
+					setcookie(PASS_COOKIE, $_pg_pass_cookie, $_pg_exp, '/');
+				}
+				$GLOBALS['current_user'] = null;
+				if (function_exists('get_currentuserinfo')) {
+					get_currentuserinfo();
+				}
+				return;
+			}
+
+			// WP 1.0–1.2: cookies are usually already set by
+			// playground_legacy_set_auth_cookies_early() in env.php,
+			// but WP 1.0–1.2 reads its user state from globals (no
+			// WP_User), so populate those explicitly here.
+			$cookiehash = defined('COOKIEHASH')
+				? COOKIEHASH
+				: (isset($GLOBALS['cookiehash']) && $GLOBALS['cookiehash']
+					? $GLOBALS['cookiehash']
+					: (function_exists('get_settings')
+						? md5(get_settings('siteurl'))
+						: ''));
+			if ($cookiehash) {
+				$_pg_user_cookie_name = 'wordpressuser_' . $cookiehash;
+				$_pg_pass_cookie_name = 'wordpresspass_' . $cookiehash;
+				$_pg_pass_cookie_value = md5(md5('password'));
+				$_COOKIE[$_pg_user_cookie_name] = $user_name;
+				$_COOKIE[$_pg_pass_cookie_name] = $_pg_pass_cookie_value;
+				if (!headers_sent()) {
+					$_pg_exp = time() + 172800;
+					setcookie($_pg_user_cookie_name, $user_name, $_pg_exp, '/');
+					setcookie($_pg_pass_cookie_name, $_pg_pass_cookie_value, $_pg_exp, '/');
+				}
+				if (function_exists('get_userdatabylogin')) {
+					$userdata = get_userdatabylogin($user_name);
+					if ($userdata) {
+						$GLOBALS['user_login']    = $user_name;
+						$GLOBALS['userdata']      = $userdata;
+						$GLOBALS['user_level']    = isset($userdata->user_level) ? (int) $userdata->user_level : 10;
+						$GLOBALS['user_ID']       = $userdata->ID;
+						$GLOBALS['user_email']    = isset($userdata->user_email) ? $userdata->user_email : '';
+						$GLOBALS['user_url']      = isset($userdata->user_url) ? $userdata->user_url : '';
+						$GLOBALS['user_nickname'] = isset($userdata->user_nickname) ? $userdata->user_nickname : $user_name;
+						$GLOBALS['user_pass_md5'] = md5(isset($userdata->user_pass) ? $userdata->user_pass : '');
+					}
+				}
+				return;
+			}
+`;
+async function B(e) {
+  await e.mkdir("/internal/shared/mu-plugins"), await e.writeFile(
+    "/internal/shared/auto_prepend_file.php",
+    `<?php
+// Polyfill the PHP 4 superglobals WP 1.0–2.5 still reads (removed
+// in PHP 5.4). Bind by reference so later writes to $_COOKIE
+// reach $HTTP_COOKIE_VARS, which WP 1.0's get_currentuserinfo()
+// consults.
+$GLOBALS['HTTP_GET_VARS']     = &$_GET;
+$GLOBALS['HTTP_POST_VARS']    = &$_POST;
+$GLOBALS['HTTP_COOKIE_VARS']  = &$_COOKIE;
+$GLOBALS['HTTP_SERVER_VARS']  = &$_SERVER;
+if (isset($_FILES))   $GLOBALS['HTTP_POST_FILES']   = &$_FILES;
+if (isset($_ENV))     $GLOBALS['HTTP_ENV_VARS']     = &$_ENV;
+if (isset($_SESSION)) $GLOBALS['HTTP_SESSION_VARS'] = &$_SESSION;
+// Top-level names register_globals=On used to expose. WP 1.0
+// reads $PHP_SELF / $REMOTE_ADDR directly instead of $_SERVER.
+if (isset($_SERVER['PHP_SELF'])) $GLOBALS['PHP_SELF'] = $_SERVER['PHP_SELF'];
+if (isset($_SERVER['REMOTE_ADDR'])) $GLOBALS['REMOTE_ADDR'] = $_SERVER['REMOTE_ADDR'];
+if (isset($_SERVER['REQUEST_URI'])) $GLOBALS['REQUEST_URI'] = $_SERVER['REQUEST_URI'];
+// Default SERVER_PROTOCOL for scripts invoked outside an HTTP
+// request (e.g. php.run() during boot/fixups) — legacy WP reads
+// it unconditionally in places like wp_redirect().
+if (!isset($_SERVER['SERVER_PROTOCOL'])) {
+	$_SERVER['SERVER_PROTOCOL'] = 'HTTP/1.1';
+}
+if(file_exists('/internal/shared/consts.json')) {
+	$consts = json_decode(file_get_contents('/internal/shared/consts.json'), true);
+	if ($consts) {
+		foreach ($consts as $const => $value) {
+			if (!defined($const) && is_scalar($value)) {
+				define($const, $value);
+			}
+		}
+	}
+}
+foreach (glob('/internal/shared/preload/*.php') as $file) {
+	require_once $file;
+}
+// Buffer early output so a stray PHP notice doesn't commit the
+// response headers before the auto-login mu-plugin gets a chance
+// to call wp_set_auth_cookie() / setcookie() on the init hook —
+// otherwise nonce validation breaks on POST requests. PHP flushes
+// the buffer at script end so output still reaches the browser.
+ob_start();
+`
+  ), await e.writeFile(
+    "/internal/shared/preload/env.php",
+    `<?php
+// Reads $wp_version from the WordPress install on disk. Falls back
+// to '1.0' so callers can use version_compare() unconditionally.
+function _playground_detect_wp_version() {
+	static $version = null;
+	if ($version !== null) return $version;
+	$doc_root = isset($_SERVER['DOCUMENT_ROOT'])
+		? $_SERVER['DOCUMENT_ROOT'] : '/wordpress';
+	$version_path = $doc_root . '/wp-includes/version.php';
+	$wp_version = '1.0';
+	if (file_exists($version_path)) {
+		include $version_path;
+	}
+	$version = $wp_version;
+	return $version;
+}
+
+// Returns 'wp10', 'wp12', or 'wp15' based on the WP version on
+// disk — the three $wp_filter shapes apply_filters() understands.
+function _playground_detect_wp_hook_format() {
+	static $format = null;
+	if ($format !== null) return $format;
+	$wp_version = _playground_detect_wp_version();
+	if (version_compare($wp_version, '1.5', '>=')) {
+		$format = 'wp15';
+	} elseif (version_compare($wp_version, '1.2', '>=')) {
+		$format = 'wp12';
+	} else {
+		$format = 'wp10';
+	}
+	return $format;
+}
+
+// Adds filters/actions before WordPress is loaded by writing the
+// $wp_filter shape the target version expects. $function_to_add
+// MUST be a string (no closures).
+function playground_add_filter( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
+	global $wp_filter;
+	$fmt = _playground_detect_wp_hook_format();
+	if ($fmt === 'wp10') {
+		$wp_filter[$tag][] = $function_to_add;
+	} elseif ($fmt === 'wp12') {
+		$wp_filter[$tag][$priority][] = $function_to_add;
+	} else {
+		$wp_filter[$tag][$priority][$function_to_add] = array(
+			'function' => $function_to_add,
+			'accepted_args' => $accepted_args
+		);
+	}
+}
+function playground_add_action( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {
+	playground_add_filter( $tag, $function_to_add, $priority, $accepted_args );
+}
+
+// Set WP 1.0–2.4 auth cookies before WordPress loads — by the time
+// the init hook fires (and on WP 1.0–1.2 it may not fire at all on
+// the front page) WordPress has already read $_COOKIE. setcookie()
+// also persists them across requests via HttpCookieStore.
+// WP 2.5+ uses the HMAC auth cookie scheme and doesn't read these
+// wordpressuser_/wordpresspass_ cookies at all — bail there so we
+// don't write inert cookies the runtime would have to clean up.
+function playground_legacy_set_auth_cookies_early() {
+	if (!defined('PLAYGROUND_AUTO_LOGIN_AS_USER')) return;
+	if (isset($_COOKIE['playground_auto_login_already_logged_out'])) return;
+	if (version_compare(_playground_detect_wp_version(), '2.5', '>=')) return;
+
+	foreach ($_COOKIE as $name => $_) {
+		if (strncmp($name, 'wordpressuser_', 14) === 0) return;
+	}
+
+	$user_name = PLAYGROUND_AUTO_LOGIN_AS_USER;
+	$pass_md5 = md5(md5('password'));
+
+	// Read siteurl from SQLite so the cookie hash matches what
+	// WP 1.0–2.4 derives from get_settings('siteurl').
+	$siteurl = null;
+	$db_path = defined('DB_DIR') ? DB_DIR . '.ht.sqlite' : '';
+	if ($db_path && class_exists('PDO') && file_exists($db_path)) {
+		try {
+			$pdo = new PDO('sqlite:' . $db_path);
+			$stmt = $pdo->query("SELECT option_value FROM wp_options WHERE option_name = 'siteurl' LIMIT 1");
+			if ($stmt) $siteurl = $stmt->fetchColumn();
+			$pdo = null;
+		} catch (Exception $e) {}
+	}
+	if (!$siteurl && defined('WP_SITEURL')) $siteurl = WP_SITEURL;
+	if (!$siteurl) return;
+
+	$cookiehash = md5($siteurl);
+	$user_cookie_name = 'wordpressuser_' . $cookiehash;
+	$pass_cookie_name = 'wordpresspass_' . $cookiehash;
+	$_COOKIE[$user_cookie_name] = $user_name;
+	$_COOKIE[$pass_cookie_name] = $pass_md5;
+
+	if (!headers_sent()) {
+		$exp = time() + 172800;
+		setcookie($user_cookie_name, $user_name, $exp, '/');
+		setcookie($pass_cookie_name, $pass_md5, $exp, '/');
+	}
+}
+playground_legacy_set_auth_cookies_early();
+
+// WP < 4.0 emits YEAR(post_date)='2026' AND MONTH(post_date)='4'
+// against MySQL's loose type coercion. The SQLite driver's UDFs
+// return integers and SQLite is strictly typed (4 != '4'), so
+// strip quotes around numeric RHS values to keep both sides ints.
+function playground_fix_sqlite_date_comparisons($query) {
+	if (
+		stripos($query, 'YEAR') === false &&
+		stripos($query, 'MONTH') === false &&
+		stripos($query, 'DAY') === false
+	) {
+		return $query;
+	}
+	return preg_replace(
+		'/\\b(YEAR|MONTH|DAYOFMONTH|DAY)\\s*\\(([^)]+)\\)\\s*=\\s*\\'(\\d+)\\'/i',
+		'$1($2) = $3',
+		$query
+	);
+}
+playground_add_filter( 'query', 'playground_fix_sqlite_date_comparisons' );
+
+// WP 2.2+ checks WP_SITEURL/WP_HOME inside get_option(); WP <2.2
+// doesn't, so backfill the same behaviour via the option filters
+// to keep admin links on the Playground-scoped URL.
+function playground_override_siteurl($value) {
+	if (defined('WP_SITEURL')) {
+		return WP_SITEURL;
+	}
+	return $value;
+}
+function playground_override_home($value) {
+	if (defined('WP_HOME')) {
+		return WP_HOME;
+	}
+	return $value;
+}
+playground_add_filter( 'option_siteurl', 'playground_override_siteurl' );
+playground_add_filter( 'option_home', 'playground_override_home' );
+
+// Load mu-plugins last so customer mu-plugins win — and so they
+// can't depend on muplugins_loaded. WP < 2.8 doesn't fire that
+// action at all, so init -1000 acts as a fallback (the $loaded
+// flag keeps it idempotent).
+playground_add_action( 'muplugins_loaded', 'playground_load_mu_plugins', 0 );
+playground_add_action( 'init', 'playground_load_mu_plugins', -1000 );
+function playground_load_mu_plugins() {
+	static $loaded = false;
+	if ($loaded) return;
+	$loaded = true;
+	$mu_plugins_dir = '/internal/shared/mu-plugins';
+	if(!is_dir($mu_plugins_dir)){
+		return;
+	}
+	$mu_plugins = glob( $mu_plugins_dir . '/*.php' );
+	sort( $mu_plugins );
+	global $wp_version;
+	$is_legacy_wp = isset($wp_version) && version_compare($wp_version, '2.8', '<');
+	foreach ( $mu_plugins as $mu_plugin ) {
+		// Loaded separately by the preload lazy loader or db.php.
+		if (strpos($mu_plugin, 'sqlite-database-integration') !== false) {
+			continue;
+		}
+		// WP < 2.8 crashes on closures in hooks and lacks
+		// site_url() (added 2.6). 1-auto-login.php is written
+		// without either, so it's the only mu-plugin we load
+		// on legacy WP.
+		if ($is_legacy_wp) {
+			if (strpos($mu_plugin, '1-auto-login.php') === false) {
+				continue;
+			}
+		}
+		require_once $mu_plugin;
+	}
+
+	// PHP 5.x's foreach over $wp_filter['init'] iterates a copy,
+	// so add_action() calls made by the mu-plugin we just loaded
+	// won't fire on this same init run. Call them directly.
+	if ($is_legacy_wp) {
+		if (function_exists('playground_auto_login_redirect_target')) {
+			playground_auto_login_redirect_target();
+		}
+		if (function_exists('playground_auto_login')) {
+			playground_auto_login();
+		}
+	}
+}
+`
+  ), await e.writeFile(
+    "/internal/shared/mu-plugins/1-auto-login.php",
+    `<?php
+		/**
+		 * Returns the username to auto-login as, if any.
+		 * @return string|false
+		 */
+		function playground_get_username_for_auto_login() {
+			if ( defined('PLAYGROUND_AUTO_LOGIN_AS_USER') && !isset($_COOKIE['playground_auto_login_already_happened']) ) {
+				return PLAYGROUND_AUTO_LOGIN_AS_USER;
+			}
+			if ( defined('PLAYGROUND_FORCE_AUTO_LOGIN_ENABLED') && isset($_GET['playground_force_auto_login_as_user']) ) {
+				return $_GET['playground_force_auto_login_as_user'];
+			}
+			return false;
+		}
+
+		function playground_auto_login() {
+			if (empty($_SERVER['REQUEST_URI'])) {
+				return;
+			}
+			$user_name = playground_get_username_for_auto_login();
+			if ( false === $user_name ) {
+				return;
+			}
+			if ((function_exists('wp_doing_ajax') && wp_doing_ajax()) || defined('REST_REQUEST')) {
+				return;
+			}
+			${H}
+		}
+		add_action('init', 'playground_auto_login', 1);
+
+		function playground_auto_login_redirect_target() {
+			if(strpos($_SERVER['REQUEST_URI'], '?playground-redirection-handler') !== false) {
+				$next = $_GET['next'];
+				header('Location: ' . $next, true, 302);
+				exit;
+			}
+		}
+		add_action('init', 'playground_auto_login_redirect_target', 1);
+
+		/**
+		 * Disable the Site Admin Email Verification Screen for any session started
+		 * via autologin.
+		 */
+		if (function_exists('add_filter')) {
+			add_filter('admin_email_check_interval', 'playground_disable_admin_email_check');
+		}
+		function playground_disable_admin_email_check($interval) {
+			if(false === playground_get_username_for_auto_login()) {
+				return 0;
+			}
+			return $interval;
+		}
+		`
+  ), await S(e), await e.writeFile(
+    "/internal/shared/preload/error-handler.php",
+    `<?php
+$GLOBALS['_playground_consts'] = array();
+if (file_exists('/internal/shared/consts.json')) {
+	$GLOBALS['_playground_consts'] = @json_decode(file_get_contents('/internal/shared/consts.json'), true);
+	if (!is_array($GLOBALS['_playground_consts'])) { $GLOBALS['_playground_consts'] = array(); }
+	$GLOBALS['_playground_consts'] = array_keys($GLOBALS['_playground_consts']);
+}
+function _playground_error_handler($severity, $message, $file, $line) {
+	$playground_consts = $GLOBALS['_playground_consts'];
+${V}
+	return false;
+}
+set_error_handler('_playground_error_handler');`
+  );
+}
+const V = `
+		// http_api_transports is deprecated since 6.4.0 but Playground's
+		// networking layer still registers it for wp_http_supports().
+		// @see https://core.trac.wordpress.org/ticket/37708
+		if (
+			strpos($message, "http_api_transports") !== false &&
+			strpos($message, "since version 6.4.0 with no alternative available") !== false
+		) {
+			return;
+		}
+		// Playground predefines constants (SITE_URL, WP_DEBUG, …) that
+		// wp-config.php is allowed to redefine; ours take precedence.
+		if (strpos($message, "already defined") !== false) {
+			foreach($playground_consts as $const) {
+				if(strpos($message, "Constant $const already defined") !== false) {
+					return;
+				}
+			}
+		}
+		// Legacy WP (2.0–3.5) assigns props on uninitialised vars,
+		// valid in PHP 4 but E_WARNING since 5.x. Unfixable in core —
+		// Playground ships unmodified WordPress releases.
+		if (strpos($message, "Creating default object from empty value") !== false) {
+			return;
+		}
+		// WP 2.8's dashboard widget calls get_error_string() on a
+		// null SimplePie when feed HTTP requests fail in WASM.
+		if (strpos($message, "get_error_string() on null") !== false ||
+			strpos($message, "get_error_string() on a non-object") !== false) {
+			return;
+		}
+		// Don't complain about WordPress.org connection errors when
+		// the runtime isn't using fetch().
+		if (
+			(
+				! defined('USE_FETCH_FOR_REQUESTS') ||
+				! USE_FETCH_FOR_REQUESTS
+			) &&
+			strpos($message, "WordPress could not establish a secure connection to WordPress.org") !== false)
+		{
+			return;
+		}
+`;
+async function X(e, t) {
+  const i = T(e, t);
+  if (i === null) return;
+  const n = parseFloat(i);
+  if (!Number.isFinite(n) || n < 5 || n >= 6.2)
+    return;
+  const s = _(t, "wp-includes/load.php");
+  if (!e.fileExists(s)) return;
+  const r = e.readFileAsText(s), a = r.replace(
+    "extension_loaded( 'mysqli' )",
+    "function_exists( 'mysqli_connect' )"
+  );
+  a !== r && await e.writeFile(s, a);
+}
+function T(e, t) {
+  const i = _(t, "wp-includes/version.php");
+  if (!e.fileExists(i)) return null;
+  const s = e.readFileAsText(i).match(/\$wp_version\s*=\s*['"]([^'"]+)['"]/);
+  return s ? s[1] : null;
+}
+const Y = 22527, L = "E_ALL & ~8192 & ~2048";
+async function K(e, t) {
+  await se(e, t), await ae(e, t), await oe(e, t), await ue(e, t), await de(e, t), await Le(e, t), await fe(e, t), await we(e, t), await Z(e, t), await z(e, t);
+  const i = T(e, t);
+  if (i === null) return;
+  const n = parseFloat(i);
+  Number.isFinite(n) && (n < 1.2 && (await re(e, t), await ie(e, t)), n < 1.5 && await J(e, t), 1.5 <= n && n < 2 && await ge(e, t), n < 2 && (await ee(e, t), await ce(e, t)), 2.1 <= n && n < 2.3 && await ne(e, t), n < 2.5 && await $e(e, t), n < 2.8 && (await Ee(e, t), await Te(e, t)), 2.9 <= n && n < 3.6 && await j(e, t), 3.3 <= n && n < 3.4 && await te(e, t), n >= 4.7 && await Q(e, t));
+}
+async function Q(e, t) {
+  const i = _(t, "wp-content/themes");
+  if (e.isDir(i))
+    for (const n of e.listFiles(i)) {
+      const s = _(i, n, "searchform.php");
+      e.fileExists(s) && e.unlink(s);
+    }
+}
+async function j(e, t) {
+  const i = _(t, "wp-admin/includes/dashboard.php");
+  if (e.fileExists(i)) {
+    let r = e.readFileAsText(i);
+    if (r.includes("function wp_dashboard_primary()") && !r.includes("/* pg_no_rss */")) {
+      for (const a of [
+        "wp_dashboard_primary",
+        "wp_dashboard_secondary",
+        "wp_dashboard_plugins"
+      ])
+        r = r.replace(
+          new RegExp(`function ${a}\\(\\)\\s*\\{`),
+          `function ${a}() { /* pg_no_rss */ return;`
+        );
+      await e.writeFile(i, r);
+    }
+  }
+  const n = _(t, "wp-admin/admin.php");
+  if (e.fileExists(n)) {
+    let r = e.readFileAsText(n);
+    r.includes("do_action('admin_init');") && !r.includes("/* pg_admin_init_cleanup */") && (r = r.replace(
+      "do_action('admin_init');",
+      `/* pg_admin_init_cleanup */
+if (function_exists('remove_action')) {
+	@remove_action('admin_init', '_maybe_update_plugins');
+	@remove_action('admin_init', '_maybe_update_themes');
+	@remove_action('admin_init', '_maybe_update_core');
+	@remove_action('admin_init', 'wp_version_check');
+	@remove_action('admin_init', 'wp_update_plugins');
+	@remove_action('admin_init', 'wp_update_themes');
+}
+do_action('admin_init');`
+    ), await e.writeFile(n, r));
+  }
+  const s = _(
+    t,
+    "wp-admin/includes/update.php"
+  );
+  if (e.fileExists(s)) {
+    let r = e.readFileAsText(s);
+    if (!r.includes("/* pg_admin_no_updates */")) {
+      for (const a of [
+        "wp_plugin_update_rows",
+        "wp_plugin_update_row",
+        "wp_theme_update_rows",
+        "wp_theme_update_row",
+        "wp_update_plugins",
+        "wp_update_themes"
+      ]) {
+        const o = new RegExp(
+          `function ${a}\\s*\\([^)]*\\)\\s*\\{`
+        );
+        o.test(r) && (r = r.replace(
+          o,
+          (l) => l + " /* pg_admin_no_updates */ return;"
+        ));
+      }
+      await e.writeFile(s, r);
+    }
+  }
+  for (const r of [
+    _(t, "wp-includes/SimplePie/File.php"),
+    _(t, "wp-includes/class-simplepie.php")
+  ]) {
+    if (!e.fileExists(r)) continue;
+    let a = e.readFileAsText(r);
+    a.includes("function SimplePie_File(") && !a.includes("/* pg_no_fetch */") && (a = a.replace(
+      /function SimplePie_File\([^)]*\)\s*\{/,
+      (o) => o + `
+		/* pg_no_fetch */
+		$this->error = 'Network requests disabled in Playground';
+		$this->success = false;
+		return;`
+    ), await e.writeFile(r, a));
+  }
+}
+async function z(e, t) {
+  const i = [
+    ["function wp_new_blog_notification", "pg_no_blog_notification"],
+    [
+      "function wp_install_maybe_enable_pretty_permalinks",
+      "pg_no_permalink_check"
+    ]
+  ], n = [
+    _(t, "wp-admin/includes/upgrade.php"),
+    _(t, "wp-admin/upgrade-functions.php")
+  ];
+  for (const s of n) {
+    if (!e.fileExists(s)) continue;
+    let r = e.readFileAsText(s), a = !1;
+    for (const [o, l] of i) {
+      if (r.includes(`/* ${l} */`)) continue;
+      const c = r.indexOf(o);
+      if (c === -1) continue;
+      const u = r.indexOf("{", c);
+      u !== -1 && (r = r.substring(0, u + 1) + ` /* ${l} */ return;` + r.substring(u + 1), a = !0);
+    }
+    a && await e.writeFile(s, r);
+  }
+}
+async function Z(e, t) {
+  const i = _(t, "wp-load.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  if (!n.includes("error_reporting(") || n.includes("~8192") && n.includes("~2048")) return;
+  const s = n.replace(
+    /error_reporting\(([^)]+)\)/g,
+    (r, a) => `error_reporting((${a}) & ~8192 & ~2048)`
+  );
+  await e.writeFile(i, s);
+}
+async function J(e, t) {
+  const i = _(t, "wp-admin/menu.php");
+  if (e.fileExists(i)) {
+    const r = e.readFileAsText(i);
+    if (!r.includes("/* pg_wp10_logo_link */")) {
+      const a = '<h1 id="wphead"><a href="http://wordpress.org" rel="external">WordPress</a></h1>';
+      if (r.includes(a)) {
+        const o = r.replace(
+          a,
+          '<h1 id="wphead"><a href="#" rel="external">WordPress</a></h1> <!-- pg_wp10_logo_link -->'
+        );
+        o !== r && await e.writeFile(i, o);
+      }
+    }
+  }
+  const n = _(
+    t,
+    "wp-admin/admin-header.php"
+  );
+  if (e.fileExists(n)) {
+    const r = e.readFileAsText(n);
+    if (!r.includes("/* pg_wp12_logo_link */")) {
+      const a = '<a href="http://wordpress.org" rel="external"', o = "</a>", l = r.indexOf(a);
+      if (l !== -1) {
+        const c = r.indexOf(o, l);
+        if (c !== -1) {
+          const u = r.substring(0, l) + '<a href="#">WordPress</a><!-- pg_wp12_logo_link -->' + r.substring(c + o.length);
+          u !== r && await e.writeFile(n, u);
+        }
+      }
+    }
+  }
+  const s = _(
+    t,
+    "wp-admin/admin-footer.php"
+  );
+  if (e.fileExists(s)) {
+    const r = e.readFileAsText(s);
+    if (!r.includes("/* pg_wp10_footer_link */")) {
+      const a = r.replace(
+        '<a href="http://wordpress.org">WordPress</a>',
+        "WordPress<!-- pg_wp10_footer_link -->"
+      ).replace(
+        '<a href="http://wordpress.org/">WordPress</a>',
+        "WordPress<!-- pg_wp10_footer_link -->"
+      );
+      a !== r && await e.writeFile(s, a);
+    }
+  }
+}
+async function ee(e, t) {
+  const i = _(t, "wp-admin/edit.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  if (n.includes("/* pg_wp10_post_title_edit */")) return;
+  let s = n;
+  const r = '<strong><a href="<?php permalink_link(); ?>" rel="permalink"><?php the_title() ?></a></strong>';
+  s.includes(r) && (s = s.replace(
+    r,
+    '<strong><a href="post.php?action=edit&amp;post=<?php echo $id /* pg_wp10_post_title_edit */ ?>"><?php the_title() ?></a></strong>'
+  ));
+  const a = '<td><a href="<?php the_permalink(); ?>" rel="permalink">';
+  s.includes(a) && (s = s.replace(
+    a,
+    '<td><a href="post.php?action=edit&amp;post=<?php echo $id /* pg_wp10_post_title_edit */ ?>">'
+  ));
+  const o = `<td><?php the_title() ?>
+		<?php if ('private' == $post->post_status) _e(' - <strong>Private</strong>'); ?></td>`;
+  s.includes(o) && (s = s.replace(
+    o,
+    `<td><a href="post.php?action=edit&amp;post=<?php echo $id /* pg_wp10_post_title_edit */ ?>"><?php the_title() ?></a>
+		<?php if ('private' == $post->post_status) _e(' - <strong>Private</strong>'); ?></td>`
+  )), s !== n && await e.writeFile(i, s);
+}
+async function te(e, t) {
+  const i = _(t, "wp-admin/includes/screen.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  if (!n.includes("self::$this->_help_sidebar")) return;
+  const s = n.replace(
+    /self::\$this->_help_sidebar/g,
+    "$this->_help_sidebar"
+  );
+  s !== n && await e.writeFile(i, s);
+}
+async function ne(e, t) {
+  const i = _(t, "wp-admin/plugins.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  if (n.includes("/* pg_wp21_active_plugins_array */")) return;
+  const s = "$current = get_option('active_plugins');";
+  if (!n.includes(s)) return;
+  const r = n.replace(
+    s,
+    s + `
+	if (!is_array($current)) $current = array(); /* pg_wp21_active_plugins_array */`
+  );
+  r !== n && await e.writeFile(i, r);
+}
+async function ie(e, t) {
+  const i = _(t, "wp-login.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i), s = "AND user_pass = '$password'";
+  if (!n.includes(s) || n.includes("pg_wp10_plain_or_md5")) return;
+  let r = n.replace(
+    s,
+    "AND (user_pass = '$password' OR user_pass = MD5('$password')) /* pg_wp10_plain_or_md5 */"
+  );
+  r = r.replace(
+    "$login->user_pass == $password",
+    "($login->user_pass == $password || $login->user_pass == md5($password))"
+  ), r !== n && await e.writeFile(i, r);
+}
+async function se(e, t) {
+  const i = _(t, "wp-includes");
+  if (!e.isDir(i)) return;
+  const n = _(i, "version.php");
+  e.fileExists(n) || await e.writeFile(n, "<?php $wp_version = '1.0';");
+}
+async function re(e, t) {
+  const i = _(t, "wp-blog-header.php");
+  if (e.fileExists(i)) {
+    const s = e.readFileAsText(i), r = `$where .= ' AND (post_status = "publish"';`;
+    s.includes(r) && await e.writeFile(
+      i,
+      s.replace(
+        r,
+        `$where .= " AND (post_status = 'publish'";`
+      )
+    );
+  }
+  const n = _(t, "wp-includes/vars.php");
+  if (e.fileExists(n)) {
+    const s = e.readFileAsText(n), r = "add_filter('all', 'wptexturize');";
+    s.includes(r) && await e.writeFile(
+      n,
+      s.replace(
+        r,
+        `// ${r} // Disabled by Playground: mangles SQL literals.`
+      )
+    );
+  }
+}
+async function ae(e, t) {
+  const i = _(t, "wp-load.php");
+  e.fileExists(i) || await e.writeFile(
+    i,
+    `<?php
+if ( !defined('ABSPATH') ) {
+	define('ABSPATH', dirname(__FILE__) . '/');
+}
+require_once(ABSPATH . 'wp-config.php');
+`
+  );
+}
+async function oe(e, t) {
+  const i = _(t, "wp-settings.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  let s = n;
+  s = s.replace(
+    /if\s*\(\s*!extension_loaded\('mysql'\)\s*\)\s*\n\s*die/,
+    `if ( false ) // Patched for SQLite
+	die`
+  ), s = s.replace(
+    /error_reporting\(([^)]+)\)/g,
+    (r, a) => a.includes("~8192") && a.includes("~2048") ? r : `error_reporting((${a}) & ~8192 & ~2048)`
+  ), s = s.replace(
+    /set_magic_quotes_runtime\(\s*0\s*\)\s*;/g,
+    "// set_magic_quotes_runtime(0); // Removed"
+  ), s.includes("function_exists('get_magic_quotes_gpc')") || (s = s.replace(
+    /get_magic_quotes_gpc\(\)/g,
+    "(function_exists('get_magic_quotes_gpc') && get_magic_quotes_gpc())"
+  )), s = s.replace(/=\s*&\s*new\b/g, "= new"), s = s.replace(/\$HTTP_SERVER_VARS/g, "$_SERVER"), !s.includes("WP_CONTENT_DIR") && s.includes("define('WPINC'") && (s = s.replace(
+    /define\('WPINC',\s*'wp-includes'\);/,
+    `define('WPINC', 'wp-includes');
+if (!defined('WP_CONTENT_DIR')) define('WP_CONTENT_DIR', ABSPATH . 'wp-content');`
+  )), s = s.replace(/unset\(\s*\$wp_filter\s*,/, "unset("), s = _e(s), s = le(s), s !== n && await e.writeFile(i, s);
+}
+function _e(e) {
+  const t = e.indexOf("installed WP");
+  if (t === -1) return e;
+  const i = e.lastIndexOf("die(", t);
+  if (i === -1) return e;
+  let n = 0;
+  for (let s = i + 3; s < e.length; s++)
+    if (e[s] === "(") n++;
+    else if (e[s] === ")" && (n--, n === 0)) {
+      let r = s + 1;
+      return e[r] === ";" && r++, e.substring(0, i) + "true; /* die removed by Playground */" + e.substring(r);
+    }
+  return e;
+}
+function le(e) {
+  return e.replace(
+    "do_action('init');",
+    `// Remove hooks that make outbound HTTP requests (crash WASM).
+if (function_exists('remove_action')) {
+	@remove_action('init', 'wp_cron');
+	@remove_action('init', 'wp_version_check');
+	@remove_action('init', 'wp_update_plugins');
+	@remove_action('init', 'wp_update_themes');
+	@remove_action('admin_init', '_maybe_update_plugins');
+	@remove_action('admin_init', '_maybe_update_themes');
+	@remove_action('admin_init', 'wp_version_check');
+	@remove_action('admin_init', 'wp_update_plugins');
+	@remove_action('admin_init', 'wp_update_themes');
+	@remove_action('load-plugins.php', 'wp_update_plugins');
+	@remove_action('load-update.php', 'wp_update_plugins');
+	@remove_action('load-update.php', 'wp_update_themes');
+	@remove_action('load-themes.php', 'wp_update_themes');
+	@remove_action('wp_update_plugins', 'wp_update_plugins');
+	@remove_action('wp_version_check', 'wp_version_check');
+}
+if (function_exists('add_filter')) {
+	function _pg_disable_curl() { return false; }
+	function _pg_disable_streams() { return false; }
+	@add_filter('use_curl_transport', '_pg_disable_curl');
+	@add_filter('use_streams_transport', '_pg_disable_streams');
+	@add_filter('use_ftp_transport', '_pg_disable_curl');
+	@add_filter('use_fsockopen_transport', '_pg_disable_streams');
+}
+do_action('init');`
+  );
+}
+async function ce(e, t) {
+  const i = _(
+    t,
+    "wp-includes/functions.php"
+  );
+  if (!e.fileExists(i)) return;
+  let n = e.readFileAsText(i), s = !1;
+  n.includes("$all_options->{$option->option_name}") && !n.includes("$all_options = new stdClass") && (n = n.replace(
+    "foreach ($options as $option) {",
+    `$all_options = new stdClass;
+	foreach ($options as $option) {`
+  ), s = !0), s && await e.writeFile(i, n);
+}
+async function ue(e, t) {
+  const i = _(t, "wp-admin/install.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  let s = n;
+  const r = _(t, "wp-admin");
+  s = s.replace(/'\.\.\/(wp-config\.php)'/g, `'${t}/$1'`).replace(/'\.\.\/(wp-load\.php)'/g, `'${t}/$1'`).replace(/'\.\/(upgrade-functions\.php)'/g, `'${r}/$1'`).replace(/'(upgrade-functions\.php)'/g, `'${r}/$1'`).replace(/'\.\/(includes\/upgrade\.php)'/g, `'${r}/$1'`).replace(/'\.\.\/(wp-includes\/[^']+)'/g, `'${t}/$1'`), s = s.replace(/\$HTTP_GET_VARS/g, "$_GET").replace(/\$HTTP_POST_VARS/g, "$_POST"), s !== n && await e.writeFile(i, s);
+}
+async function de(e, t) {
+  const i = _(t, "wp-includes/wp-db.php");
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  let s = n;
+  s.includes("isset($wpdb)") || (s = s.replace(
+    "$wpdb = new wpdb(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST);",
+    "if ( !isset($wpdb) ) { $wpdb = new wpdb(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST); }"
+  )), s.includes("db_connect") || (s = s.replace(
+    /\$this->dbh\s*=\s*@mysql_connect\(\$dbhost\s*,\s*\$dbuser\s*,\s*\$dbpassword(?:\s*,\s*true)?\);/,
+    'if (method_exists($this, "db_connect")) { $this->dbname = $dbname; $this->db_connect(); } else { $this->dbh = @mysql_connect($dbhost, $dbuser, $dbpassword); }'
+  )), s = pe(s), s !== n && await e.writeFile(i, s);
+}
+function pe(e) {
+  const t = [];
+  if (e.includes("function set_prefix") || t.push(`
+	function set_prefix($prefix) {
+		$this->prefix = $prefix;
+		$tables = array('posts', 'users', 'categories', 'post2cat', 'comments', 'link2cat', 'links', 'options', 'postmeta', 'usermeta', 'terms', 'term_taxonomy', 'term_relationships');
+		foreach ($tables as $t) {
+			$this->$t = $prefix . $t;
+		}
+		return $prefix;
+	}`), e.includes("function timer_start") || t.push(`
+	function timer_start() {
+		$this->time_start = microtime(true);
+		return true;
+	}`), e.includes("function timer_stop") || t.push(`
+	function timer_stop() {
+		return microtime(true) - $this->time_start;
+	}`), e.includes("function init_charset") || t.push(`
+	function init_charset() {
+		if (defined('DB_CHARSET')) $this->charset = DB_CHARSET;
+		if (defined('DB_COLLATE')) $this->collate = DB_COLLATE;
+	}`), e.includes("function bail") || t.push(`
+	function bail($message, $error_code = '500') {
+		die($message);
+	}`), e.includes("function check_connection") || t.push(`
+	function check_connection($allow_bail = true) {
+		return true;
+	}`), t.length === 0) return e;
+  const i = e.match(
+    /^(\s*})\s*\n+(\$wpdb|\?>\s*$|if\s*\(\s*!\s*isset\(\s*\$wpdb\s*\))/m
+  );
+  if (!i || i.index === void 0) return e;
+  const n = `
+	// Polyfills added by WordPress Playground.
+` + t.join(`
+`) + `
+
+`;
+  return e.substring(0, i.index) + n + e.substring(i.index);
+}
+async function fe(e, t) {
+  const i = (a) => {
+    let o = a, l = 0;
+    for (; o.startsWith("../"); )
+      l++, o = o.slice(3);
+    for (; o.startsWith("./"); )
+      o = o.slice(2);
+    let c = "dirname(__FILE__)";
+    for (let u = 0; u < l; u++)
+      c = `dirname(${c})`;
+    return `${c} . '/${o}'`;
+  }, n = _(t, "wp-admin");
+  if (e.isDir(n))
+    for (const a of e.listFiles(n)) {
+      if (!a.endsWith(".php")) continue;
+      const o = _(n, a), l = e.readFileAsText(o), c = l.replace(
+        /((?:require|include)(?:_once)?)\s*\(\s*(['"])(\.\.\/[^'"]+)\2\s*\)/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(
+        /((?:require|include)(?:_once)?)\s*\(\s*(['"])(\.\/[^'"]+)\2\s*\)/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(
+        /((?:require|include)(?:_once)?)\s*\(\s*(['"])([a-z][\w-]*\.php)\2\s*\)/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(
+        /((?:require|include)(?:_once)?)\s+(['"])(\.\.\/[^'"]+)\2/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(
+        /((?:require|include)(?:_once)?)\s+(['"])(\.\/[^'"]+)\2/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(
+        /((?:require|include)(?:_once)?)\s+(['"])([a-z][\w-]*\.php)\2/g,
+        (u, d, f, p) => `${d}(${i(p)})`
+      ).replace(/ABSPATH\s*\.\s*'\/wp-/g, "ABSPATH . 'wp-");
+      c !== l && await e.writeFile(o, c);
+    }
+  const s = _(t, "wp-admin/index.php");
+  if (e.fileExists(s)) {
+    let a = e.readFileAsText(s);
+    a.includes("get_settings('siteurl')") && (a = a.replace(
+      /get_settings\('siteurl'\)\s*\.\s*'\/wp-admin\//g,
+      "'"
+    ), await e.writeFile(s, a));
+  }
+  const r = _(t, "wp-admin/menu.php");
+  if (e.fileExists(r)) {
+    const a = e.readFileAsText(r), o = "file('./menu.txt')";
+    a.includes(o) && await e.writeFile(
+      r,
+      a.replace(o, "file(dirname(__FILE__) . '/menu.txt')")
+    );
+  }
+}
+async function $e(e, t) {
+  const i = _(
+    t,
+    "wp-admin/admin-functions.php"
+  );
+  if (!e.fileExists(i)) return;
+  const n = e.readFileAsText(i);
+  if (!n.includes("function check_admin_referer()") || !n.includes("$_SERVER['HTTP_REFERER']"))
+    return;
+  const s = he(
+    n,
+    "check_admin_referer",
+    `
+	do_action('check_admin_referer', '');
+`
+  );
+  s !== n && await e.writeFile(i, s);
+}
+function he(e, t, i) {
+  const n = `function ${t}()`, s = e.indexOf(n);
+  if (s === -1) return e;
+  const r = e.indexOf("{", s + n.length);
+  if (r === -1) return e;
+  let a = 1;
+  for (let o = r + 1; o < e.length; o++) {
+    const l = e[o];
+    if (l === "{") a++;
+    else if (l === "}" && (a--, a === 0))
+      return e.substring(0, r + 1) + i + e.substring(o);
+  }
+  return e;
+}
+async function ge(e, t) {
+  const i = _(t, "wp-admin/index.php");
+  if (e.fileExists(i)) {
+    const n = e.readFileAsText(i), s = n.replace(/AND post_date_gmt < '\$today'/, "");
+    s !== n && await e.writeFile(i, s);
+  }
+  await me(e, t);
+}
+async function me(e, t) {
+  const i = _(t, "wp-includes/rss-functions.php");
+  if (!e.fileExists(i)) return;
+  let n = e.readFileAsText(i);
+  !/^\s*error\s*\(/m.test(n) || /^function\s+error\s*\(/m.test(n) || (n = n.replace(
+    /^(<\?php\s*)/,
+    `$1
+if (!function_exists('error')) {
+	function error($msg = '', $lvl = E_USER_WARNING) {
+		if (defined('MAGPIE_DEBUG') && MAGPIE_DEBUG) {
+			trigger_error($msg, $lvl);
+		}
+	}
+}
+`
+  ), await e.writeFile(i, n));
+}
+async function we(e, t) {
+  const i = _(t, "wp-login.php");
+  if (!e.fileExists(i)) return;
+  let n = e.readFileAsText(i), s = !1;
+  for (const r of ["log", "pwd"]) {
+    const a = new RegExp(
+      `(\\bname=(['"])${r}\\2)(?![^>]*data-1p-ignore)`
+    );
+    a.test(n) && (n = n.replace(a, "$1 data-1p-ignore"), s = !0);
+  }
+  s && await e.writeFile(i, n);
+}
+async function Ee(e, t) {
+  const i = _(t, "wp-admin/admin.php");
+  if (e.fileExists(i)) {
+    const s = e.readFileAsText(i);
+    if (s.includes("auth_redirect()")) {
+      const r = `
+// Playground: populate auth cookies and force admin user before auth_redirect.
+if (defined('PLAYGROUND_AUTO_LOGIN_AS_USER')) {
+	if (function_exists('is_user_logged_in') && is_user_logged_in()) {
+		// On WP < 4.0, wp_set_auth_cookie() does not update $_COOKIE
+		// in-process — auth_redirect() reads $_COOKIE, so re-emit.
+		if (function_exists('wp_generate_auth_cookie') && defined('LOGGED_IN_COOKIE') && empty($_COOKIE[LOGGED_IN_COOKIE])) {
+			$_pg_uid = wp_get_current_user()->ID;
+			$_pg_exp = time() + 172800;
+			$_COOKIE[AUTH_COOKIE] = wp_generate_auth_cookie($_pg_uid, $_pg_exp, 'auth');
+			if (defined('SECURE_AUTH_COOKIE'))
+				$_COOKIE[SECURE_AUTH_COOKIE] = wp_generate_auth_cookie($_pg_uid, $_pg_exp, 'secure_auth');
+			$_COOKIE[LOGGED_IN_COOKIE] = wp_generate_auth_cookie($_pg_uid, $_pg_exp, 'logged_in');
+		}
+	} else {
+		${x("PLAYGROUND_AUTO_LOGIN_AS_USER")}
+		// WP 2.0-2.4: kses_init() runs during do_action('init') inside
+		// wp-settings.php and caches $current_user as WP_User(0) when
+		// no cookies were set yet. Reset and re-evaluate so capability
+		// checks see the user we just authenticated.
+		if (!function_exists('wp_generate_auth_cookie')) {
+			$GLOBALS['current_user'] = null;
+			if (function_exists('get_currentuserinfo')) {
+				get_currentuserinfo();
+			}
+		}
+	}
+	// Force admin caps in-memory: if populate_roles() never ran
+	// (e.g. WP 2.0, or WP 2.5 installs that crashed before writing
+	// roles), the user has no caps and every current_user_can() fails.
+	$_pg_cu = isset($GLOBALS['current_user']) ? $GLOBALS['current_user'] : null;
+	if ($_pg_cu && isset($_pg_cu->ID) && $_pg_cu->ID > 0 && empty($_pg_cu->allcaps['read'])) {
+		// Respect a DB-stored user_level so a blueprint that auto-logs
+		// in as a lower-privilege user doesn't silently get level 10.
+		$_pg_db_level = isset($_pg_cu->user_level)
+			? (int) $_pg_cu->user_level
+			: null;
+		if ($_pg_db_level === null && isset($_pg_user) && $_pg_user) {
+			$_pg_db_level = isset($_pg_user->user_level)
+				? (int) $_pg_user->user_level
+				: null;
+		}
+		$_pg_cu->user_level = $_pg_db_level !== null ? $_pg_db_level : 10;
+		$_pg_effective_level = $_pg_cu->user_level;
+		$_pg_caps = array('read');
+		for ($_pg_i = 0; $_pg_i <= $_pg_effective_level; $_pg_i++) {
+			$_pg_caps[] = 'level_' . $_pg_i;
+		}
+		if ($_pg_effective_level >= 10) {
+			$_pg_caps = array_merge($_pg_caps, array(
+				'switch_themes','edit_themes','activate_plugins',
+				'edit_plugins','edit_users','edit_files','manage_options',
+				'moderate_comments','manage_categories','manage_links',
+				'upload_files','import','unfiltered_html','edit_posts',
+				'edit_others_posts','edit_published_posts','publish_posts',
+				'edit_pages'));
+		}
+		foreach ($_pg_caps as $_pg_c) {
+			$_pg_cu->allcaps[$_pg_c] = true;
+		}
+		if ($_pg_effective_level >= 10) {
+			$_pg_cu->caps = array('administrator' => true);
+		}
+	}
+}
+`, a = s.replace(
+        "auth_redirect();",
+        r + "auth_redirect();"
+      );
+      a !== s && await e.writeFile(i, a);
+    }
+  }
+  const n = _(t, "wp-admin/auth.php");
+  if (e.fileExists(n)) {
+    const s = e.readFileAsText(n);
+    if (s.includes("$cookiehash") && !s.includes("Playground: bypass auth")) {
+      const r = `<?php
+require_once(ABSPATH . 'wp-config.php');
+// Playground: bypass auth and manually populate user globals.
+global $user_login, $userdata, $user_level, $user_ID,
+	$user_nickname, $user_email, $user_url, $user_pass_md5, $cookiehash;
+$__pg_user_login = defined('PLAYGROUND_AUTO_LOGIN_AS_USER')
+	? PLAYGROUND_AUTO_LOGIN_AS_USER
+	: 'admin';
+$__pg_cookiehash = defined('COOKIEHASH')
+	? COOKIEHASH
+	: (isset($cookiehash) && $cookiehash
+		? $cookiehash
+		: md5(function_exists('get_settings') ? get_settings('siteurl') : ''));
+if ($__pg_cookiehash) {
+	$_COOKIE['wordpressuser_' . $__pg_cookiehash] = $__pg_user_login;
+}
+if (function_exists('get_userdatabylogin')) {
+	$__pg_userdata = get_userdatabylogin($__pg_user_login);
+	if ($__pg_userdata) {
+		$user_login = $__pg_user_login;
+		$userdata = $__pg_userdata;
+		$user_level = isset($__pg_userdata->user_level)
+			? (int) $__pg_userdata->user_level
+			: 10;
+		$user_ID = $__pg_userdata->ID;
+		$user_nickname = isset($__pg_userdata->user_nickname)
+			? $__pg_userdata->user_nickname
+			: $__pg_user_login;
+		$user_email = isset($__pg_userdata->user_email)
+			? $__pg_userdata->user_email
+			: '';
+		$user_url = isset($__pg_userdata->user_url)
+			? $__pg_userdata->user_url
+			: '';
+		$user_pass_md5 = md5(
+			isset($__pg_userdata->user_pass) ? $__pg_userdata->user_pass : ''
+		);
+	}
+}
+?>`;
+      r !== s && await e.writeFile(n, r);
+    }
+  }
+}
+async function Te(e, t) {
+  const i = _(t, "wp-admin/admin-ajax.php");
+  if (!e.fileExists(i)) return;
+  let n = e.readFileAsText(i);
+  if (!n.includes("is_user_logged_in")) return;
+  const s = `
+// Playground: authenticate admin user for AJAX requests on WP < 2.8.
+if (defined('PLAYGROUND_AUTO_LOGIN_AS_USER')) {
+	${x("PLAYGROUND_AUTO_LOGIN_AS_USER")}
+}
+`;
+  n = n.replace(
+    /if\s*\(\s*!\s*is_user_logged_in\(\)\s*\)/,
+    s + "if ( !is_user_logged_in() )"
+  ), await e.writeFile(i, n);
+}
+function x(e) {
+  return `
+$_pg_user = null;
+if (function_exists('wp_generate_auth_cookie')) {
+	$_pg_user = function_exists('get_user_by')
+		? get_user_by('login', ${e})
+		: (function_exists('get_userdatabylogin')
+			? get_userdatabylogin(${e}) : null);
+	if ($_pg_user) {
+		wp_set_current_user($_pg_user->ID, $_pg_user->user_login);
+		$_pg_exp = time() + 172800;
+		if (defined('AUTH_COOKIE'))
+			$_COOKIE[AUTH_COOKIE] = wp_generate_auth_cookie($_pg_user->ID, $_pg_exp, 'auth');
+		if (defined('SECURE_AUTH_COOKIE'))
+			$_COOKIE[SECURE_AUTH_COOKIE] = wp_generate_auth_cookie($_pg_user->ID, $_pg_exp, 'secure_auth');
+		if (defined('LOGGED_IN_COOKIE'))
+			$_COOKIE[LOGGED_IN_COOKIE] = wp_generate_auth_cookie($_pg_user->ID, $_pg_exp, 'logged_in');
+	}
+}
+`;
+}
+async function Le(e, t) {
+  const i = T(e, t);
+  if (i === null) return;
+  const n = parseFloat(i);
+  if (!Number.isFinite(n) || n >= 3.3) return;
+  const s = _(
+    t,
+    "wp-admin/includes/schema.php"
+  );
+  if (!e.fileExists(s)) return;
+  const r = e.readFileAsText(s);
+  /\$wp_queries\s*=\s*"CREATE TABLE/.test(r) && !r.includes("function wp_get_db_schema") && await ye(e, t, s, r);
+}
+async function ye(e, t, i, n) {
+  const s = n.match(/\$wp_queries\s*=\s*"CREATE TABLE/);
+  if (!s || s.index === void 0)
+    return;
+  const r = s.index, a = '";', o = n.indexOf(a, r);
+  if (o === -1)
+    return;
+  const l = o + a.length, u = `function wp_get_db_schema( $scope = 'all', $blog_id = null ) {
+	global $wpdb, $wp_queries, $charset_collate;
+	$charset_collate = '';
+	if ( ! empty($wpdb->charset) )
+		$charset_collate = "DEFAULT CHARACTER SET $wpdb->charset";
+	if ( ! empty($wpdb->collate) )
+		$charset_collate .= " COLLATE $wpdb->collate";
+	${n.substring(r, l)}
+	return $wp_queries;
+}`, d = n.substring(0, r) + u + n.substring(l);
+  await e.writeFile(i, d);
+  const f = _(
+    t,
+    "wp-admin/includes/upgrade.php"
+  );
+  if (e.fileExists(f)) {
+    const p = e.readFileAsText(f), y = p.replace(
+      /(\$alterations\s*=\s*dbDelta\(\s*\$wp_queries\s*\))/g,
+      "if ( function_exists('wp_get_db_schema') ) { $wp_queries = wp_get_db_schema(); } $1"
+    );
+    y !== p && await e.writeFile(f, y);
+  }
+}
+function be() {
+  return `<?php
+// @playground-managed — Playground-generated db.php.
+// WP < 3.0 loads only db.php and skips wp-db.php, so we pull
+// in the wpdb class definition explicitly.
+if (defined('ABSPATH') && defined('WPINC') && !class_exists('wpdb', false)) {
+	require_once(ABSPATH . WPINC . '/wp-db.php');
+}
+// Old wpdb (WP < 3.0) has no db_connect() and calls mysql_connect()
+// inline, so the SQLite driver never gets a chance to attach. Load
+// the integration here and reinitialise to swap the dbh in place.
+if (
+	class_exists('wpdb', false) &&
+	isset($GLOBALS['wpdb']) &&
+	!($GLOBALS['wpdb'] instanceof wpdb) &&
+	!method_exists('wpdb', 'db_connect') &&
+	file_exists('/internal/shared/mu-plugins/sqlite-database-integration.php')
+) {
+	require_once '/internal/shared/mu-plugins/sqlite-database-integration.php';
+	if (
+		isset($GLOBALS['wpdb']) &&
+		$GLOBALS['wpdb'] instanceof wpdb &&
+		method_exists($GLOBALS['wpdb'], 'reinitialize_sqlite')
+	) {
+		$GLOBALS['wpdb']->reinitialize_sqlite();
+	}
+}
+// Remaining mysqli_* stubs not covered by the 0-sqlite.php preload.
+// WP 4.x's extension_loaded('mysqli') check expects these to exist.
+if (!function_exists('mysqli_real_connect')) {
+	function mysqli_real_connect() { return true; }
+}
+if (!function_exists('mysqli_error')) {
+	function mysqli_error() { return ''; }
+}
+if (!function_exists('mysqli_errno')) {
+	function mysqli_errno() { return 0; }
+}
+if (!function_exists('mysqli_query')) {
+	function mysqli_query() { return false; }
+}
+if (!function_exists('mysqli_set_charset')) {
+	function mysqli_set_charset() { return true; }
+}
+if (!function_exists('mysqli_select_db')) {
+	function mysqli_select_db() { return true; }
+}
+if (!function_exists('mysqli_close')) {
+	function mysqli_close() { return true; }
+}
+`;
+}
+async function Oe(e, t) {
+  let i = null;
+  const n = _(e.documentRoot, "wp-includes/version.php");
+  if (e.fileExists(n)) {
+    const r = e.readFileAsText(n).match(/\$wp_version\s*=\s*['"]([^'"]+)['"]/);
+    r && (i = r[1]);
+  }
+  const s = i !== null && parseFloat(i) < 3.5;
+  try {
+    await e.run({
+      code: `<?php
+				// WP_INSTALLING bypasses WP 1.x's "not installed" die() in wp-settings.php.
+				define('WP_INSTALLING', true);
+				error_reporting(${L});
+				ini_set('display_errors', '0');
+				ob_start();
+				$_pg_db_path = getenv('DOCUMENT_ROOT') . '/wp-content/database/.ht.sqlite';
+				if (!file_exists($_pg_db_path)) { exit; }
+				$_pg_pdo = new PDO('sqlite:' . $_pg_db_path);
+				$_pg_check = $_pg_pdo->query("SELECT count(*) FROM sqlite_master WHERE type='table' AND name='wp_users'")->fetchColumn();
+				$_pg_pdo = null;
+				if (!$_pg_check) { exit; }
+				$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
+				if (!file_exists($wp_load)) { exit; }
+				require $wp_load;
+				ob_clean();
+				global $wpdb;
+				if (!isset($wpdb) || !method_exists($wpdb, 'query')) { exit; }
+
+				// Persist the scoped siteurl/home to the DB so parse_request()
+				// strips the scope prefix from REQUEST_URI. Filters alone
+				// (env.php) aren't enough on WP < 2.2.
+				$_pg_opts = !empty($wpdb->options) ? $wpdb->options : $GLOBALS['table_prefix'] . 'options';
+				try {
+					$_pg_url = getenv('PLAYGROUND_SITE_URL');
+					if ($_pg_url) {
+						$_pg_current = $wpdb->get_var("SELECT option_value FROM {$_pg_opts} WHERE option_name = 'siteurl'");
+						if ($_pg_current !== $_pg_url) {
+							$wpdb->query("UPDATE {$_pg_opts} SET option_value = '{$_pg_url}' WHERE option_name = 'siteurl'");
+							$wpdb->query("UPDATE {$_pg_opts} SET option_value = '{$_pg_url}' WHERE option_name = 'home'");
+						}
+					}
+				} catch (Exception $e) {}
+
+				// $wpdb->users exists on WP 1.5+; older WP needs the prefix.
+				$users_table = !empty($wpdb->users) ? $wpdb->users : $GLOBALS['table_prefix'] . 'users';
+
+				// WP 1.0/1.2 installers often leave the users table or admin row missing.
+				$wpdb->query("CREATE TABLE IF NOT EXISTS {$users_table} (
+					ID int(10) unsigned NOT NULL auto_increment,
+					user_login varchar(20) NOT NULL default '',
+					user_pass varchar(64) NOT NULL default '',
+					user_firstname varchar(50) NOT NULL default '',
+					user_lastname varchar(50) NOT NULL default '',
+					user_nickname varchar(50) NOT NULL default '',
+					user_icq int(10) unsigned NOT NULL default '0',
+					user_email varchar(100) NOT NULL default '',
+					user_url varchar(100) NOT NULL default '',
+					user_ip varchar(15) NOT NULL default '',
+					user_domain varchar(200) NOT NULL default '',
+					user_browser varchar(200) NOT NULL default '',
+					dateYMDhour datetime NOT NULL default '0000-00-00 00:00:00',
+					user_level int(2) unsigned NOT NULL default '0',
+					user_aim varchar(50) NOT NULL default '',
+					user_msn varchar(100) NOT NULL default '',
+					user_yim varchar(50) NOT NULL default '',
+					user_idmode varchar(20) NOT NULL default '',
+					PRIMARY KEY (ID),
+					UNIQUE KEY user_login (user_login)
+				)");
+				if (!$wpdb->get_var("SELECT COUNT(*) FROM {$users_table}")) {
+					$now = date('Y-m-d H:i:s');
+					$wpdb->query(
+						"INSERT INTO {$users_table} (ID, user_login, user_pass, user_email, user_level, dateYMDhour, user_nickname) " .
+						"VALUES (1, 'admin', MD5('password'), 'admin@localhost.com', 10, '{$now}', 'admin')"
+					);
+				}
+				$wpdb->query(
+					"UPDATE {$users_table} SET user_pass = MD5('password') WHERE user_login = 'admin'"
+				);
+
+				// populate_roles() can fail on SQLite; seed the admin role and caps directly.
+				$p = $GLOBALS['table_prefix'];
+				$roles_key = $p . 'user_roles';
+				try {
+					$has_roles = $wpdb->get_var(
+						"SELECT COUNT(*) FROM {$p}options WHERE option_name = '{$roles_key}'"
+					);
+				} catch (Exception $e) {
+					$has_roles = 0;
+				}
+				if (!$has_roles) {
+					$roles = array('administrator' => array(
+						'name' => 'Administrator',
+						'capabilities' => array(
+							'switch_themes'=>true, 'edit_themes'=>true,
+							'activate_plugins'=>true, 'edit_plugins'=>true,
+							'edit_users'=>true, 'edit_files'=>true,
+							'manage_options'=>true, 'moderate_comments'=>true,
+							'manage_categories'=>true, 'manage_links'=>true,
+							'upload_files'=>true, 'import'=>true,
+							'unfiltered_html'=>true, 'edit_posts'=>true,
+							'edit_others_posts'=>true, 'edit_published_posts'=>true,
+							'publish_posts'=>true, 'edit_pages'=>true,
+							'read'=>true, 'level_10'=>true, 'level_9'=>true,
+							'level_8'=>true, 'level_7'=>true, 'level_6'=>true,
+							'level_5'=>true, 'level_4'=>true, 'level_3'=>true,
+							'level_2'=>true, 'level_1'=>true, 'level_0'=>true,
+							'edit_others_pages'=>true, 'edit_published_pages'=>true,
+							'publish_pages'=>true, 'delete_pages'=>true,
+							'delete_others_pages'=>true, 'delete_published_pages'=>true,
+							'delete_posts'=>true, 'delete_others_posts'=>true,
+							'delete_published_posts'=>true, 'delete_private_posts'=>true,
+							'edit_private_posts'=>true, 'read_private_posts'=>true,
+							'delete_private_pages'=>true, 'edit_private_pages'=>true,
+							'read_private_pages'=>true,
+						)
+					));
+					$wpdb->query("INSERT INTO {$p}options (option_name, option_value, autoload) VALUES ('{$roles_key}', '" . addslashes(serialize($roles)) . "', 'yes')");
+				}
+				$um = isset($wpdb->usermeta) ? $wpdb->usermeta : $p . 'usermeta';
+				try {
+					$has_cap = $wpdb->get_var("SELECT COUNT(*) FROM {$um} WHERE user_id=1 AND meta_key='{$p}capabilities'");
+					if (!$has_cap) {
+						$cap_val = addslashes(serialize(array('administrator' => true)));
+						$wpdb->query("INSERT INTO {$um} (user_id, meta_key, meta_value) VALUES (1, '{$p}capabilities', '{$cap_val}')");
+					}
+					$has_level = $wpdb->get_var("SELECT COUNT(*) FROM {$um} WHERE user_id=1 AND meta_key='{$p}user_level'");
+					if (!$has_level) {
+						$wpdb->query("INSERT INTO {$um} (user_id, meta_key, meta_value) VALUES (1, '{$p}user_level', '10')");
+					}
+				} catch (Exception $e) {}
+
+				// Seed default content when the install left the posts table empty.
+				$posts_table = !empty($wpdb->posts) ? $wpdb->posts : $GLOBALS['table_prefix'] . 'posts';
+				$has_posts = false;
+				try { $has_posts = (bool)$wpdb->get_var("SELECT COUNT(*) FROM {$posts_table}"); } catch (Exception $e) {}
+				if (!$has_posts) {
+					$now = date('Y-m-d H:i:s');
+					$now_gmt = gmdate('Y-m-d H:i:s');
+					if (isset($wpdb->categories)) {
+						$wpdb->query("INSERT INTO {$wpdb->categories} (cat_ID, cat_name, category_nicename, category_description, category_parent) VALUES (1, 'Uncategorized', 'uncategorized', '', 0)");
+					}
+					// Columns common to WP 1.0+.
+					$wpdb->query("INSERT INTO {$posts_table} (ID, post_author, post_date, post_date_gmt, post_content, post_title, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered) VALUES (1, 1, '{$now}', '{$now_gmt}', 'Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!', 'Hello world!', '', 'publish', 'open', 'open', '', 'hello-world', '', '', '{$now}', '{$now_gmt}', '')");
+					if (isset($wpdb->comments)) {
+						$wpdb->query("INSERT INTO {$wpdb->comments} (comment_post_ID, comment_author, comment_author_email, comment_author_url, comment_author_IP, comment_date, comment_date_gmt, comment_content, comment_karma, comment_approved, comment_agent, comment_type, comment_parent, user_id) VALUES (1, 'Mr WordPress', '', 'http://wordpress.org', '127.0.0.1', '{$now}', '{$now_gmt}', 'Hi, this is a comment. To delete a comment, just log in and view the post comments. There you will have the option to edit or delete them.', 0, '1', '', '', 0, 0)");
+					}
+					if (isset($wpdb->post2cat)) {
+						$wpdb->query("INSERT INTO {$wpdb->post2cat} (rel_id, post_id, category_id) VALUES (1, 1, 1)");
+					}
+				}
+			`,
+      env: {
+        DOCUMENT_ROOT: e.documentRoot,
+        PLAYGROUND_SITE_URL: t || ""
+      }
+    });
+  } catch (r) {
+    h.warn("Legacy WP post-install fixups failed (non-fatal):", r);
+  }
+  if (s)
+    try {
+      await e.run({
+        code: `<?php
+				$db_dir = getenv('DOCUMENT_ROOT') . '/wp-content/database/';
+				if (!is_dir($db_dir)) { @mkdir($db_dir, 0777, true); }
+				$db_path = $db_dir . '.ht.sqlite';
+				$pdo = new PDO('sqlite:' . $db_path);
+				$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+				$prefix = 'wp_';
+				$table = $prefix . 'users';
+				try {
+					$count = $pdo->query("SELECT COUNT(*) FROM {$table}")->fetchColumn();
+				} catch (Exception $e) {
+					$pdo->exec("CREATE TABLE IF NOT EXISTS {$table} (
+						ID INTEGER PRIMARY KEY AUTOINCREMENT,
+						user_login TEXT NOT NULL DEFAULT '',
+						user_pass TEXT NOT NULL DEFAULT '',
+						user_nickname TEXT NOT NULL DEFAULT '',
+						user_email TEXT NOT NULL DEFAULT '',
+						user_url TEXT NOT NULL DEFAULT '',
+						user_ip TEXT NOT NULL DEFAULT '',
+						user_domain TEXT NOT NULL DEFAULT '',
+						user_browser TEXT NOT NULL DEFAULT '',
+						dateYMDhour TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						user_level INTEGER NOT NULL DEFAULT 0,
+						user_idmode TEXT NOT NULL DEFAULT '',
+						user_firstname TEXT NOT NULL DEFAULT '',
+						user_lastname TEXT NOT NULL DEFAULT '',
+						user_icq INTEGER NOT NULL DEFAULT 0,
+						user_aim TEXT NOT NULL DEFAULT '',
+						user_msn TEXT NOT NULL DEFAULT '',
+						user_yim TEXT NOT NULL DEFAULT ''
+					)");
+					$count = 0;
+				}
+				if ($count == 0) {
+					$now = date('Y-m-d H:i:s');
+					// SECURITY: md5('password') matches WP 1.0-1.2's single-md5
+					// scheme so auto-login works without a blueprint password.
+					// Safe only inside the Playground WASM sandbox.
+					$pass = md5('password');
+					try {
+						$col_info = $pdo->query("PRAGMA table_info({$table})")->fetchAll(PDO::FETCH_ASSOC);
+						$known = array(
+							'ID' => '1', 'user_login' => "'admin'",
+							'user_pass' => "'{$pass}'", 'user_email' => "'admin@localhost.com'",
+							'user_level' => '10', 'dateYMDhour' => "'{$now}'",
+							'user_nickname' => "'admin'", 'user_nicename' => "'admin'",
+							'user_registered' => "'{$now}'", 'user_status' => '0',
+						);
+						$ins_cols = array(); $ins_vals = array();
+						foreach ($col_info as $ci) {
+							$cn = $ci['name'];
+							$ins_cols[] = $cn;
+							if (isset($known[$cn])) {
+								$ins_vals[] = $known[$cn];
+							} elseif ($ci['dflt_value'] !== null) {
+								$ins_vals[] = $ci['dflt_value'];
+							} elseif (stripos($ci['type'], 'int') !== false) {
+								$ins_vals[] = '0';
+							} else {
+								$ins_vals[] = "''";
+							}
+						}
+						$pdo->exec("INSERT INTO {$table} (" . implode(',', $ins_cols) . ") VALUES (" . implode(',', $ins_vals) . ")");
+					} catch (Exception $e) {}
+				} else {
+					// See SECURITY note above.
+					$pass = md5('password');
+					try { $pdo->exec("UPDATE {$table} SET user_pass = '{$pass}' WHERE user_login = 'admin'"); } catch (Exception $e) {}
+				}
+
+				// WP 1.0-1.2 install often leaves these tables missing because
+				// the SQLite driver can't translate the old-style CREATE TABLEs.
+				$now = date('Y-m-d H:i:s');
+				$now_gmt = gmdate('Y-m-d H:i:s');
+				$tables_sql = array(
+					'posts' => "CREATE TABLE IF NOT EXISTS {$prefix}posts (
+						ID INTEGER PRIMARY KEY AUTOINCREMENT,
+						post_author INTEGER NOT NULL DEFAULT 0,
+						post_date TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						post_date_gmt TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						post_content TEXT NOT NULL DEFAULT '',
+						post_title TEXT NOT NULL DEFAULT '',
+						post_category INTEGER NOT NULL DEFAULT 0,
+						post_excerpt TEXT NOT NULL DEFAULT '',
+						post_status TEXT NOT NULL DEFAULT 'publish',
+						comment_status TEXT NOT NULL DEFAULT 'open',
+						ping_status TEXT NOT NULL DEFAULT 'open',
+						post_password TEXT NOT NULL DEFAULT '',
+						post_name TEXT NOT NULL DEFAULT '',
+						to_ping TEXT NOT NULL DEFAULT '',
+						pinged TEXT NOT NULL DEFAULT '',
+						post_modified TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						post_modified_gmt TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						post_content_filtered TEXT NOT NULL DEFAULT '',
+						post_parent INTEGER NOT NULL DEFAULT 0,
+						menu_order INTEGER NOT NULL DEFAULT 0,
+						post_mime_type TEXT NOT NULL DEFAULT ''
+					)",
+					'categories' => "CREATE TABLE IF NOT EXISTS {$prefix}categories (
+						cat_ID INTEGER PRIMARY KEY AUTOINCREMENT,
+						cat_name TEXT NOT NULL DEFAULT '',
+						category_nicename TEXT NOT NULL DEFAULT '',
+						category_description TEXT NOT NULL DEFAULT '',
+						category_parent INTEGER NOT NULL DEFAULT 0
+					)",
+					'post2cat' => "CREATE TABLE IF NOT EXISTS {$prefix}post2cat (
+						rel_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						post_id INTEGER NOT NULL DEFAULT 0,
+						category_id INTEGER NOT NULL DEFAULT 0
+					)",
+					'comments' => "CREATE TABLE IF NOT EXISTS {$prefix}comments (
+						comment_ID INTEGER PRIMARY KEY AUTOINCREMENT,
+						comment_post_ID INTEGER NOT NULL DEFAULT 0,
+						comment_author TEXT NOT NULL DEFAULT '',
+						comment_author_email TEXT NOT NULL DEFAULT '',
+						comment_author_url TEXT NOT NULL DEFAULT '',
+						comment_author_IP TEXT NOT NULL DEFAULT '',
+						comment_date TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						comment_date_gmt TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						comment_content TEXT NOT NULL DEFAULT '',
+						comment_karma INTEGER NOT NULL DEFAULT 0,
+						comment_approved TEXT NOT NULL DEFAULT '1',
+						comment_agent TEXT NOT NULL DEFAULT '',
+						comment_type TEXT NOT NULL DEFAULT '',
+						comment_parent INTEGER NOT NULL DEFAULT 0,
+						user_id INTEGER NOT NULL DEFAULT 0
+					)",
+					'options' => "CREATE TABLE IF NOT EXISTS {$prefix}options (
+						option_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						blog_id INTEGER NOT NULL DEFAULT 0,
+						option_name TEXT NOT NULL DEFAULT '',
+						option_can_override TEXT NOT NULL DEFAULT 'Y',
+						option_type INTEGER NOT NULL DEFAULT 1,
+						option_value TEXT NOT NULL DEFAULT '',
+						option_width INTEGER NOT NULL DEFAULT 20,
+						option_height INTEGER NOT NULL DEFAULT 8,
+						option_description TEXT NOT NULL DEFAULT '',
+						option_admin_level INTEGER NOT NULL DEFAULT 1,
+						autoload TEXT NOT NULL DEFAULT 'yes'
+					)",
+					'postmeta' => "CREATE TABLE IF NOT EXISTS {$prefix}postmeta (
+						meta_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						post_id INTEGER NOT NULL DEFAULT 0,
+						meta_key TEXT NOT NULL DEFAULT '',
+						meta_value TEXT NOT NULL DEFAULT ''
+					)",
+					'links' => "CREATE TABLE IF NOT EXISTS {$prefix}links (
+						link_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						link_url TEXT NOT NULL DEFAULT '',
+						link_name TEXT NOT NULL DEFAULT '',
+						link_image TEXT NOT NULL DEFAULT '',
+						link_target TEXT NOT NULL DEFAULT '',
+						link_category INTEGER NOT NULL DEFAULT 0,
+						link_description TEXT NOT NULL DEFAULT '',
+						link_visible TEXT NOT NULL DEFAULT 'Y',
+						link_owner INTEGER NOT NULL DEFAULT 1,
+						link_rating INTEGER NOT NULL DEFAULT 0,
+						link_updated TEXT NOT NULL DEFAULT '0000-00-00 00:00:00',
+						link_rel TEXT NOT NULL DEFAULT '',
+						link_notes TEXT NOT NULL DEFAULT '',
+						link_rss TEXT NOT NULL DEFAULT ''
+					)",
+					'linkcategories' => "CREATE TABLE IF NOT EXISTS {$prefix}linkcategories (
+						cat_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						cat_name TEXT NOT NULL DEFAULT '',
+						auto_toggle TEXT NOT NULL DEFAULT 'N',
+						show_images TEXT NOT NULL DEFAULT 'Y',
+						show_description TEXT NOT NULL DEFAULT 'N',
+						show_rating TEXT NOT NULL DEFAULT 'Y',
+						show_updated TEXT NOT NULL DEFAULT 'Y',
+						sort_order TEXT NOT NULL DEFAULT 'name',
+						sort_desc TEXT NOT NULL DEFAULT 'ASC',
+						text_before_link TEXT NOT NULL DEFAULT '<li>',
+						text_after_link TEXT NOT NULL DEFAULT '<br />',
+						text_after_all TEXT NOT NULL DEFAULT '</li>',
+						list_limit INTEGER NOT NULL DEFAULT -1
+					)",
+					'optiongroups' => "CREATE TABLE IF NOT EXISTS {$prefix}optiongroups (
+						group_id INTEGER PRIMARY KEY AUTOINCREMENT,
+						group_name TEXT NOT NULL DEFAULT '',
+						group_desc TEXT DEFAULT '',
+						group_longdesc TEXT DEFAULT ''
+					)",
+					'optiongroup_options' => "CREATE TABLE IF NOT EXISTS {$prefix}optiongroup_options (
+						group_id INTEGER NOT NULL DEFAULT 0,
+						option_id INTEGER NOT NULL DEFAULT 0,
+						seq INTEGER NOT NULL DEFAULT 0,
+						PRIMARY KEY (group_id, option_id)
+					)"
+				);
+				foreach ($tables_sql as $t => $sql) {
+					try { $pdo->exec($sql); } catch (Exception $e) {}
+				}
+				// Backfill columns that WP 1.0-1.2 installs leave off but later code paths read.
+				$alter_cols = array(
+					'categories' => array(
+						'category_nicename' => "TEXT NOT NULL DEFAULT ''",
+						'category_description' => "TEXT NOT NULL DEFAULT ''",
+						'category_parent' => "INTEGER NOT NULL DEFAULT 0",
+						'category_count' => "INTEGER NOT NULL DEFAULT 0",
+					),
+					// WP 1.5+ get_comments_number() reads comment_count off wp_posts.
+					'posts' => array(
+						'comment_count' => "INTEGER NOT NULL DEFAULT 0",
+					),
+				);
+				foreach ($alter_cols as $t => $cols_to_add) {
+					try {
+						$existing = $pdo->query("PRAGMA table_info({$prefix}{$t})")->fetchAll(PDO::FETCH_COLUMN, 1);
+						foreach ($cols_to_add as $col => $type) {
+							if (!in_array($col, $existing)) {
+								$pdo->exec("ALTER TABLE {$prefix}{$t} ADD COLUMN {$col} {$type}");
+							}
+						}
+					} catch (Exception $e) {}
+				}
+				// Dynamic column detection because the schema differs across WP 1.x.
+				try {
+					if (!$pdo->query("SELECT COUNT(*) FROM {$prefix}posts")->fetchColumn()) {
+						$post_cols = $pdo->query("PRAGMA table_info({$prefix}posts)")->fetchAll(PDO::FETCH_COLUMN, 1);
+						$post_vals = array(
+							'ID' => '1', 'post_author' => '1',
+							'post_date' => "'{$now}'", 'post_date_gmt' => "'{$now_gmt}'",
+							'post_content' => "'Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!'",
+							'post_title' => "'Hello world!'", 'post_excerpt' => "''",
+							'post_status' => "'publish'", 'comment_status' => "'open'",
+							'ping_status' => "'open'", 'post_password' => "''",
+							'post_name' => "'hello-world'", 'to_ping' => "''", 'pinged' => "''",
+							'post_modified' => "'{$now}'", 'post_modified_gmt' => "'{$now_gmt}'",
+							'post_content_filtered' => "''",
+						);
+						$ins_c = array(); $ins_v = array();
+						foreach ($post_vals as $c => $v) {
+							if (in_array($c, $post_cols)) { $ins_c[] = $c; $ins_v[] = $v; }
+						}
+						if ($ins_c) $pdo->exec("INSERT INTO {$prefix}posts (" . implode(',', $ins_c) . ") VALUES (" . implode(',', $ins_v) . ")");
+					}
+				} catch (Exception $e) {}
+				try {
+					if (!$pdo->query("SELECT COUNT(*) FROM {$prefix}categories")->fetchColumn()) {
+						$pdo->exec("INSERT INTO {$prefix}categories (cat_ID, cat_name, category_nicename, category_description, category_parent) VALUES (1, 'Uncategorized', 'uncategorized', '', 0)");
+					}
+				} catch (Exception $e) {}
+				try {
+					$env_site = getenv('PLAYGROUND_SITE_URL');
+					$site = $env_site ? $env_site : 'http://localhost';
+					if (!$pdo->query("SELECT COUNT(*) FROM {$prefix}options WHERE option_name='siteurl'")->fetchColumn()) {
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value) VALUES ('siteurl', '{$site}')");
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value) VALUES ('blogname', 'My WordPress Website')");
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value) VALUES ('blogdescription', 'Just another WordPress weblog')");
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value) VALUES ('home', '{$site}')");
+					}
+					// Overwrite the placeholder 'http://localhost' with the scoped URL.
+					if ($env_site) {
+						$pdo->exec("UPDATE {$prefix}options SET option_value = '{$env_site}' WHERE option_name = 'siteurl'");
+						$pdo->exec("UPDATE {$prefix}options SET option_value = '{$env_site}' WHERE option_name = 'home'");
+					}
+					// populate_options() sets template/stylesheet; backfill if it crashed.
+					if (!$pdo->query("SELECT COUNT(*) FROM {$prefix}options WHERE option_name='template'")->fetchColumn()) {
+						$themes_dir = getenv('DOCUMENT_ROOT') . '/wp-content/themes/';
+						$tpl = 'default';
+						if (is_dir($themes_dir)) {
+							$entries = glob($themes_dir . '*', GLOB_ONLYDIR);
+							if ($entries) {
+								foreach ($entries as $e) {
+									$name = basename($e);
+									if ($name === '.' || $name === '..') continue;
+									if (file_exists($e . '/style.css')) {
+										$tpl = $name;
+										break;
+									}
+								}
+							}
+						}
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value, autoload) VALUES ('template', '{$tpl}', 'yes')");
+						$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value, autoload) VALUES ('stylesheet', '{$tpl}', 'yes')");
+					}
+					// Without a correct db_version, WP 2.0-2.5 admin redirects to upgrade.php.
+					$version_path = getenv('DOCUMENT_ROOT') . '/wp-includes/version.php';
+					if (file_exists($version_path)) {
+						$wp_db_version = 0;
+						include $version_path;
+						if ($wp_db_version > 0) {
+							$has_dbv = $pdo->query("SELECT COUNT(*) FROM {$prefix}options WHERE option_name='db_version'")->fetchColumn();
+							if (!$has_dbv) {
+								$pdo->exec("INSERT INTO {$prefix}options (option_name, option_value, autoload) VALUES ('db_version', '{$wp_db_version}', 'yes')");
+							} else {
+								$pdo->exec("UPDATE {$prefix}options SET option_value = '{$wp_db_version}' WHERE option_name = 'db_version'");
+							}
+						}
+					}
+				} catch (Exception $e) {}
+			`,
+        env: {
+          DOCUMENT_ROOT: e.documentRoot,
+          PLAYGROUND_SITE_URL: t || ""
+        }
+      });
+    } catch (r) {
+      h.warn("Legacy WP PDO fallback failed (non-fatal):", r);
+    }
+}
+const Pe = `
+// Connection stubs — wpdb::__construct bails on a falsy return.
+if (!function_exists('mysqli_connect')) {
+	function mysqli_connect() { return true; }
+}
+if (!function_exists('mysqli_init')) {
+	function mysqli_init() { return true; }
+}
+if (!function_exists('mysql_connect')) {
+	function mysql_connect() { return true; }
+}
+if (!function_exists('mysql_select_db')) {
+	function mysql_select_db() { return true; }
+}
+// WordPress < 3.0 wpdb::__construct calls mysql_set_charset directly.
+if (!function_exists('mysql_set_charset')) {
+	function mysql_set_charset() { return true; }
+}
+// Functional mysql_* stubs that delegate to $wpdb (SQLite driver).
+$GLOBALS['_mysql_results'] = array();
+$GLOBALS['_mysql_result_id'] = 0;
+if (!function_exists('mysql_query')) {
+	function mysql_query($query, $link = null) {
+		global $wpdb;
+		if (isset($wpdb) && method_exists($wpdb, 'query')) {
+			$wpdb->query($query);
+			if (preg_match('/^\\s*(SELECT|SHOW|DESCRIBE|EXPLAIN)/i', $query)) {
+				$rows = isset($wpdb->last_result) ? $wpdb->last_result : array();
+				$id = ++$GLOBALS['_mysql_result_id'];
+				$GLOBALS['_mysql_results'][$id] = array(
+					'rows' => $rows,
+					'index' => 0,
+				);
+				return $id;
+			}
+			return true;
+		}
+		return false;
+	}
+}
+if (!function_exists('mysql_error')) {
+	function mysql_error($link = null) {
+		global $wpdb;
+		if (isset($wpdb) && isset($wpdb->last_error)) {
+			return $wpdb->last_error;
+		}
+		return '';
+	}
+}
+if (!function_exists('mysql_list_tables')) {
+	function mysql_list_tables($db = '', $link = null) {
+		global $wpdb;
+		if (isset($wpdb) && method_exists($wpdb, 'get_results')) {
+			$tables = $wpdb->get_results(
+				"SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+			);
+			$rows = array();
+			if ($tables) {
+				foreach ($tables as $t) {
+					$obj = new stdClass();
+					$obj->name = is_object($t) ? $t->name : $t['name'];
+					$rows[] = $obj;
+				}
+			}
+			$id = ++$GLOBALS['_mysql_result_id'];
+			$GLOBALS['_mysql_results'][$id] = array(
+				'rows' => $rows,
+				'index' => 0,
+			);
+			return $id;
+		}
+		return false;
+	}
+}
+if (!function_exists('mysql_fetch_row')) {
+	function mysql_fetch_row($result) {
+		if (!isset($GLOBALS['_mysql_results'][$result])) return null;
+		$r = &$GLOBALS['_mysql_results'][$result];
+		if ($r['index'] >= count($r['rows'])) return null;
+		$row = $r['rows'][$r['index']++];
+		return array_values((array)$row);
+	}
+}
+if (!function_exists('mysql_fetch_object')) {
+	function mysql_fetch_object($result) {
+		if (!isset($GLOBALS['_mysql_results'][$result])) return null;
+		$r = &$GLOBALS['_mysql_results'][$result];
+		if ($r['index'] >= count($r['rows'])) return null;
+		return (object)(array)$r['rows'][$r['index']++];
+	}
+}
+if (!function_exists('mysql_num_rows')) {
+	function mysql_num_rows($result) {
+		if (isset($GLOBALS['_mysql_results'][$result])) {
+			return count($GLOBALS['_mysql_results'][$result]['rows']);
+		}
+		return 0;
+	}
+}
+if (!function_exists('mysql_get_server_info')) {
+	function mysql_get_server_info() { return '8.0.0'; }
+}
+if (!function_exists('mysql_affected_rows')) {
+	function mysql_affected_rows() {
+		global $wpdb;
+		if (isset($wpdb) && isset($wpdb->rows_affected)) {
+			return $wpdb->rows_affected;
+		}
+		return 0;
+	}
+}
+if (!function_exists('mysql_insert_id')) {
+	function mysql_insert_id() {
+		global $wpdb;
+		if (isset($wpdb) && isset($wpdb->insert_id)) {
+			return $wpdb->insert_id;
+		}
+		return 0;
+	}
+}
+if (!function_exists('mysql_free_result')) {
+	function mysql_free_result($result) {
+		unset($GLOBALS['_mysql_results'][$result]);
+		return true;
+	}
+}
+if (!function_exists('mysql_num_fields')) {
+	function mysql_num_fields($result) {
+		if (isset($GLOBALS['_mysql_results'][$result])
+			&& !empty($GLOBALS['_mysql_results'][$result]['rows'])) {
+			return count((array)$GLOBALS['_mysql_results'][$result]['rows'][0]);
+		}
+		return 0;
+	}
+}
+if (!function_exists('mysql_real_escape_string')) {
+	function mysql_real_escape_string($s) { return addslashes($s); }
+}
+if (!function_exists('mysql_escape_string')) {
+	function mysql_escape_string($s) { return addslashes($s); }
+}`;
+async function Ne(e, t, i = {}) {
+  await e.isDir("/tmp/sqlite-database-integration") && await e.rmdir("/tmp/sqlite-database-integration", {
+    recursive: !0
+  }), await e.mkdir("/tmp/sqlite-database-integration"), await m(e, t, "/tmp/sqlite-database-integration");
+  const n = "/internal/shared/sqlite-database-integration", s = `/tmp/sqlite-database-integration/${(await e.listFiles("/tmp/sqlite-database-integration"))[0]}`;
+  await e.mv(s, n), await Ae(e, n), await e.defineConstant("SQLITE_MAIN_FILE", "1");
+  let a = (await e.readFileAsText(
+    _(n, "db.copy")
+  )).replace(
+    "'{SQLITE_IMPLEMENTATION_FOLDER_PATH}'",
+    $(n)
+  ).replace(
+    "'{SQLITE_PLUGIN}'",
+    $(_(n, "load.php"))
+  );
+  a = a.replace(
+    /^add_action\(/gm,
+    'function_exists("add_action") && add_action('
+  );
+  const o = _(await e.documentRoot, "wp-content/db.php"), l = "/internal/shared/mu-plugins/sqlite-database-integration.php", c = `
+if(file_exists(${$(o)})) {
+	$_pg_db_php = @file_get_contents(${$(o)});
+	if (strpos($_pg_db_php, '@playground-managed') === false) {
+		return;
+	}
+	unset($_pg_db_php);
+}
+`;
+  await e.writeFile(l, `<?php
+${c}?>` + a), await e.writeFile(
+    "/internal/shared/preload/0-sqlite.php",
+    Se(c, l)
+  ), await e.writeFile(
+    "/internal/shared/mu-plugins/sqlite-test.php",
+    `<?php
+		global $wpdb;
+		if(!($wpdb instanceof WP_SQLite_DB)) {
+			var_dump(isset($wpdb));
+			die("SQLite integration not loaded " . get_class($wpdb));
+		}
+		`
+  );
+}
+async function Ae(e, t) {
+  const i = _(
+    t,
+    "wp-includes/database/sqlite/class-wp-pdo-mysql-on-sqlite.php"
+  );
+  if (!await e.fileExists(i)) return;
+  const n = await e.readFileAsText(i), s = n.replace(
+    /\$active_sql_modes\s*=\s*array\s*\([^)]*\)\s*;/,
+    "$active_sql_modes = array();"
+  );
+  s !== n && await e.writeFile(i, s);
+}
+function Se(e, t) {
+  return `<?php
+${e}?>
+<?php
+// Shim __() etc. only for WP < 1.2 (no l10n layer; the SQLite
+// plugin calls __() from print_error()). WP 1.2–1.4 ship
+// wp-l10n.php and WP 1.5+ ships l10n.php — defining the shims
+// then would fatal on redeclare.
+$_pg_doc_root = isset($_SERVER['DOCUMENT_ROOT'])
+	? $_SERVER['DOCUMENT_ROOT'] : '/wordpress';
+if (
+	!file_exists($_pg_doc_root . '/wp-includes/l10n.php')
+	&& !file_exists($_pg_doc_root . '/wp-includes/wp-l10n.php')
+) {
+	if (!function_exists('__')) {
+		function __($text, $domain = null) { return $text; }
+	}
+	if (!function_exists('_e')) {
+		function _e($text, $domain = null) { echo $text; }
+	}
+	if (!function_exists('esc_html__')) {
+		function esc_html__($text, $domain = null) {
+			return htmlspecialchars($text, ENT_QUOTES);
+		}
+	}
+	if (!function_exists('esc_html_e')) {
+		function esc_html_e($text, $domain = null) {
+			echo htmlspecialchars($text, ENT_QUOTES);
+		}
+	}
+}
+?>
+<?php
+${v(
+    // WP < 3.0's wpdb does mysql_connect() inline so the SQLite
+    // plugin's db_connect() never runs; reinitialize_sqlite()
+    // swaps the dbh in place after the integration is loaded.
+    `require_once ${$(t)};
+        if (
+            isset($GLOBALS['wpdb']) &&
+            method_exists($GLOBALS['wpdb'], 'reinitialize_sqlite')
+        ) {
+            $GLOBALS['wpdb']->reinitialize_sqlite();
+        }`
+  )}
+${Pe}
+if (PHP_MAJOR_VERSION < 7) {
+	// E_DEPRECATED (8192) / E_STRICT (2048) are PHP 5.3+ symbols;
+	// LEGACY_WP_ERROR_REPORTING_PHP_EXPR uses numeric literals.
+	$level = ${L};
+	error_reporting($level);
+	ini_set('error_reporting', $level);
+}
+
+		`;
+}
+const U = `<?php
 
 /**
  * Transforms the "wp-config.php" file.
@@ -474,133 +2719,327 @@ class WP_Config_Transformer {
 	}
 }
 `;
-async function I(t, e) {
-  const n = s(e, "wp-config.php");
-  !t.fileExists(n) && t.fileExists(s(e, "wp-config-sample.php")) && await t.writeFile(
-    n,
-    await t.readFileAsBuffer(
-      s(e, "wp-config-sample.php")
+async function ve(e, t) {
+  const i = _(t, "wp-config.php");
+  !e.fileExists(i) && e.fileExists(_(t, "wp-config-sample.php")) && await e.writeFile(
+    i,
+    await e.readFileAsBuffer(
+      _(t, "wp-config-sample.php")
     )
-  ), t.fileExists(n) && await x(t, n, {
+  ), e.fileExists(i) && await xe(e, i, {
     DB_NAME: "wordpress"
   });
 }
-async function V(t, e, n) {
-  const i = $({ wpConfigPath: e, constants: n });
-  if ((await t.run({
-    code: `${m}
-		$wp_config_path = ${i.wpConfigPath};
-		$transformer = WP_Config_Transformer::from_file($wp_config_path);
-		$transformer->define_constants(${i.constants});
-		$transformer->to_file($wp_config_path);
-		`
-  })).errors.length > 0)
-    throw new Error("Failed to rewrite constants in wp-config.php.");
+async function st(e, t, i) {
+  const n = A({ wpConfigPath: t, constants: i });
+  if ((await e.run({
+    code: `${U}
+		$wp_config_path = ${n.wpConfigPath};
+		$transformer = WP_Config_Transformer::from_file($wp_config_path);
+		$transformer->define_constants(${n.constants});
+		$transformer->to_file($wp_config_path);
+		`
+  })).errors.length > 0)
+    throw new Error("Failed to rewrite constants in wp-config.php.");
+}
+async function xe(e, t, i) {
+  const n = Object.keys(i), s = A({ wpConfigPath: t, constantNames: n }), r = await e.run({
+    code: `${U}
+		$transformer = WP_Config_Transformer::from_file(${s.wpConfigPath});
+		$missing = [];
+		foreach (${s.constantNames} as $name) {
+			if (!$transformer->constant_exists($name)) {
+				$missing[] = $name;
+			}
+		}
+		echo json_encode($missing);
+		`
+  });
+  if (r.errors.length > 0)
+    throw new Error("Failed to check wp-config.php for constants.");
+  let a;
+  try {
+    a = JSON.parse(r.text);
+  } catch {
+    throw new Error(
+      `Failed to parse wp-config.php constant check output: ${r.text}`
+    );
+  }
+  for (const o of a)
+    await e.defineConstant(o, i[o]);
+}
+async function E(e, {
+  usesSqlite: t,
+  hasCustomDatabasePath: i
+}) {
+  const n = await e.getPrimaryPhp();
+  if (n.isFile("/internal/shared/preload/0-sqlite.php"))
+    return;
+  const s = _(
+    e.documentRoot,
+    "wp-content/mu-plugins/sqlite-database-integration"
+  );
+  if (!n.isDir(s) && !t && !i && !Ue(n))
+    throw new Error("Error connecting to the MySQL database.");
+}
+function Ue(e) {
+  const t = _(e.documentRoot, "wp-config.php");
+  if (!e.isFile(t)) return !1;
+  const i = e.readFileAsText(t), n = i.match(
+    /define\s*\(\s*['"]DB_NAME['"]\s*,\s*['"]([^'"]*)['"]/
+  ), s = i.match(
+    /define\s*\(\s*['"]DB_USER['"]\s*,\s*['"]([^'"]*)['"]/
+  );
+  return !n || !s ? !1 : n[1] !== "database_name_here" && s[1] !== "username_here";
+}
+const R = [
+  "fsockopen",
+  "pfsockopen",
+  "curl_init",
+  "curl_exec",
+  "curl_multi_exec",
+  "mail"
+];
+function Re(e, t) {
+  var r, a;
+  if (!w(t.phpVersion)) return;
+  const i = (((r = t.phpIniEntries) == null ? void 0 : r.disable_functions) ?? "").split(",").map((o) => o.trim()).filter((o) => o), s = {
+    disable_functions: Array.from(
+      /* @__PURE__ */ new Set([...i, ...R])
+    ).join(","),
+    allow_url_fopen: "0"
+  };
+  (a = t.phpIniEntries) != null && a["date.timezone"] || (s["date.timezone"] = "UTC"), P(e, s);
+}
+async function ke(e, t) {
+  var a, o;
+  const i = await e.getPrimaryPhp();
+  if ((a = t.hooks) != null && a.beforeWordPressFiles && await t.hooks.beforeWordPressFiles(i), t.wordPressZip && await D(i, await t.wordPressZip), t.constants)
+    for (const l in t.constants)
+      i.defineConstant(l, t.constants[l]);
+  i.defineConstant("WP_HOME", t.siteUrl), i.defineConstant("WP_SITEURL", t.siteUrl), await Ie(i, e.documentRoot), await K(i, e.documentRoot), (o = t.hooks) != null && o.beforeDatabaseSetup && await t.hooks.beforeDatabaseSetup(i);
+  let n = !1;
+  t.sqliteIntegrationPluginZip && (n = !0, await I(
+    i,
+    await t.sqliteIntegrationPluginZip,
+    { phpVersion: t.phpVersion }
+  ), await De(i, e.documentRoot));
+  const s = t.wordpressInstallMode ?? "download-and-install", r = !!t.dataSqlPath;
+  return (s === "download-and-install" || s === "install-from-existing-files" || // Legacy PHP: isWordPressInstalled() can trigger a WASM trap
+  // (not a PHP exception) on old WordPress (< 3.0) and corrupt
+  // the runtime beyond recovery. Always run the installer; it
+  // is idempotent and its post-install fixups short-circuit
+  // cheaply when the schema already exists.
+  s === "install-from-existing-files-if-needed") && (await E(e, {
+    usesSqlite: n,
+    hasCustomDatabasePath: r
+  }), await Fe(i, e)), e;
+}
+async function Ie(e, t) {
+  const i = _(t, "wp-config.php"), n = _(t, "wp-config-sample.php");
+  !e.fileExists(i) && e.fileExists(n) && await e.writeFile(
+    i,
+    await e.readFileAsBuffer(n)
+  );
 }
-async function x(t, e, n) {
-  const i = Object.keys(n), a = $({ wpConfigPath: e, constantNames: i }), o = await t.run({
-    code: `${m}
-		$transformer = WP_Config_Transformer::from_file(${a.wpConfigPath});
-		$missing = [];
-		foreach (${a.constantNames} as $name) {
-			if (!$transformer->constant_exists($name)) {
-				$missing[] = $name;
-			}
-		}
-		echo json_encode($missing);
-		`
-  });
-  if (o.errors.length > 0)
-    throw new Error("Failed to check wp-config.php for constants.");
-  let l;
+async function De(e, t) {
+  const i = _(t, "wp-content"), n = _(i, "db.php");
+  e.isDir(i) && !e.fileExists(n) && await e.writeFile(n, be());
+}
+async function Fe(e, t) {
   try {
-    l = JSON.parse(o.text);
-  } catch {
+    await Ce(e);
+  } catch (i) {
+    h.warn("Legacy PHP WordPress installation error:", i);
+  }
+  await Oe(e, t.absoluteUrl);
+}
+async function Ce(e) {
+  var r, a, o, l, c, u;
+  const t = Ge(e, e.documentRoot);
+  if (t !== null) {
+    const d = parseFloat(t);
+    if (d < 2.1)
+      return;
+    if (d <= 3) {
+      await We(e);
+      return;
+    }
+  }
+  const i = {
+    disable_functions: R.join(","),
+    allow_url_fopen: "0",
+    error_reporting: String(Y)
+  }, n = await N(
+    e,
+    i,
+    async () => await e.request({
+      url: "/wp-admin/install.php?step=2",
+      method: "POST",
+      body: {
+        language: "en",
+        prefix: "wp_",
+        weblog_title: "My WordPress Website",
+        user_name: "admin",
+        admin_password: "password",
+        admin_password2: "password",
+        Submit: "Install WordPress",
+        pw_weak: "1",
+        admin_email: "admin@localhost.com"
+      }
+    })
+  );
+  if (!(((r = n.text) == null ? void 0 : r.includes("Success")) || ((a = n.text) == null ? void 0 : a.includes("successful")) || ((o = n.text) == null ? void 0 : o.includes("Finished")) || ((l = n.text) == null ? void 0 : l.includes("Already Installed")) || ((c = n.text) == null ? void 0 : c.includes("already have WordPress installed")) || !1))
     throw new Error(
-      `Failed to parse wp-config.php constant check output: ${o.text}`
+      `Failed to install WordPress – installer responded with "${(u = n.text) == null ? void 0 : u.substring(
+        0,
+        100
+      )}"`
+    );
+  await qe(e);
+}
+async function qe(e) {
+  try {
+    (await e.run({
+      code: `<?php
+				$db_dir = getenv('DOCUMENT_ROOT') . '/wp-content/database/';
+				$db_path = $db_dir . '.ht.sqlite';
+				if (!file_exists($db_path)) { echo '0'; exit; }
+				$pdo = new PDO('sqlite:' . $db_path);
+				$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+				$nice_permalinks = '/%year%/%monthnum%/%day%/%postname%/';
+				$stmt = $pdo->prepare(
+					"UPDATE wp_options SET option_value = :val WHERE option_name = 'permalink_structure'"
+				);
+				$stmt->execute(array(':val' => $nice_permalinks));
+				if ($stmt->rowCount() === 0) {
+					$stmt = $pdo->prepare(
+						"INSERT INTO wp_options (option_name, option_value, autoload) VALUES ('permalink_structure', :val, 'yes')"
+					);
+					$stmt->execute(array(':val' => $nice_permalinks));
+				}
+				$check = $pdo->query(
+					"SELECT option_value FROM wp_options WHERE option_name = 'permalink_structure'"
+				)->fetchColumn();
+				echo $check === $nice_permalinks ? '1' : '0';
+			`,
+      env: { DOCUMENT_ROOT: e.documentRoot }
+    })).text !== "1" && h.warn(
+      "Failed to default to pretty permalinks after WP install."
+    );
+  } catch {
+    h.warn(
+      "Failed to set pretty permalinks after WP install (non-fatal)."
     );
   }
-  for (const r of l)
-    await t.defineConstant(r, n[r]);
-}
-async function Z(t) {
-  const e = await C(t);
-  return await L(e, t), e;
-}
-async function L(t, e) {
-  var l, r;
-  const n = await t.getPrimaryPhp();
-  if ((l = e.hooks) != null && l.beforeWordPressFiles && await e.hooks.beforeWordPressFiles(n), e.wordPressZip && await M(n, await e.wordPressZip), e.constants)
-    for (const c in e.constants)
-      n.defineConstant(c, e.constants[c]);
-  e.dataSqlPath && (n.defineConstant("DB_DIR", y(e.dataSqlPath)), n.defineConstant("DB_FILE", b(e.dataSqlPath))), n.defineConstant("WP_HOME", e.siteUrl), n.defineConstant("WP_SITEURL", e.siteUrl), await I(n, t.documentRoot), (r = e.hooks) != null && r.beforeDatabaseSetup && await e.hooks.beforeDatabaseSetup(n);
-  let i = !1;
-  e.sqliteIntegrationPluginZip && (i = !0, await D(
-    n,
-    await e.sqliteIntegrationPluginZip
-  ));
-  const a = e.wordpressInstallMode ?? "download-and-install", o = !!e.dataSqlPath;
+}
+async function We(e) {
+  try {
+    await e.run({
+      code: `<?php
+				define('WP_INSTALLING', true);
+				error_reporting(${L});
+				ini_set('display_errors', '0');
+				ob_start();
+				require getenv('DOCUMENT_ROOT') . '/wp-load.php';
+				ob_clean();
+				if (file_exists(ABSPATH . 'wp-admin/includes/upgrade.php')) {
+					require_once ABSPATH . 'wp-admin/includes/upgrade.php';
+				} elseif (file_exists(ABSPATH . 'wp-admin/upgrade-functions.php')) {
+					require_once ABSPATH . 'wp-admin/upgrade-functions.php';
+				}
+				if (function_exists('make_db_current_silent')) {
+					make_db_current_silent();
+				}
+				// Seed essential options/roles when the loader exposes
+				// them. The PDO fallback in runPostInstallLegacyFixups
+				// backfills anything missing if either call dies.
+				if (function_exists('populate_options')) populate_options();
+				if (function_exists('populate_roles')) populate_roles();
+				echo 'OK';
+			`,
+      env: { DOCUMENT_ROOT: e.documentRoot }
+    });
+  } catch (t) {
+    h.warn("runDbDeltaOnly failed (non-fatal):", t);
+  }
+}
+function Ge(e, t) {
+  const i = _(t, "wp-includes/version.php");
+  if (!e.fileExists(i)) return null;
+  const s = e.readFileAsText(i).match(/\$wp_version\s*=\s*['"]([^'"]+)['"]/);
+  return s ? s[1] : null;
+}
+async function rt(e) {
+  const t = await He(e);
+  return await Me(t, e), t;
+}
+async function Me(e, t) {
+  var a, o;
+  if (w(t.phpVersion))
+    return ke(e, t);
+  const i = await e.getPrimaryPhp();
+  if ((a = t.hooks) != null && a.beforeWordPressFiles && await t.hooks.beforeWordPressFiles(i), t.wordPressZip && await D(i, await t.wordPressZip), t.constants)
+    for (const l in t.constants)
+      i.defineConstant(l, t.constants[l]);
+  t.dataSqlPath && (i.defineConstant("DB_DIR", W(t.dataSqlPath)), i.defineConstant("DB_FILE", G(t.dataSqlPath))), i.defineConstant("WP_HOME", t.siteUrl), i.defineConstant("WP_SITEURL", t.siteUrl), await ve(i, e.documentRoot), (o = t.hooks) != null && o.beforeDatabaseSetup && await t.hooks.beforeDatabaseSetup(i);
+  let n = !1;
+  t.sqliteIntegrationPluginZip && (n = !0, await I(
+    i,
+    await t.sqliteIntegrationPluginZip,
+    { phpVersion: t.phpVersion }
+  ), await X(i, e.documentRoot));
+  const s = t.wordpressInstallMode ?? "download-and-install", r = !!t.dataSqlPath;
   if (["download-and-install", "install-from-existing-files"].includes(
-    a
+    s
   )) {
-    await _(t, {
-      usesSqlite: i,
-      hasCustomDatabasePath: o
+    await E(e, {
+      usesSqlite: n,
+      hasCustomDatabasePath: r
     });
     try {
-      await h(n);
-    } catch (c) {
-      throw o || await u(t), c;
+      await O(i);
+    } catch (l) {
+      throw r || await g(e), l;
     }
-    o || await u(t);
-  } else if (a === "install-from-existing-files-if-needed") {
-    if (await _(t, {
-      usesSqlite: i,
-      hasCustomDatabasePath: o
-    }), !await w(n))
+    r || await g(e);
+  } else if (s === "install-from-existing-files-if-needed") {
+    if (await E(e, {
+      usesSqlite: n,
+      hasCustomDatabasePath: r
+    }), !await k(i))
       try {
-        await h(n);
-      } catch (c) {
-        throw o || await u(t), c;
+        await O(i);
+      } catch (l) {
+        throw r || await g(e), l;
       }
-    o || await u(t);
+    r || await g(e);
   }
-  return t;
-}
-async function _(t, {
-  usesSqlite: e,
-  hasCustomDatabasePath: n
-}) {
-  const i = await t.getPrimaryPhp();
-  if (i.isFile("/internal/shared/preload/0-sqlite.php"))
-    return;
-  const a = s(
-    t.documentRoot,
-    "wp-content/mu-plugins/sqlite-database-integration"
-  );
-  if (!i.isDir(a) && !e && !n && !A(i))
-    throw new Error("Error connecting to the MySQL database.");
+  return e;
 }
-async function u(t) {
-  const e = await t.getPrimaryPhp();
-  if (await W(e))
+async function g(e) {
+  const t = await e.getPrimaryPhp();
+  if (await Ve(t))
     return;
-  if (e.isFile("/internal/shared/preload/0-sqlite.php"))
+  if (t.isFile("/internal/shared/preload/0-sqlite.php"))
     throw new Error("Error connecting to the SQLite database.");
-  const i = s(
-    t.documentRoot,
+  const n = _(
+    e.documentRoot,
     "wp-content/mu-plugins/sqlite-database-integration"
   );
-  throw e.isDir(i) ? new Error("Error connecting to the SQLite database.") : new Error("Error connecting to the MySQL database.");
-}
-async function C(t) {
-  const e = t.spawnHandler ?? T;
-  async function n(a, o = !1) {
-    const l = await t.createPhpRuntime(o), r = new v(l);
-    if (t.sapiName && r.setSapiName(t.sapiName), a && (r.requestHandler = a), t.phpIniEntries && S(r, t.phpIniEntries), r.defineConstant("WP_SQLITE_AST_DRIVER", !0), t.constants)
-      for (const c in t.constants)
-        r.defineConstant(c, t.constants[c]);
-    return o && /**
+  throw t.isDir(n) ? new Error("Error connecting to the SQLite database.") : new Error("Error connecting to the MySQL database.");
+}
+async function He(e) {
+  const t = e.spawnHandler ?? F;
+  async function i(s, r = !1) {
+    const a = await e.createPhpRuntime(r), o = new q(a);
+    if (e.sapiName && o.setSapiName(e.sapiName), s && (o.requestHandler = s), e.phpIniEntries && P(o, e.phpIniEntries), Re(o, {
+      phpVersion: e.phpVersion,
+      phpIniEntries: e.phpIniEntries
+    }), o.defineConstant("WP_SQLITE_AST_DRIVER", !0), e.constants)
+      for (const l in e.constants)
+        o.defineConstant(l, e.constants[l]);
+    return r && /**
     * Only the first PHP instance of the first worker created
     * during WordPress boot writes these files – otherwise we'll keep
     * overwriting them with concurrent writers living in other worker
@@ -610,45 +3049,47 @@ async function C(t) {
     * mechanism. It works, because secondary workers are only booted
     * once the primary worker has fully booted.
     */
-    !r.isFile("/internal/.boot-files-written") && (await N(r), await f(r, "/", t.createFiles || {}), await F(
-      r,
-      s(new URL(t.siteUrl).pathname, "phpinfo.php")
-    ), await f(r, "/internal", {
+    !o.isFile("/internal/.boot-files-written") && (await Ke(o, {
+      phpVersion: e.phpVersion
+    }), await b(o, "/", e.createFiles || {}), await Qe(
+      o,
+      _(new URL(e.siteUrl).pathname, "phpinfo.php")
+    ), await b(o, "/internal", {
       ".boot-files-written": ""
-    })), e && await r.setSpawnHandler(
-      e(
-        a ? () => a.instanceManager.acquirePHPInstance() : void 0
+    })), t && await o.setSpawnHandler(
+      t(
+        s ? () => s.instanceManager.acquirePHPInstance() : void 0
       )
-    ), r.enableRuntimeRotation({
-      recreateRuntime: t.createPhpRuntime,
+    ), o.enableRuntimeRotation({
+      recreateRuntime: e.createPhpRuntime,
       maxRequests: 400
-    }), t.onPHPInstanceCreated && await t.onPHPInstanceCreated(r, { isPrimary: o }), r;
+    }), e.onPHPInstanceCreated && await e.onPHPInstanceCreated(o, { isPrimary: r }), o;
   }
-  const i = new E({
-    documentRoot: t.documentRoot || "/wordpress",
-    absoluteUrl: t.siteUrl,
-    rewriteRules: q,
-    pathAliases: t.pathAliases,
-    getFileNotFoundAction: t.getFileNotFoundAction ?? O,
-    cookieStore: t.cookieStore,
+  const n = new C({
+    documentRoot: e.documentRoot || "/wordpress",
+    absoluteUrl: e.siteUrl,
+    rewriteRules: Ye,
+    pathAliases: e.pathAliases,
+    getFileNotFoundAction: e.getFileNotFoundAction ?? Be,
+    cookieStore: e.cookieStore,
     /**
      * If maxPhpInstances is 1, the PHPRequestHandler constructor needs
      * a PHP instance. Internally, it creates a SinglePHPInstanceManager
      * and uses the same PHP instance to handle all requests.
      */
-    php: t.maxPhpInstances === 1 ? await n(void 0, !0) : void 0,
+    php: e.maxPhpInstances === 1 ? await i(void 0, !0) : void 0,
     /**
      * If maxPhpInstances is not 1, the PHPRequestHandler constructor needs
      * a PHP factory function. Internally, it creates a PHPProcessManager that
      * maintains a pool of reusable PHP instances.
      */
-    phpFactory: t.maxPhpInstances !== 1 ? async ({ isPrimary: a }) => n(i, a) : void 0,
-    maxPhpInstances: t.maxPhpInstances
+    phpFactory: e.maxPhpInstances !== 1 ? async ({ isPrimary: s }) => i(n, s) : void 0,
+    maxPhpInstances: e.maxPhpInstances
   });
-  return i;
+  return n;
 }
-async function w(t) {
-  return (await t.run({
+async function k(e) {
+  return (await e.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -662,19 +3103,19 @@ async function w(t) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: t.documentRoot
+      DOCUMENT_ROOT: e.documentRoot
     }
   })).text === "1";
 }
-async function h(t) {
-  var i;
-  const e = await R(
-    t,
+async function O(e) {
+  var n;
+  const t = await N(
+    e,
     {
       disable_functions: "fsockopen",
       allow_url_fopen: "0"
     },
-    async () => await t.request({
+    async () => await e.request({
       url: "/wp-admin/install.php?step=2",
       method: "POST",
       body: {
@@ -691,14 +3132,14 @@ async function h(t) {
       }
     })
   );
-  if (!await w(t))
+  if (!await k(e))
     throw new Error(
-      `Failed to install WordPress – installer responded with "${(i = e.text) == null ? void 0 : i.substring(
+      `Failed to install WordPress – installer responded with "${(n = t.text) == null ? void 0 : n.substring(
         0,
         100
       )}"`
     );
-  (await t.run({
+  (await e.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -721,28 +3162,18 @@ async function h(t) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: t.documentRoot
+      DOCUMENT_ROOT: e.documentRoot
     }
-  })).text !== "1" && g.warn("Failed to default to pretty permalinks after WP install.");
+  })).text !== "1" && h.warn("Failed to default to pretty permalinks after WP install.");
 }
-function O(t) {
+function Be(e) {
   return {
     type: "internal-redirect",
     uri: "/index.php"
   };
 }
-function A(t) {
-  const e = s(t.documentRoot, "wp-config.php");
-  if (!t.isFile(e)) return !1;
-  const n = t.readFileAsText(e), i = n.match(
-    /define\s*\(\s*['"]DB_NAME['"]\s*,\s*['"]([^'"]*)['"]/
-  ), a = n.match(
-    /define\s*\(\s*['"]DB_USER['"]\s*,\s*['"]([^'"]*)['"]/
-  );
-  return !i || !a ? !1 : i[1] !== "database_name_here" && a[1] !== "username_here";
-}
-async function W(t) {
-  return (await t.run({
+async function Ve(e) {
+  return (await e.run({
     code: `<?php
 			ob_start();
 			$wp_load = getenv('DOCUMENT_ROOT') . '/wp-load.php';
@@ -756,35 +3187,35 @@ async function W(t) {
 			ob_end_flush();
 		`,
     env: {
-      DOCUMENT_ROOT: t.documentRoot
+      DOCUMENT_ROOT: e.documentRoot
     }
   })).text === "1";
 }
-async function Y(t) {
-  const { php: e, reap: n } = await t.instanceManager.acquirePHPInstance();
+async function at(e) {
+  const { php: t, reap: i } = await e.instanceManager.acquirePHPInstance();
   try {
-    const a = (await e.run({
+    const s = (await t.run({
       code: `<?php
-				require '${t.documentRoot}/wp-includes/version.php';
+				require '${e.documentRoot}/wp-includes/version.php';
 				echo $wp_version;
 			`
     })).text;
-    if (!a)
+    if (!s)
       throw new Error("Unable to read loaded WordPress version.");
-    return U(a);
+    return Xe(s);
   } finally {
-    n();
+    i();
   }
 }
-function U(t) {
-  if (/-(alpha|beta|RC)\d*-\d+$/.test(t))
+function Xe(e) {
+  if (/-(alpha|beta|RC)\d*-\d+$/.test(e))
     return "trunk";
-  if (/-(beta|RC)\d*$/.test(t))
+  if (/-(beta|RC)\d*$/.test(e))
     return "beta";
-  const i = t.match(/^(\d+\.\d+)(?:\.\d+)?$/);
-  return i !== null ? i[1] : t;
+  const n = e.match(/^(\d+\.\d+)(?:\.\d+)?$/);
+  return n !== null ? n[1] : e;
 }
-const q = [
+const Ye = [
   /**
    * Substitutes the multisite WordPress rewrite rule:
    *
@@ -800,8 +3231,10 @@ const q = [
     replacement: "$2"
   }
 ];
-async function N(t) {
-  await t.mkdir("/internal/shared/mu-plugins"), await t.writeFile(
+async function Ke(e, t = {}) {
+  if (w(t.phpVersion))
+    return B(e);
+  await e.mkdir("/internal/shared/mu-plugins"), await e.writeFile(
     "/internal/shared/preload/env.php",
     `<?php
 
@@ -831,7 +3264,7 @@ async function N(t) {
             }
         }
     `
-  ), await t.writeFile(
+  ), await e.writeFile(
     "/internal/shared/mu-plugins/1-auto-login.php",
     `<?php
 		/**
@@ -988,111 +3421,7 @@ async function N(t) {
 			return $interval;
 		});
 		`
-  ), await t.writeFile(
-    "/internal/shared/mu-plugins/0-playground.php",
-    `<?php
-
-		// Save WordPress environment information to a file.
-		add_action('wp_loaded', function() {
-			if (defined('DB_ENGINE') && DB_ENGINE === 'sqlite') {
-				$db_info = array(
-					'type' => 'sqlite',
-					'path' => FQDB,
-					'driver_path' => defined('WP_MYSQL_ON_SQLITE_LOADER_PATH')
-						? WP_MYSQL_ON_SQLITE_LOADER_PATH
-						: dirname(SQLITE_MAIN_FILE) . '/wp-pdo-mysql-on-sqlite.php',
-				);
-			} else {
-				$db_info = array(
-					'type' => 'mysql',
-					// TODO: Save MySQL connection config.
-				);
-			}
-			$wp_env = array('db' => $db_info);
-			$wp_env_php = sprintf('<?php return %s;', var_export($wp_env, true));
-			$wp_env_file = '/internal/shared/wp-env.php';
-			if (!file_exists($wp_env_file) || file_get_contents($wp_env_file) !== $wp_env_php ) {
-				file_put_contents($wp_env_file, $wp_env_php);
-			}
-		});
-
-        // Needed because gethostbyname( 'wordpress.org' ) returns
-        // a private network IP address for some reason.
-        add_filter( 'allowed_redirect_hosts', function( $deprecated = '' ) {
-            return array(
-                'wordpress.org',
-                'api.wordpress.org',
-                'downloads.wordpress.org',
-            );
-        } );
-
-		/**
-		 * Prevents wp_http_validate_url() from universally failing.
-		 *
-		 * wp_http_validate_url() calls gethostbyname() to verify whether the host
-		 * is external. If it is internal, the URL validation fails and WordPress
-		 * refuses to make a request.
-		 *
-		 * However, in EMscripten, gethostbyname() returns a private network IP address.
-		 * This causes wp_http_validate_url() to return false for all URLs.
-		 *
-		 * This filter ensures that all URLs are considered external. In production
-		 * environments, this would be considered a security risk. However, Playground
-		 * already provides multiple code execution vectors as features (e.g. Blueprints).
-		 *
-		 * If someone wants to poke around local IP addresses, they already have multiple
-		 * tools at their disposal. Therefore, this is not a real security risk in context
-		 * of WordPress Playground or Playground CLI.
-		 */
-		add_filter('http_request_host_is_external', '__return_true');
-
-		// Support pretty permalinks
-        add_filter( 'got_url_rewrite', '__return_true' );
-
-        // Create the fonts directory if missing
-        if(!file_exists(WP_CONTENT_DIR . '/fonts')) {
-            mkdir(WP_CONTENT_DIR . '/fonts');
-        }
-
-        $log_file = WP_CONTENT_DIR . '/debug.log';
-        if ( defined( 'WP_DEBUG_LOG' ) && WP_DEBUG_LOG ) {
-            if ( is_string( WP_DEBUG_LOG ) ) {
-                $log_file = WP_DEBUG_LOG;
-            }
-            ini_set('error_log', $log_file);
-        } else {
-            ini_set('log_errors', '0');
-        }
-        define('ERROR_LOG_FILE', $log_file);
-        ?>`
-  ), await t.writeFile(
-    "/internal/shared/mu-plugins/sitemap-redirect.php",
-    `<?php
-		/**
-		 * Redirect sitemap.xml to wp-sitemap.xml for non-root installations.
-		 *
-		 * WordPress seems to only generate the sitemap.xml → wp-sitemap.xml rewrite
-		 * rule when installed at the domain root. This mu-plugin handles the
-		 * redirect for non-root installations.
-		 */
-		if (isset($_SERVER['REQUEST_URI'])) {
-			$site_url = site_url();
-			$parsed = parse_url($site_url);
-			$base_path = isset($parsed['path']) ? rtrim($parsed['path'], '/') : '';
-
-			$request_uri = $_SERVER['REQUEST_URI'];
-			if (
-				$request_uri === $base_path . '/sitemap.xml' ||
-				strpos($request_uri, $base_path . '/sitemap.xml?') === 0 ||
-				strpos($request_uri, $base_path . '/sitemap.xml/') === 0
-			) {
-				$query_string = strpos($request_uri, '?') !== false ? substr($request_uri, strpos($request_uri, '?')) : '';
-				header('Location: ' . $base_path . '/wp-sitemap.xml' . $query_string, true, 301);
-				exit;
-			}
-		}
-		`
-  ), await t.writeFile(
+  ), await S(e), await e.writeFile(
     "/internal/shared/preload/error-handler.php",
     `<?php
 		(function() {
@@ -1145,13 +3474,13 @@ async function N(t) {
 		})();`
   );
 }
-async function F(t, e = "/phpinfo.php") {
-  await t.writeFile(
+async function Qe(e, t = "/phpinfo.php") {
+  await e.writeFile(
     "/internal/shared/preload/phpinfo.php",
     `<?php
     // Render PHPInfo if the requested page is /phpinfo.php
-    if ( isset($_SERVER['REQUEST_URI']) && ${d(
-      e
+    if ( isset($_SERVER['REQUEST_URI']) && ${$(
+      t
     )} === $_SERVER['REQUEST_URI'] ) {
         phpinfo();
         exit;
@@ -1159,105 +3488,44 @@ async function F(t, e = "/phpinfo.php") {
     `
   );
 }
-async function D(t, e) {
-  await t.isDir("/tmp/sqlite-database-integration") && await t.rmdir("/tmp/sqlite-database-integration", {
+async function I(e, t, i = {}) {
+  if (w(i.phpVersion))
+    return Ne(e, t, i);
+  await e.isDir("/tmp/sqlite-database-integration") && await e.rmdir("/tmp/sqlite-database-integration", {
     recursive: !0
-  }), await t.mkdir("/tmp/sqlite-database-integration"), await p(t, e, "/tmp/sqlite-database-integration");
-  const n = "/internal/shared/sqlite-database-integration", i = `/tmp/sqlite-database-integration/${(await t.listFiles("/tmp/sqlite-database-integration"))[0]}`;
-  await t.mv(i, n), await t.defineConstant("SQLITE_MAIN_FILE", "1");
-  const o = (await t.readFileAsText(
-    s(n, "db.copy")
+  }), await e.mkdir("/tmp/sqlite-database-integration"), await m(e, t, "/tmp/sqlite-database-integration");
+  const n = "/internal/shared/sqlite-database-integration", s = `/tmp/sqlite-database-integration/${(await e.listFiles("/tmp/sqlite-database-integration"))[0]}`;
+  await e.mv(s, n);
+  const r = _(
+    n,
+    "wp-includes/sqlite/class-wp-sqlite-db.php"
+  );
+  if (await e.fileExists(r)) {
+    const d = await e.readFileAsText(r), f = d.replace(
+      "private $allow_unsafe_unquoted_parameters",
+      "protected $allow_unsafe_unquoted_parameters"
+    );
+    f !== d && await e.writeFile(r, f);
+  }
+  await e.defineConstant("SQLITE_MAIN_FILE", "1");
+  const o = (await e.readFileAsText(
+    _(n, "db.copy")
   )).replace(
     "'{SQLITE_IMPLEMENTATION_FOLDER_PATH}'",
-    d(n)
+    $(n)
   ).replace(
     "'{SQLITE_PLUGIN}'",
-    d(s(n, "load.php"))
-  ), l = s(await t.documentRoot, "wp-content/db.php"), r = `<?php
+    $(_(n, "load.php"))
+  ), l = _(await e.documentRoot, "wp-content/db.php"), c = `<?php
 	// Do not preload this if WordPress comes with a custom db.php file.
-	if(file_exists(${d(l)})) {
+	if(file_exists(${$(l)})) {
 		return;
 	}
-	?>`, c = "/internal/shared/mu-plugins/sqlite-database-integration.php";
-  await t.writeFile(c, r + o), await t.writeFile(
+	?>`, u = "/internal/shared/mu-plugins/sqlite-database-integration.php";
+  await e.writeFile(u, c + o), await e.writeFile(
     "/internal/shared/preload/0-sqlite.php",
-    r + `<?php
-
-/**
- * Loads the SQLite integration plugin before WordPress is loaded
- * and without creating a drop-in "db.php" file.
- *
- * Technically, it creates a global $wpdb object whose only two
- * purposes are to:
- *
- * * Exist – because the require_wp_db() WordPress function won't
- *           connect to MySQL if $wpdb is already set.
- * * Load the SQLite integration plugin the first time it's used
- *   and replace the global $wpdb reference with the SQLite one.
- *
- * This lets Playground keep the WordPress installation clean and
- * solves dillemas like:
- *
- * * Should we include db.php in Playground exports?
- * * Should we remove db.php from Playground imports?
- * * How should we treat stale db.php from long-lived OPFS sites?
- *
- * @see https://github.com/WordPress/wordpress-playground/discussions/1379 for
- *      more context.
- */
-class Playground_SQLite_Integration_Loader {
-	public function __call($name, $arguments) {
-		$this->load_sqlite_integration();
-		if($GLOBALS['wpdb'] === $this) {
-			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
-		}
-		return call_user_func_array(
-			array($GLOBALS['wpdb'], $name),
-			$arguments
-		);
-	}
-	public function __get($name) {
-		$this->load_sqlite_integration();
-		if($GLOBALS['wpdb'] === $this) {
-			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
-		}
-		return $GLOBALS['wpdb']->$name;
-	}
-	public function __set($name, $value) {
-		$this->load_sqlite_integration();
-		if($GLOBALS['wpdb'] === $this) {
-			throw new Exception('Infinite loop detected in $wpdb – SQLite integration plugin could not be loaded');
-		}
-		$GLOBALS['wpdb']->$name = $value;
-	}
-    protected function load_sqlite_integration() {
-        require_once ${d(c)};
-    }
-}
-/**
- * The Query Monitor plugin short-circuits in the CLI SAPI. However, in Playground,
- * the SAPI is always "cli" at the moment. Let's set a constant to disable the CLI
- * detection.
- *
- * @see https://github.com/WordPress/sqlite-database-integration/pull/212
- * @see https://github.com/WordPress/sqlite-database-integration/pull/215
- */
-define('QM_TESTS', true);
-$wpdb = $GLOBALS['wpdb'] = new Playground_SQLite_Integration_Loader();
-
-/**
- * WordPress is capable of using a preloaded global $wpdb. However, if
- * it cannot find the drop-in db.php plugin it still checks whether
- * the mysqli_connect() function exists even though it's not used.
- *
- * What WordPress demands, Playground shall provide.
- */
-if(!function_exists('mysqli_connect')) {
-	function mysqli_connect() {}
-}
-
-		`
-  ), await t.writeFile(
+    je(c, u)
+  ), await e.writeFile(
     "/internal/shared/mu-plugins/sqlite-test.php",
     `<?php
 		global $wpdb;
@@ -1268,117 +3536,127 @@ if(!function_exists('mysqli_connect')) {
 		`
   );
 }
-async function M(t, e) {
-  t.mkdir("/tmp/unzipped-wordpress"), await p(t, e, "/tmp/unzipped-wordpress"), t.fileExists("/tmp/unzipped-wordpress/wordpress.zip") && await p(
-    t,
+function je(e, t) {
+  return e + `<?php
+
+${v(`require_once ${$(t)};`)}
+if(!function_exists('mysqli_connect')) {
+	function mysqli_connect() {}
+}
+
+		`;
+}
+async function D(e, t) {
+  e.mkdir("/tmp/unzipped-wordpress"), await m(e, t, "/tmp/unzipped-wordpress"), e.fileExists("/tmp/unzipped-wordpress/wordpress.zip") && await m(
+    e,
     "/tmp/unzipped-wordpress/wordpress.zip",
     "/tmp/unzipped-wordpress"
   );
-  let n = t.fileExists("/tmp/unzipped-wordpress/wordpress") ? "/tmp/unzipped-wordpress/wordpress" : t.fileExists("/tmp/unzipped-wordpress/build") ? "/tmp/unzipped-wordpress/build" : "/tmp/unzipped-wordpress";
-  if (!t.fileExists(s(n, "wp-config-sample.php"))) {
-    const a = t.listFiles(n);
-    if (a.length) {
-      const o = a[0];
-      t.fileExists(
-        s(n, o, "wp-config-sample.php")
-      ) && (n = s(n, o));
+  let i = e.fileExists("/tmp/unzipped-wordpress/wordpress") ? "/tmp/unzipped-wordpress/wordpress" : e.fileExists("/tmp/unzipped-wordpress/build") ? "/tmp/unzipped-wordpress/build" : "/tmp/unzipped-wordpress";
+  if (!e.fileExists(_(i, "wp-config-sample.php"))) {
+    const s = e.listFiles(i);
+    if (s.length) {
+      const r = s[0];
+      e.fileExists(
+        _(i, r, "wp-config-sample.php")
+      ) && (i = _(i, r));
     }
   }
-  const i = (a, o, l) => {
-    if (l.isDir(a) && l.isDir(o))
-      for (const r of l.listFiles(a)) {
-        const c = s(a, r), k = s(o, r);
-        i(c, k, l);
+  const n = (s, r, a) => {
+    if (a.isDir(s) && a.isDir(r))
+      for (const o of a.listFiles(s)) {
+        const l = _(s, o), c = _(r, o);
+        n(l, c, a);
       }
     else {
-      if (l.fileExists(o)) {
-        const r = a.replace(
+      if (a.fileExists(r)) {
+        const o = s.replace(
           /^\/tmp\/unzipped-wordpress\//,
           "/"
         );
-        g.warn(
-          `Cannot unzip WordPress files at ${o}: ${r} already exists.`
+        h.warn(
+          `Cannot unzip WordPress files at ${r}: ${o} already exists.`
         );
         return;
       }
-      l.mv(a, o);
+      a.mv(s, r);
     }
   };
-  i(n, t.documentRoot, t), t.fileExists(n) && t.rmdir(n, { recursive: !0 }), !t.fileExists(s(t.documentRoot, "wp-config.php")) && t.fileExists(s(t.documentRoot, "wp-config-sample.php")) && t.writeFile(
-    s(t.documentRoot, "wp-config.php"),
-    t.readFileAsText(
-      s(t.documentRoot, "/wp-config-sample.php")
+  n(i, e.documentRoot, e), e.fileExists(i) && e.rmdir(i, { recursive: !0 }), !e.fileExists(_(e.documentRoot, "wp-config.php")) && e.fileExists(_(e.documentRoot, "wp-config-sample.php")) && e.writeFile(
+    _(e.documentRoot, "wp-config.php"),
+    e.readFileAsText(
+      _(e.documentRoot, "/wp-config-sample.php")
     )
   );
 }
-const G = P(fetch), H = "https://github.com/WordPress/WordPress/archive/refs/heads/master.zip";
-async function K(t = "latest") {
-  if (t === null)
-    t = "latest";
-  else if (t.startsWith("https://") || t.startsWith("http://")) {
-    const i = await crypto.subtle.digest(
+const ze = M(fetch), Ze = "https://github.com/WordPress/WordPress/archive/refs/heads/master.zip";
+async function ot(e = "latest") {
+  if (e === null)
+    e = "latest";
+  else if (e.startsWith("https://") || e.startsWith("http://")) {
+    const n = await crypto.subtle.digest(
       "SHA-1",
-      new TextEncoder().encode(t)
-    ), a = Array.from(new Uint8Array(i)).map((o) => o.toString(16).padStart(2, "0")).join("");
+      new TextEncoder().encode(e)
+    ), s = Array.from(new Uint8Array(n)).map((r) => r.toString(16).padStart(2, "0")).join("");
     return {
-      releaseUrl: t,
-      version: "custom-" + a.substring(0, 8),
+      releaseUrl: e,
+      version: "custom-" + s.substring(0, 8),
       source: "inferred"
     };
-  } else if (t === "trunk" || t === "nightly") {
-    const i = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  } else if (e === "trunk" || e === "nightly") {
+    const n = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     return {
-      releaseUrl: `${H}?ts=${i}`,
+      releaseUrl: `${Ze}?ts=${n}`,
       version: "trunk",
       source: "inferred"
     };
   }
-  let n = await (await G(
+  let i = await (await ze(
     "https://api.wordpress.org/core/version-check/1.7/?channel=beta"
   )).json();
-  n = n.offers.filter(
-    (i) => i.response === "autoupdate"
+  i = i.offers.filter(
+    (n) => n.response === "autoupdate"
   );
-  for (const i of n) {
-    if (t === "beta" && (i.version.includes("beta") || i.version.includes("RC")))
+  for (const n of i) {
+    if (e === "beta" && (n.version.includes("beta") || n.version.includes("RC")))
       return {
-        releaseUrl: i.download,
-        version: i.version,
+        releaseUrl: n.download,
+        version: n.version,
         source: "api"
       };
-    if (t === "latest" && !i.version.includes("beta") && !i.version.includes("RC"))
+    if (e === "latest" && !n.version.includes("beta") && !n.version.includes("RC"))
       return {
-        releaseUrl: i.download,
-        version: i.version,
+        releaseUrl: n.download,
+        version: n.version,
         source: "api"
       };
-    if (i.version.substring(0, t.length) === t)
+    if (n.version.substring(0, e.length) === e)
       return {
-        releaseUrl: i.download,
-        version: i.version,
+        releaseUrl: n.download,
+        version: n.version,
         source: "api"
       };
   }
-  return t.match(/^\d+\.\d+\.0$/) && (t = t.split(".").slice(0, 2).join(".")), {
-    releaseUrl: `https://wordpress.org/wordpress-${t}.zip`,
-    version: t,
+  return e.match(/^\d+\.\d+\.0$/) && (e = e.split(".").slice(0, 2).join(".")), {
+    releaseUrl: `https://wordpress.org/wordpress-${e}.zip`,
+    version: e,
     source: "inferred"
   };
 }
 export {
-  C as bootRequestHandler,
-  L as bootWordPress,
-  Z as bootWordPressAndRequestHandler,
-  V as defineWpConfigConstants,
-  I as ensureWpConfig,
-  O as getFileNotFoundActionForWordPress,
-  Y as getLoadedWordPressVersion,
-  F as preloadPhpInfoRoute,
-  D as preloadSqliteIntegration,
-  K as resolveWordPressRelease,
-  N as setupPlatformLevelMuPlugins,
-  M as unzipWordPress,
-  U as versionStringToLoadedWordPressVersion,
-  q as wordPressRewriteRules
+  He as bootRequestHandler,
+  Me as bootWordPress,
+  rt as bootWordPressAndRequestHandler,
+  st as defineWpConfigConstants,
+  ve as ensureWpConfig,
+  Be as getFileNotFoundActionForWordPress,
+  at as getLoadedWordPressVersion,
+  Qe as preloadPhpInfoRoute,
+  I as preloadSqliteIntegration,
+  ot as resolveWordPressRelease,
+  Ke as setupPlatformLevelMuPlugins,
+  D as unzipWordPress,
+  Xe as versionStringToLoadedWordPressVersion,
+  Ye as wordPressRewriteRules
 };
 //# sourceMappingURL=index.js.map