@zeropress/build-core 0.1.15 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Shared ZeroPress build core",
   "type": "module",
   "license": "MIT",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@zeropress/slug-policy": "^0.1.0",
     "@zeropress/preview-data-validator": "^0.4.4",
-    "@zeropress/theme-validator": "^0.3.4",
+    "@zeropress/theme-validator": "^0.4.0",
     "highlight.js": "^11.11.1",
     "markdown-it": "^14.1.0",
     "markdown-it-anchor": "^9.2.0"

package/src/api/build-site.js

@@ -17,8 +17,6 @@ const DEFAULT_DATE_FORMAT = 'YYYY-MM-DD';
 const DEFAULT_TIME_FORMAT = 'HH:mm';
 const DEFAULT_TIMEZONE = 'UTC';
 const DEFAULT_LOCALE = 'en-US';
-const DEFAULT_THEME_RUNTIME = '0.3';
-const THEME_RUNTIME_V0_4 = '0.4';
 const COMMENT_POLICY_OUTPUT_PATH = '_zeropress/comment-policy.json';
 const OUTPUT_PATH_CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
 const SAFE_MEDIA_PROTOCOLS = new Set(['http:', 'https:']);
@@ -89,15 +87,13 @@ async function createBuildState(input, options) {
   }
 
   assertPreviewData(input.previewData);
-  await assertValidThemePackage(input.themePackage);
+  const themePackage = await normalizeAndValidateThemePackage(input.themePackage);
 
   const engine = new ZeroPressEngine();
   const assetProcessor = new AssetProcessor();
   const summaries = [];
-  const themePackage = input.themePackage;
   const previewData = normalizePreviewData(input.previewData);
   const renderData = createRenderData(previewData, themePackage.metadata);
-  const themeRuntime = normalizeThemeRuntime(themePackage.metadata?.runtime);
 
   engine.initialize(themePackage);
 
@@ -114,8 +110,7 @@ async function createBuildState(input, options) {
     writer: input.writer,
     previewData,
     renderData,
-    themeRuntime,
-    widgets: buildWidgetsForTheme(previewData, renderData, themeRuntime),
+    widgets: resolveWidgetAreas(previewData, renderData),
     engine,
     assetProcessor,
     summaries,
@@ -375,11 +370,14 @@ function createRenderData(previewData, themeMetadata = {}) {
     }
   }
 
-  const posts = previewData.content.posts.map((post) => preparePost(post, previewData.site, authorsById, categoriesBySlug, tagsBySlug, themeSupportsComments));
+  const preparedPosts = previewData.content.posts.map((post) => preparePost(post, previewData.site, authorsById, categoriesBySlug, tagsBySlug, themeSupportsComments));
+  const posts = preparedPosts.map((post, index) => ({
+    ...post,
+    prev: index > 0 ? buildAdjacentPostSummary(preparedPosts[index - 1]) : null,
+    next: index < preparedPosts.length - 1 ? buildAdjacentPostSummary(preparedPosts[index + 1]) : null,
+  }));
   const pages = previewData.content.pages.map((page) => preparePage(page));
   const postBySlug = new Map(posts.map((post) => [post.slug, post]));
-  const categoryLinks = renderCategoryLinks(previewData.content.categories, categoryCountBySlug);
-  const tagLinks = renderTagLinks(previewData.content.tags, tagCountBySlug);
 
   return {
     posts,
@@ -393,10 +391,8 @@ function createRenderData(previewData, themeMetadata = {}) {
       path: entry.path,
       page: entry.page,
       totalPages: entry.totalPages,
-      posts: renderPostList(entry.items, postBySlug),
-      categories: categoryLinks,
-      tags: tagLinks,
-      pagination: renderPagination(entry.paginationData),
+      posts: buildStructuredPostCollection(entry.items, postBySlug),
+      pagination: buildStructuredPagination(entry.paginationData),
     })),
     archiveRoutes: buildPaginatedCollection({
       items: previewData.content.posts,
@@ -406,40 +402,34 @@ function createRenderData(previewData, themeMetadata = {}) {
       path: entry.path,
       page: entry.page,
       totalPages: entry.totalPages,
-      posts: renderArchive(entry.items, postBySlug),
-      pagination: renderPagination(entry.paginationData),
+      archive: {
+        groups: buildArchiveGroups(entry.items, postBySlug),
+      },
+      pagination: buildStructuredPagination(entry.paginationData),
     })),
     categoryRoutes: buildTaxonomyRoutes({
       items: previewData.content.categories,
       postsBySlug: categoryPostsBySlug,
+      postBySlug,
       postsPerPage: previewData.site.postsPerPage,
       buildBasePath: (category) => `/categories/${encodeSlugSegment(category.slug)}/`,
-      renderList: (postsForRoute) => renderPostList(postsForRoute, postBySlug),
-      renderExtras: () => ({ categories: categoryLinks }),
+      renderExtras: (category) => ({
+        taxonomy: buildTaxonomyRouteData('category', category, categoryCountBySlug),
+      }),
     }),
     tagRoutes: buildTaxonomyRoutes({
       items: previewData.content.tags,
       postsBySlug: tagPostsBySlug,
+      postBySlug,
       postsPerPage: previewData.site.postsPerPage,
       buildBasePath: (tag) => `/tags/${encodeSlugSegment(tag.slug)}/`,
-      renderList: (postsForRoute) => renderPostList(postsForRoute, postBySlug),
-      renderExtras: () => ({ tags: tagLinks }),
+      renderExtras: (tag) => ({
+        taxonomy: buildTaxonomyRouteData('tag', tag, tagCountBySlug),
+      }),
     }),
   };
 }
 
-function normalizeThemeRuntime(value) {
-  return value === THEME_RUNTIME_V0_4 ? THEME_RUNTIME_V0_4 : DEFAULT_THEME_RUNTIME;
-}
-
-function buildWidgetsForTheme(previewData, renderData, themeRuntime) {
-  if (themeRuntime === THEME_RUNTIME_V0_4) {
-    return resolveWidgetAreas(previewData, renderData);
-  }
-
-  return renderWidgetAreas(previewData, renderData);
-}
-
 function resolveWidgetAreas(previewData, renderData) {
   if (!previewData.widgets || typeof previewData.widgets !== 'object') {
     return {};
@@ -667,253 +657,6 @@ function resolveProfileWidget(baseWidget, settings) {
   };
 }
 
-function renderWidgetAreas(previewData, renderData) {
-  if (!previewData.widgets || typeof previewData.widgets !== 'object') {
-    return {};
-  }
-
-  return Object.fromEntries(
-    Object.entries(previewData.widgets).map(([widgetAreaId, widgetArea]) => [
-      widgetAreaId,
-      renderWidgetArea(widgetArea, previewData, renderData, widgetAreaId),
-    ]),
-  );
-}
-
-function renderWidgetArea(widgetArea, previewData, renderData, widgetAreaId) {
-  if (!widgetArea || !Array.isArray(widgetArea.items) || widgetArea.items.length === 0) {
-    return '';
-  }
-
-  return widgetArea.items
-    .map((item, index) => renderWidgetItem(item, previewData, renderData, widgetAreaId, index))
-    .filter(Boolean)
-    .join('\n');
-}
-
-function renderWidgetItem(item, previewData, renderData, widgetAreaId, index) {
-  if (!item || typeof item !== 'object') {
-    return '';
-  }
-
-  const title = normalizeNonEmptyString(item.title, 'Widget');
-
-  switch (item.type) {
-    case 'recent-posts':
-      return renderRecentPostsWidget(title, item.settings, renderData);
-    case 'categories':
-      return renderCategoriesWidget(title, item.settings, previewData);
-    case 'tags':
-      return renderTagsWidget(title, item.settings, previewData);
-    case 'archives':
-      return renderArchivesWidget(title, item.settings, previewData);
-    case 'image':
-      return renderImageWidget(title, item.settings);
-    case 'text':
-      return renderTextWidget(title, item.settings);
-    case 'link-list':
-      return renderLinkListWidget(title, item.settings);
-    case 'search':
-      return renderSearchWidget(title, item.settings, widgetAreaId, index);
-    case 'profile':
-      return renderProfileWidget(title, item.settings);
-    default:
-      return '';
-  }
-}
-
-function renderRecentPostsWidget(title, settings, renderData) {
-  const limit = clampInteger(settings?.limit, 5, 1, 20);
-  const showDate = settings?.show_date !== false;
-  const items = renderData.posts
-    .slice(0, limit)
-    .map((post) => {
-      const dateMeta = showDate
-        ? `<span class="widget-list__meta">${escapeHtml(post.published_at)}</span>`
-        : '';
-
-      return `<li class="widget-list__item"><a href="/posts/${escapeHtml(encodeSlugSegment(post.slug))}/">${escapeHtml(post.title)}</a>${dateMeta}</li>`;
-    })
-    .join('');
-
-  if (!items) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'recent-posts', `<ul class="widget-list">${items}</ul>`);
-}
-
-function renderCategoriesWidget(title, settings, previewData) {
-  const countBySlug = buildTaxonomyCountMap(previewData.content.posts, 'category_slugs');
-  const items = previewData.content.categories
-    .map((category) => {
-      const count = countBySlug.get(category.slug) || 0;
-      if (count === 0) {
-        return '';
-      }
-
-      const suffix = settings?.show_count === true ? ` <span class="widget-taxonomy__count">(${count})</span>` : '';
-      return `<a href="/categories/${escapeHtml(encodeSlugSegment(category.slug))}/" class="category-link">${escapeHtml(category.name)}${suffix}</a>`;
-    })
-    .filter(Boolean)
-    .join('');
-
-  if (!items) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'categories', `<div class="taxonomy-list taxonomy-list--stack widget-taxonomy">${items}</div>`);
-}
-
-function renderTagsWidget(title, settings, previewData) {
-  const countBySlug = buildTaxonomyCountMap(previewData.content.posts, 'tag_slugs');
-  const limit = clampInteger(settings?.limit, 20, 1, 100);
-  const items = previewData.content.tags
-    .map((tag) => ({
-      ...tag,
-      count: countBySlug.get(tag.slug) || 0,
-    }))
-    .filter((tag) => tag.count > 0)
-    .slice(0, limit)
-    .map((tag) => {
-      const suffix = settings?.show_count === true ? ` <span class="widget-taxonomy__count">(${tag.count})</span>` : '';
-      return `<a href="/tags/${escapeHtml(encodeSlugSegment(tag.slug))}/" class="tag-link">${escapeHtml(tag.name)}${suffix}</a>`;
-    })
-    .join('');
-
-  if (!items) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'tags', `<div class="taxonomy-list widget-taxonomy">${items}</div>`);
-}
-
-function renderArchivesWidget(title, settings, previewData) {
-  const limit = clampInteger(settings?.limit, 12, 1, 120);
-  const archiveEntries = buildArchiveEntries(previewData.content.posts, previewData.site).slice(0, limit);
-  const items = archiveEntries
-    .map((entry) => `<li class="widget-list__item"><a href="/archive/">${escapeHtml(entry.label)}</a><span class="widget-list__meta">${entry.count} posts</span></li>`)
-    .join('');
-
-  if (!items) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'archives', `<ul class="widget-list">${items}</ul>`);
-}
-
-function renderImageWidget(title, settings) {
-  const src = normalizeOptionalString(settings?.src);
-  if (!src) {
-    return '';
-  }
-
-  const alt = escapeHtml(normalizeOptionalString(settings?.alt));
-  const caption = normalizeOptionalString(settings?.caption);
-  const href = normalizeOptionalString(settings?.href);
-  const target = normalizeLinkTarget(settings?.target);
-  const rel = target === '_blank' ? ' rel="noreferrer noopener"' : '';
-  const image = `<img class="widget-image__media" src="${escapeHtml(src)}" alt="${alt}">`;
-  const linkedImage = href ? `<a href="${escapeHtml(href)}" target="${target}"${rel}>${image}</a>` : image;
-  const captionHtml = caption ? `<figcaption class="widget-image__caption">${escapeHtml(caption)}</figcaption>` : '';
-
-  return renderWidgetCard(title, 'image', `<figure class="widget-image">${linkedImage}${captionHtml}</figure>`);
-}
-
-function renderTextWidget(title, settings) {
-  const content = typeof settings?.content === 'string' ? settings.content : '';
-  const html = renderDocumentContent(content, normalizeDocumentType(settings?.document_type));
-  if (!normalizeOptionalString(html)) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'text', `<div class="widget-copy">${html}</div>`);
-}
-
-function renderLinkListWidget(title, settings) {
-  const links = Array.isArray(settings?.links) ? settings.links : [];
-  const items = links
-    .map((link) => {
-      const label = normalizeOptionalString(link?.label);
-      const url = normalizeThemeLinkUrl(link?.url);
-      if (!label || !url) {
-        return '';
-      }
-
-      const target = normalizeLinkTarget(link?.target);
-      const rel = target === '_blank' ? ' rel="noreferrer noopener"' : '';
-      return `<a href="${escapeHtml(url)}" target="${target}"${rel}>${escapeHtml(label)}</a>`;
-    })
-    .filter(Boolean)
-    .join('');
-
-  if (!items) {
-    return '';
-  }
-
-  return renderWidgetCard(title, 'link-list', `<div class="taxonomy-list taxonomy-list--stack widget-link-list">${items}</div>`);
-}
-
-function renderSearchWidget(title, settings, widgetAreaId, index) {
-  const placeholder = escapeHtml(normalizeNonEmptyString(settings?.placeholder, 'Search...'));
-  const buttonLabel = escapeHtml(normalizeNonEmptyString(settings?.button_label, 'Search'));
-  const searchId = `widget-search-${widgetAreaId}-${index + 1}`;
-
-  return renderWidgetCard(title, 'search', [
-    '<div class="widget-search" data-search-root>',
-    `  <label class="sr-only" for="${escapeHtml(searchId)}">${escapeHtml(title)}</label>`,
-    '  <form class="search-theme-wrapper" data-search-form>',
-    `    <input id="${escapeHtml(searchId)}" class="search-input" data-theme-search type="search" placeholder="${placeholder}" autocomplete="off" enterkeyhint="search">`,
-    `    <button class="widget-search-button" type="submit">${buttonLabel}</button>`,
-    '  </form>',
-    '  <div class="search-results" data-search-results hidden></div>',
-    '  <p class="search-feedback search-feedback--sidebar" data-search-feedback aria-live="polite"></p>',
-    '</div>',
-  ].join('\n'));
-}
-
-function renderProfileWidget(title, settings) {
-  const displayName = normalizeOptionalString(settings?.display_name);
-  const affiliation = normalizeOptionalString(settings?.affiliation);
-  const bioShort = normalizeOptionalString(settings?.bio_short);
-  const avatar = normalizeOptionalString(settings?.avatar);
-
-  if (!displayName && !bioShort && !avatar) {
-    return '';
-  }
-
-  const avatarHtml = avatar
-    ? `<img class="widget-profile__avatar" src="${escapeHtml(avatar)}" alt="${escapeHtml(displayName || title)}">`
-    : '';
-  const affiliationHtml = affiliation ? `<p class="widget-profile__affiliation">${escapeHtml(affiliation)}</p>` : '';
-  const bioHtml = bioShort ? `<p class="sidebar-copy">${escapeHtml(bioShort)}</p>` : '';
-
-  return renderWidgetCard(title, 'profile', [
-    '<div class="widget-profile">',
-    avatarHtml,
-    '  <div class="widget-profile__body">',
-    displayName ? `    <p class="widget-profile__name">${escapeHtml(displayName)}</p>` : '',
-    affiliationHtml ? `    ${affiliationHtml}` : '',
-    bioHtml ? `    ${bioHtml}` : '',
-    '  </div>',
-    '</div>',
-  ].filter(Boolean).join('\n'));
-}
-
-function renderWidgetCard(title, modifier, body) {
-  if (!normalizeOptionalString(body)) {
-    return '';
-  }
-
-  return [
-    `<section class="content-card sidebar-card widget-card widget-card--${escapeHtml(modifier)}">`,
-    '  <p class="section-kicker">Widget</p>',
-    `  <h2>${escapeHtml(title)}</h2>`,
-    `  ${body}`,
-    '</section>',
-  ].join('\n');
-}
-
 function preparePage(page) {
   const documentType = normalizeDocumentType(page.document_type);
 
@@ -928,11 +671,28 @@ function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug, them
   const documentType = normalizeDocumentType(post.document_type);
   const html = renderDocumentContent(post.content, documentType);
   const author = authorsById.get(post.author_id);
+  const categories = post.category_slugs
+    .map((slug) => categoriesBySlug.get(slug))
+    .filter(Boolean)
+    .map((category) => ({
+      name: category.name,
+      slug: category.slug,
+      url: `/categories/${encodeSlugSegment(category.slug)}/`,
+    }));
+  const tags = post.tag_slugs
+    .map((slug) => tagsBySlug.get(slug))
+    .filter(Boolean)
+    .map((tag) => ({
+      name: tag.name,
+      slug: tag.slug,
+      url: `/tags/${encodeSlugSegment(tag.slug)}/`,
+    }));
 
   return {
     public_id: post.public_id,
     title: post.title,
     slug: post.slug,
+    url: `/posts/${encodeSlugSegment(post.slug)}/`,
     content: post.content,
     document_type: documentType,
     excerpt: post.excerpt,
@@ -944,14 +704,17 @@ function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug, them
     allow_comments: post.allow_comments,
     category_slugs: post.category_slugs,
     tag_slugs: post.tag_slugs,
+    author: {
+      id: post.author_id,
+      display_name: normalizeNonEmptyString(author?.display_name, post.author_id),
+      avatar: author?.avatar || '',
+    },
+    categories,
+    tags,
     html,
-    author_name: normalizeNonEmptyString(author?.display_name, post.author_id),
-    author_avatar: author?.avatar,
     published_at: formatTimestamp(post.published_at_iso, site),
     updated_at: formatTimestamp(post.updated_at_iso, site),
     reading_time: calculateReadingTime(html),
-    categories_html: renderInlineTaxonomyLinks(post.category_slugs, categoriesBySlug, 'category'),
-    tags_html: renderInlineTaxonomyLinks(post.tag_slugs, tagsBySlug, 'tag'),
     comments_enabled: themeSupportsComments && site.disallowComments !== true && post.allow_comments === true,
   };
 }
@@ -989,8 +752,8 @@ function buildTaxonomyRoutes(options) {
         slug: item.slug,
         page: entry.page,
         totalPages: entry.totalPages,
-        posts: options.renderList(entry.items),
-        pagination: renderPagination(entry.paginationData),
+        posts: buildStructuredPostCollection(entry.items, options.postBySlug),
+        pagination: buildStructuredPagination(entry.paginationData),
         ...options.renderExtras(item),
       });
     }
@@ -1022,6 +785,12 @@ function buildPaginatedCollection(options) {
   return pages;
 }
 
+function buildStructuredPostCollection(posts, postBySlug) {
+  return {
+    items: buildStructuredPostItems(posts, postBySlug),
+  };
+}
+
 function buildPaginatedPath(basePath, page) {
   const normalizedBasePath = normalizePaginationBasePath(basePath);
   if (page <= 1) {
@@ -1062,124 +831,99 @@ function buildPaginationData(currentPage, totalPages, totalPosts, basePath) {
   };
 }
 
-function renderPostList(posts, postBySlug) {
-  if (posts.length === 0) {
-    return '<p>No posts</p>';
-  }
+function buildStructuredPagination(paginationData) {
+  return {
+    current_page: paginationData.currentPage,
+    total_pages: paginationData.totalPages,
+    total_items: paginationData.totalPosts,
+    has_prev: paginationData.hasPrev,
+    has_next: paginationData.hasNext,
+    has_multiple_pages: paginationData.totalPages > 1,
+    prev_url: paginationData.prevUrl || '',
+    next_url: paginationData.nextUrl || '',
+    pages: paginationData.pages.map((page) => ({
+      number: page.number,
+      url: page.url,
+      current: page.current,
+    })),
+  };
+}
 
+function buildStructuredPostItems(posts, postBySlug) {
   return posts
-    .map((post) => {
-      const prepared = postBySlug.get(post.slug);
-      if (!prepared) {
-        return '';
-      }
-
-      return [
-        '<article class="post-list-item">',
-        `  <h2><a href="/posts/${escapeHtml(encodeSlugSegment(post.slug))}/">${escapeHtml(post.title)}</a></h2>`,
-        `  <div class="post-meta"><time datetime="${escapeHtml(prepared.published_at_iso)}">${escapeHtml(prepared.published_at)}</time> • ${escapeHtml(prepared.reading_time)}</div>`,
-        `  <div class="post-excerpt">${escapeHtml(prepared.excerpt)}</div>`,
-        '</article>',
-      ].join('\n');
-    })
+    .map((post) => postBySlug.get(post.slug))
     .filter(Boolean)
-    .join('\n');
+    .map((post) => buildStructuredPostSummary(post));
 }
 
-function renderArchive(posts, postBySlug) {
-  if (posts.length === 0) {
-    return '<p>No posts</p>';
-  }
-
-  const groups = new Map();
-
-  for (const post of posts) {
-    const key = `${toDate(post.published_at_iso).getUTCFullYear()}-${String(toDate(post.published_at_iso).getUTCMonth() + 1).padStart(2, '0')}`;
-    const items = groups.get(key) || [];
-    items.push(post);
-    groups.set(key, items);
-  }
-
-  return Array.from(groups.entries())
-    .map(([key, groupPosts]) => {
-      const items = groupPosts
-        .map((post) => {
-          const prepared = postBySlug.get(post.slug);
-          if (!prepared) {
-            return '';
-          }
-
-          return `<li><a href="/posts/${escapeHtml(encodeSlugSegment(post.slug))}/">${escapeHtml(post.title)}</a> <time datetime="${escapeHtml(prepared.published_at_iso)}">${escapeHtml(prepared.published_at)}</time></li>`;
-        })
-        .filter(Boolean)
-        .join('\n');
-
-      return `<section class="archive-group"><h2>${escapeHtml(key)}</h2><ul>${items}</ul></section>`;
-    })
-    .join('\n');
+function buildStructuredPostSummary(post) {
+  return {
+    title: post.title,
+    slug: post.slug,
+    url: post.url,
+    excerpt: post.excerpt,
+    published_at: post.published_at,
+    published_at_iso: post.published_at_iso,
+    reading_time: post.reading_time,
+    featured_image: post.featured_image,
+    author: {
+      display_name: post.author?.display_name || '',
+      avatar: post.author?.avatar || '',
+    },
+    categories: Array.isArray(post.categories) ? post.categories.map((category) => ({ ...category })) : [],
+    tags: Array.isArray(post.tags) ? post.tags.map((tag) => ({ ...tag })) : [],
+  };
 }
 
-function renderCategoryLinks(categories, countBySlug) {
-  return categories
-    .map((category) => {
-      const count = countBySlug.get(category.slug) || 0;
-      if (count === 0) {
-        return null;
-      }
+function buildAdjacentPostSummary(post) {
+  if (!post) {
+    return null;
+  }
 
-      return `<a href="/categories/${escapeHtml(encodeSlugSegment(category.slug))}/" class="category-link">${escapeHtml(category.name)} (${count})</a>`;
-    })
-    .filter(Boolean)
-    .join('\n');
+  return {
+    title: post.title,
+    slug: post.slug,
+    url: post.url,
+    excerpt: post.excerpt,
+    published_at: post.published_at,
+    published_at_iso: post.published_at_iso,
+  };
 }
 
-function renderTagLinks(tags, countBySlug) {
-  return tags
-    .map((tag) => {
-      const count = countBySlug.get(tag.slug) || 0;
-      if (count === 0) {
-        return null;
-      }
+function buildArchiveGroups(posts, postBySlug) {
+  const groups = new Map();
 
-      return `<a href="/tags/${escapeHtml(encodeSlugSegment(tag.slug))}/" class="tag-link">${escapeHtml(tag.name)} (${count})</a>`;
-    })
-    .filter(Boolean)
-    .join('\n');
-}
+  for (const post of posts) {
+    const prepared = postBySlug.get(post.slug);
+    if (!prepared?.published_at_iso) {
+      continue;
+    }
 
-function renderInlineTaxonomyLinks(slugs, taxonomyBySlug, kind) {
-  const links = slugs
-    .map((slug) => taxonomyBySlug.get(slug))
-    .filter(Boolean)
-    .map((item) => {
-      const base = kind === 'category' ? '/categories/' : '/tags/';
-      const className = kind === 'category' ? 'category-link' : 'tag-link';
-      return `<a href="${base}${escapeHtml(encodeSlugSegment(item.slug))}/" class="${className}">${escapeHtml(item.name)}</a>`;
-    });
+    const date = toDate(prepared.published_at_iso);
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth() + 1;
+    const label = `${year}-${String(month).padStart(2, '0')}`;
+    const current = groups.get(label) || {
+      label,
+      year,
+      month,
+      items: [],
+    };
 
-  if (links.length === 0) {
-    return '';
+    current.items.push(buildStructuredPostSummary(prepared));
+    groups.set(label, current);
   }
 
-  return kind === 'category' ? links.join(', ') : links.join(' ');
+  return Array.from(groups.values());
 }
 
-function renderPagination(paginationData) {
-  if (paginationData.totalPages <= 1) {
-    return '';
-  }
-
-  const prevLink = paginationData.hasPrev && paginationData.prevUrl
-    ? `<a href="${paginationData.prevUrl}" class="prev">Previous</a>`
-    : '';
-  const nextLink = paginationData.hasNext && paginationData.nextUrl
-    ? `<a href="${paginationData.nextUrl}" class="next">Next</a>`
-    : '';
-  const pageLinks = paginationData.pages
-    .map((page) => `<a href="${page.url}" class="page-link ${page.current ? 'current' : ''}">${page.number}</a>`)
-    .join(' ');
-
-  return `<nav class="pagination">\n  ${prevLink}\n  <span class="pages">${pageLinks}</span>\n  ${nextLink}\n</nav>`;
+function buildTaxonomyRouteData(kind, item, countBySlug) {
+  return {
+    kind,
+    slug: item.slug,
+    name: item.name,
+    count: countBySlug.get(item.slug) || 0,
+  };
 }
 
 function buildTaxonomyCountMap(posts, fieldName) {
@@ -1351,7 +1095,7 @@ function recordRouteEmission(state, templateName, route, currentUrl) {
   });
 }
 
-async function assertValidThemePackage(themePackage) {
+async function normalizeAndValidateThemePackage(themePackage) {
   if (!themePackage?.templates || !themePackage?.partials || !themePackage?.assets || !themePackage?.metadata) {
     throw new Error('Invalid themePackage: expected metadata, templates, partials, and assets');
   }
@@ -1389,6 +1133,25 @@ async function assertValidThemePackage(themePackage) {
   if (!validation.ok) {
     throw new Error(`Theme validation failed: ${validation.errors[0]?.message || 'Unknown error'}`);
   }
+
+  if (!validation.manifest) {
+    throw new Error('Theme validation failed: normalized manifest not available');
+  }
+
+  return {
+    metadata: normalizeThemePackageMetadata(themePackage.metadata, validation.manifest),
+    templates: themePackage.templates,
+    partials: themePackage.partials,
+    assets: themePackage.assets,
+  };
+}
+
+function normalizeThemePackageMetadata(sourceMetadata, manifest) {
+  return {
+    ...manifest,
+    ...(sourceMetadata?.thumbnail ? { thumbnail: sourceMetadata.thumbnail } : {}),
+    settings: sourceMetadata?.settings || {},
+  };
 }
 
 async function buildAssetOutputs(assets, assetProcessor, options) {

package/src/index.d.ts

@@ -1,29 +1,10 @@
 import type { PreviewDataV05 } from '@zeropress/preview-data-validator';
+import type { ThemeManifest } from '@zeropress/theme-validator';
 
 export interface ThemePackage {
-  metadata: {
-    name: string;
-    version: string;
-    author?: string | null;
-    description?: string;
+  metadata: ThemeManifest & {
     thumbnail?: string;
     settings?: Record<string, unknown>;
-    features?: {
-      comments?: boolean;
-      newsletter?: boolean;
-    };
-    menuSlots?: Record<string, {
-      title: string;
-      description?: string;
-    }>;
-    widgetAreas?: Record<string, {
-      title: string;
-      description?: string;
-    }>;
-    namespace?: string;
-    slug?: string;
-    license?: 'MIT' | 'Apache-2.0' | 'BSD-3-Clause' | 'GPL-3.0-only' | 'GPL-3.0-or-later';
-    runtime?: '0.3' | '0.4';
   };
   templates: Map<string, string>;
   partials: Map<string, string>;

package/src/render/partial-resolver.js

@@ -0,0 +1,23 @@
+export class PartialResolver {
+  static PARTIAL_PATTERN = /\{\{partial:([a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*)\}\}/g;
+
+  resolve(template, partials) {
+    return this.resolveTemplate(String(template || ''), partials, []);
+  }
+
+  resolveTemplate(template, partials, activeStack) {
+    return template.replace(PartialResolver.PARTIAL_PATTERN, (_, partialName) => {
+      if (!partials.has(partialName)) {
+        throw new Error(`Partial "${partialName}" not found`);
+      }
+
+      if (activeStack.includes(partialName)) {
+        const cycle = [...activeStack, partialName].join(' -> ');
+        throw new Error(`Circular partial reference detected: ${cycle}`);
+      }
+
+      const partialContent = partials.get(partialName);
+      return this.resolveTemplate(String(partialContent || ''), partials, [...activeStack, partialName]);
+    });
+  }
+}

package/src/render/variable-resolver.js

@@ -2,7 +2,6 @@ export class VariableResolver {
   static MENU_PATTERN = /\{\{menu:([a-z][a-z0-9_-]{0,63})\}\}/g;
   static VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+)\}\}/g;
   static STANDALONE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
-  static RAW_STANDALONE = new Set(['posts', 'categories', 'tags', 'pagination']);
 
   resolve(template, data, options = {}) {
     let result = template.replace(VariableResolver.MENU_PATTERN, (_, menuId) => {
@@ -95,10 +94,6 @@ export class VariableResolver {
       }
     }
 
-    if (VariableResolver.RAW_STANDALONE.has(variablePath)) {
-      return true;
-    }
-
     const lastSegment = variablePath.split('.').pop();
     if (lastSegment === 'html' || lastSegment?.endsWith('_html')) {
       return true;

package/src/render/zeropress-engine.js

@@ -1,10 +1,12 @@
 import { SlotResolver } from './slot-resolver.js';
 import { VariableResolver } from './variable-resolver.js';
 import { ControlFlowRenderer } from './control-flow-renderer.js';
+import { PartialResolver } from './partial-resolver.js';
 
 export class ZeroPressEngine {
   constructor() {
     this.slotResolver = new SlotResolver();
+    this.partialResolver = new PartialResolver();
     this.variableResolver = new VariableResolver();
     this.controlFlowRenderer = new ControlFlowRenderer({
       resolvePath: (data, path) => this.variableResolver.resolvePath(data, path),
@@ -33,9 +35,9 @@ export class ZeroPressEngine {
     }
 
     const renderData = this.combineRenderData(data, context);
-    const renderedContent = this.renderTemplate(template, renderData);
+    const renderedContent = this.renderTemplate(this.expandPartials(template), renderData);
     const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, renderedContent);
-    return this.renderTemplate(layoutWithSlots, renderData);
+    return this.renderTemplate(this.expandPartials(layoutWithSlots), renderData);
   }
 
   combineRenderData(data, context) {
@@ -58,4 +60,12 @@ export class ZeroPressEngine {
 
     return this.variableResolver.resolve(template, data);
   }
+
+  expandPartials(template) {
+    if (this.themePackage?.metadata?.runtime !== '0.4') {
+      return template;
+    }
+
+    return this.partialResolver.resolve(template, this.themePackage.partials);
+  }
 }

package/src/theme/load-theme-dir.js

@@ -16,6 +16,10 @@ export async function loadThemePackageFromDir(themeDir) {
 
   const rawThemeJson = String(fileMap.get('theme.json'));
   const themeJson = JSON.parse(rawThemeJson);
+  const manifest = validation.manifest;
+  if (!manifest) {
+    throw new Error('Theme validation failed: normalized manifest not available');
+  }
   const templates = new Map();
   const partials = new Map();
   const assets = new Map();
@@ -45,19 +49,9 @@ export async function loadThemePackageFromDir(themeDir) {
 
   return {
     metadata: {
-      name: themeJson.name,
-      version: themeJson.version,
-      author: themeJson.author,
-      description: themeJson.description,
+      ...manifest,
       thumbnail: themeJson.thumbnail,
       settings: themeJson.settings || {},
-      features: themeJson.features,
-      menuSlots: themeJson.menuSlots,
-      widgetAreas: themeJson.widgetAreas,
-      namespace: themeJson.namespace,
-      slug: themeJson.slug,
-      license: themeJson.license,
-      runtime: themeJson.runtime,
     },
     templates,
     partials,