methanol 0.0.20 → 0.0.22

package/src/main.js

@@ -20,14 +20,19 @@
 
 import { loadUserConfig, applyConfig } from './config.js'
 import { runViteDev } from './dev-server.js'
-import { buildHtmlEntries, runViteBuild } from './build-system.js'
+import { buildHtmlEntries, runViteBuild, scanHtmlEntries } from './build-system.js'
+import { buildPrecacheManifest, patchServiceWorker, writeWebManifest } from './pwa.js'
+import { terminateWorkers } from './workers/build-pool.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'
-import { readFile } from 'fs/promises'
+import { readFile, rm, mkdir, copyFile, cp } from 'fs/promises'
+import { resolve, dirname } from 'path'
 import { style, logger } from './logger.js'
+import { createStageLogger } from './stage-logger.js'
+import { preparePublicAssets } from './public-assets.js'
 
 const printBanner = async () => {
 	try {
@@ -111,9 +116,27 @@ const main = async () => {
 	}
 	if (isBuild) {
 		const startTime = performance.now()
+		const logEnabled = state.CURRENT_MODE === 'production' && cli.command === 'build' && !cli.CLI_VERBOSE
+		const stageLogger = createStageLogger(logEnabled)
 		await runHooks(state.USER_PRE_BUILD_HOOKS)
 		await runHooks(state.THEME_PRE_BUILD_HOOKS)
-		const { entry, htmlCache, pagesContext, rssContent } = await buildHtmlEntries()
+		const {
+			htmlEntries,
+			pagesContext,
+			rssContent,
+			renderScans,
+			renderScansById,
+			htmlStageDir,
+			workers,
+			assignments
+		} = await buildHtmlEntries({ keepWorkers: true })
+		const scanResult = await scanHtmlEntries(htmlEntries, renderScans)
+		const hasEntryModules = Array.isArray(scanResult.entryModules) && scanResult.entryModules.length > 0
+		const hasCommonScripts = Array.isArray(scanResult.commonScripts) && scanResult.commonScripts.length > 0
+		const hasCommonEntry = Boolean(scanResult.commonScriptEntry)
+		const hasAssetsEntry = Boolean(scanResult.assetsEntryPath)
+		const hasStaticHtmlInputs = htmlEntries.some((entry) => entry?.source === 'static' && entry.inputPath)
+		const shouldBundle = state.PWA_ENABLED || hasEntryModules || hasCommonScripts || hasCommonEntry || hasAssetsEntry || hasStaticHtmlInputs
 		const buildContext = pagesContext
 			? {
 					pagesContext,
@@ -125,15 +148,83 @@ const main = async () => {
 			: null
 		await runHooks(state.USER_PRE_BUNDLE_HOOKS, buildContext)
 		await runHooks(state.THEME_PRE_BUNDLE_HOOKS, buildContext)
-		await runViteBuild(entry, htmlCache)
-		await runHooks(state.THEME_POST_BUNDLE_HOOKS, buildContext)
-		await runHooks(state.USER_POST_BUNDLE_HOOKS, buildContext)
+
+		let finalizeToken = null
+		try {
+			if (shouldBundle) {
+				await runViteBuild({
+					...scanResult,
+					htmlEntries,
+					preWrite: async () => {
+						await runHooks(state.THEME_POST_BUNDLE_HOOKS, buildContext)
+						await runHooks(state.USER_POST_BUNDLE_HOOKS, buildContext)
+						await runHooks(state.USER_PRE_WRITE_HOOKS, buildContext)
+						await runHooks(state.THEME_PRE_WRITE_HOOKS, buildContext)
+					},
+					postWrite: async () => {
+						await runHooks(state.THEME_POST_WRITE_HOOKS, buildContext)
+						await runHooks(state.USER_POST_WRITE_HOOKS, buildContext)
+						finalizeToken = stageLogger.start('Finalizing build')
+					},
+					rewrite: {
+						pages: pagesContext?.pagesAll || pagesContext?.pages || [],
+						htmlStageDir,
+						scanResult,
+						renderScansById,
+						workers,
+						assignments
+					}
+				})
+			} else {
+				await runHooks(state.THEME_POST_BUNDLE_HOOKS, buildContext)
+				await runHooks(state.USER_POST_BUNDLE_HOOKS, buildContext)
+				await runHooks(state.USER_PRE_WRITE_HOOKS, buildContext)
+				await runHooks(state.THEME_PRE_WRITE_HOOKS, buildContext)
+				if (state.STATIC_DIR !== false && state.MERGED_ASSETS_DIR) {
+					await preparePublicAssets({
+						themeDir: state.THEME_ASSETS_DIR,
+						userDir: state.USER_ASSETS_DIR,
+						targetDir: state.MERGED_ASSETS_DIR
+					})
+				}
+				await rm(state.DIST_DIR, { recursive: true, force: true })
+				await mkdir(state.DIST_DIR, { recursive: true })
+				if (state.STATIC_DIR !== false && state.STATIC_DIR) {
+					await cp(state.STATIC_DIR, state.DIST_DIR, { recursive: true, dereference: true })
+				}
+				for (const entry of htmlEntries) {
+					const name = entry?.name
+					const stagePath = entry?.stagePath || entry?.inputPath
+					if (!name || !stagePath) continue
+					const distPath = resolve(state.DIST_DIR, `${name}.html`)
+					await mkdir(dirname(distPath), { recursive: true })
+					await copyFile(stagePath, distPath)
+				}
+				await runHooks(state.THEME_POST_WRITE_HOOKS, buildContext)
+				await runHooks(state.USER_POST_WRITE_HOOKS, buildContext)
+				finalizeToken = stageLogger.start('Finalizing build')
+			}
+		} finally {
+			if (workers) {
+				await terminateWorkers(workers)
+			}
+		}
+		await runHooks(state.THEME_FINALIZE_HOOKS, buildContext)
+		await runHooks(state.USER_FINALIZE_HOOKS, buildContext)
+		stageLogger.end(finalizeToken)
 		if (state.PAGEFIND_ENABLED) {
 			await runPagefind()
 		}
 		if (state.RSS_ENABLED) {
 			await generateRssFeed(pagesContext, rssContent)
 		}
+		if (state.PWA_ENABLED) {
+			await writeWebManifest({ distDir: state.DIST_DIR, options: state.PWA_OPTIONS })
+			const precache = await buildPrecacheManifest({ distDir: state.DIST_DIR, options: state.PWA_OPTIONS })
+			if (precache?.manifestHash) {
+				await patchServiceWorker({ distDir: state.DIST_DIR, manifestHash: precache.manifestHash })
+			}
+		}
 		await runHooks(state.THEME_POST_BUILD_HOOKS, buildContext)
 		await runHooks(state.USER_POST_BUILD_HOOKS, buildContext)
 		const endTime = performance.now()

package/src/mdx.js

@@ -49,6 +49,7 @@ const RWND_FALLBACK = HTMLRenderer.rawHTML(
 )
 
 let cachedHeadAssets = null
+let cachedSiteHeadAssets = null
 
 const resolveUserHeadAssets = () => {
 	if (cachedHeadAssets) {
@@ -125,6 +126,36 @@ const resolvePageHeadAssets = (page) => {
 	return assets
 }
 
+const resolveSiteHeadAssets = (ctx) => {
+	if (cachedSiteHeadAssets) {
+		return cachedSiteHeadAssets
+	}
+	const assets = []
+	const site = ctx?.site || {}
+	const feed = site.feed
+	if (feed?.enabled && feed.href) {
+		const label = feed.atom ? 'Atom' : 'RSS'
+		const name = typeof site.name === 'string' && site.name.trim() ? site.name : 'Site'
+		const type = feed.atom ? 'application/atom+xml' : 'application/rss+xml'
+		assets.push(
+			HTMLRenderer.c('link', {
+				rel: 'alternate',
+				type,
+				title: `${name} ${label}`,
+				href: feed.href
+			})
+		)
+	}
+	const pwa = site.pwa
+	if (state.CURRENT_MODE === 'production' && pwa?.enabled && pwa.manifestHref) {
+		assets.push(HTMLRenderer.c('link', { rel: 'manifest', href: pwa.manifestHref }))
+	}
+	if (state.CURRENT_MODE === 'production') {
+		cachedSiteHeadAssets = assets
+	}
+	return assets
+}
+
 export const buildPageContext = ({ routePath, path, pageMeta, pagesContext, lazyPagesTree = false }) => {
 	const page = pageMeta
 	const language = pagesContext.getLanguageForRoute ? pagesContext.getLanguageForRoute(routePath) : null
@@ -583,6 +614,7 @@ export const renderHtml = async ({ routePath, path, components, pagesContext, pa
 			resolveRewindInject(),
 			...resolveUserHeadAssets(),
 			...resolvePageHeadAssets(pageMeta),
+			...resolveSiteHeadAssets(ctx),
 			Outlet(),
 			RWND_FALLBACK
 		]
@@ -636,7 +668,8 @@ export const renderPageContent = async ({ routePath, path, components, pagesCont
 		routePath,
 		path,
 		pageMeta,
-		pagesContext
+		pagesContext,
+		lazyPagesTree: true
 	})
 
 	await compilePageMdx(pageMeta, pagesContext, { ctx })
@@ -646,7 +679,7 @@ export const renderPageContent = async ({ routePath, path, components, pagesCont
 	setReframeHydrationEnabled(false)
 	state.THEME_ENV?.setHydrationEnabled?.(false)
 	const mdxComponent = pageMeta.mdxComponent
-	const PageContent = () => mdxComponent()
+	const PageContent = () => mdxComponent({ components })
 
 	try {
 		const renderResult = await new Promise((resolve, reject) => {

package/src/pages-index.js

@@ -18,10 +18,18 @@
  * under the License.
  */
 
-import JSON5 from 'json5'
 import { extractExcerpt } from './text-utils.js'
 
-const OMIT_KEYS = new Set(['content', 'mdxComponent', 'mdxCtx', 'getSiblings'])
+const OMIT_KEYS = new Set([
+	'content',
+	'mdxComponent',
+	'mdxCtx',
+	'getSiblings',
+	'matter',
+	'path',
+	'exclude',
+	'segments'
+])
 
 const sanitizePage = (page) => {
 	const result = {}
@@ -38,5 +46,5 @@ export const serializePagesIndex = (pages) => {
 	const list = Array.isArray(pages)
 		? pages.filter((page) => !page?.hidden).map(sanitizePage)
 		: []
-	return JSON5.stringify(list)
+	return JSON.stringify(JSON.stringify(list))
 }

package/src/pages.js

@@ -34,7 +34,7 @@ const isIgnoredEntry = (name) => name.startsWith('.') || name.startsWith('_')
 
 const pageMetadataCache = new Map()
 const pageDerivedCache = new Map()
-const MDX_WORKER_URL = new URL('./workers/mdx-compile-worker.js', import.meta.url)
+const MDX_WORKER_URL = new URL('./workers/entry-mdx-compile-worker.js', import.meta.url)
 const cliOverrides = {
 	CLI_INTERMEDIATE_DIR: cli.CLI_INTERMEDIATE_DIR,
 	CLI_EMIT_INTERMEDIATE: cli.CLI_EMIT_INTERMEDIATE,
@@ -523,13 +523,14 @@ export const buildPageEntry = async ({ path, pagesDir, source }) => {
 	const isSpecialPage = isNotFoundPage || isOfflinePage
 	const isSiteRoot = routePath === '/'
 	const frontmatterIsRoot = Boolean(metadata.frontmatter?.isRoot)
-	const hidden = isSpecialPage
-		? true
-		: frontmatterHidden === false
+	const hidden =
+		frontmatterHidden === false
 			? false
 			: frontmatterHidden === true
 				? true
-				: frontmatterIsRoot
+				: isSpecialPage
+					? true
+					: frontmatterIsRoot
 	return {
 		routePath,
 		routeHref: withBase(routePath),
@@ -608,12 +609,12 @@ const collectPages = async () => {
 }
 
 const buildIndexFallback = (pages, siteName) => {
+	const isSpecialPage = (page) => page?.routePath === '/404' || page?.routePath === '/offline'
 	const visiblePages = pages
 		.filter(
 			(page) =>
 				page.routePath !== '/' &&
-				page.routePath !== '/404' &&
-				page.routePath !== '/offline'
+				(!(isSpecialPage(page)) || page.hidden === false)
 		)
 		.sort((a, b) => a.routePath.localeCompare(b.routePath))
 
@@ -694,6 +695,11 @@ const buildNavSequence = (nodes, pagesByRoute) => {
 
 export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDirs } = {}) => {
 	const pageList = Array.isArray(pages) ? pages : []
+	const pagesAll = pageList
+	const isSpecialPage = (page) => page?.routePath === '/404' || page?.routePath === '/offline'
+	const listForNavigation = pageList.filter(
+		(page) => !(isSpecialPage(page) && page.hidden !== false)
+	)
 	const routeExcludes = excludedRoutes || new Set()
 	const dirExcludes = excludedDirs || new Set()
 	const pagesByRoute = new Map()
@@ -705,7 +711,7 @@ export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDir
 	const getPageByRoute = (routePath, options = {}) => {
 		const { path } = options || {}
 		if (path) {
-			for (const page of pages) {
+			for (const page of pagesAll) {
 				if (page.routePath === routePath && page.path === path) {
 					return page
 				}
@@ -715,7 +721,7 @@ export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDir
 	}
 	const filterPagesForRoot = (rootPath) => {
 		const normalizedRoot = normalizeRoutePath(rootPath || '/')
-		return pages.filter((page) => {
+		return listForNavigation.filter((page) => {
 			const resolvedRoot = resolveRootPath(page.routePath, pagesByRoute)
 			if (normalizedRoot === '/') {
 				return resolvedRoot === '/' || page.routePath === resolvedRoot
@@ -783,6 +789,13 @@ export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDir
 				href: withBase(feedPath)
 			}
 		: { enabled: false }
+	const pwa = state.PWA_ENABLED
+		? {
+				enabled: true,
+				manifestPath: '/manifest.webmanifest',
+				manifestHref: withBase('/manifest.webmanifest')
+			}
+		: { enabled: false }
 	const site = {
 		...userSite,
 		base: siteBase,
@@ -800,11 +813,13 @@ export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDir
 			build: state.PAGEFIND_BUILD || null
 		},
 		feed,
+		pwa,
 		generatedAt: new Date().toISOString()
 	}
 	const excludedDirPaths = new Set(Array.from(dirExcludes).map((dir) => `/${dir}`))
 	const pagesContext = {
-		pages: pageList,
+		pages: listForNavigation,
+		pagesAll,
 		pagesByRoute,
 		getPageByRoute,
 		pagesTree: pagesTreeGlobal,
@@ -864,7 +879,7 @@ export const createPagesContextFromPages = ({ pages, excludedRoutes, excludedDir
 			}
 		},
 		refreshLanguages: () => {
-			pagesContext.languages = collectLanguagesFromPages(pages)
+			pagesContext.languages = collectLanguagesFromPages(pagesAll)
 			pagesContext.getLanguageForRoute = (routePath) =>
 				resolveLanguageForRoute(pagesContext.languages, routePath)
 		},

package/src/pwa.js

@@ -0,0 +1,240 @@
+/* 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 { createHash } from 'crypto'
+import { existsSync } from 'fs'
+import { readFile, writeFile } from 'fs/promises'
+import { resolve } from 'path'
+import fg from 'fast-glob'
+import picomatch from 'picomatch'
+import { normalizePath } from 'vite'
+import { state } from './state.js'
+import { resolveBasePrefix } from './config.js'
+
+const DEFAULT_PRECACHE = {
+	include: ['**/*.{html,js,css,ico,png,svg,webp,jpg,jpeg,gif,woff,woff2,ttf}'],
+	exclude: ['**/*.map', '**/pagefind/**'],
+	priority: null,
+	limit: null,
+	batchSize: null
+}
+
+const DEFAULT_INSTALL_PRIORITY_MAX = 2
+const TEXT_EXTS = new Set([
+	'.css',
+	'.js',
+	'.mjs',
+	'.json',
+	'.txt',
+	'.xml',
+	'.webmanifest'
+])
+const BINARY_EXTS = new Set([
+	'.png',
+	'.jpg',
+	'.jpeg',
+	'.gif',
+	'.webp',
+	'.avif',
+	'.svg',
+	'.ico',
+	'.bmp',
+	'.woff',
+	'.woff2',
+	'.ttf',
+	'.otf',
+	'.eot',
+	'.mp3',
+	'.wav',
+	'.ogg',
+	'.mp4',
+	'.webm',
+	'.pdf'
+])
+
+const normalizeList = (value, fallback) => {
+	if (Array.isArray(value)) return value.filter(Boolean)
+	if (typeof value === 'string') return [value]
+	return fallback
+}
+
+export const resolvePwaOptions = (input) => {
+	if (input === true) {
+		return { enabled: true, options: { precache: { ...DEFAULT_PRECACHE } } }
+	}
+	if (input && typeof input === 'object') {
+		const precache = resolvePrecacheOptions(input.precache)
+		return { enabled: true, options: { ...input, precache } }
+	}
+	if (input === false) {
+		return { enabled: false, options: null }
+	}
+	return { enabled: false, options: null }
+}
+
+export const resolvePrecacheOptions = (input) => {
+	const precache = input && typeof input === 'object' ? input : {}
+	return {
+		include: normalizeList(precache.include, DEFAULT_PRECACHE.include),
+		exclude: normalizeList(precache.exclude, DEFAULT_PRECACHE.exclude),
+		priority: Array.isArray(precache.priority) ? precache.priority : DEFAULT_PRECACHE.priority,
+		limit: Number.isFinite(precache.limit) && precache.limit >= 0 ? precache.limit : null,
+		batchSize: Number.isFinite(precache.batchSize) ? precache.batchSize : null
+	}
+}
+
+const hashMd5 = (value) => createHash('md5').update(value).digest('hex')
+
+const joinBase = (prefix, value) => {
+	if (!prefix) return value
+	if (value.startsWith(prefix)) return value
+	return `${prefix}${value}`
+}
+
+const isRootOrAssets = (relativePath) => {
+	if (relativePath.startsWith('assets/')) return true
+	return !relativePath.includes('/')
+}
+
+const getExtension = (relativePath) => {
+	const index = relativePath.lastIndexOf('.')
+	if (index === -1) return ''
+	return relativePath.slice(index).toLowerCase()
+}
+
+const isTextAsset = (relativePath) => TEXT_EXTS.has(getExtension(relativePath))
+const isBinaryAsset = (relativePath) => BINARY_EXTS.has(getExtension(relativePath))
+
+const resolveDefaultPriority = (relativePath) => {
+	const lower = relativePath.toLowerCase()
+	if (lower === 'offline.html' || lower === '404.html') return 0
+	if (relativePath.startsWith('assets/') && isTextAsset(relativePath)) return 0
+	if (lower.endsWith('.html')) return 1
+	if (isBinaryAsset(relativePath)) return 3
+	if (isTextAsset(relativePath)) return 2
+	if (isRootOrAssets(relativePath)) return 2
+	return 3
+}
+
+const resolvePriorityBuckets = (priority) => {
+	if (!Array.isArray(priority) || priority.length === 0) return null
+	const buckets = []
+	for (const entry of priority) {
+		if (typeof entry === 'function') {
+			buckets.push(entry)
+			continue
+		}
+		if (typeof entry === 'string' || Array.isArray(entry)) {
+			const matcher = picomatch(entry)
+			buckets.push((item) => matcher(item.path))
+			continue
+		}
+		if (entry && typeof entry === 'object') {
+			if (typeof entry.test === 'function') {
+				buckets.push(entry.test)
+				continue
+			}
+			const match = entry.match || entry.include
+			if (typeof match === 'string' || Array.isArray(match)) {
+				const matcher = picomatch(match)
+				buckets.push((item) => matcher(item.path))
+			}
+		}
+	}
+	return buckets.length ? buckets : null
+}
+
+const resolvePriority = (relativePath, buckets) => {
+	if (!buckets || !buckets.length) return resolveDefaultPriority(relativePath)
+	const item = { path: relativePath }
+	for (let i = 0; i < buckets.length; i += 1) {
+		try {
+			if (buckets[i](item)) return i
+		} catch {}
+	}
+	return buckets.length
+}
+
+export const writeWebManifest = async ({ distDir, options }) => {
+	if (!options) return null
+	const manifest = {
+		name: state.SITE_NAME,
+		short_name: state.SITE_NAME,
+		...(options.manifest || {})
+	}
+	const outPath = resolve(distDir, 'manifest.webmanifest')
+	await writeFile(outPath, JSON.stringify(manifest, null, 2))
+	return outPath
+}
+
+export const buildPrecacheManifest = async ({ distDir, options }) => {
+	if (!options) return null
+	const precache = resolvePrecacheOptions(options.precache)
+	const basePrefix = resolveBasePrefix()
+	const buckets = resolvePriorityBuckets(precache.priority)
+	const files = (await fg(precache.include, {
+		cwd: distDir,
+		onlyFiles: true,
+		dot: false,
+		ignore: precache.exclude
+	})).filter((file) => normalizePath(file) !== 'precache-manifest.json')
+	const entries = []
+	for (const file of files.sort()) {
+		const normalized = normalizePath(file)
+		const fsPath = resolve(distDir, file)
+		if (!existsSync(fsPath)) continue
+		const content = await readFile(fsPath)
+		const revision = hashMd5(content)
+		const url = joinBase(basePrefix, `/${normalized}`)
+		const priority = resolvePriority(normalized, buckets)
+		entries.push({ url, revision, priority })
+	}
+	entries.sort((a, b) => {
+		if (a.priority !== b.priority) return a.priority - b.priority
+		return a.url.localeCompare(b.url)
+	})
+	if (precache.limit && entries.length > precache.limit) {
+		entries.length = precache.limit
+	}
+	const installCount = entries.filter((entry) => entry.priority <= DEFAULT_INSTALL_PRIORITY_MAX).length
+	const manifestBody = {
+		entries: entries.map(({ url, revision }) => ({ url, revision })),
+		installCount,
+		batchSize: precache.batchSize
+	}
+	const manifestHash = hashMd5(JSON.stringify(manifestBody))
+	const manifest = { ...manifestBody, hash: manifestHash }
+	const manifestPath = resolve(distDir, 'precache-manifest.json')
+	await writeFile(manifestPath, JSON.stringify(manifest, null, 2))
+	return { manifestPath, manifestHash }
+}
+
+export const patchServiceWorker = async ({ distDir, manifestHash }) => {
+	if (!manifestHash) return false
+	const swPath = resolve(distDir, 'sw.js')
+	if (!existsSync(swPath)) return false
+	const raw = await readFile(swPath, 'utf-8')
+	if (!raw.includes('__METHANOL_MANIFEST_HASH__')) return false
+	const next = raw.replace(/__METHANOL_MANIFEST_HASH__/g, manifestHash)
+	if (next !== raw) {
+		await writeFile(swPath, next)
+	}
+	return true
+}

package/src/state.js

@@ -169,19 +169,25 @@ const parser = yargs(hideBin(process.argv))
 	.wrap(null)
 
 const argv = parser.parseSync()
+const parsedCommand = argv._[0] ? String(argv._[0]) : null
+const isServeCommand = parsedCommand === 'serve' || parsedCommand === 'preview'
+const rawInput = argv.input || null
+const rawOutput = argv.output || null
+const normalizedInput = isServeCommand && rawInput && !rawOutput ? null : rawInput
+const normalizedOutput = isServeCommand && rawInput && !rawOutput ? rawInput : rawOutput
 
 export const cli = {
 	argv,
-	command: argv._[0] ? String(argv._[0]) : null,
+	command: parsedCommand,
 	showHelp: () => parser.showHelp(),
 	CLI_INTERMEDIATE_DIR: argv['intermediate-dir'] || null,
 	CLI_EMIT_INTERMEDIATE: Boolean(argv['emit-intermediate']),
 	CLI_HOST: argv.host ?? null,
 	CLI_PORT: typeof argv.port === 'number' ? argv.port : null,
-	CLI_PAGES_DIR: argv.input || null,
+	CLI_PAGES_DIR: normalizedInput,
 	CLI_COMPONENTS_DIR: argv.components || null,
 	CLI_ASSETS_DIR: argv.assets || null,
-	CLI_OUTPUT_DIR: argv.output || null,
+	CLI_OUTPUT_DIR: normalizedOutput,
 	CLI_CONFIG_PATH: argv.config || null,
 	CLI_SITE_NAME: argv['site-name'] || null,
 	CLI_OWNER: argv.owner || null,
@@ -231,10 +237,16 @@ export const state = {
 	USER_POST_BUILD_HOOKS: [],
 	USER_PRE_BUNDLE_HOOKS: [],
 	USER_POST_BUNDLE_HOOKS: [],
+	USER_PRE_WRITE_HOOKS: [],
+	USER_POST_WRITE_HOOKS: [],
+	USER_FINALIZE_HOOKS: [],
 	THEME_PRE_BUILD_HOOKS: [],
 	THEME_POST_BUILD_HOOKS: [],
 	THEME_PRE_BUNDLE_HOOKS: [],
 	THEME_POST_BUNDLE_HOOKS: [],
+	THEME_PRE_WRITE_HOOKS: [],
+	THEME_POST_WRITE_HOOKS: [],
+	THEME_FINALIZE_HOOKS: [],
 	STARRY_NIGHT_ENABLED: false,
 	STARRY_NIGHT_OPTIONS: null,
 	WORKER_JOBS: 0,

package/src/utils.js

@@ -22,7 +22,7 @@ import NullProtoObj from 'null-prototype-object'
 
 export const cached = (fn) => {
 	let cache = null
-	return () => (cache ?? (cache = fn()))
+	return (...args) => (cache ?? (cache = fn(...args)))
 }
 
 export const cachedStr = (fn) => {

package/src/vite-plugins.js

@@ -137,7 +137,7 @@ const virtualModuleMap = {
 		return PAGEFIND_LOADER_SCRIPT()
 	},
 	get 'pwa-inject'() {
-		if (state.PWA_ENABLED) {
+		if (state.PWA_ENABLED && state.CURRENT_MODE === 'production') {
 			return PWA_INJECT_SCRIPT()
 		}
 
@@ -145,7 +145,7 @@ const virtualModuleMap = {
 	},
 	get pages() {
 		const pages = state.PAGES_CONTEXT?.pages || []
-		return `export const pages = ${serializePagesIndex(pages)}\nexport default pages`
+		return `export const pages = JSON.parse(${serializePagesIndex(pages)})\nexport default pages`
 	}
 }
 
@@ -162,6 +162,10 @@ export const methanolResolverPlugin = () => {
 	return {
 		name: 'methanol-resolver',
 		resolveId(id) {
+			if (id.startsWith('/.methanol/')) {
+				return resolve(state.PAGES_DIR, '.methanol', id.slice('/.methanol/'.length))
+			}
+
 			if (id === 'refui' || id.startsWith('refui/')) {
 				try {
 					return projectRequire.resolve(id)

package/src/workers/build-pool.js

@@ -22,7 +22,7 @@ import { cpus } from 'os'
 import { Worker } from 'worker_threads'
 import { state, cli } from '../state.js'
 
-const BUILD_WORKER_URL = new URL('./build-worker.js', import.meta.url)
+const BUILD_WORKER_URL = new URL('./entry-build-worker.js', import.meta.url)
 const cliOverrides = {
 	CLI_INTERMEDIATE_DIR: cli.CLI_INTERMEDIATE_DIR,
 	CLI_EMIT_INTERMEDIATE: cli.CLI_EMIT_INTERMEDIATE,