methanol 0.0.19 → 0.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "methanol",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Static site generator powered by rEFui and MDX",
   "main": "./index.js",
   "type": "module",

package/src/build-system.js

@@ -26,6 +26,7 @@ import { VitePWA } from 'vite-plugin-pwa'
 import { state, cli } from './state.js'
 import { resolveUserViteConfig } from './config.js'
 import { buildPagesContext } from './pages.js'
+import { selectFeedPages } from './feed.js'
 import { buildComponentRegistry } from './components.js'
 import { createBuildWorkers, runWorkerStage, terminateWorkers } from './workers/build-pool.js'
 import { methanolVirtualHtmlPlugin, methanolResolverPlugin } from './vite-plugins.js'
@@ -98,6 +99,8 @@ export const buildHtmlEntries = async () => {
 	const { workers, assignments } = createBuildWorkers(totalPages)
 	const excludedRoutes = Array.from(pagesContext.excludedRoutes || [])
 	const excludedDirs = Array.from(pagesContext.excludedDirs || [])
+	const rssContent = new Map()
+	const intermediateOutputs = []
 	try {
 		await runWorkerStage({
 			workers,
@@ -136,6 +139,10 @@ export const buildHtmlEntries = async () => {
 		})
 		stageLogger.end(compileToken)
 
+		const titleUpdates = updates
+			.filter((update) => update && update.title !== undefined)
+			.map((update) => ({ id: update.id, title: update.title }))
+
 		for (const update of updates) {
 			const page = pages[update.id]
 			if (!page) continue
@@ -149,7 +156,6 @@ export const buildHtmlEntries = async () => {
 		pagesContext.refreshPagesTree?.()
 		state.PAGES_CONTEXT = pagesContext
 
-		const titleSnapshot = pages.map((page) => page.title)
 		await runWorkerStage({
 			workers,
 			stage: 'sync',
@@ -158,15 +164,13 @@ export const buildHtmlEntries = async () => {
 				message: {
 					type: 'sync',
 					stage: 'sync',
-					updates,
-					titles: titleSnapshot
+					updates: titleUpdates
 				}
 			}))
 		})
-
 		const renderToken = stageLogger.start('Rendering pages')
 		completed = 0
-		const rendered = await runWorkerStage({
+		await runWorkerStage({
 			workers,
 			stage: 'render',
 			messages: workers.map((worker, index) => ({
@@ -182,27 +186,80 @@ export const buildHtmlEntries = async () => {
 				completed = count
 				stageLogger.update(renderToken, `Rendering pages [${completed}/${totalPages}]`)
 			},
-			collect: (message) => message.results || []
+			onResult: (result) => {
+				if (!result || typeof result.id !== 'number') return
+				const page = pages[result.id]
+				if (!page) return
+				const html = result.html
+				const name = resolveOutputName(page)
+				const id = normalizePath(resolve(state.VIRTUAL_HTML_OUTPUT_ROOT, `${name}.html`))
+				entry[name] = id
+				htmlCache.set(id, html)
+				if (state.INTERMEDIATE_DIR) {
+					intermediateOutputs.push({ name, id })
+				}
+			}
 		})
 		stageLogger.end(renderToken)
 
-		for (const item of rendered) {
-			const page = pages[item.id]
-			if (!page) continue
-			const html = item.html
-			const name = resolveOutputName(page)
-			const id = normalizePath(resolve(state.VIRTUAL_HTML_OUTPUT_ROOT, `${name}.html`))
-			entry[name] = id
-			htmlCache.set(id, html)
-			if (state.INTERMEDIATE_DIR) {
-				const outPath = resolve(state.INTERMEDIATE_DIR, `${name}.html`)
-				await ensureDir(dirname(outPath))
-				await writeFile(outPath, html)
+		if (state.RSS_ENABLED) {
+			const feedPages = selectFeedPages(pages, state.RSS_OPTIONS || {})
+			const feedIds = []
+			const pageIndex = new Map(pages.map((page, index) => [page, index]))
+			for (const page of feedPages) {
+				const id = pageIndex.get(page)
+				if (id != null) {
+					feedIds.push(id)
+				}
+			}
+			if (feedIds.length) {
+				const rssToken = stageLogger.start('Rendering feed')
+				completed = 0
+				const rssAssignments = Array.from({ length: workers.length }, () => [])
+				for (let i = 0; i < feedIds.length; i += 1) {
+					rssAssignments[i % workers.length].push(feedIds[i])
+				}
+				await runWorkerStage({
+					workers,
+					stage: 'rss',
+					messages: workers.map((worker, index) => ({
+						worker,
+						message: {
+							type: 'rss',
+							stage: 'rss',
+							ids: rssAssignments[index]
+						}
+					})),
+					onProgress: (count) => {
+						if (!logEnabled) return
+						completed = count
+						stageLogger.update(rssToken, `Rendering feed [${completed}/${feedIds.length}]`)
+					},
+					onResult: (result) => {
+						if (!result || typeof result.id !== 'number') return
+						const page = pages[result.id]
+						if (!page) return
+						const key = page.path || page.routePath
+						if (key) {
+							rssContent.set(key, result.content || '')
+						}
+					}
+				})
+				stageLogger.end(rssToken)
 			}
 		}
 	} finally {
 		await terminateWorkers(workers)
 	}
+	if (state.INTERMEDIATE_DIR) {
+		for (const output of intermediateOutputs) {
+			const html = htmlCache.get(output.id)
+			if (typeof html !== 'string') continue
+			const outPath = resolve(state.INTERMEDIATE_DIR, `${output.name}.html`)
+			await ensureDir(dirname(outPath))
+			await writeFile(outPath, html)
+		}
+	}
 
 	const htmlFiles = await collectHtmlFiles(state.PAGES_DIR)
 	const htmlExcludedDirs = pagesContext.excludedDirs || new Set()
@@ -238,7 +295,7 @@ export const buildHtmlEntries = async () => {
 		}
 	}
 
-	return { entry, htmlCache, pagesContext }
+	return { entry, htmlCache, pagesContext, rssContent }
 }
 
 export const runViteBuild = async (entry, htmlCache) => {

package/src/components.js

@@ -52,6 +52,8 @@ export const register = reframeEnv.register
 export const invalidateRegistryEntry = reframeEnv.invalidate
 export const genRegistryScript = reframeEnv.genRegistryScript
 export const resetReframeRenderCount = () => reframeEnv.resetRenderCount()
+export const setReframeHydrationEnabled = (value) => reframeEnv.setHydrationEnabled(value)
+export const getReframeHydrationEnabled = () => reframeEnv.getHydrationEnabled()
 
 const resolveComponentExport = (componentPath, exportName, ext) => {
 	const staticCandidate = `${componentPath}.static${ext}`

package/src/config.js

@@ -23,6 +23,7 @@ import { existsSync } from 'fs'
 import { resolve, isAbsolute, extname, basename, dirname } from 'path'
 import { pathToFileURL, fileURLToPath } from 'url'
 import { mergeConfig } from 'vite'
+import { isMainThread } from 'worker_threads'
 import { projectRequire } from './node-loader.js'
 import { cli, state } from './state.js'
 import { logger } from './logger.js'
@@ -122,6 +123,7 @@ const normalizeViteBase = (value) => {
 }
 
 const warnDevBase = (value) => {
+	if (!isMainThread) return
 	if (devBaseWarningShown) return
 	devBaseWarningShown = true
 	const label = value ? ` (received "${value}")` : ''
@@ -191,6 +193,28 @@ const resolvePagefindBuild = (config) => {
 	return null
 }
 
+const resolveFeedEnabled = (config) => {
+	if (config?.feed == null) return false
+	if (typeof config.feed === 'boolean') return config.feed
+	if (typeof config.feed === 'object') {
+		if (hasOwn(config.feed, 'enabled')) {
+			return config.feed.enabled !== false
+		}
+		return true
+	}
+	return false
+}
+
+const resolveFeedOptions = (config) => {
+	const value = config?.feed
+	if (!value || typeof value !== 'object') return null
+	const { enabled, ...rest } = value
+	if (Object.keys(rest).length) {
+		return { ...rest }
+	}
+	return null
+}
+
 const resolveStarryNightConfig = (value) => {
 	if (value == null) return { enabled: true, options: null }
 	if (typeof value === 'boolean') {
@@ -301,10 +325,15 @@ export const applyConfig = async (config, mode) => {
 	state.ROOT_DIR = root
 	const configSiteName = cli.CLI_SITE_NAME ?? config.site?.name ?? null
 	state.SITE_NAME = configSiteName || basename(root) || 'Methanol Site'
+	const configOwner = cli.CLI_OWNER ?? config.site?.owner ?? null
+	state.SITE_OWNER = configOwner ? String(configOwner) : null
 	const userSite = config.site && typeof config.site === 'object' ? { ...config.site } : null
 	const siteBase = normalizeSiteBase(cli.CLI_BASE || userSite?.base)
 	state.SITE_BASE = siteBase
 	if (userSite) {
+		if (configOwner != null) {
+			userSite.owner = String(configOwner)
+		}
 		if (siteBase == null) {
 			delete userSite.base
 		} else {
@@ -426,6 +455,18 @@ export const applyConfig = async (config, mode) => {
 	}
 	state.PAGEFIND_OPTIONS = resolvePagefindOptions(config)
 	state.PAGEFIND_BUILD = resolvePagefindBuild(config)
+
+	state.RSS_ENABLED = resolveFeedEnabled(config)
+	if (cli.CLI_RSS !== undefined) {
+		state.RSS_ENABLED = cli.CLI_RSS
+	}
+	state.RSS_OPTIONS = resolveFeedOptions(config)
+	if (cli.CLI_ATOM !== undefined) {
+		if (cli.CLI_ATOM === true) {
+			state.RSS_ENABLED = true
+		}
+		state.RSS_OPTIONS = { ...(state.RSS_OPTIONS || {}), atom: cli.CLI_ATOM }
+	}
 	
 	if (hasOwn(config, 'pwa')) {
 		if (config.pwa === true) {

package/src/dev-server.js

@@ -38,7 +38,7 @@ import {
 } from './components.js'
 import { buildPagesContext, buildPageEntry, routePathFromFile } from './pages.js'
 import { compilePageMdx, renderHtml } from './mdx.js'
-import { DevErrorPage } from './error-page.jsx'
+import { DevErrorPage } from './templates/error-page.jsx'
 import { HTMLRenderer } from './renderer.js'
 import { methanolResolverPlugin } from './vite-plugins.js'
 import { preparePublicAssets, updateAsset } from './public-assets.js'
@@ -251,6 +251,10 @@ export const runViteDev = async () => {
 			})
 			if (token !== pagesContextToken) return
 
+			const titleUpdates = updates
+				.filter((update) => update && update.title !== undefined)
+				.map((update) => ({ id: update.id, title: update.title }))
+
 			for (const update of updates) {
 				const page = pages[update.id]
 				if (!page) continue
@@ -266,7 +270,6 @@ export const runViteDev = async () => {
 			invalidateHtmlCache()
 			const renderEpoch = htmlCacheEpoch
 
-			const titleSnapshot = pages.map((page) => page.title)
 			await runWorkerStage({
 				workers,
 				stage: 'sync',
@@ -275,8 +278,7 @@ export const runViteDev = async () => {
 					message: {
 						type: 'sync',
 						stage: 'sync',
-						updates,
-						titles: titleSnapshot
+						updates: titleUpdates
 					}
 				}))
 			})

package/src/feed.js

@@ -0,0 +1,198 @@
+/* Copyright Yukino Song, SudoMaker Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { dirname, resolve } from 'path'
+import { mkdir, writeFile } from 'fs/promises'
+import { state } from './state.js'
+import { HTMLRenderer } from './renderer.js'
+import { extractExcerpt } from './text-utils.js'
+import { withBase } from './config.js'
+import { logger } from './logger.js'
+import { setReframeHydrationEnabled, getReframeHydrationEnabled } from './components.js'
+import RssFeed from './templates/rss-feed.jsx'
+import AtomFeed from './templates/atom-feed.jsx'
+
+const DEFAULT_RSS_PATH = '/rss.xml'
+const DEFAULT_ATOM_PATH = '/atom.xml'
+const DEFAULT_RSS_LIMIT = 10
+
+const isAbsoluteUrl = (value) =>
+	typeof value === 'string' && /^https?:\/\//i.test(value.trim())
+
+const normalizeFeedPath = (value, isAtom) => {
+	if (!value || typeof value !== 'string') return isAtom ? DEFAULT_ATOM_PATH : DEFAULT_RSS_PATH
+	const trimmed = value.trim()
+	if (!trimmed) return isAtom ? DEFAULT_ATOM_PATH : DEFAULT_RSS_PATH
+	return trimmed.startsWith('/') ? trimmed : `/${trimmed}`
+}
+
+const ensureDir = async (dir) => {
+	await mkdir(dir, { recursive: true })
+}
+
+const resolveFeedLimit = (options) => {
+	return typeof options?.limit === 'number' && Number.isFinite(options.limit)
+		? Math.max(0, Math.floor(options.limit))
+		: DEFAULT_RSS_LIMIT
+}
+
+const wrapCdata = (value) => {
+	const text = value == null ? '' : String(value)
+	if (!text) return ''
+	const trimmed = text.trim()
+	if (trimmed.startsWith('<![CDATA[') && trimmed.endsWith(']]>')) {
+		return trimmed
+	}
+	return `<![CDATA[${text.replace(/]]>/g, ']]]]><![CDATA[>')}]]>`
+}
+
+const escapeXml = (value) => {
+	const text = value == null ? '' : String(value)
+	if (!text) return ''
+	return text
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+}
+
+const resolveSiteUrl = (options, site) => {
+	if (options?.siteUrl) return options.siteUrl
+	if (state.SITE_BASE) return state.SITE_BASE
+	if (site?.base) return site.base
+	return null
+}
+
+const buildItem = (page, siteUrl, htmlContent = null, isAtom = false, siteOwner = null) => {
+	if (!page) return null
+	const href = page.routeHref || withBase(page.routePath)
+	if (!href) return null
+	const link = new URL(href, siteUrl).href
+	const title = page.title || page.name || page.routePath || link
+	const description = extractExcerpt(page)
+	const contentSource = htmlContent || page.content || ''
+	const content = contentSource
+		? (isAtom
+			? HTMLRenderer.rawHTML(escapeXml(contentSource))
+			: HTMLRenderer.rawHTML(wrapCdata(contentSource)))
+		: null
+	const authorValue = page.frontmatter?.author
+	const author = Array.isArray(authorValue)
+		? authorValue.filter(Boolean).join(', ')
+		: authorValue || siteOwner || null
+	const pubDate = page.date ? new Date(page.date).toUTCString() : null
+	const updated = page.date ? new Date(page.date).toISOString() : null
+	return {
+		title,
+		link,
+		description,
+		content,
+		author,
+		pubDate,
+		updated
+	}
+}
+
+const getSortTime = (page) => {
+	const value = page?.date
+	if (!value) return 0
+	const time = Date.parse(value)
+	return Number.isNaN(time) ? 0 : time
+}
+
+export const selectFeedPages = (pages, options) => {
+	const limit = resolveFeedLimit(options)
+	if (!limit) return []
+	return (Array.isArray(pages) ? pages : [])
+		.filter((page) => page && !page.hidden)
+		.sort((a, b) => getSortTime(b) - getSortTime(a))
+		.slice(0, limit)
+}
+
+export const renderRssFeed = ({ site, items }) => {
+	const prevHydration = getReframeHydrationEnabled()
+	const prevThemeHydration = state.THEME_ENV?.getHydrationEnabled?.()
+	setReframeHydrationEnabled(false)
+	state.THEME_ENV?.setHydrationEnabled?.(false)
+	try {
+		return HTMLRenderer.serialize(HTMLRenderer.c(RssFeed, { site, items }))
+	} finally {
+		setReframeHydrationEnabled(prevHydration)
+		if (prevThemeHydration != null) {
+			state.THEME_ENV?.setHydrationEnabled?.(prevThemeHydration)
+		}
+	}
+}
+
+export const renderAtomFeed = ({ site, items }) => {
+	const prevHydration = getReframeHydrationEnabled()
+	const prevThemeHydration = state.THEME_ENV?.getHydrationEnabled?.()
+	setReframeHydrationEnabled(false)
+	state.THEME_ENV?.setHydrationEnabled?.(false)
+	try {
+		return HTMLRenderer.serialize(HTMLRenderer.c(AtomFeed, { site, items }))
+	} finally {
+		setReframeHydrationEnabled(prevHydration)
+		if (prevThemeHydration != null) {
+			state.THEME_ENV?.setHydrationEnabled?.(prevThemeHydration)
+		}
+	}
+}
+
+export const generateRssFeed = async (pagesContext, rssContent = null) => {
+	if (!state.RSS_ENABLED) return null
+	const options = state.RSS_OPTIONS || {}
+	const site = pagesContext?.site || state.USER_SITE || {}
+	const siteUrl = resolveSiteUrl(options, site)
+	if (!isAbsoluteUrl(siteUrl)) {
+		logger.warn('Feed skipped: site.base must be an absolute URL (e.g. https://example.com/).')
+		return null
+	}
+	const isAtom = options.atom === true
+	const path = normalizeFeedPath(options.path, isAtom)
+	const now = new Date()
+	const finalSite = {
+		name: site.name,
+		title: Object.prototype.hasOwnProperty.call(options, 'title') ? options.title : site.name,
+		description: Object.prototype.hasOwnProperty.call(options, 'description') ? options.description : site.description,
+		language: Object.prototype.hasOwnProperty.call(options, 'language') ? options.language : (site.language || site.lang),
+		url: siteUrl,
+		feedUrl: new URL(path, siteUrl).href,
+		generator: 'Methanol',
+		lastBuildDate: now.toUTCString(),
+		updated: now.toISOString()
+	}
+	const pages = selectFeedPages(pagesContext?.pages || [], options)
+	const siteOwner = site.owner || null
+	const items = pages
+		.map((page) => ({
+			page,
+			content: rssContent?.get(page.path) || rssContent?.get(page.routePath) || null
+		}))
+		.map((entry) => buildItem(entry.page, siteUrl, entry.content, isAtom, siteOwner))
+		.filter(Boolean)
+	const xml = isAtom
+		? renderAtomFeed({ site: finalSite, items })
+		: renderRssFeed({ site: finalSite, items })
+	const outPath = resolve(state.DIST_DIR, path.slice(1))
+	await ensureDir(dirname(outPath))
+	await writeFile(outPath, xml)
+	logger.success(`${isAtom ? 'Atom' : 'RSS'} feed generated: ${path} (${items.length} ${items.length === 1 ? 'item' : 'items'})`)
+	return { path, count: items.length }
+}

package/src/main.js

@@ -22,6 +22,7 @@ import { loadUserConfig, applyConfig } from './config.js'
 import { runViteDev } from './dev-server.js'
 import { buildHtmlEntries, runViteBuild } from './build-system.js'
 import { runPagefind } from './pagefind.js'
+import { generateRssFeed } from './feed.js'
 import { runVitePreview } from './preview-server.js'
 import { cli, state } from './state.js'
 import { HTMLRenderer } from './renderer.js'
@@ -77,6 +78,7 @@ const main = async () => {
 			...userSite,
 			base: siteBase,
 			name: state.SITE_NAME,
+			owner: state.SITE_OWNER,
 			root: state.ROOT_DIR,
 			pagesDir: state.PAGES_DIR,
 			componentsDir: state.COMPONENTS_DIR,
@@ -111,7 +113,7 @@ const main = async () => {
 		const startTime = performance.now()
 		await runHooks(state.USER_PRE_BUILD_HOOKS)
 		await runHooks(state.THEME_PRE_BUILD_HOOKS)
-		const { entry, htmlCache, pagesContext } = await buildHtmlEntries()
+		const { entry, htmlCache, pagesContext, rssContent } = await buildHtmlEntries()
 		const buildContext = pagesContext
 			? {
 					pagesContext,
@@ -129,6 +131,9 @@ const main = async () => {
 		if (state.PAGEFIND_ENABLED) {
 			await runPagefind()
 		}
+		if (state.RSS_ENABLED) {
+			await generateRssFeed(pagesContext, rssContent)
+		}
 		await runHooks(state.THEME_POST_BUILD_HOOKS, buildContext)
 		await runHooks(state.USER_POST_BUILD_HOOKS, buildContext)
 		const endTime = performance.now()

package/src/mdx.js

@@ -28,7 +28,7 @@ import rehypeStarryNight from 'rehype-starry-night'
 import { createStarryNight } from '@wooorm/starry-night'
 import remarkGfm from 'remark-gfm'
 import { HTMLRenderer } from './renderer.js'
-import { signal, computed, read, Suspense, nextTick } from 'refui'
+import { Suspense, nextTick } from 'refui'
 import { createPortal } from 'refui/extras'
 import { pathToFileURL } from 'url'
 import { existsSync } from 'fs'
@@ -38,7 +38,7 @@ import { resolveUserMdxConfig, withBase } from './config.js'
 import { methanolCtx } from './rehype-plugins/methanol-ctx.js'
 import { linkResolve } from './rehype-plugins/link-resolve.js'
 import { cached } from './utils.js'
-import { resetReframeRenderCount } from './components.js'
+import { resetReframeRenderCount, setReframeHydrationEnabled, getReframeHydrationEnabled } from './components.js'
 
 // Workaround for Vite: it doesn't support resolving module/virtual modules in script src in dev mode
 const resolveRewindInject = cached(() =>
@@ -145,27 +145,8 @@ export const buildPageContext = ({ routePath, path, pageMeta, pagesContext, lazy
 		getSiblings,
 		withBase
 	}
-	const resolvePagesTree = () =>
-		pagesContext.getPagesTree ? pagesContext.getPagesTree(routePath) : pagesContext.pagesTree || []
-	if (lazyPagesTree) {
-		let cachedTree = null
-		let hasTree = false
-		Object.defineProperty(ctx, 'pagesTree', {
-			enumerable: true,
-			get() {
-				if (!hasTree) {
-					cachedTree = resolvePagesTree()
-					hasTree = true
-				}
-				return cachedTree
-			},
-			set(value) {
-				cachedTree = value
-				hasTree = true
-			}
-		})
-	} else {
-		ctx.pagesTree = resolvePagesTree()
+	if (!lazyPagesTree) {
+		ctx.pagesTree = pagesContext.getPagesTree ? pagesContext.getPagesTree(routePath) : pagesContext.pagesTree || []
 	}
 	return ctx
 }
@@ -645,5 +626,48 @@ export const renderHtml = async ({ routePath, path, components, pagesContext, pa
 		)
 	})
 
-	return HTMLRenderer.serialize(renderResult)
+	const result = HTMLRenderer.serialize(renderResult)
+
+	return result
+}
+
+export const renderPageContent = async ({ routePath, path, components, pagesContext, pageMeta }) => {
+	const ctx = buildPageContext({
+		routePath,
+		path,
+		pageMeta,
+		pagesContext
+	})
+
+	await compilePageMdx(pageMeta, pagesContext, { ctx })
+
+	const prevHydration = getReframeHydrationEnabled()
+	const prevThemeHydration = state.THEME_ENV?.getHydrationEnabled?.()
+	setReframeHydrationEnabled(false)
+	state.THEME_ENV?.setHydrationEnabled?.(false)
+	const mdxComponent = pageMeta.mdxComponent
+	const PageContent = () => mdxComponent()
+
+	try {
+		const renderResult = await new Promise((resolve, reject) => {
+			const result = HTMLRenderer.c(
+				Suspense,
+				{
+					onLoad() {
+						nextTick(() => resolve(result))
+					},
+					catch({ error }) {
+						reject(error)
+					}
+				},
+				PageContent
+			)
+		})
+		return HTMLRenderer.serialize(renderResult)
+	} finally {
+		setReframeHydrationEnabled(prevHydration)
+		if (prevThemeHydration != null) {
+			state.THEME_ENV?.setHydrationEnabled?.(prevThemeHydration)
+		}
+	}
 }