mdorigin 0.4.1 → 0.5.1

package/dist/core/request-handler.js

@@ -1,15 +1,22 @@
 import path from 'node:path';
 import { isIgnoredContentName } from './content-store.js';
-import { inferDirectoryContentType } from './content-type.js';
+import { inferDirectoryContentType, resolveContentType, } from './content-type.js';
 import { getDirectoryIndexCandidates } from './directory-index.js';
-import { extractManagedIndexEntries, getDocumentSummary, getDocumentTitle as getParsedDocumentTitle, parseMarkdownDocument, stripManagedIndexBlock, stripManagedIndexLinks, } from './markdown.js';
+import { extractManagedIndexEntries, getDocumentSummary, getDocumentTitle as getParsedDocumentTitle, parseMarkdownDocument, stripManagedIndexBlock, stripManagedIndexLinks, stripMachineOnlyMarkdownComments, } from './markdown.js';
+import { ensureTrailingSlash, trimLeadingSlash } from './site-url.js';
 import { applyIndexTransforms, renderFooterOverride, renderHeaderOverride, renderPageWithPlugins, transformHtmlWithPlugins, } from './extensions.js';
 import { handleApiRoute } from './api.js';
-import { normalizeRequestPath, resolveRequest } from './router.js';
+import { matchRequestLocale, normalizeRequestPath, resolveRequest } from './router.js';
 import { escapeHtml, renderListingArticleItems, renderDocument, } from '../html/template.js';
+import { formatSiteMessage, resolveSiteMessages, } from '../i18n/messages.js';
 export async function handleSiteRequest(store, pathname, options) {
     const plugins = options.plugins ?? [];
     const searchEnabled = options.searchApi !== undefined;
+    const requestLocale = matchRequestLocale(pathname, options.siteConfig.locales);
+    const defaultLocale = options.siteConfig.locales?.find((locale) => locale.isDefault);
+    if (defaultLocale !== undefined && defaultLocale.pathPrefix !== '' && pathname === '/') {
+        return redirect(`${defaultLocale.pathPrefix}/`);
+    }
     const apiRoute = await handleApiRoute(pathname, options.searchParams, {
         searchApi: options.searchApi,
         siteConfig: options.siteConfig,
@@ -21,6 +28,16 @@ export async function handleSiteRequest(store, pathname, options) {
     if (pathname === '/sitemap.xml') {
         return renderSitemap(store, options);
     }
+    if (pathname === '/feed.xml') {
+        return renderRssFeed(store, options, defaultLocale ?? null);
+    }
+    if (options.siteConfig.locales !== undefined && requestLocale !== null) {
+        for (const locale of options.siteConfig.locales) {
+            if (locale.pathPrefix !== '' && pathname === `${locale.pathPrefix}/feed.xml`) {
+                return renderRssFeed(store, options, locale);
+            }
+        }
+    }
     const resolved = resolveRequest(pathname);
     const listingFragmentRequest = getListingFragmentRequest(options.searchParams);
     const negotiatedMarkdown = shouldServeMarkdownForRequest(resolved, options.acceptHeader);
@@ -29,7 +46,7 @@ export async function handleSiteRequest(store, pathname, options) {
         if (aliasRedirect !== null) {
             return aliasRedirect;
         }
-        return notFound();
+        return renderNotFoundForRequest(store, pathname, options);
     }
     const entry = await store.get(resolved.sourcePath);
     if (entry === null) {
@@ -45,25 +62,29 @@ export async function handleSiteRequest(store, pathname, options) {
         if (alternateMarkdownRedirect !== null) {
             return alternateMarkdownRedirect;
         }
+        const canonicalDirectoryRedirect = await tryRedirectCanonicalDirectoryPath(store, resolved);
+        if (canonicalDirectoryRedirect !== null) {
+            return canonicalDirectoryRedirect;
+        }
         if (resolved.kind === 'html' && resolved.requestPath.endsWith('/')) {
             const directoryIndexResponse = await tryRenderAlternateDirectoryIndex(store, resolved.requestPath, options);
             if (directoryIndexResponse !== null) {
                 return directoryIndexResponse;
             }
-            return renderDirectoryListing(store, resolved.requestPath, options.siteConfig, searchEnabled);
+            return renderDirectoryListing(store, resolved.requestPath, options.siteConfig, searchEnabled, requestLocale);
         }
-        return notFound();
+        return renderNotFoundForResolvedRequest(store, resolved, options, negotiatedMarkdown, requestLocale);
     }
     if (resolved.kind === 'asset') {
         return serveAsset(entry);
     }
     if (entry.kind !== 'text' || entry.text === undefined) {
-        return notFound();
+        return renderNotFoundForResolvedRequest(store, resolved, options, negotiatedMarkdown, requestLocale);
     }
     if (resolved.kind === 'markdown' || negotiatedMarkdown) {
         const parsed = await parseMarkdownDocument(resolved.sourcePath, entry.text);
         if (parsed.meta.draft === true && options.draftMode === 'exclude') {
-            return notFound();
+            return renderNotFoundForResolvedRequest(store, resolved, options, negotiatedMarkdown, requestLocale);
         }
         return {
             status: 200,
@@ -75,7 +96,7 @@ export async function handleSiteRequest(store, pathname, options) {
     }
     const parsed = await parseMarkdownDocument(resolved.sourcePath, entry.text);
     if (parsed.meta.draft === true && options.draftMode === 'exclude') {
-        return notFound();
+        return renderNotFoundForResolvedRequest(store, resolved, options, negotiatedMarkdown, requestLocale);
     }
     const navigation = await resolveTopNav(store, options.siteConfig);
     const renderedBody = isRootHomeRequest(resolved.requestPath) && !options.siteConfig.showHomeIndex
@@ -106,6 +127,9 @@ export async function handleSiteRequest(store, pathname, options) {
         listingEntries,
         searchEnabled,
         plugins,
+        store,
+        requestLocale,
+        draftMode: options.draftMode,
         varyOnAccept: shouldVaryOnAccept(resolved),
     });
 }
@@ -140,6 +164,8 @@ function buildPageRenderModel(options) {
         kind: options.listingEntries.length > 0 ? 'listing' : 'page',
         requestPath: options.resolvedRequestPath,
         sourcePath: options.sourcePath,
+        locale: options.locale,
+        languages: options.languages,
         siteTitle: options.siteConfig.siteTitle,
         siteDescription: options.siteConfig.siteDescription,
         siteUrl: options.siteConfig.siteUrl,
@@ -172,9 +198,18 @@ function buildPageRenderModel(options) {
     };
 }
 async function renderStructuredPage(options) {
+    const localeConfig = options.requestLocale;
+    const localeCode = localeConfig?.code ?? options.siteConfig.locale;
+    const messages = getEffectiveLocaleMessages(options.siteConfig, localeConfig);
+    const htmlLang = getFrontmatterLocale(options.parsed.meta) ?? localeCode;
+    const languages = await buildLanguageOptions(options.store, { sourcePath: options.sourcePath }, localeConfig, options.siteConfig, options.draftMode);
+    const hreflangAlternates = buildHreflangAlternates(languages, options.siteConfig);
+    const searchLocaleFilter = buildSearchLocaleFilter(options.siteConfig, localeConfig);
     const page = buildPageRenderModel({
         resolvedRequestPath: options.requestPath,
         sourcePath: options.sourcePath,
+        locale: localeCode,
+        languages,
         renderedBodyHtml: options.renderedParsed.html,
         parsed: options.parsed,
         siteConfig: options.siteConfig,
@@ -196,6 +231,8 @@ async function renderStructuredPage(options) {
         return renderDocument({
             siteTitle: currentPage.siteTitle,
             siteDescription: currentPage.siteDescription,
+            locale: htmlLang,
+            messages,
             siteUrl: currentPage.siteUrl,
             favicon: currentPage.favicon,
             socialImage: currentPage.socialImage,
@@ -214,11 +251,15 @@ async function renderStructuredPage(options) {
             stylesheetContent: currentPage.stylesheetContent,
             canonicalPath: currentPage.canonicalPath,
             alternateMarkdownPath: currentPage.alternateMarkdownPath,
+            rssFeedUrl: getRssFeedUrl(currentPage.siteUrl, options.siteConfig, localeConfig),
             listingEntries: currentPage.listingEntries,
             listingRequestPath: currentPage.listingRequestPath,
             listingInitialPostCount: currentPage.listingInitialPostCount,
             listingLoadMoreStep: currentPage.listingLoadMoreStep,
             searchEnabled: currentPage.searchEnabled,
+            languages: currentPage.languages,
+            hreflangAlternates,
+            searchLocaleFilter,
             headerHtml,
             footerHtml,
         });
@@ -281,6 +322,69 @@ function notFound() {
         body: 'Not Found',
     };
 }
+async function renderNotFoundForRequest(store, pathname, options) {
+    const resolved = resolveRequest(pathname);
+    return renderNotFoundForResolvedRequest(store, resolved, options, false, matchRequestLocale(pathname, options.siteConfig.locales));
+}
+async function renderNotFoundForResolvedRequest(store, resolved, options, negotiatedMarkdown, requestLocale) {
+    const varyOnAccept = shouldVaryOnAccept(resolved);
+    if (resolved.kind !== 'html' || negotiatedMarkdown) {
+        return withNotFoundVary(varyOnAccept);
+    }
+    return renderHtmlNotFound(store, resolved.requestPath, options, varyOnAccept, requestLocale);
+}
+async function renderHtmlNotFound(store, requestPath, options, varyOnAccept, requestLocale) {
+    const navigation = await resolveTopNav(store, options.siteConfig);
+    const localeConfig = requestLocale;
+    const locale = localeConfig?.code ?? options.siteConfig.locale;
+    const messages = getEffectiveLocaleMessages(options.siteConfig, localeConfig);
+    const languages = await buildLanguageOptions(store, {}, localeConfig, options.siteConfig, options.draftMode);
+    const body = [
+        `<h1>${escapeHtml(messages['error.notFoundTitle'])}</h1>`,
+        `<p>${formatSiteMessage(messages['error.notFoundBody'], {
+            path: escapeHtml(requestPath),
+        })}</p>`,
+    ].join('');
+    return {
+        status: 404,
+        headers: withVaryAcceptIfNeeded({
+            'content-type': 'text/html; charset=utf-8',
+        }, varyOnAccept),
+        body: renderDocument({
+            siteTitle: options.siteConfig.siteTitle,
+            siteDescription: options.siteConfig.siteDescription,
+            siteUrl: options.siteConfig.siteUrl,
+            favicon: options.siteConfig.favicon,
+            socialImage: options.siteConfig.socialImage,
+            logo: options.siteConfig.logo,
+            title: messages['error.notFoundTitle'],
+            body,
+            locale,
+            messages,
+            languages,
+            showSummary: false,
+            showDate: false,
+            topNav: navigation.items,
+            footerNav: options.siteConfig.footerNav,
+            footerText: options.siteConfig.footerText,
+            socialLinks: options.siteConfig.socialLinks,
+            stylesheetContent: options.siteConfig.stylesheetContent,
+            rssFeedUrl: getRssFeedUrl(options.siteConfig.siteUrl, options.siteConfig, localeConfig),
+            searchEnabled: options.searchApi !== undefined,
+        }),
+    };
+}
+function withNotFoundVary(varyOnAccept) {
+    if (!varyOnAccept) {
+        return notFound();
+    }
+    return {
+        ...notFound(),
+        headers: withVaryAcceptIfNeeded({
+            'content-type': 'text/plain; charset=utf-8',
+        }, true),
+    };
+}
 function redirect(location) {
     return {
         status: 308,
@@ -289,6 +393,127 @@ function redirect(location) {
         },
     };
 }
+function getEffectiveLocaleMessages(siteConfig, localeConfig) {
+    if (localeConfig === null) {
+        return resolveSiteMessages(siteConfig.locale, siteConfig.messages);
+    }
+    return resolveSiteMessages(localeConfig.code, {
+        ...siteConfig.messages,
+        ...localeConfig.messages,
+    });
+}
+function getFrontmatterLocale(meta) {
+    if (typeof meta.lang !== 'string') {
+        return null;
+    }
+    const trimmed = meta.lang.trim();
+    return trimmed === '' ? null : trimmed;
+}
+async function buildLanguageOptions(store, target, currentLocale, siteConfig, draftMode) {
+    const locales = siteConfig.locales;
+    if (locales === undefined || locales.length === 0) {
+        return [];
+    }
+    const languages = [];
+    for (const locale of locales) {
+        const translated = await localeHasContent(store, target, currentLocale, locale, draftMode);
+        languages.push({
+            code: locale.code,
+            label: locale.label,
+            href: translated === null
+                ? getLocaleHomePath(locale)
+                : getCanonicalHtmlPathForContentPath(translated),
+            current: locale === currentLocale,
+            translated: translated !== null,
+        });
+    }
+    return languages;
+}
+async function localeHasContent(store, target, currentLocale, locale, draftMode) {
+    if (locale === currentLocale) {
+        return target.sourcePath
+            ? target.sourcePath
+            : target.directoryPath === ''
+                ? 'index.md'
+                : `${target.directoryPath}/index.md`;
+    }
+    const candidates = [];
+    if (target.sourcePath !== undefined) {
+        candidates.push(mapContentPathForLocale(target.sourcePath, currentLocale, locale));
+    }
+    else {
+        const directoryPath = target.directoryPath ?? '';
+        for (const candidate of getDirectoryIndexCandidates(mapContentPathForLocale(directoryPath, currentLocale, locale))) {
+            candidates.push(candidate);
+        }
+    }
+    for (const candidate of candidates) {
+        if (await hasPublishedContent(store, candidate, draftMode)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function mapContentPathForLocale(contentPath, from, to) {
+    if (from === null || from.contentBase === '') {
+        return to.contentBase === '' ? contentPath : `${to.contentBase}/${contentPath}`;
+    }
+    if (!contentPath.startsWith(`${from.contentBase}/`)) {
+        return contentPath;
+    }
+    const rest = contentPath.slice(from.contentBase.length + 1);
+    return to.contentBase === '' ? rest : `${to.contentBase}/${rest}`;
+}
+function getLocaleHomePath(locale) {
+    return locale.pathPrefix === '' ? '/' : `${locale.pathPrefix}/`;
+}
+async function hasPublishedContent(store, contentPath, draftMode) {
+    const entry = await store.get(contentPath);
+    if (entry === null || entry.kind !== 'text' || entry.text === undefined) {
+        return false;
+    }
+    if (draftMode === 'exclude') {
+        const parsed = await parseMarkdownDocument(contentPath, entry.text);
+        if (parsed.meta.draft === true) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildHreflangAlternates(languages, siteConfig) {
+    if (languages.length === 0 || siteConfig.siteUrl === undefined) {
+        return [];
+    }
+    const base = ensureTrailingSlash(siteConfig.siteUrl);
+    const alternates = languages
+        .filter((language) => language.translated)
+        .map((language) => ({
+        hreflang: language.code,
+        href: new URL(trimLeadingSlash(language.href), base).toString(),
+    }));
+    const defaultLocale = siteConfig.locales?.find((locale) => locale.isDefault);
+    const defaultLanguage = defaultLocale
+        ? languages.find((language) => language.code === defaultLocale.code)
+        : undefined;
+    if (defaultLanguage?.translated) {
+        alternates.push({
+            hreflang: 'x-default',
+            href: new URL(trimLeadingSlash(defaultLanguage.href), base).toString(),
+        });
+    }
+    return alternates;
+}
+function buildSearchLocaleFilter(siteConfig, localeConfig) {
+    if (siteConfig.locales === undefined || localeConfig === null) {
+        return undefined;
+    }
+    return {
+        include: localeConfig.contentBase === '' ? '' : `${localeConfig.contentBase}/`,
+        exclude: siteConfig.locales
+            .filter((locale) => locale !== localeConfig && locale.contentBase !== '')
+            .map((locale) => `${locale.contentBase}/`),
+    };
+}
 async function renderSitemap(store, options) {
     if (!options.siteConfig.siteUrl) {
         return {
@@ -317,6 +542,62 @@ async function renderSitemap(store, options) {
         body,
     };
 }
+async function renderRssFeed(store, options, locale) {
+    if (!isRssEnabled(options.siteConfig) || !options.siteConfig.siteUrl) {
+        return notFound();
+    }
+    const excludedLocaleDirectories = new Set((options.siteConfig.locales ?? [])
+        .filter((entry) => entry.contentBase !== '' && entry !== locale)
+        .map((entry) => entry.contentBase));
+    const items = await collectRssFeedItems(store, locale?.contentBase ?? '', options, excludedLocaleDirectories);
+    const limitedItems = items.slice(0, options.siteConfig.rss?.maxItems ?? 20);
+    const rssFeedUrl = getRssFeedUrl(options.siteConfig.siteUrl, options.siteConfig, locale);
+    const title = options.siteConfig.rss?.title ?? options.siteConfig.siteTitle;
+    const description = options.siteConfig.rss?.description ?? options.siteConfig.siteDescription;
+    const lastBuildDate = limitedItems[0]?.pubDate.toUTCString();
+    const body = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+        '<channel>',
+        `  <title>${escapeHtml(title)}</title>`,
+        `  <link>${escapeHtml(options.siteConfig.siteUrl)}</link>`,
+        description
+            ? `  <description>${escapeHtml(description)}</description>`
+            : '  <description></description>',
+        '  <generator>mdorigin</generator>',
+        rssFeedUrl
+            ? `  <atom:link href="${escapeHtml(rssFeedUrl)}" rel="self" type="application/rss+xml" />`
+            : '',
+        options.siteConfig.rss?.author
+            ? `  <managingEditor>${escapeHtml(options.siteConfig.rss.author)}</managingEditor>`
+            : '',
+        lastBuildDate ? `  <lastBuildDate>${escapeHtml(lastBuildDate)}</lastBuildDate>` : '',
+        ...limitedItems.map((item) => [
+            '  <item>',
+            `    <title>${escapeHtml(item.title)}</title>`,
+            `    <link>${escapeHtml(item.absoluteUrl)}</link>`,
+            `    <guid isPermaLink="true">${escapeHtml(item.absoluteUrl)}</guid>`,
+            `    <pubDate>${escapeHtml(item.pubDate.toUTCString())}</pubDate>`,
+            item.summary
+                ? `    <description>${escapeHtml(item.summary)}</description>`
+                : '',
+            '  </item>',
+        ]
+            .filter((line) => line !== '')
+            .join('\n')),
+        '</channel>',
+        '</rss>',
+    ]
+        .filter((line) => line !== '')
+        .join('\n');
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'application/rss+xml; charset=utf-8',
+        },
+        body,
+    };
+}
 function withVaryAcceptIfNeeded(headers, enabled) {
     if (!enabled) {
         return headers;
@@ -387,7 +668,78 @@ function dedupeSitemapEntries(entries) {
     }
     return Array.from(deduped.values());
 }
-async function renderDirectoryListing(store, requestPath, siteConfig, searchEnabled) {
+async function collectRssFeedItems(store, directoryPath, options, excludedDirectories) {
+    const entries = await store.listDirectory(directoryPath);
+    if (entries === null) {
+        return [];
+    }
+    const feedItems = [];
+    const directoryShape = inspectDirectoryShapeEntries(entries);
+    for (const entry of entries) {
+        if (entry.kind === 'directory') {
+            if (excludedDirectories.has(entry.path)) {
+                continue;
+            }
+            feedItems.push(...(await collectRssFeedItems(store, entry.path, options, excludedDirectories)));
+            continue;
+        }
+        if (!isMarkdownEntry(entry)) {
+            continue;
+        }
+        const document = await store.get(entry.path);
+        if (document === null || document.kind !== 'text' || document.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(entry.path, document.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            continue;
+        }
+        const pubDate = parseFeedDate(parsed.meta.date);
+        if (pubDate === null) {
+            continue;
+        }
+        const contentType = inferFeedContentType(entry.path, parsed.meta, directoryShape);
+        if (contentType !== 'post') {
+            continue;
+        }
+        const canonicalPath = getCanonicalHtmlPathForContentPath(entry.path);
+        feedItems.push({
+            title: getDocumentTitle(parsed),
+            canonicalPath,
+            absoluteUrl: new URL(trimLeadingSlash(canonicalPath), ensureTrailingSlash(options.siteConfig.siteUrl ?? '')).toString(),
+            summary: getFeedSummary(parsed),
+            pubDate,
+        });
+    }
+    feedItems.sort((left, right) => {
+        const timeDelta = right.pubDate.getTime() - left.pubDate.getTime();
+        return timeDelta !== 0
+            ? timeDelta
+            : left.canonicalPath.localeCompare(right.canonicalPath);
+    });
+    return feedItems;
+}
+function inferFeedContentType(contentPath, meta, directoryShape) {
+    const explicitType = resolveContentType(meta);
+    if (explicitType) {
+        return explicitType;
+    }
+    if (isDirectoryIndexContentPath(contentPath)) {
+        return inferDirectoryContentType(meta, directoryShape);
+    }
+    return typeof meta.date === 'string' && meta.date !== '' ? 'post' : 'page';
+}
+function getFeedSummary(parsed) {
+    return getDocumentSummary(parsed.meta, stripMachineOnlyMarkdownComments(stripManagedIndexBlock(parsed.body)));
+}
+function parseFeedDate(value) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        return null;
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+async function renderDirectoryListing(store, requestPath, siteConfig, searchEnabled, requestLocale) {
     const directoryPath = requestPath === '/' ? '' : requestPath.slice(1).replace(/\/$/, '');
     const entries = await store.listDirectory(directoryPath);
     if (entries === null) {
@@ -395,12 +747,17 @@ async function renderDirectoryListing(store, requestPath, siteConfig, searchEnab
     }
     const visibleEntries = entries.filter(isVisibleDirectoryEntry);
     const navigation = await resolveTopNav(store, siteConfig);
+    const locale = requestLocale?.code ?? siteConfig.locale;
+    const messages = getEffectiveLocaleMessages(siteConfig, requestLocale);
+    const languages = await buildLanguageOptions(store, { directoryPath }, requestLocale, siteConfig, 'exclude');
     const listItems = visibleEntries
         .map((entry) => `<li><a href="${getDirectoryEntryHref(requestPath, entry)}">${escapeHtml(getDirectoryEntryLabel(entry))}</a></li>`)
         .join('');
     const body = [
         `<h1>${escapeHtml(getDirectoryTitle(requestPath))}</h1>`,
-        visibleEntries.length > 0 ? `<ul>${listItems}</ul>` : '<p>This directory is empty.</p>',
+        visibleEntries.length > 0
+            ? `<ul>${listItems}</ul>`
+            : `<p>${escapeHtml(messages['listing.emptyDirectory'])}</p>`,
     ].join('');
     return {
         status: 200,
@@ -410,6 +767,9 @@ async function renderDirectoryListing(store, requestPath, siteConfig, searchEnab
         body: renderDocument({
             siteTitle: siteConfig.siteTitle,
             siteDescription: siteConfig.siteDescription,
+            locale,
+            messages,
+            languages,
             siteUrl: siteConfig.siteUrl,
             favicon: siteConfig.favicon,
             logo: siteConfig.logo,
@@ -424,6 +784,7 @@ async function renderDirectoryListing(store, requestPath, siteConfig, searchEnab
             stylesheetContent: siteConfig.stylesheetContent,
             canonicalPath: requestPath,
             alternateMarkdownPath: getMarkdownRequestPathForContentPath(getDirectoryIndexContentPathForRequestPath(requestPath)),
+            rssFeedUrl: getRssFeedUrl(siteConfig.siteUrl, siteConfig, requestLocale),
             searchEnabled,
         }),
     };
@@ -499,6 +860,9 @@ async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
             listingEntries,
             searchEnabled: options.searchApi !== undefined,
             plugins,
+            store,
+            requestLocale: matchRequestLocale(requestPath, options.siteConfig.locales),
+            draftMode: options.draftMode,
         });
     }
     return null;
@@ -558,6 +922,23 @@ async function tryRedirectAlternateDirectoryMarkdown(store, resolved, options) {
     }
     return null;
 }
+async function tryRedirectCanonicalDirectoryPath(store, resolved) {
+    if (resolved.kind !== 'html' || resolved.requestPath.endsWith('/')) {
+        return null;
+    }
+    if (path.posix.extname(resolved.requestPath) !== '') {
+        return null;
+    }
+    const directoryPath = resolved.requestPath.slice(1);
+    if (directoryPath === '') {
+        return null;
+    }
+    const directoryEntries = await store.listDirectory(directoryPath);
+    if (directoryEntries === null) {
+        return null;
+    }
+    return redirect(`${resolved.requestPath}/`);
+}
 function getMarkdownRequestPathForContentPath(contentPath) {
     return `/${contentPath}`;
 }
@@ -628,6 +1009,10 @@ async function findAliasRedirectLocation(store, directoryPath, requestPath, opti
 function isMarkdownEntry(entry) {
     return path.posix.extname(entry.name).toLowerCase() === '.md';
 }
+function isDirectoryIndexContentPath(contentPath) {
+    const basename = path.posix.basename(contentPath).toLowerCase();
+    return basename === 'index.md' || basename === 'readme.md' || basename === 'skill.md';
+}
 function normalizeAliases(aliases) {
     if (!Array.isArray(aliases)) {
         return [];
@@ -642,12 +1027,26 @@ function normalizeAliases(aliases) {
 }
 function getCanonicalHtmlPathForContentPath(contentPath) {
     const basename = path.posix.basename(contentPath).toLowerCase();
-    if (basename === 'index.md' || basename === 'readme.md') {
+    if (basename === 'index.md' ||
+        basename === 'readme.md' ||
+        basename === 'skill.md') {
         const directory = path.posix.dirname(contentPath);
         return directory === '.' ? '/' : `/${directory}/`;
     }
     return `/${contentPath.slice(0, -'.md'.length)}`;
 }
+function isRssEnabled(siteConfig) {
+    return Boolean(siteConfig.siteUrl) && (siteConfig.rss?.enabled ?? true);
+}
+function getRssFeedUrl(siteUrl, siteConfig, locale) {
+    if (!siteUrl || !isRssEnabled(siteConfig)) {
+        return undefined;
+    }
+    const feedPath = locale !== null && locale.pathPrefix !== ''
+        ? `${locale.pathPrefix.slice(1)}/feed.xml`
+        : 'feed.xml';
+    return new URL(feedPath, ensureTrailingSlash(siteUrl)).toString();
+}
 function getEditLinkHref(siteConfig, sourcePath) {
     if (!siteConfig.editLink || !sourcePath) {
         return undefined;
@@ -669,9 +1068,15 @@ async function resolveTopNav(store, siteConfig) {
         };
     }
     const directories = rootEntries.filter((entry) => entry.kind === 'directory');
+    const localeDirectoryNames = new Set((siteConfig.locales ?? [])
+        .filter((locale) => locale.contentBase !== '')
+        .map((locale) => locale.contentBase));
     const navItems = [];
     const orderedNavItems = [];
     for (const entry of directories) {
+        if (localeDirectoryNames.has(entry.name)) {
+            continue;
+        }
         const resolved = await resolveDirectoryNav(store, entry);
         if (resolved.type !== 'page') {
             continue;
@@ -731,6 +1136,9 @@ async function inspectDirectoryShape(store, directoryPath) {
             hasAssetFiles: false,
         };
     }
+    return inspectDirectoryShapeEntries(entries);
+}
+function inspectDirectoryShapeEntries(entries) {
     let hasSkillIndex = false;
     let hasChildDirectories = false;
     let hasExtraMarkdownFiles = false;

package/dist/core/router.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedLocaleConfig } from './site-config.js';
 export type ResolvedRequestKind = 'markdown' | 'html' | 'asset' | 'not-found';
 export interface ResolvedRequest {
     kind: ResolvedRequestKind;
@@ -6,3 +7,11 @@ export interface ResolvedRequest {
 }
 export declare function resolveRequest(pathname: string): ResolvedRequest;
 export declare function normalizeRequestPath(pathname: string): string | null;
+/**
+ * Attributes a request path to a configured content locale. Locale URL
+ * prefixes map 1:1 to top-level `{code}` content directories, so attribution
+ * never rewrites content resolution: a path that matches a locale prefix keeps
+ * resolving to that locale's directory, and any other path belongs to the
+ * default locale (whose content lives at the content root when unprefixed).
+ */
+export declare function matchRequestLocale(pathname: string, locales: readonly ResolvedLocaleConfig[] | undefined): ResolvedLocaleConfig | null;

package/dist/core/router.js

@@ -80,3 +80,29 @@ export function normalizeRequestPath(pathname) {
         return null;
     }
 }
+/**
+ * Attributes a request path to a configured content locale. Locale URL
+ * prefixes map 1:1 to top-level `{code}` content directories, so attribution
+ * never rewrites content resolution: a path that matches a locale prefix keeps
+ * resolving to that locale's directory, and any other path belongs to the
+ * default locale (whose content lives at the content root when unprefixed).
+ */
+export function matchRequestLocale(pathname, locales) {
+    if (locales === undefined || locales.length === 0) {
+        return null;
+    }
+    const normalized = normalizeRequestPath(pathname);
+    if (normalized === null) {
+        return null;
+    }
+    const prefixed = locales
+        .filter((locale) => locale.pathPrefix !== '')
+        .sort((left, right) => right.pathPrefix.length - left.pathPrefix.length);
+    for (const locale of prefixed) {
+        if (normalized === locale.pathPrefix ||
+            normalized.startsWith(`${locale.pathPrefix}/`)) {
+            return locale;
+        }
+    }
+    return locales.find((locale) => locale.isDefault) ?? null;
+}