@zeropress/build-core 0.5.2 → 0.6.2

package/src/api/build-site.js

@@ -14,10 +14,13 @@ const DEFAULT_OPTIONS = {
 };
 
 const DEFAULT_POSTS_PER_PAGE = 10;
-const DEFAULT_DATE_FORMAT = 'YYYY-MM-DD';
-const DEFAULT_TIME_FORMAT = 'HH:mm';
+const DEFAULT_DATETIME_DISPLAY = 'static';
+const DEFAULT_DATE_STYLE = 'medium';
+const DEFAULT_TIME_STYLE = 'none';
 const DEFAULT_TIMEZONE = 'UTC';
 const DEFAULT_LOCALE = 'en-US';
+const DATETIME_DISPLAY_MODES = new Set(['static', 'client']);
+const DATETIME_STYLES = new Set(['none', 'short', 'medium', 'long', 'full']);
 const DEFAULT_PERMALINKS = Object.freeze({
   output_style: 'directory',
   posts: '/posts/:slug/',
@@ -35,12 +38,25 @@ const DEFAULT_POST_INDEX = Object.freeze({
 });
 const PERMALINK_OUTPUT_STYLES = new Set(['directory', 'html-extension']);
 const COMMENT_POLICY_OUTPUT_PATH = '_zeropress/comment-policy.json';
+const SEARCH_INDEX_OUTPUT_PATH = '_zeropress/search.json';
+const SEARCH_ADAPTER_OUTPUT_PATH = '_zeropress/search.js';
+const SEARCH_PAGEFIND_ADAPTER_OUTPUT_PATH = '_zeropress/search_pagefind.js';
 const OUTPUT_PATH_CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
 const SAFE_MEDIA_PROTOCOLS = new Set(['http:', 'https:']);
 const SAFE_LINK_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'tel:']);
 const MEDIA_DELIVERY_MODES = new Set(['none', 'media_domain']);
+const DISCOVERABILITY_VALUES = new Set(['default', 'noindex', 'delist']);
 const RESPONSIVE_IMAGE_WIDTHS = [320, 480, 768, 1024, 1280, 1600, 1920];
 const RESPONSIVE_IMAGE_EXTENSIONS = new Set(['jpg', 'jpeg', 'png', 'webp', 'avif']);
+const SEARCH_FIELD_WEIGHTS = Object.freeze({
+  title: 5,
+  headings: 3,
+  tags: 2.5,
+  categories: 2,
+  excerpt: 1.5,
+  content_text: 1,
+});
+const SEARCH_RECENCY_BOOST_MAX = 0.15;
 export async function buildSite(input) {
   const options = { ...DEFAULT_OPTIONS, ...(input.options || {}) };
   const state = await createBuildState(input, options);
@@ -92,10 +108,22 @@ export async function buildSite(input) {
     'application/json',
   );
 
+  if (shouldGenerateSearchArtifacts(state, options)) {
+    await writeOutput(state.writer, state.summaries, SEARCH_INDEX_OUTPUT_PATH, buildSearchIndexJson(state), 'application/json');
+    await writeOutput(state.writer, state.summaries, SEARCH_ADAPTER_OUTPUT_PATH, buildSearchAdapterJs(), 'application/javascript');
+    await writeOutput(state.writer, state.summaries, SEARCH_PAGEFIND_ADAPTER_OUTPUT_PATH, buildSearchPagefindAdapterJs(), 'application/javascript');
+  }
+
   if (options.generateSpecialFiles) {
     await maybeRenderNotFoundPage(state);
     if (hasCanonicalSiteUrl(state.previewData.site.url)) {
-      await writeOutput(state.writer, state.summaries, 'sitemap.xml', buildSitemapXml(state.previewData.site, state.emitted, state.generatedAt), 'application/xml');
+      await writeOutput(
+        state.writer,
+        state.summaries,
+        'sitemap.xml',
+        buildSitemapXml(state.previewData.site, state.emitted, state.generatedAt, options.sitemapStylesheetHref),
+        'application/xml',
+      );
       await writeOutput(state.writer, state.summaries, 'feed.xml', buildFeedXml(state.previewData.site, state.emitted, state.generatedAt), 'application/rss+xml');
     }
     if (shouldGenerateRobotsTxt(options)) {
@@ -144,6 +172,7 @@ async function createBuildState(input, options) {
     customCssHref: customCssAsset ? `/${customCssAsset.path}` : '',
     customHtml: previewData.custom_html,
     favicon: previewData.site.favicon,
+    exposeGenerator: previewData.site.expose_generator !== false,
     commentPolicyContent: buildCommentPolicyManifest(renderData.posts),
     options,
     generatedAt: new Date(),
@@ -261,6 +290,7 @@ async function renderFrontPage(state, route) {
           description: page.excerpt,
           ogType: 'website',
           image: page.featured_image,
+          robotsNoindex: shouldNoindexDocument(page),
         }),
       },
       createRenderContext(state.previewData.site, currentUrl),
@@ -273,6 +303,7 @@ async function renderFrontPage(state, route) {
       title: page.title,
       description: page.excerpt,
       includeInFeed: false,
+      includeInSitemap: !isDelistedDocument(page),
     };
     return;
   }
@@ -325,6 +356,7 @@ async function renderPost(state, post) {
         image: post.featured_image,
         publishedTime: post.published_at_iso,
         modifiedTime: post.updated_at_iso,
+        robotsNoindex: shouldNoindexDocument(post),
       }),
     },
     createRenderContext(state.previewData.site, currentUrl),
@@ -332,14 +364,16 @@ async function renderPost(state, post) {
   html = state.assetProcessor.updateAssetReferences(html, state.assetMap);
   html = injectSiteCustomizations(html, state);
   await writeOutput(state.writer, state.summaries, routePathToOutputPath(post.url, state.previewData.site.permalinks.output_style), html, 'text/html');
-  state.emitted.posts.push({
-    url: currentUrl,
-    title: post.title,
-    description: post.excerpt,
-    publishedAt: post.published_at_iso,
-    updatedAt: post.updated_at_iso,
-    status: post.status,
-  });
+  if (!isDelistedDocument(post)) {
+    state.emitted.posts.push({
+      url: currentUrl,
+      title: post.title,
+      description: post.excerpt,
+      publishedAt: post.published_at_iso,
+      updatedAt: post.updated_at_iso,
+      status: post.status,
+    });
+  }
 }
 
 async function renderPage(state, page) {
@@ -362,6 +396,7 @@ async function renderPage(state, page) {
         description: page.excerpt,
         ogType: 'website',
         image: page.featured_image,
+        robotsNoindex: shouldNoindexDocument(page),
       }),
     },
     createRenderContext(state.previewData.site, currentUrl),
@@ -374,7 +409,7 @@ async function renderPage(state, page) {
     title: page.title,
     description: page.excerpt,
     status: page.status,
-    includeInSitemap: page.omit_from_sitemap !== true,
+    includeInSitemap: page.omit_from_sitemap !== true && !isDelistedDocument(page),
   });
 }
 
@@ -408,19 +443,28 @@ async function maybeRenderNotFoundPage(state) {
 function normalizePreviewData(previewData, options = {}) {
   const normalizedSite = {
     ...previewData.site,
-    mediaBaseUrl: normalizeOptionalString(previewData.site.mediaBaseUrl),
-    mediaDeliveryMode: MEDIA_DELIVERY_MODES.has(previewData.site.mediaDeliveryMode)
-      ? previewData.site.mediaDeliveryMode
+    media_base_url: normalizeOptionalString(previewData.site.media_base_url),
+    media_delivery_mode: MEDIA_DELIVERY_MODES.has(previewData.site.media_delivery_mode)
+      ? previewData.site.media_delivery_mode
       : 'none',
     favicon: normalizeSiteFavicon(previewData.site.favicon || options.favicon),
-    postsPerPage: Number.isInteger(previewData.site.postsPerPage) && previewData.site.postsPerPage > 0
-      ? previewData.site.postsPerPage
+    posts_per_page: Number.isInteger(previewData.site.posts_per_page) && previewData.site.posts_per_page > 0
+      ? previewData.site.posts_per_page
       : DEFAULT_POSTS_PER_PAGE,
-    dateFormat: normalizeNonEmptyString(previewData.site.dateFormat, DEFAULT_DATE_FORMAT),
-    timeFormat: typeof previewData.site.timeFormat === 'string' ? previewData.site.timeFormat : DEFAULT_TIME_FORMAT,
+    datetime_display: DATETIME_DISPLAY_MODES.has(previewData.site.datetime_display)
+      ? previewData.site.datetime_display
+      : DEFAULT_DATETIME_DISPLAY,
+    date_style: DATETIME_STYLES.has(previewData.site.date_style)
+      ? previewData.site.date_style
+      : DEFAULT_DATE_STYLE,
+    time_style: DATETIME_STYLES.has(previewData.site.time_style)
+      ? previewData.site.time_style
+      : DEFAULT_TIME_STYLE,
     timezone: normalizeNonEmptyString(previewData.site.timezone, DEFAULT_TIMEZONE),
     locale: normalizeLocale(previewData.site.locale || DEFAULT_LOCALE),
-    disallowComments: previewData.site.disallowComments === true,
+    disallow_comments: previewData.site.disallow_comments === true,
+    expose_generator: previewData.site.expose_generator !== false,
+    search: previewData.site.search !== false,
     indexing: previewData.site.indexing !== false,
     permalinks: normalizePermalinks(previewData.site.permalinks),
     front_page: normalizeFrontPage(previewData.site.front_page),
@@ -435,13 +479,13 @@ function normalizePreviewData(previewData, options = {}) {
     site: normalizedSite,
     menus: normalizeRecordMap(previewData.menus),
     collections: normalizeCollections(previewData.collections),
-    widgets: normalizeWidgetAreas(previewData.widgets, normalizedSite.mediaBaseUrl),
+    widgets: normalizeWidgetAreas(previewData.widgets, normalizedSite.media_base_url),
     custom_css: normalizeCustomCss(previewData.custom_css),
     custom_html: normalizeCustomHtml(previewData.custom_html),
     content: {
       ...previewData.content,
       authors: previewData.content.authors.map((author) => {
-        const avatar = normalizeMediaField(author.avatar, normalizedSite.mediaBaseUrl);
+        const avatar = normalizeMediaField(author.avatar, normalizedSite.media_base_url);
         const avatarMedia = deriveManagedMedia(avatar, mediaRegistry, normalizedSite);
         return {
           ...author,
@@ -451,22 +495,24 @@ function normalizePreviewData(previewData, options = {}) {
       }),
       posts: previewData.content.posts
         .map((post) => {
-          const featuredImage = normalizeMediaField(post.featured_image, normalizedSite.mediaBaseUrl);
+          const featuredImage = normalizeMediaField(post.featured_image, normalizedSite.media_base_url);
           const featuredMedia = deriveManagedMedia(featuredImage, mediaRegistry, normalizedSite);
           return {
             ...post,
             published_at_iso: normalizeIsoTimestamp(post.published_at_iso),
             updated_at_iso: normalizeIsoTimestamp(post.updated_at_iso),
+            discoverability: normalizeDiscoverability(post.discoverability),
             featured_image: featuredImage,
             ...(featuredMedia ? { featured_media: featuredMedia } : {}),
           };
         })
         .sort((left, right) => toDate(right.published_at_iso).getTime() - toDate(left.published_at_iso).getTime()),
       pages: previewData.content.pages.map((page) => {
-        const featuredImage = normalizeMediaField(page.featured_image, normalizedSite.mediaBaseUrl);
+        const featuredImage = normalizeMediaField(page.featured_image, normalizedSite.media_base_url);
         const featuredMedia = deriveManagedMedia(featuredImage, mediaRegistry, normalizedSite);
         return {
           ...page,
+          discoverability: normalizeDiscoverability(page.discoverability),
           featured_image: featuredImage,
           ...(featuredMedia ? { featured_media: featuredMedia } : {}),
         };
@@ -486,6 +532,18 @@ function normalizeRecordMap(value) {
   return { ...value };
 }
 
+function normalizeDiscoverability(value) {
+  return DISCOVERABILITY_VALUES.has(value) ? value : 'default';
+}
+
+function isDelistedDocument(document) {
+  return document?.discoverability === 'delist';
+}
+
+function shouldNoindexDocument(document) {
+  return document?.discoverability === 'noindex' || document?.discoverability === 'delist';
+}
+
 function normalizeContentMedia(mediaItems, site) {
   if (!Array.isArray(mediaItems)) {
     return [];
@@ -496,7 +554,7 @@ function normalizeContentMedia(mediaItems, site) {
       if (!item || typeof item !== 'object') {
         return null;
       }
-      const src = normalizeMediaField(item.src, site.mediaBaseUrl);
+      const src = normalizeMediaField(item.src, site.media_base_url);
       const width = Number.isInteger(item.width) && item.width > 0 ? item.width : 0;
       const height = Number.isInteger(item.height) && item.height > 0 ? item.height : 0;
       if (!src || !width || !height) {
@@ -538,12 +596,12 @@ function deriveManagedMedia(src, mediaRegistry, site) {
 }
 
 function buildResponsiveImageSrcset(media, site) {
-  if (site.mediaDeliveryMode !== 'media_domain') {
+  if (site.media_delivery_mode !== 'media_domain') {
     return '';
   }
 
-  const mediaBaseUrl = normalizeOptionalString(site.mediaBaseUrl);
-  if (!mediaBaseUrl || !isUrlUnderMediaBase(media.src, mediaBaseUrl) || !isResponsiveRasterImage(media.src)) {
+  const media_base_url = normalizeOptionalString(site.media_base_url);
+  if (!media_base_url || !isUrlUnderMediaBase(media.src, media_base_url) || !isResponsiveRasterImage(media.src)) {
     return '';
   }
 
@@ -570,10 +628,10 @@ function buildResponsiveImageVariantUrl(src, width) {
   }
 }
 
-function isUrlUnderMediaBase(src, mediaBaseUrl) {
+function isUrlUnderMediaBase(src, media_base_url) {
   try {
     const sourceUrl = new URL(src);
-    const baseUrl = new URL(mediaBaseUrl);
+    const baseUrl = new URL(media_base_url);
     const basePath = baseUrl.pathname.endsWith('/') ? baseUrl.pathname : `${baseUrl.pathname}/`;
     return sourceUrl.origin === baseUrl.origin && sourceUrl.pathname.startsWith(basePath);
   } catch {
@@ -610,19 +668,19 @@ function normalizeCollections(collections) {
   );
 }
 
-function normalizeWidgetAreas(widgetAreas, mediaBaseUrl) {
-  if (!widgetAreas || typeof widgetAreas !== 'object') {
+function normalizeWidgetAreas(widget_areas, media_base_url) {
+  if (!widget_areas || typeof widget_areas !== 'object') {
     return {};
   }
 
   return Object.fromEntries(
-    Object.entries(widgetAreas).map(([widgetAreaId, widgetArea]) => [
+    Object.entries(widget_areas).map(([widgetAreaId, widgetArea]) => [
       widgetAreaId,
       {
         ...widgetArea,
         name: normalizeNonEmptyString(widgetArea?.name, widgetAreaId),
         items: Array.isArray(widgetArea?.items)
-          ? widgetArea.items.map((item) => normalizeWidgetItem(item, mediaBaseUrl))
+          ? widgetArea.items.map((item) => normalizeWidgetItem(item, media_base_url))
           : [],
       },
     ]),
@@ -631,21 +689,15 @@ function normalizeWidgetAreas(widgetAreas, mediaBaseUrl) {
 
 function normalizeSiteFooter(footer) {
   const source = footer && typeof footer === 'object' && !Array.isArray(footer) ? footer : {};
-  const attribution = source.attribution && typeof source.attribution === 'object' && !Array.isArray(source.attribution)
-    ? source.attribution
-    : {};
 
   return {
     ...source,
     copyright_text: normalizeOptionalString(source.copyright_text),
-    attribution: {
-      ...attribution,
-      enabled: attribution.enabled !== false,
-    },
+    attribution: source.attribution !== false,
   };
 }
 
-function normalizeWidgetItem(item, mediaBaseUrl) {
+function normalizeWidgetItem(item, media_base_url) {
   const normalizedItem = {
     ...item,
     title: typeof item?.title === 'string' ? item.title.trim() : '',
@@ -656,7 +708,7 @@ function normalizeWidgetItem(item, mediaBaseUrl) {
       ...normalizedItem,
       settings: {
         ...item.settings,
-        avatar: normalizeMediaField(item.settings.avatar, mediaBaseUrl),
+        avatar: normalizeMediaField(item.settings.avatar, media_base_url),
       },
     };
   }
@@ -733,21 +785,23 @@ function normalizeFrontPage(frontPage) {
   };
 }
 
-function normalizePostIndex(postIndex) {
-  if (!postIndex || typeof postIndex !== 'object') {
+function normalizePostIndex(post_index) {
+  if (!post_index || typeof post_index !== 'object') {
     return { ...DEFAULT_POST_INDEX };
   }
 
   return {
-    enabled: postIndex.enabled !== false,
-    path: normalizeNonEmptyString(postIndex.path, DEFAULT_POST_INDEX.path),
-    paginate: postIndex.paginate !== false,
+    enabled: post_index.enabled !== false,
+    path: normalizeNonEmptyString(post_index.path, DEFAULT_POST_INDEX.path),
+    paginate: post_index.paginate !== false,
   };
 }
 
 function createRenderData(previewData, themeMetadata = {}) {
   const themeSupportsComments = themeMetadata?.features?.comments === true;
-  const themeSupportsPostIndex = themeMetadata?.features?.postIndex !== false;
+  const themeSupportsPostIndex = themeMetadata?.features?.post_index !== false;
+  const themeSupportsSearch = themeMetadata?.features?.search === true;
+  previewData.site.search = previewData.site.search !== false && themeSupportsSearch;
   const authorsById = new Map(previewData.content.authors.map((author) => [author.id, author]));
   const categoriesBySlug = new Map(previewData.content.categories.map((category) => [category.slug, category]));
   const tagsBySlug = new Map(previewData.content.tags.map((tag) => [tag.slug, tag]));
@@ -755,8 +809,9 @@ function createRenderData(previewData, themeMetadata = {}) {
   const tagPostsBySlug = new Map();
   const categoryCountBySlug = new Map();
   const tagCountBySlug = new Map();
+  const discoverableSourcePosts = previewData.content.posts.filter((post) => !isDelistedDocument(post));
 
-  for (const post of previewData.content.posts) {
+  for (const post of discoverableSourcePosts) {
     for (const slug of post.category_slugs) {
       pushToSlugMap(categoryPostsBySlug, slug, post);
       categoryCountBySlug.set(slug, (categoryCountBySlug.get(slug) || 0) + 1);
@@ -769,25 +824,34 @@ function createRenderData(previewData, themeMetadata = {}) {
   }
 
   const preparedPosts = previewData.content.posts.map((post) => preparePost(post, previewData.site, authorsById, categoriesBySlug, tagsBySlug, themeSupportsComments));
-  const posts = preparedPosts.map((post, index) => ({
+  const discoverablePreparedPosts = preparedPosts.filter((post) => !isDelistedDocument(post));
+  const adjacentPostsBySlug = new Map(
+    discoverablePreparedPosts.map((post, index) => [post.slug, {
+      prev: index > 0 ? buildAdjacentPostSummary(discoverablePreparedPosts[index - 1]) : null,
+      next: index < discoverablePreparedPosts.length - 1 ? buildAdjacentPostSummary(discoverablePreparedPosts[index + 1]) : null,
+    }]),
+  );
+  const posts = preparedPosts.map((post) => ({
     ...post,
-    prev: index > 0 ? buildAdjacentPostSummary(preparedPosts[index - 1]) : null,
-    next: index < preparedPosts.length - 1 ? buildAdjacentPostSummary(preparedPosts[index + 1]) : null,
+    prev: adjacentPostsBySlug.get(post.slug)?.prev || null,
+    next: adjacentPostsBySlug.get(post.slug)?.next || null,
   }));
   const pages = previewData.content.pages.map((page) => preparePage(page, previewData.site));
   const postBySlug = new Map(posts.map((post) => [post.slug, post]));
   const pageBySlug = new Map(pages.map((page) => [page.slug, page]));
   const frontPage = previewData.site.front_page;
-  const postIndex = previewData.site.post_index;
-  const effectivePostIndexEnabled = postIndex.enabled !== false && themeSupportsPostIndex;
-  const effectivePostIndexPaginate = effectivePostIndexEnabled && postIndex.paginate !== false;
-  const postIndexBasePath = normalizeRoutePath(postIndex.path || DEFAULT_POST_INDEX.path);
-
-  if (frontPage.type !== 'theme_index' && effectivePostIndexEnabled && postIndexBasePath === '/') {
+  const collections = resolveCollections(previewData.collections, postBySlug, pageBySlug, frontPage);
+  attachCollectionCursors(posts, pages, collections);
+  const post_index = previewData.site.post_index;
+  const effectivePostIndexEnabled = post_index.enabled !== false && themeSupportsPostIndex;
+  const effectivePostIndexPaginate = effectivePostIndexEnabled && post_index.paginate !== false;
+  const post_indexBasePath = normalizeRoutePath(post_index.path || DEFAULT_POST_INDEX.path);
+
+  if (frontPage.type !== 'theme_index' && effectivePostIndexEnabled && post_indexBasePath === '/') {
     throw new Error('Invalid front page configuration: site.front_page occupies "/" so site.post_index.path must not be "/". Set site.post_index.path to a non-root path or disable site.post_index.');
   }
 
-  const frontPageRoute = buildFrontPageRoute(frontPage, pages, effectivePostIndexEnabled, postIndexBasePath);
+  const frontPageRoute = buildFrontPageRoute(frontPage, pages, effectivePostIndexEnabled, post_indexBasePath);
   const pageFrontPageSlug = frontPage.type === 'page' ? frontPage.page_slug : '';
   const preparedPages = pageFrontPageSlug
     ? pages.filter((page) => page.slug !== pageFrontPageSlug)
@@ -797,22 +861,22 @@ function createRenderData(previewData, themeMetadata = {}) {
     posts,
     pages: preparedPages,
     postBySlug,
-    collections: resolveCollections(previewData.collections, postBySlug, pageBySlug, frontPage),
+    collections,
     taxonomies: buildGlobalTaxonomies(previewData, categoryCountBySlug, tagCountBySlug),
     frontPageRoute,
     indexRoutes: buildPostIndexRoutes({
       enabled: effectivePostIndexEnabled,
       paginate: effectivePostIndexPaginate,
-      items: previewData.content.posts,
-      postsPerPage: previewData.site.postsPerPage,
-      basePath: postIndexBasePath,
+      items: discoverableSourcePosts,
+      posts_per_page: previewData.site.posts_per_page,
+      basePath: post_indexBasePath,
       outputStyle: previewData.site.permalinks.output_style,
       postBySlug,
       frontPage,
     }),
     archiveRoutes: buildPaginatedCollection({
-      items: previewData.content.posts,
-      postsPerPage: previewData.site.postsPerPage,
+      items: discoverableSourcePosts,
+      posts_per_page: previewData.site.posts_per_page,
       basePath: '/archive/',
       outputStyle: previewData.site.permalinks.output_style,
     }).map((entry) => ({
@@ -828,7 +892,7 @@ function createRenderData(previewData, themeMetadata = {}) {
       items: previewData.content.categories,
       postsBySlug: categoryPostsBySlug,
       postBySlug,
-      postsPerPage: previewData.site.postsPerPage,
+      posts_per_page: previewData.site.posts_per_page,
       outputStyle: previewData.site.permalinks.output_style,
       buildBasePath: (category) => resolvePermalink(previewData.site, 'categories', category).path,
       renderExtras: (category) => ({
@@ -839,7 +903,7 @@ function createRenderData(previewData, themeMetadata = {}) {
       items: previewData.content.tags,
       postsBySlug: tagPostsBySlug,
       postBySlug,
-      postsPerPage: previewData.site.postsPerPage,
+      posts_per_page: previewData.site.posts_per_page,
       outputStyle: previewData.site.permalinks.output_style,
       buildBasePath: (tag) => resolvePermalink(previewData.site, 'tags', tag).path,
       renderExtras: (tag) => ({
@@ -862,15 +926,19 @@ function resolveCollections(collections, postBySlug, pageBySlug, frontPage) {
   }
 
   return Object.fromEntries(
-    Object.entries(collections).map(([collectionId, collection]) => [
-      collectionId,
-      {
-        id: collectionId,
-        title: normalizeOptionalString(collection?.title),
-        description: normalizeOptionalString(collection?.description),
-        items: resolveCollectionItems(collectionId, collection?.items, postBySlug, pageBySlug, frontPage),
-      },
-    ]),
+    Object.entries(collections).map(([collectionId, collection]) => {
+      const items = resolveCollectionItems(collectionId, collection?.items, postBySlug, pageBySlug, frontPage);
+      return [
+        collectionId,
+        {
+          id: collectionId,
+          title: normalizeOptionalString(collection?.title),
+          description: normalizeOptionalString(collection?.description),
+          count: items.length,
+          items,
+        },
+      ];
+    }),
   );
 }
 
@@ -916,12 +984,70 @@ function buildCollectionPageSummary(page, frontPage) {
     featured_image: page.featured_image || '',
     ...(page.featured_media ? { featured_media: { ...page.featured_media } } : {}),
     meta: page.meta,
+    data: page.data,
   };
 }
 
-function buildFrontPageRoute(frontPage, pages, effectivePostIndexEnabled, postIndexBasePath) {
+function attachCollectionCursors(posts, pages, collections) {
+  const postTargets = new Map(posts.map((post) => [post.slug, post]));
+  const pageTargets = new Map(pages.map((page) => [page.slug, page]));
+
+  for (const [collectionId, collection] of Object.entries(collections || {})) {
+    const items = Array.isArray(collection.items) ? collection.items : [];
+
+    items.forEach((item, index) => {
+      const target = item.type === 'post'
+        ? postTargets.get(item.slug)
+        : item.type === 'page'
+          ? pageTargets.get(item.slug)
+          : null;
+
+      if (!target) {
+        return;
+      }
+
+      target.collection_cursors = target.collection_cursors || {};
+      target.collection_cursors[collectionId] = buildCollectionCursor(collectionId, collection, items, index);
+    });
+  }
+}
+
+function buildCollectionCursor(collectionId, collection, items, index) {
+  const count = items.length;
+
+  return {
+    collection_id: collectionId,
+    collection_title: collection.title || '',
+    index,
+    position: index + 1,
+    count,
+    first: index === 0,
+    last: index === count - 1,
+    prev: index > 0 ? buildCollectionCursorItemSummary(items[index - 1]) : null,
+    next: index < count - 1 ? buildCollectionCursorItemSummary(items[index + 1]) : null,
+  };
+}
+
+function buildCollectionCursorItemSummary(item) {
+  if (!item) {
+    return null;
+  }
+
+  return {
+    type: item.type,
+    title: item.title,
+    slug: item.slug,
+    url: item.url,
+    excerpt: item.excerpt || '',
+    featured_image: item.featured_image || '',
+    meta: item.meta,
+    data: item.data,
+  };
+}
+
+function buildFrontPageRoute(frontPage, pages, effectivePostIndexEnabled, post_indexBasePath) {
   if (frontPage.type === 'theme_index') {
-    if (effectivePostIndexEnabled && postIndexBasePath === '/') {
+    if (effectivePostIndexEnabled && post_indexBasePath === '/') {
       return null;
     }
 
@@ -967,7 +1093,7 @@ function buildPostIndexRoutes(options) {
   }
 
   if (!options.paginate) {
-    const items = options.items.slice(0, options.postsPerPage);
+    const items = options.items.slice(0, options.posts_per_page);
     return [{
       path: options.basePath,
       route_type: 'post_index',
@@ -982,7 +1108,7 @@ function buildPostIndexRoutes(options) {
 
   return buildPaginatedCollection({
     items: options.items,
-    postsPerPage: options.postsPerPage,
+    posts_per_page: options.posts_per_page,
     basePath: options.basePath,
     outputStyle: options.outputStyle,
   }).map((entry) => ({
@@ -1073,6 +1199,7 @@ function resolveWidgetItem(item, previewData, renderData, widgetAreaId, index) {
 function resolveRecentPostsWidget(baseWidget, settings, renderData) {
   const limit = clampInteger(settings?.limit, 5, 1, 20);
   const items = renderData.posts
+    .filter((post) => !isDelistedDocument(post))
     .slice(0, limit)
     .map((post) => ({
       title: post.title,
@@ -1284,7 +1411,9 @@ function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug, them
     featured_image: post.featured_image,
     ...(post.featured_media ? { featured_media: { ...post.featured_media } } : {}),
     meta: post.meta,
+    data: post.data,
     status: post.status,
+    discoverability: post.discoverability,
     allow_comments: post.allow_comments,
     category_slugs: post.category_slugs,
     tag_slugs: post.tag_slugs,
@@ -1301,7 +1430,7 @@ function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug, them
     published_at: formatTimestamp(post.published_at_iso, site),
     updated_at: formatTimestamp(post.updated_at_iso, site),
     reading_time: calculateReadingTime(renderedDocument.html),
-    comments_enabled: themeSupportsComments && site.disallowComments !== true && post.allow_comments === true,
+    comments_enabled: themeSupportsComments && site.disallow_comments !== true && post.allow_comments === true,
   };
 }
 
@@ -1328,7 +1457,7 @@ function buildTaxonomyRoutes(options) {
 
     const paginated = buildPaginatedCollection({
       items: matchedPosts,
-      postsPerPage: options.postsPerPage,
+      posts_per_page: options.posts_per_page,
       basePath: options.buildBasePath(item),
       outputStyle: options.outputStyle,
     });
@@ -1352,14 +1481,14 @@ function buildTaxonomyRoutes(options) {
 function buildPaginatedCollection(options) {
   const basePath = normalizePaginationBasePath(options.basePath);
   const outputStyle = PERMALINK_OUTPUT_STYLES.has(options.outputStyle) ? options.outputStyle : DEFAULT_PERMALINKS.output_style;
-  const postsPerPage = Number.isInteger(options.postsPerPage) && options.postsPerPage > 0 ? options.postsPerPage : DEFAULT_POSTS_PER_PAGE;
+  const posts_per_page = Number.isInteger(options.posts_per_page) && options.posts_per_page > 0 ? options.posts_per_page : DEFAULT_POSTS_PER_PAGE;
   const totalPosts = options.items.length;
-  const totalPages = Math.max(1, Math.ceil(totalPosts / postsPerPage));
+  const totalPages = Math.max(1, Math.ceil(totalPosts / posts_per_page));
   const pages = [];
 
   for (let page = 1; page <= totalPages; page += 1) {
-    const start = (page - 1) * postsPerPage;
-    const end = start + postsPerPage;
+    const start = (page - 1) * posts_per_page;
+    const end = start + posts_per_page;
 
     pages.push({
       path: buildPaginatedPath(basePath, page),
@@ -1535,6 +1664,8 @@ function buildStructuredPostSummary(post) {
     reading_time: post.reading_time,
     featured_image: post.featured_image,
     ...(post.featured_media ? { featured_media: { ...post.featured_media } } : {}),
+    meta: post.meta,
+    data: post.data,
     author: {
       display_name: post.author?.display_name || '',
       avatar: post.author?.avatar || '',
@@ -1557,6 +1688,7 @@ function buildAdjacentPostSummary(post) {
     excerpt: post.excerpt,
     published_at: post.published_at,
     published_at_iso: post.published_at_iso,
+    data: post.data,
   };
 }
 
@@ -1646,50 +1778,25 @@ function formatArchiveLabel(date, site) {
 function formatTimestamp(value, site) {
   const date = toDate(value);
   const locale = normalizeLocale(site.locale || DEFAULT_LOCALE);
-  const dateFormat = normalizeNonEmptyString(site.dateFormat, DEFAULT_DATE_FORMAT);
-  const timeFormat = typeof site.timeFormat === 'string' ? site.timeFormat : DEFAULT_TIME_FORMAT;
+  const dateStyle = DATETIME_STYLES.has(site.date_style) ? site.date_style : DEFAULT_DATE_STYLE;
+  const timeStyle = DATETIME_STYLES.has(site.time_style) ? site.time_style : DEFAULT_TIME_STYLE;
   const siteTimezone = normalizeNonEmptyString(site.timezone, DEFAULT_TIMEZONE);
 
-  const dateParts = new Intl.DateTimeFormat(locale, {
-    timeZone: siteTimezone,
-    year: 'numeric',
-    month: dateFormat === 'MMMM D, YYYY' ? 'long' : '2-digit',
-    day: '2-digit',
-  }).formatToParts(date);
-
-  const year = dateParts.find((part) => part.type === 'year')?.value || '';
-  const month = dateParts.find((part) => part.type === 'month')?.value || '';
-  const day = dateParts.find((part) => part.type === 'day')?.value || '';
-
-  let formattedDate = `${year}-${month}-${day}`;
-  if (dateFormat === 'DD/MM/YYYY') {
-    formattedDate = `${day}/${month}/${year}`;
-  } else if (dateFormat === 'MM/DD/YYYY') {
-    formattedDate = `${month}/${day}/${year}`;
-  } else if (dateFormat === 'MMMM D, YYYY') {
-    formattedDate = `${month} ${String(Number(day))}, ${year}`;
-  }
-
-  if (!timeFormat) {
-    return formattedDate;
+  if (dateStyle === 'none' && timeStyle === 'none') {
+    return '';
   }
 
-  const timeParts = new Intl.DateTimeFormat(locale, {
+  const options = {
     timeZone: siteTimezone,
-    hour: '2-digit',
-    minute: '2-digit',
-    hour12: timeFormat === 'hh:mm A',
-  }).formatToParts(date);
-
-  const hour = timeParts.find((part) => part.type === 'hour')?.value || '';
-  const minute = timeParts.find((part) => part.type === 'minute')?.value || '';
-  const dayPeriod = (timeParts.find((part) => part.type === 'dayPeriod')?.value || '').toUpperCase();
-
-  const formattedTime = timeFormat === 'hh:mm A'
-    ? `${hour}:${minute}${dayPeriod ? ` ${dayPeriod}` : ''}`
-    : `${hour}:${minute}`;
+  };
+  if (dateStyle !== 'none') {
+    options.dateStyle = dateStyle;
+  }
+  if (timeStyle !== 'none') {
+    options.timeStyle = timeStyle;
+  }
 
-  return `${formattedDate} ${formattedTime}`.trim();
+  return new Intl.DateTimeFormat(locale, options).format(date);
 }
 
 function calculateReadingTime(html) {
@@ -1785,11 +1892,12 @@ async function normalizeAndValidateThemePackage(themePackage) {
     ...(themePackage.metadata.author ? { author: themePackage.metadata.author } : {}),
     ...(themePackage.metadata.description ? { description: themePackage.metadata.description } : {}),
     ...(themePackage.metadata.thumbnail ? { thumbnail: themePackage.metadata.thumbnail } : {}),
+    ...(themePackage.metadata.links ? { links: themePackage.metadata.links } : {}),
     ...(themePackage.metadata.features ? { features: themePackage.metadata.features } : {}),
-    ...(themePackage.metadata.menuSlots ? { menuSlots: themePackage.metadata.menuSlots } : {}),
-    ...(themePackage.metadata.widgetAreas ? { widgetAreas: themePackage.metadata.widgetAreas } : {}),
-    ...(themePackage.metadata.siteMeta ? { siteMeta: themePackage.metadata.siteMeta } : {}),
-    ...(themePackage.metadata.collectionSlots ? { collectionSlots: themePackage.metadata.collectionSlots } : {}),
+    ...(themePackage.metadata.menu_slots ? { menu_slots: themePackage.metadata.menu_slots } : {}),
+    ...(themePackage.metadata.widget_areas ? { widget_areas: themePackage.metadata.widget_areas } : {}),
+    ...(themePackage.metadata.site_meta ? { site_meta: themePackage.metadata.site_meta } : {}),
+    ...(themePackage.metadata.collection_slots ? { collection_slots: themePackage.metadata.collection_slots } : {}),
   }));
 
   for (const [templateName, templateContent] of themePackage.templates.entries()) {
@@ -1806,7 +1914,7 @@ async function normalizeAndValidateThemePackage(themePackage) {
 
   const validation = await validateThemeFiles(fileMap);
   if (!validation.ok) {
-    throw new Error(`Theme validation failed: ${validation.errors[0]?.message || 'Unknown error'}`);
+    throw new Error(formatThemeValidationFailure(validation));
   }
 
   if (!validation.manifest) {
@@ -1821,6 +1929,61 @@ async function normalizeAndValidateThemePackage(themePackage) {
   };
 }
 
+function formatThemeValidationFailure(validation) {
+  const blocks = [
+    [
+      'Theme validation failed',
+      `Errors: ${validation.errors.length}`,
+      `Checked files: ${validation.checkedFiles}`,
+    ].join('\n'),
+    ...validation.errors.map((issue) => formatThemeValidationIssue(issue)),
+  ];
+  return blocks.join('\n\n');
+}
+
+function formatThemeValidationIssue(issue) {
+  if (!issue) {
+    return 'Reason: Unknown error';
+  }
+
+  const lines = [`ERROR ${issue.code || 'THEME_VALIDATION_ERROR'}`];
+  const location = splitIssuePath(issue.path);
+  if (location.file) {
+    lines.push(`File: ${location.file}`);
+  }
+  if (location.path) {
+    lines.push(`Path: ${location.path}`);
+  }
+  if (Number.isInteger(issue.line) && Number.isInteger(issue.column)) {
+    lines.push(`Line: ${issue.line}, Column: ${issue.column}`);
+  }
+  if (issue.category) {
+    lines.push(`Category: ${issue.category}`);
+  }
+  lines.push(`Reason: ${issue.message || 'Unknown error'}`);
+  if (issue.snippet) {
+    const lineLabel = Number.isInteger(issue.line) ? String(issue.line) : '';
+    lines.push('', `${lineLabel} | ${issue.snippet.line}`, `${' '.repeat(lineLabel.length)} | ${issue.snippet.pointer}`);
+  }
+  if (issue.hint) {
+    lines.push('', 'Hint:', issue.hint);
+  }
+
+  return lines.join('\n');
+}
+
+function splitIssuePath(issuePath) {
+  const normalizedPath = String(issuePath || '');
+  if (normalizedPath.startsWith('theme.json.')) {
+    return {
+      file: 'theme.json',
+      path: normalizedPath.slice('theme.json.'.length),
+    };
+  }
+
+  return { file: normalizedPath, path: '' };
+}
+
 function normalizeThemePackageMetadata(sourceMetadata, manifest) {
   return {
     ...manifest,
@@ -1902,6 +2065,7 @@ function buildPageMeta(site, options = {}) {
   const ogType = normalizeNonEmptyString(options.ogType, 'website');
   const publishedTime = normalizeOptionalString(options.publishedTime);
   const modifiedTime = normalizeOptionalString(options.modifiedTime);
+  const robotsNoindex = options.robotsNoindex === true;
 
   const meta = {
     title: escapeHtml(resolvedTitle),
@@ -1915,6 +2079,7 @@ function buildPageMeta(site, options = {}) {
     og_image: ogImage ? escapeHtml(ogImage) : '',
     article_published_time: publishedTime ? escapeHtml(publishedTime) : '',
     article_modified_time: modifiedTime ? escapeHtml(modifiedTime) : '',
+    robots_noindex: robotsNoindex,
   };
 
   return {
@@ -1935,6 +2100,9 @@ function buildMetaHeadTags(meta) {
   if (meta.description) {
     tags.push(`<meta name="description" content="${meta.description}">`);
   }
+  if (meta.robots_noindex) {
+    tags.push('<meta name="robots" content="noindex">');
+  }
   if (meta.canonical_url) {
     tags.push(`<link rel="canonical" href="${meta.canonical_url}">`);
   }
@@ -1982,7 +2150,7 @@ function resolveMetaImageUrl(image) {
   return '';
 }
 
-function normalizeMediaField(value, mediaBaseUrl) {
+function normalizeMediaField(value, media_base_url) {
   if (value === undefined) {
     return undefined;
   }
@@ -1996,7 +2164,7 @@ function normalizeMediaField(value, mediaBaseUrl) {
     return normalizeAbsoluteUrl(normalizedValue, SAFE_MEDIA_PROTOCOLS);
   }
 
-  const normalizedBaseUrl = normalizeOptionalString(mediaBaseUrl);
+  const normalizedBaseUrl = normalizeOptionalString(media_base_url);
   if (!normalizedBaseUrl) {
     return normalizedValue;
   }
@@ -2233,6 +2401,10 @@ function assertPlannedOutputPathsSafe(state) {
     COMMENT_POLICY_OUTPUT_PATH,
   ];
 
+  if (shouldGenerateSearchArtifacts(state, state.options)) {
+    plannedPaths.push(SEARCH_INDEX_OUTPUT_PATH, SEARCH_ADAPTER_OUTPUT_PATH, SEARCH_PAGEFIND_ADAPTER_OUTPUT_PATH);
+  }
+
   if (state.options.generateSpecialFiles) {
     plannedPaths.push('404.html');
     if (shouldGenerateRobotsTxt(state.options)) {
@@ -2338,6 +2510,7 @@ function sha256(content) {
 
 function injectSiteCustomizations(html, state) {
   let next = injectFaviconLinks(html, state.favicon);
+  next = injectGeneratorMeta(next, state.exposeGenerator);
   next = injectCustomCssAssetLink(next, state.customCssHref);
   next = injectCustomHtml(next, state.customHtml);
   return next;
@@ -2374,6 +2547,14 @@ function buildFaviconLinks(favicon) {
   return lines.join('\n');
 }
 
+function injectGeneratorMeta(html, exposeGenerator) {
+  if (exposeGenerator === false) {
+    return html;
+  }
+
+  return html.replace('</head>', '  <meta name="generator" content="ZeroPress">\n</head>');
+}
+
 function injectCustomCssAssetLink(html, href) {
   if (!normalizeOptionalString(href)) {
     return html;
@@ -2397,9 +2578,489 @@ function injectCustomHtml(html, customHtml) {
   return next;
 }
 
-function buildSitemapXml(site, emitted, generatedAt) {
+function buildSearchIndexJson(state) {
+  return `${JSON.stringify(buildSearchIndexItems(state), null, 2)}\n`;
+}
+
+function buildSearchIndexItems(state) {
+  const posts = state.renderData.posts
+    .filter((post) => post.status === 'published' && !isDelistedDocument(post))
+    .map((post) => ({
+      id: `post:${post.slug}`,
+      type: 'post',
+      title: post.title,
+      url: post.url,
+      excerpt: normalizeSearchText(post.excerpt),
+      headings: buildSearchHeadings(post.toc),
+      categories: Array.isArray(post.categories) ? post.categories.map((category) => category.name).filter(Boolean) : [],
+      tags: Array.isArray(post.tags) ? post.tags.map((tag) => tag.name).filter(Boolean) : [],
+      published_at_iso: normalizeIsoTimestamp(post.published_at_iso),
+      updated_at_iso: normalizeIsoTimestamp(post.updated_at_iso),
+      content_text: htmlToSearchText(post.html),
+    }));
+
+  const frontPagePage = state.renderData.frontPageRoute?.front_page_type === 'page'
+    ? state.renderData.frontPageRoute.page
+    : null;
+  const frontPageItems = frontPagePage && frontPagePage.status === 'published' && !isDelistedDocument(frontPagePage)
+    ? [buildSearchPageItem(frontPagePage, '/')]
+    : [];
+  const pageItems = state.renderData.pages
+    .filter((page) => page.status === 'published' && !isDelistedDocument(page))
+    .map((page) => buildSearchPageItem(page, page.url));
+
+  return [...posts, ...frontPageItems, ...pageItems];
+}
+
+function buildSearchPageItem(page, url) {
+  return {
+    id: `page:${page.slug}`,
+    type: 'page',
+    title: page.title,
+    url,
+    excerpt: normalizeSearchText(page.excerpt),
+    headings: buildSearchHeadings(page.toc),
+    categories: [],
+    tags: [],
+    published_at_iso: '',
+    updated_at_iso: '',
+    content_text: htmlToSearchText(page.html),
+  };
+}
+
+function buildSearchHeadings(toc) {
+  return Array.isArray(toc)
+    ? toc.map((item) => normalizeSearchText(item?.title)).filter(Boolean)
+    : [];
+}
+
+function htmlToSearchText(html) {
+  return normalizeSearchText(decodeHtmlEntities(
+    String(html || '')
+      .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ')
+      .replace(/<!--[\s\S]*?-->/g, ' ')
+      .replace(/<[^>]+>/g, ' '),
+  ));
+}
+
+function decodeHtmlEntities(value) {
+  const namedEntities = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+  };
+
+  return String(value || '').replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z][a-zA-Z0-9]+);/g, (match, entity) => {
+    if (entity.startsWith('#x')) {
+      const codePoint = Number.parseInt(entity.slice(2), 16);
+      return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : match;
+    }
+    if (entity.startsWith('#')) {
+      const codePoint = Number.parseInt(entity.slice(1), 10);
+      return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : match;
+    }
+    return Object.prototype.hasOwnProperty.call(namedEntities, entity) ? namedEntities[entity] : match;
+  });
+}
+
+function normalizeSearchText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function buildSearchAdapterJs() {
+  const fieldWeightsJson = JSON.stringify(SEARCH_FIELD_WEIGHTS, null, 2);
+  return `const FIELD_WEIGHTS = ${fieldWeightsJson};
+const FIELD_NAMES = Object.keys(FIELD_WEIGHTS);
+const RECENCY_BOOST_MAX = ${SEARCH_RECENCY_BOOST_MAX};
+const DEFAULT_LIMIT = 20;
+const BM25_K1 = 1.2;
+const BM25_B = 0.75;
+
+let preparedIndexPromise;
+
+export async function preload() {
+  await loadPreparedIndex();
+}
+
+export async function search(query, options = {}) {
+  const prepared = await loadPreparedIndex();
+  const terms = tokenize(query);
+  const phrase = normalizeText(query);
+  if (terms.length === 0 && !phrase) {
+    return { results: [] };
+  }
+
+  const hits = [];
+  for (const document of prepared.documents) {
+    const score = scoreDocument(document, terms, phrase, prepared);
+    if (score > 0) {
+      hits.push({ document, score });
+    }
+  }
+
+  const limit = normalizeLimit(options.limit);
+  hits.sort((left, right) => right.score - left.score || left.document.raw.title.localeCompare(right.document.raw.title));
+
+  return {
+    results: hits.slice(0, limit).map((hit) => ({
+      id: hit.document.raw.id,
+      score: Number(hit.score.toFixed(6)),
+      data: async () => buildResultData(hit.document.raw, query),
+    })),
+  };
+}
+
+async function loadPreparedIndex() {
+  if (!preparedIndexPromise) {
+    preparedIndexPromise = fetch(new URL('./search.json', import.meta.url))
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error('ZeroPress search index not found');
+        }
+        return response.json();
+      })
+      .then((items) => prepareIndex(Array.isArray(items) ? items : []));
+  }
+
+  return preparedIndexPromise;
+}
+
+function prepareIndex(items) {
+  const documents = items.map((item) => prepareDocument(item));
+  const documentFrequencies = new Map();
+  const averageLengths = Object.fromEntries(FIELD_NAMES.map((fieldName) => [fieldName, 1]));
+  const newestPostTime = documents.reduce((newest, document) => {
+    if (document.raw.type !== 'post') {
+      return newest;
+    }
+    return Math.max(newest, document.publishedTime || 0);
+  }, 0);
+
+  for (const document of documents) {
+    const seenTerms = new Set();
+    for (const fieldName of FIELD_NAMES) {
+      for (const term of document.fieldTokens[fieldName]) {
+        seenTerms.add(term);
+      }
+    }
+    for (const term of seenTerms) {
+      documentFrequencies.set(term, (documentFrequencies.get(term) || 0) + 1);
+    }
+  }
+
+  for (const fieldName of FIELD_NAMES) {
+    const total = documents.reduce((sum, document) => sum + document.fieldLengths[fieldName], 0);
+    averageLengths[fieldName] = documents.length > 0 ? Math.max(1, total / documents.length) : 1;
+  }
+
+  return {
+    documents,
+    documentFrequencies,
+    averageLengths,
+    documentCount: documents.length,
+    newestPostTime,
+  };
+}
+
+function prepareDocument(item) {
+  const raw = normalizeItem(item);
+  const fields = {
+    title: raw.title,
+    headings: raw.headings.join(' '),
+    tags: raw.tags.join(' '),
+    categories: raw.categories.join(' '),
+    excerpt: raw.excerpt,
+    content_text: raw.content_text,
+  };
+  const fieldTexts = {};
+  const fieldTokens = {};
+  const fieldTermCounts = {};
+  const fieldLengths = {};
+
+  for (const [fieldName, value] of Object.entries(fields)) {
+    const normalizedText = normalizeText(value);
+    const tokens = tokenize(normalizedText);
+    fieldTexts[fieldName] = normalizedText;
+    fieldTokens[fieldName] = tokens;
+    fieldTermCounts[fieldName] = countTerms(tokens);
+    fieldLengths[fieldName] = Math.max(1, tokens.length);
+  }
+
+  return {
+    raw,
+    fieldTexts,
+    fieldTokens,
+    fieldTermCounts,
+    fieldLengths,
+    publishedTime: Date.parse(raw.published_at_iso) || 0,
+  };
+}
+
+function normalizeItem(item) {
+  return {
+    id: String(item && item.id || ''),
+    type: item && item.type === 'page' ? 'page' : 'post',
+    title: String(item && item.title || ''),
+    url: String(item && item.url || ''),
+    excerpt: String(item && item.excerpt || ''),
+    headings: Array.isArray(item && item.headings) ? item.headings.map(String) : [],
+    categories: Array.isArray(item && item.categories) ? item.categories.map(String) : [],
+    tags: Array.isArray(item && item.tags) ? item.tags.map(String) : [],
+    published_at_iso: String(item && item.published_at_iso || ''),
+    updated_at_iso: String(item && item.updated_at_iso || ''),
+    content_text: String(item && item.content_text || ''),
+  };
+}
+
+function scoreDocument(document, terms, phrase, prepared) {
+  let score = 0;
+  const uniqueTerms = Array.from(new Set(terms));
+
+  for (const term of uniqueTerms) {
+    const documentFrequency = prepared.documentFrequencies.get(term) || 0;
+    const idf = Math.log(1 + (prepared.documentCount - documentFrequency + 0.5) / (documentFrequency + 0.5));
+
+    for (const fieldName of FIELD_NAMES) {
+      const termFrequency = document.fieldTermCounts[fieldName].get(term) || 0;
+      if (termFrequency === 0) {
+        continue;
+      }
+
+      const fieldLength = document.fieldLengths[fieldName];
+      const averageLength = prepared.averageLengths[fieldName];
+      const denominator = termFrequency + BM25_K1 * (1 - BM25_B + BM25_B * (fieldLength / averageLength));
+      score += FIELD_WEIGHTS[fieldName] * idf * ((termFrequency * (BM25_K1 + 1)) / denominator);
+    }
+  }
+
+  if (phrase && phrase.length > 1) {
+    for (const fieldName of FIELD_NAMES) {
+      if (document.fieldTexts[fieldName].includes(phrase)) {
+        score += FIELD_WEIGHTS[fieldName] * 0.6;
+      }
+    }
+  }
+
+  if (score <= 0) {
+    return 0;
+  }
+
+  return score * (1 + recencyBoost(document, prepared.newestPostTime));
+}
+
+function recencyBoost(document, newestPostTime) {
+  if (document.raw.type !== 'post' || !document.publishedTime || !newestPostTime) {
+    return 0;
+  }
+  const ageMs = Math.max(0, newestPostTime - document.publishedTime);
+  const halfLifeMs = 180 * 24 * 60 * 60 * 1000;
+  return RECENCY_BOOST_MAX * Math.exp(-ageMs / halfLifeMs);
+}
+
+function buildResultData(item, query) {
+  const excerpt = buildExcerpt(item, query);
+  return {
+    url: item.url,
+    excerpt,
+    plain_excerpt: excerpt,
+    meta: {
+      title: item.title,
+      type: item.type,
+      published_at_iso: item.published_at_iso,
+      updated_at_iso: item.updated_at_iso,
+      categories: item.categories,
+      tags: item.tags,
+    },
+    sub_results: [],
+  };
+}
+
+function buildExcerpt(item, query) {
+  const explicitExcerpt = String(item.excerpt || '').trim();
+  if (explicitExcerpt) {
+    return explicitExcerpt;
+  }
+
+  const text = String(item.content_text || '').replace(/\\s+/g, ' ').trim();
+  if (!text) {
+    return '';
+  }
+
+  const normalizedText = normalizeText(text);
+  const terms = tokenize(query);
+  const firstMatch = terms.map((term) => normalizedText.indexOf(term)).filter((index) => index >= 0).sort((a, b) => a - b)[0];
+  const start = Math.max(0, (firstMatch || 0) - 80);
+  const end = Math.min(text.length, start + 180);
+  const prefix = start > 0 ? '...' : '';
+  const suffix = end < text.length ? '...' : '';
+  return prefix + text.slice(start, end).trim() + suffix;
+}
+
+function countTerms(tokens) {
+  const counts = new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) || 0) + 1);
+  }
+  return counts;
+}
+
+function tokenize(value) {
+  const text = normalizeText(value);
+  if (!text) {
+    return [];
+  }
+
+  const tokens = [];
+  if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
+    try {
+      const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+      for (const part of segmenter.segment(text)) {
+        if (part.isWordLike && isUsefulToken(part.segment)) {
+          tokens.push(part.segment);
+        }
+      }
+    } catch {
+      // Fall through to regex tokenization.
+    }
+  }
+
+  for (const match of text.matchAll(/[\\p{Letter}\\p{Number}]+/gu)) {
+    if (isUsefulToken(match[0])) {
+      tokens.push(match[0]);
+    }
+  }
+
+  for (const match of text.matchAll(/[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}]+/gu)) {
+    tokens.push(...buildNgrams(match[0], 2));
+  }
+
+  return tokens;
+}
+
+function buildNgrams(value, size) {
+  const normalized = Array.from(value);
+  if (normalized.length <= size) {
+    return isUsefulToken(value) ? [value] : [];
+  }
+
+  const tokens = [];
+  for (let index = 0; index <= normalized.length - size; index += 1) {
+    tokens.push(normalized.slice(index, index + size).join(''));
+  }
+  tokens.push(value);
+  return tokens;
+}
+
+function isUsefulToken(value) {
+  const token = String(value || '').trim();
+  return token.length > 1 || /^\\d$/.test(token);
+}
+
+function normalizeText(value) {
+  return String(value || '')
+    .normalize('NFKC')
+    .toLowerCase()
+    .replace(/[\\u2018\\u2019]/g, "'")
+    .replace(/[_-]+/g, ' ')
+    .replace(/\\s+/g, ' ')
+    .trim();
+}
+
+function normalizeLimit(value) {
+  return Number.isInteger(value) && value > 0 ? Math.min(value, 100) : DEFAULT_LIMIT;
+}
+`;
+}
+
+function buildSearchPagefindAdapterJs() {
+  return `let pagefindPromise;
+
+export async function preload() {
+  if (!pagefindPromise) {
+    pagefindPromise = import(new URL('./pagefind/pagefind.js', import.meta.url).href).then(async (pagefind) => {
+      if (typeof pagefind.options === 'function') {
+        await pagefind.options({ baseUrl: '/' });
+      }
+      return pagefind;
+    });
+  }
+
+  return pagefindPromise;
+}
+
+export async function search(query, options = {}) {
+  const pagefind = await preload();
+  const result = await pagefind.search(query, options);
+  const limit = normalizeLimit(options.limit);
+  if (!Array.isArray(result?.results)) {
+    return result;
+  }
+
+  const results = result.results.map(normalizeResult);
+  return {
+    ...result,
+    results: limit ? results.slice(0, limit) : results,
+  };
+}
+
+function normalizeResult(result) {
+  if (!result || typeof result.data !== 'function') {
+    return result;
+  }
+
+  return {
+    ...result,
+    data: async () => normalizeResultData(await result.data()),
+  };
+}
+
+function normalizeResultData(data) {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  return {
+    ...data,
+    url: normalizeUrl(data.url),
+    sub_results: Array.isArray(data.sub_results)
+      ? data.sub_results.map((item) => ({ ...item, url: normalizeUrl(item.url) }))
+      : data.sub_results,
+  };
+}
+
+function normalizeUrl(value) {
+  const url = String(value || '');
+  if (url.startsWith('/_zeropress/') && !url.startsWith('/_zeropress/pagefind/')) {
+    return url.replace(/^\\/_zeropress/, '') || '/';
+  }
+  if (url.startsWith('_zeropress/') && !url.startsWith('_zeropress/pagefind/')) {
+    return url.replace(/^_zeropress/, '') || '/';
+  }
+  return url;
+}
+
+function normalizeLimit(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  const limit = Number(value);
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return null;
+  }
+
+  return Math.floor(limit);
+}
+`;
+}
+
+function buildSitemapXml(site, emitted, generatedAt, stylesheetHref = '') {
   const entries = [
-    ...(emitted.frontPage
+    ...(emitted.frontPage && emitted.frontPage.includeInSitemap !== false
       ? [{
         url: emitted.frontPage.url,
         changefreq: 'daily',
@@ -2436,7 +3097,12 @@ function buildSitemapXml(site, emitted, generatedAt) {
     return `  <url>\n    <loc>${loc}</loc>${lastmod}\n    <changefreq>${entry.changefreq}</changefreq>\n    <priority>${entry.priority.toFixed(1)}</priority>\n  </url>`;
   }).join('\n');
 
-  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${body}\n</urlset>`;
+  const normalizedStylesheetHref = normalizeOptionalString(stylesheetHref);
+  const stylesheet = normalizedStylesheetHref
+    ? `\n<?xml-stylesheet type="text/xsl" href="${escapeXml(normalizedStylesheetHref)}"?>`
+    : '';
+
+  return `<?xml version="1.0" encoding="UTF-8"?>${stylesheet}\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${body}\n</urlset>`;
 }
 
 function buildFeedXml(site, emitted, generatedAt) {
@@ -2472,6 +3138,10 @@ function shouldGenerateRobotsTxt(options) {
   return options.generateSpecialFiles && options.generateRobotsTxt !== false;
 }
 
+function shouldGenerateSearchArtifacts(state, options) {
+  return options.generateSpecialFiles && state.previewData.site.search === true;
+}
+
 function getContentType(assetPath) {
   const ext = assetPath.split('.').pop()?.toLowerCase();
   const contentTypes = {