methanol 0.0.1 → 0.0.3

package/src/mdx.js

@@ -24,12 +24,13 @@ import * as JSXDevFactory from 'refui/jsx-dev-runtime'
 import rehypeSlug from 'rehype-slug'
 import extractToc from '@stefanprobst/rehype-extract-toc'
 import withTocExport from '@stefanprobst/rehype-extract-toc/mdx'
+import rehypeStarryNight from 'rehype-starry-night'
 import { HTMLRenderer } from './renderer.js'
 import { signal, computed, read, Suspense, nextTick } from 'refui'
 import { createPortal } from 'refui/extras'
 import { pathToFileURL } from 'url'
 import { existsSync } from 'fs'
-import { resolve } from 'path'
+import { resolve, dirname, basename, relative } from 'path'
 import { state } from './state.js'
 import { resolveUserMdxConfig } from './config.js'
 import { methanolCtx } from './rehype-plugins/methanol-ctx.js'
@@ -71,21 +72,113 @@ const resolveUserHeadAssets = () => {
 	return assets
 }
 
-export const buildPageContext = ({ routePath, filePath, pageMeta, pagesContext }) => {
+const resolvePageAssetUrl = (page, filePath) => {
+	const root = page?.source === 'theme' && state.THEME_PAGES_DIR
+		? state.THEME_PAGES_DIR
+		: state.PAGES_DIR
+	if (!root) return null
+	const relPath = relative(root, filePath).replace(/\\/g, '/')
+	if (!relPath || relPath.startsWith('..')) return null
+	return `/${relPath}`
+}
+
+const resolvePageHeadAssets = (page) => {
+	if (!page?.filePath) return []
+	const baseDir = dirname(page.filePath)
+	const baseName = basename(page.filePath).replace(/\.(mdx|md)$/, '')
+	const pagesRoot = state.PAGES_DIR ? resolve(state.PAGES_DIR) : null
+	const isRootIndex =
+		pagesRoot && baseName === 'index' && resolve(baseDir) === pagesRoot && page.source !== 'theme'
+	const isRootStylePage =
+		pagesRoot && baseName === 'style' && resolve(baseDir) === pagesRoot && page.source !== 'theme'
+	const assets = []
+	const cssPath = resolve(baseDir, `${baseName}.css`)
+	if (existsSync(cssPath)) {
+		if (isRootStylePage) {
+			const rootStyle = resolve(pagesRoot, 'style.css')
+			if (cssPath === rootStyle) {
+				return assets
+			}
+		}
+		const href = resolvePageAssetUrl(page, cssPath)
+		if (href) {
+			assets.push(HTMLRenderer.c('link', { rel: 'stylesheet', href }))
+		}
+	}
+	const scriptExtensions = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts']
+	let scriptPath = null
+	for (const ext of scriptExtensions) {
+		const candidate = resolve(baseDir, `${baseName}${ext}`)
+		if (existsSync(candidate)) {
+			scriptPath = candidate
+			break
+		}
+	}
+	if (scriptPath) {
+		if (isRootIndex) {
+			const rootIndexJs = resolve(pagesRoot, 'index.js')
+			const rootIndexTs = resolve(pagesRoot, 'index.ts')
+			if (scriptPath === rootIndexJs || scriptPath === rootIndexTs) {
+				return assets
+			}
+		}
+		const src = resolvePageAssetUrl(page, scriptPath)
+		if (src) {
+			assets.push(HTMLRenderer.c('script', { type: 'module', src }))
+		}
+	}
+	return assets
+}
+
+export const buildPageContext = ({
+	routePath,
+	filePath,
+	pageMeta,
+	pagesContext,
+	lazyPagesTree = false
+}) => {
 	const page = pageMeta
-	const pagesTree = pagesContext?.getPagesTree ? pagesContext.getPagesTree(routePath) : pagesContext?.pagesTree || []
 	const language = pagesContext?.getLanguageForRoute ? pagesContext.getLanguageForRoute(routePath) : null
-	return {
+	const getSiblings = pagesContext?.getSiblings
+		? () => pagesContext.getSiblings(routePath, page?.filePath || filePath)
+		: null
+	if (page && getSiblings && page.getSiblings !== getSiblings) {
+		page.getSiblings = getSiblings
+	}
+	const ctx = {
 		routePath,
 		filePath,
 		page,
 		pages: pagesContext?.pages || [],
-		pagesTree,
 		pagesByRoute: pagesContext?.pagesByRoute || new Map(),
 		languages: pagesContext?.languages || [],
 		language,
-		site: pagesContext?.site || null
+		site: pagesContext?.site || null,
+		getSiblings
+	}
+	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()
 	}
+	return ctx
 }
 
 const findTitleFromToc = (toc = []) => {
@@ -121,7 +214,39 @@ const findTitleFromToc = (toc = []) => {
 
 let cachedMdxConfig = null
 
-const resolveMdxConfig = async () => {
+const normalizeStarryNightConfig = (value) => {
+	if (value == null) return null
+	if (typeof value === 'boolean') {
+		return { enabled: value, options: null }
+	}
+	if (typeof value !== 'object') return null
+	const { enabled, options, ...rest } = value
+	if (enabled === false) return { enabled: false, options: null }
+	if (options && typeof options === 'object') {
+		return { enabled: true, options: { ...options } }
+	}
+	if (Object.keys(rest).length) {
+		return { enabled: true, options: { ...rest } }
+	}
+	return { enabled: true, options: null }
+}
+
+const resolveStarryNightForPage = (frontmatter) => {
+	const base = {
+		enabled: state.STARRY_NIGHT_ENABLED === true,
+		options: state.STARRY_NIGHT_OPTIONS || null
+	}
+	if (!frontmatter || !Object.prototype.hasOwnProperty.call(frontmatter, 'starryNight')) {
+		return base
+	}
+	const override = normalizeStarryNightConfig(frontmatter.starryNight)
+	if (!override) return base
+	if (override.enabled === false) return { enabled: false, options: null }
+	const options = override.options != null ? override.options : base.options
+	return { enabled: true, options }
+}
+
+const resolveBaseMdxConfig = async () => {
 	const userMdxConfig = await resolveUserMdxConfig()
 	if (cachedMdxConfig) {
 		return cachedMdxConfig
@@ -135,16 +260,33 @@ const resolveMdxConfig = async () => {
 		rehypePlugins: [rehypeSlug, extractToc, [withTocExport, { name: 'toc' }]]
 	}
 	const mdxConfig = { ...baseMdxConfig, ...userMdxConfig }
-	if (userMdxConfig.rehypePlugins.length) {
-		mdxConfig.rehypePlugins = [...baseMdxConfig.rehypePlugins, ...userMdxConfig.rehypePlugins]
-	}
+	const userRehypePlugins = Array.isArray(userMdxConfig.rehypePlugins) ? userMdxConfig.rehypePlugins : []
+	mdxConfig.rehypePlugins = [...baseMdxConfig.rehypePlugins, ...userRehypePlugins]
 	mdxConfig.rehypePlugins.push(linkResolve)
 	mdxConfig.rehypePlugins.push(methanolCtx)
 	return (cachedMdxConfig = mdxConfig)
 }
 
+const resolveMdxConfigForPage = async (frontmatter) => {
+	const baseConfig = await resolveBaseMdxConfig()
+	const mdxConfig = {
+		...baseConfig,
+		rehypePlugins: [...baseConfig.rehypePlugins]
+	}
+	const starryNightConfig = resolveStarryNightForPage(frontmatter)
+	if (!starryNightConfig.enabled) return mdxConfig
+	const plugin = starryNightConfig.options ? [rehypeStarryNight, starryNightConfig.options] : [rehypeStarryNight]
+	const insertIndex = mdxConfig.rehypePlugins.indexOf(linkResolve)
+	if (insertIndex >= 0) {
+		mdxConfig.rehypePlugins.splice(insertIndex, 0, plugin)
+	} else {
+		mdxConfig.rehypePlugins.push(plugin)
+	}
+	return mdxConfig
+}
+
 export const compileMdx = async ({ content, filePath, ctx }) => {
-	const mdxConfig = await resolveMdxConfig()
+	const mdxConfig = await resolveMdxConfigForPage(ctx?.page?.frontmatter)
 	const runtimeFactory = mdxConfig.development ? JSXDevFactory : JSXFactory
 	const compiled = await compile({ value: content, path: filePath }, mdxConfig)
 
@@ -156,17 +298,22 @@ export const compileMdx = async ({ content, filePath, ctx }) => {
 	})
 }
 
-export const compilePageMdx = async (page, pagesContext) => {
+export const compilePageMdx = async (page, pagesContext, options = {}) => {
 	if (!page || page.content == null || page.mdxComponent) return
-	const mdxModule = await compileMdx({
-		content: page.content,
-		filePath: page.filePath,
-		ctx: buildPageContext({
+	const { ctx = null, lazyPagesTree = false, refreshPagesTree = true } = options || {}
+	const activeCtx =
+		ctx ||
+		buildPageContext({
 			routePath: page.routePath,
 			filePath: page.filePath,
 			pageMeta: page,
-			pagesContext
+			pagesContext,
+			lazyPagesTree
 		})
+	const mdxModule = await compileMdx({
+		content: page.content,
+		filePath: page.filePath,
+		ctx: activeCtx
 	})
 	page.mdxComponent = mdxModule.default
 	page.toc = mdxModule.toc
@@ -181,11 +328,10 @@ export const compilePageMdx = async (page, pagesContext) => {
 		}
 	}
 	if (typeof pagesContext?.setDerivedTitle === 'function') {
-		pagesContext.setDerivedTitle(
-			page.filePath,
-			shouldUseTocTitle ? page.title : null,
-			page.toc
-		)
+		pagesContext.setDerivedTitle(page.filePath, shouldUseTocTitle ? page.title : null, page.toc)
+	}
+	if (ctx && refreshPagesTree && pagesContext?.getPagesTree) {
+		ctx.pagesTree = pagesContext.getPagesTree(activeCtx.routePath)
 	}
 }
 
@@ -208,13 +354,19 @@ export const renderHtml = async ({
 		pageMeta,
 		pagesContext
 	})
+	await compilePageMdx(pageMeta, pagesContext, { ctx })
 
 	const [Head, Outlet] = createPortal()
 	const ExtraHead = () => {
-		return [RWND_INJECT, ...resolveUserHeadAssets(), Outlet(), RWND_FALLBACK]
+		return [
+			RWND_INJECT,
+			...resolveUserHeadAssets(),
+			...resolvePageHeadAssets(pageMeta),
+			Outlet(),
+			RWND_FALLBACK
+		]
 	}
 
-	await compilePageMdx(pageMeta, pagesContext)
 	const mdxComponent = pageMeta?.mdxComponent
 
 	const Page = ({ components: extraComponents, ...props }, ...children) =>

package/src/pagefind.js

@@ -20,7 +20,7 @@
 
 import { access } from 'fs/promises'
 import { constants } from 'fs'
-import { join } from 'path'
+import { join, delimiter } from 'path'
 import { spawn } from 'child_process'
 import { state } from './state.js'
 
@@ -36,6 +36,14 @@ const resolvePagefindBin = async () => {
 			return candidate
 		} catch {}
 	}
+	const pathEntries = (process.env.PATH || '').split(delimiter).filter(Boolean)
+	for (const entry of pathEntries) {
+		const candidate = join(entry, binName)
+		try {
+			await access(candidate, constants.X_OK)
+			return candidate
+		} catch {}
+	}
 	return null
 }
 
@@ -88,7 +96,7 @@ export const runPagefind = async () => {
 		return false
 	}
 	console.log('Running Pagefind search indexing...')
-	const extraArgs = buildArgsFromOptions(state.PAGEFIND_BUILD_OPTIONS)
+	const extraArgs = buildArgsFromOptions(state.PAGEFIND_BUILD)
 	const ok = await runCommand(bin, ['--site', state.DIST_DIR, ...extraArgs], {
 		cwd: state.PROJECT_ROOT
 	})

package/src/pages.js

@@ -28,7 +28,7 @@ import { createStageLogger } from './stage-logger.js'
 
 const isPageFile = (name) => name.endsWith('.mdx') || name.endsWith('.md')
 const isInternalPage = (name) => name.startsWith('_') || name.startsWith('.')
-const isIgnoredEntry = (name) => name.startsWith('.')
+const isIgnoredEntry = (name) => name.startsWith('.') || name.startsWith('_')
 
 const pageMetadataCache = new Map()
 const pageDerivedCache = new Map()
@@ -41,10 +41,18 @@ const collectLanguagesFromPages = (pages = []) => {
 		if (label == null || label === '') continue
 		const routePath = page.routePath || '/'
 		const href = page.routeHref || routePath || '/'
+		const frontmatterCode = page?.frontmatter?.langCode
+		const code =
+			typeof frontmatterCode === 'string' && frontmatterCode.trim()
+				? frontmatterCode.trim()
+				: routePath === '/'
+					? null
+					: routePath.replace(/^\/+/, '')
 		languages.set(routePath, {
 			routePath,
 			href,
-			label: String(label)
+			label: String(label),
+			code: code || null
 		})
 	}
 	return Array.from(languages.values()).sort((a, b) => a.href.localeCompare(b.href))
@@ -103,7 +111,13 @@ export const routePathFromFile = (filePath, pagesDir = state.PAGES_DIR) => {
 
 const parseFrontmatter = (raw) => {
 	const parsed = matter(raw)
-	const data = parsed.data || {}
+	const data = { ...(parsed.data || {}) }
+	if (data.excerpt == null && data.description != null) {
+		data.excerpt = data.description
+	}
+	if (data.description == null && data.excerpt != null) {
+		data.description = data.excerpt
+	}
 	const content = parsed.content ?? ''
 	return {
 		data,
@@ -150,7 +164,19 @@ const buildPagesTree = (pages, options = {}) => {
 	const rootPath = normalizeRoutePath(options.rootPath || '/')
 	const rootDir = rootPath === '/' ? '' : rootPath.replace(/^\/+/, '')
 	const includeHiddenRoot = Boolean(options.includeHiddenRoot)
+	const currentRoutePath = normalizeRoutePath(options.currentRoutePath || '/')
 	const rootSegments = rootDir ? rootDir.split('/') : []
+	const resolveRouteWithinRoot = (routePath) => {
+		if (!routePath) return '/'
+		if (!rootDir) return routePath
+		if (routePath === rootPath) return '/'
+		if (routePath.startsWith(`${rootPath}/`)) {
+			const stripped = routePath.slice(rootPath.length)
+			return stripped.startsWith('/') ? stripped : `/${stripped}`
+		}
+		return routePath
+	}
+	const currentRouteWithinRoot = resolveRouteWithinRoot(currentRoutePath)
 	const isUnderRoot = (page) => {
 		if (!rootDir) return true
 		return page.routePath === rootPath || page.routePath.startsWith(`${rootPath}/`)
@@ -179,6 +205,18 @@ const buildPagesTree = (pages, options = {}) => {
 			.filter((page) => page.isIndex && page.dir && page.hidden && !(includeHiddenRoot && page.routePath === rootPath))
 			.map((page) => page.dir)
 	)
+	const exposedHiddenDirs = new Set()
+	if (currentRoutePath && currentRoutePath !== '/' && hiddenDirs.size) {
+		for (const hiddenDir of hiddenDirs) {
+			const hiddenRoute = `/${hiddenDir}`
+			if (
+				currentRouteWithinRoot === hiddenRoute ||
+				currentRouteWithinRoot.startsWith(`${hiddenRoute}/`)
+			) {
+				exposedHiddenDirs.add(hiddenDir)
+			}
+		}
+	}
 	if (includeHiddenRoot && rootDir) {
 		for (const hiddenDir of Array.from(hiddenDirs)) {
 			if (rootDir === hiddenDir || rootDir.startsWith(`${hiddenDir}/`)) {
@@ -186,6 +224,11 @@ const buildPagesTree = (pages, options = {}) => {
 			}
 		}
 	}
+	if (exposedHiddenDirs.size) {
+		for (const hiddenDir of exposedHiddenDirs) {
+			hiddenDirs.delete(hiddenDir)
+		}
+	}
 	const isUnderHiddenDir = (dir) => {
 		if (!dir) return false
 		const parts = dir.split('/')
@@ -215,9 +258,25 @@ const buildPagesTree = (pages, options = {}) => {
 		dirs.set(path, dir)
 		return dir
 	}
+	const isUnderExposedHiddenDir = (dir) => {
+		if (!dir || !exposedHiddenDirs.size) return false
+		for (const hiddenDir of exposedHiddenDirs) {
+			if (dir === hiddenDir || dir.startsWith(`${hiddenDir}/`)) {
+				return true
+			}
+		}
+		return false
+	}
 	for (const page of treePages) {
 		if (page.hidden && !(includeHiddenRoot && page.routePath === rootPath)) {
-			continue
+			const isHidden404 = page.routePath === '/404'
+			const shouldExposeHidden =
+				!isHidden404 &&
+				page.hiddenByFrontmatter === true &&
+				(page.routePath === currentRoutePath || isUnderExposedHiddenDir(page.dir))
+			if (!shouldExposeHidden) {
+				continue
+			}
 		}
 		if (isUnderHiddenDir(page.dir)) {
 			continue
@@ -352,6 +411,7 @@ export const buildPageEntry = async ({ filePath, pagesDir, source }) => {
 	const derived = pageDerivedCache.get(filePath)
 	const exclude = Boolean(metadata.frontmatter?.exclude)
 	const frontmatterHidden = metadata.frontmatter?.hidden
+	const hiddenByFrontmatter = frontmatterHidden === true
 	const isNotFoundPage = routePath === '/404'
 	const hidden = frontmatterHidden === false
 		? false
@@ -375,6 +435,7 @@ export const buildPageEntry = async ({ filePath, pagesDir, source }) => {
 		date: parseDate(metadata.frontmatter?.date) || parseDate(stats.mtime),
 		isRoot: Boolean(metadata.frontmatter?.isRoot),
 		hidden,
+		hiddenByFrontmatter,
 		exclude,
 		content: metadata.content,
 		frontmatter: metadata.frontmatter,
@@ -479,6 +540,38 @@ const resolveRootPath = (routePath, pagesByRoute, pagesByRouteIndex = null) => {
 	return '/'
 }
 
+const buildNavSequence = (nodes, pagesByRoute) => {
+	const result = []
+	const seen = new Set()
+	const addEntry = (entry) => {
+		if (!entry?.routePath) return
+		const key = entry.filePath || entry.routePath
+		if (seen.has(key)) return
+		seen.add(key)
+		result.push(entry)
+	}
+	const walk = (items = []) => {
+		for (const node of items) {
+			if (node.type === 'directory') {
+				if (node.routePath) {
+					const page = pagesByRoute.get(node.routePath) || node.page || null
+					if (page) addEntry(page)
+				}
+				if (node.children?.length) {
+					walk(node.children)
+				}
+				continue
+			}
+			if (node.type === 'page') {
+				const page = pagesByRoute.get(node.routePath) || node
+				addEntry(page)
+			}
+		}
+	}
+	walk(nodes)
+	return result
+}
+
 export const buildPagesContext = async ({ compileAll = true } = {}) => {
 	const logEnabled = state.CURRENT_MODE === 'production' && cli.command === 'build'
 	const stageLogger = createStageLogger(logEnabled)
@@ -555,18 +648,34 @@ export const buildPagesContext = async ({ compileAll = true } = {}) => {
 		return pagesByRoute.get(routePath) || pagesByRouteIndex.get(routePath) || null
 	}
 	const pagesTreeCache = new Map()
+	const navSequenceCache = new Map()
 	const getPagesTree = (routePath) => {
 		const rootPath = resolveRootPath(routePath, pagesByRoute, pagesByRouteIndex)
-		if (pagesTreeCache.has(rootPath)) {
-			return pagesTreeCache.get(rootPath)
+		const normalizedRoute = normalizeRoutePath(routePath || '/')
+		const cacheKey = `${rootPath}::${normalizedRoute}`
+		if (pagesTreeCache.has(cacheKey)) {
+			return pagesTreeCache.get(cacheKey)
 		}
 		const tree = buildPagesTree(pages, {
 			rootPath,
-			includeHiddenRoot: rootPath !== '/'
+			includeHiddenRoot: rootPath !== '/',
+			currentRoutePath: normalizedRoute
 		})
-		pagesTreeCache.set(rootPath, tree)
+		pagesTreeCache.set(cacheKey, tree)
 		return tree
 	}
+	const getNavSequence = (routePath) => {
+		const rootPath = resolveRootPath(routePath, pagesByRoute, pagesByRouteIndex)
+		const normalizedRoute = normalizeRoutePath(routePath || '/')
+		const cacheKey = `${rootPath}::${normalizedRoute}`
+		if (navSequenceCache.has(cacheKey)) {
+			return navSequenceCache.get(cacheKey)
+		}
+		const tree = getPagesTree(routePath)
+		const sequence = buildNavSequence(tree, pagesByRoute)
+		navSequenceCache.set(cacheKey, sequence)
+		return sequence
+	}
 	let pagesTree = getPagesTree('/')
 	const notFound = pagesByRoute.get('/404') || null
 	const languages = collectLanguagesFromPages(pages)
@@ -581,7 +690,7 @@ export const buildPagesContext = async ({ compileAll = true } = {}) => {
 		pagefind: {
 			enabled: state.PAGEFIND_ENABLED,
 			options: state.PAGEFIND_OPTIONS || null,
-			buildOptions: state.PAGEFIND_BUILD_OPTIONS || null
+			build: state.PAGEFIND_BUILD || null
 		},
 		generatedAt: new Date().toISOString()
 	}
@@ -604,8 +713,35 @@ export const buildPagesContext = async ({ compileAll = true } = {}) => {
 		},
 		refreshPagesTree: () => {
 			pagesTreeCache.clear()
+			navSequenceCache.clear()
 			pagesContext.pagesTree = getPagesTree('/')
 		},
+		getSiblings: (routePath, filePath = null) => {
+			if (!routePath) return { prev: null, next: null }
+			const sequence = getNavSequence(routePath)
+			if (!sequence.length) return { prev: null, next: null }
+			let index = -1
+			if (filePath) {
+				index = sequence.findIndex((entry) => entry.filePath === filePath)
+			}
+			if (index < 0) {
+				index = sequence.findIndex((entry) => entry.routePath === routePath)
+			}
+			if (index < 0) return { prev: null, next: null }
+			const toNavEntry = (entry) => {
+				if (!entry) return null
+				return {
+					routePath: entry.routePath,
+					routeHref: entry.routeHref || entry.routePath,
+					title: entry.title || entry.name || entry.routePath,
+					filePath: entry.filePath || null
+				}
+			}
+			return {
+				prev: toNavEntry(sequence[index - 1] || null),
+				next: toNavEntry(sequence[index + 1] || null)
+			}
+		},
 		refreshLanguages: () => {
 			pagesContext.languages = collectLanguagesFromPages(pages)
 			pagesContext.getLanguageForRoute = (routePath) =>
@@ -627,7 +763,10 @@ export const buildPagesContext = async ({ compileAll = true } = {}) => {
 			if (logEnabled) {
 				stageLogger.update(compileToken, `Compiling MDX [${i + 1}/${totalPages}] ${page.filePath}`)
 			}
-			await compilePageMdx(page, pagesContext)
+			await compilePageMdx(page, pagesContext, {
+				lazyPagesTree: true,
+				refreshPagesTree: false
+			})
 		}
 		stageLogger.end(compileToken)
 		pagesTreeCache.clear()

package/src/register-loader.js

@@ -18,12 +18,7 @@
  * under the License.
  */
 
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
 import { register } from 'node:module'
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const loaderPath = resolve(__dirname, '../src/node-loader.js')
-
-register(loaderPath, import.meta.url)
+const loaderUrl = new URL('./node-loader.js', import.meta.url)
+register(loaderUrl.href, import.meta.url)

package/src/rehype-plugins/link-resolve.js

@@ -19,9 +19,10 @@
  */
 
 import { existsSync } from 'fs'
-import { dirname, resolve } from 'path'
+import { dirname, resolve, relative, isAbsolute } from 'path'
 import { isElement } from 'hast-util-is-element'
 import { visit } from 'unist-util-visit'
+import { state } from '../state.js'
 
 const extensionRegex = /\.(mdx?|html)$/i
 
@@ -44,14 +45,40 @@ const splitHref = (href) => {
 
 const resolveCandidate = (baseDir, targetPath) => resolve(baseDir, targetPath)
 
-const hasExistingSource = (baseDir, pathWithoutSuffix, extension) => {
-	const targetPath = `${pathWithoutSuffix}${extension}`
-	return existsSync(resolveCandidate(baseDir, targetPath))
+const isWithinRoot = (root, targetPath) => {
+	if (!root) return false
+	const relPath = relative(root, targetPath)
+	if (relPath === '') return true
+	if (relPath.startsWith('..') || relPath.startsWith('..\\')) return false
+	if (isAbsolute(relPath)) return false
+	return true
+}
+
+const hasExistingSource = (baseDir, pathWithoutSuffix, extension, root) => {
+	const targetPath = resolveCandidate(baseDir, `${pathWithoutSuffix}${extension}`)
+	if (root && !isWithinRoot(root, targetPath)) {
+		return false
+	}
+	return existsSync(targetPath)
+}
+
+const resolvePagesRoot = (filePath) => {
+	const roots = [state.PAGES_DIR, state.THEME_PAGES_DIR].filter(Boolean).map((dir) => resolve(dir))
+	if (!roots.length) return null
+	if (!filePath) return roots[0]
+	const resolvedFile = resolve(filePath)
+	for (const root of roots) {
+		if (isWithinRoot(root, resolvedFile)) {
+			return root
+		}
+	}
+	return roots[0]
 }
 
 export const linkResolve = () => {
 	return (tree, file) => {
 		const baseDir = file?.path ? dirname(file.path) : file?.cwd || process.cwd()
+		const pagesRoot = resolvePagesRoot(file?.path || null)
 		visit(tree, (node) => {
 			if (!isElement(node) || node.tagName !== 'a') {
 				return
@@ -71,12 +98,12 @@ export const linkResolve = () => {
 
 			let shouldStrip = false
 			if (/\.mdx?$/i.test(extension)) {
-				shouldStrip = hasExistingSource(baseDir, withoutExtension, extension)
+				shouldStrip = hasExistingSource(baseDir, withoutExtension, extension, pagesRoot)
 			} else if (/\.html$/i.test(extension)) {
 				shouldStrip =
-					hasExistingSource(baseDir, withoutExtension, extension) ||
-					hasExistingSource(baseDir, withoutExtension, '.md') ||
-					hasExistingSource(baseDir, withoutExtension, '.mdx')
+					hasExistingSource(baseDir, withoutExtension, extension, pagesRoot) ||
+					hasExistingSource(baseDir, withoutExtension, '.md', pagesRoot) ||
+					hasExistingSource(baseDir, withoutExtension, '.mdx', pagesRoot)
 			}
 
 			if (!shouldStrip) {