@zeropress/build-core 0.1.15 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeropress/build-core",
-  "version": "0.1.15",
+  "version": "0.2.0",
   "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.5.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,161 @@ 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,
+    })),
+    window: buildPaginationWindow(paginationData),
+  };
+}
+
+function buildPaginationWindow(paginationData) {
+  const totalPages = paginationData.totalPages;
+  if (!Number.isInteger(totalPages) || totalPages <= 0) {
+    return [];
   }
 
-  return posts
-    .map((post) => {
-      const prepared = postBySlug.get(post.slug);
-      if (!prepared) {
-        return '';
-      }
+  const currentPage = paginationData.currentPage;
+  const pageMap = new Map(
+    paginationData.pages.map((page) => [page.number, {
+      kind: 'page',
+      number: page.number,
+      url: page.url,
+      current: page.current,
+    }]),
+  );
 
-      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');
-    })
-    .filter(Boolean)
-    .join('\n');
-}
+  if (totalPages <= 7) {
+    return paginationData.pages.map((page) => ({
+      kind: 'page',
+      number: page.number,
+      url: page.url,
+      current: page.current,
+    }));
+  }
 
-function renderArchive(posts, postBySlug) {
-  if (posts.length === 0) {
-    return '<p>No posts</p>';
+  const pageNumbers = new Set([1, totalPages, currentPage - 1, currentPage, currentPage + 1]);
+
+  if (currentPage <= 4) {
+    for (let number = 1; number <= 5; number += 1) {
+      pageNumbers.add(number);
+    }
   }
 
-  const groups = new Map();
+  if (currentPage >= totalPages - 3) {
+    for (let number = totalPages - 4; number <= totalPages; number += 1) {
+      pageNumbers.add(number);
+    }
+  }
 
-  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');
-}
+  const orderedNumbers = Array.from(pageNumbers)
+    .filter((number) => Number.isInteger(number) && number >= 1 && number <= totalPages)
+    .sort((left, right) => left - right);
 
-function renderCategoryLinks(categories, countBySlug) {
-  return categories
-    .map((category) => {
-      const count = countBySlug.get(category.slug) || 0;
-      if (count === 0) {
-        return null;
-      }
+  const windowItems = [];
+  let previousNumber = null;
 
-      return `<a href="/categories/${escapeHtml(encodeSlugSegment(category.slug))}/" class="category-link">${escapeHtml(category.name)} (${count})</a>`;
-    })
-    .filter(Boolean)
-    .join('\n');
-}
+  for (const number of orderedNumbers) {
+    if (previousNumber != null && number - previousNumber > 1) {
+      windowItems.push({ kind: 'gap' });
+    }
 
-function renderTagLinks(tags, countBySlug) {
-  return tags
-    .map((tag) => {
-      const count = countBySlug.get(tag.slug) || 0;
-      if (count === 0) {
-        return null;
-      }
+    const pageItem = pageMap.get(number);
+    if (pageItem) {
+      windowItems.push(pageItem);
+    }
+    previousNumber = number;
+  }
 
-      return `<a href="/tags/${escapeHtml(encodeSlugSegment(tag.slug))}/" class="tag-link">${escapeHtml(tag.name)} (${count})</a>`;
-    })
-    .filter(Boolean)
-    .join('\n');
+  return windowItems;
 }
 
-function renderInlineTaxonomyLinks(slugs, taxonomyBySlug, kind) {
-  const links = slugs
-    .map((slug) => taxonomyBySlug.get(slug))
+function buildStructuredPostItems(posts, postBySlug) {
+  return posts
+    .map((post) => postBySlug.get(post.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>`;
-    });
+    .map((post) => buildStructuredPostSummary(post));
+}
 
-  if (links.length === 0) {
-    return '';
+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 buildAdjacentPostSummary(post) {
+  if (!post) {
+    return null;
   }
 
-  return kind === 'category' ? links.join(', ') : links.join(' ');
+  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 renderPagination(paginationData) {
-  if (paginationData.totalPages <= 1) {
-    return '';
+function buildArchiveGroups(posts, postBySlug) {
+  const groups = new Map();
+
+  for (const post of posts) {
+    const prepared = postBySlug.get(post.slug);
+    if (!prepared?.published_at_iso) {
+      continue;
+    }
+
+    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: [],
+    };
+
+    current.items.push(buildStructuredPostSummary(prepared));
+    groups.set(label, current);
   }
 
-  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 Array.from(groups.values());
+}
 
-  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 +1157,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 +1195,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/control-flow-renderer.js

@@ -1,6 +1,8 @@
-function isWhitespace(value) {
-  return /^[\s\r\n\t]*$/.test(value);
-}
+import { parsePartialToken } from './partial-resolver.js';
+
+const PATH_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+const FOR_EXPRESSION_REGEX = /^([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)$/;
+const IF_EQ_EXPRESSION_REGEX = /^([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s+("(?:[^"\\]|\\.)*")$/;
 
 export class ControlFlowRenderer {
   constructor(options = {}) {
@@ -18,6 +20,13 @@ export class ControlFlowRenderer {
   }
 
   render(template, data, renderOptions = {}) {
+    return this.renderTemplate(template, data, {
+      ...renderOptions,
+      partialStack: Array.isArray(renderOptions.partialStack) ? renderOptions.partialStack : [],
+    });
+  }
+
+  renderTemplate(template, data, renderOptions) {
     const nodes = this.parse(template);
     return this.renderNodes(nodes, data, renderOptions);
   }
@@ -94,58 +103,46 @@ export class ControlFlowRenderer {
         return { nodes, nextIndex: tokenEnd + 2, stopTag: 'else' };
       }
 
-      if (token.startsWith('#if_eq ')) {
-        const expression = token.slice('#if_eq '.length).trim();
-        const match = /^([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s+("(?:[^"\\]|\\.)*")$/.exec(expression);
-        if (!match) {
-          throw new Error(`Invalid if_eq expression: ${expression}`);
+      if (token.startsWith('#else_if_eq ')) {
+        if (!stopTags.has('else_if_eq')) {
+          throw new Error('Unexpected else_if_eq tag');
         }
-        const [, path, literalSource] = match;
-        const literal = JSON.parse(literalSource);
-        const ifResult = this.parseNodes(source, tokenEnd + 2, new Set(['else', 'if_eq']));
-        let elseNodes = [];
-        let nextIndex = ifResult.nextIndex;
-        if (ifResult.stopTag === 'else') {
-          const elseResult = this.parseNodes(source, ifResult.nextIndex, new Set(['if_eq']));
-          if (elseResult.stopTag !== 'if_eq') {
-            throw new Error('Unclosed if_eq block after else');
-          }
-          elseNodes = elseResult.nodes;
-          nextIndex = elseResult.nextIndex;
-        } else if (ifResult.stopTag !== 'if_eq') {
-          throw new Error('Unclosed if_eq block');
+        return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
+      }
+
+      if (token.startsWith('#else_if ')) {
+        if (!stopTags.has('else_if')) {
+          throw new Error('Unexpected else_if tag');
         }
-        nodes.push({ type: 'if_eq', path, literal, consequent: ifResult.nodes, alternate: elseNodes });
-        index = nextIndex;
+        return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
+      }
+
+      if (token.startsWith('partial:')) {
+        const { name, args } = parsePartialToken(token);
+        nodes.push({ type: 'partial', name, args });
+        index = tokenEnd + 2;
+        continue;
+      }
+
+      if (token.startsWith('#if_eq ')) {
+        const expression = token.slice('#if_eq '.length).trim();
+        const block = this.parseIfEqBlock(source, tokenEnd + 2, expression);
+        nodes.push(block.node);
+        index = block.nextIndex;
         continue;
       }
 
       if (token.startsWith('#if ')) {
-        const path = token.slice('#if '.length).trim();
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(path)) {
-          throw new Error(`Invalid if expression: ${path}`);
-        }
-        const ifResult = this.parseNodes(source, tokenEnd + 2, new Set(['else', 'if']));
-        let elseNodes = [];
-        let nextIndex = ifResult.nextIndex;
-        if (ifResult.stopTag === 'else') {
-          const elseResult = this.parseNodes(source, ifResult.nextIndex, new Set(['if']));
-          if (elseResult.stopTag !== 'if') {
-            throw new Error('Unclosed if block after else');
-          }
-          elseNodes = elseResult.nodes;
-          nextIndex = elseResult.nextIndex;
-        } else if (ifResult.stopTag !== 'if') {
-          throw new Error('Unclosed if block');
-        }
-        nodes.push({ type: 'if', path, consequent: ifResult.nodes, alternate: elseNodes });
-        index = nextIndex;
+        const expression = token.slice('#if '.length).trim();
+        const block = this.parseIfBlock(source, tokenEnd + 2, expression);
+        nodes.push(block.node);
+        index = block.nextIndex;
         continue;
       }
 
       if (token.startsWith('#for ')) {
         const expression = token.slice('#for '.length).trim();
-        const match = /^([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)$/.exec(expression);
+        const match = FOR_EXPRESSION_REGEX.exec(expression);
         if (!match) {
           throw new Error(`Invalid for expression: ${expression}`);
         }
@@ -164,13 +161,132 @@ export class ControlFlowRenderer {
     }
 
     if (stopTags.size > 0) {
-      const expected = Array.from(stopTags).filter((entry) => entry !== 'else').join(', ');
+      const expected = Array.from(stopTags).join(', ');
       throw new Error(`Missing closing tag for ${expected}`);
     }
 
     return { nodes, nextIndex: source.length, stopTag: null };
   }
 
+  parseIfBlock(source, startIndex, initialPath) {
+    if (!PATH_REGEX.test(initialPath)) {
+      throw new Error(`Invalid if expression: ${initialPath}`);
+    }
+
+    const branches = [];
+    let alternate = [];
+    let nextIndex = startIndex;
+    let currentPath = initialPath;
+
+    while (true) {
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if', 'if']));
+      branches.push({
+        path: currentPath,
+        consequent: branchResult.nodes,
+      });
+
+      if (branchResult.stopTag === 'else') {
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if']));
+        if (elseResult.stopTag !== 'if') {
+          throw new Error('Unclosed if block after else');
+        }
+        alternate = elseResult.nodes;
+        nextIndex = elseResult.nextIndex;
+        break;
+      }
+
+      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith('#else_if ')) {
+        currentPath = branchResult.stopTag.slice('#else_if '.length).trim();
+        if (!PATH_REGEX.test(currentPath)) {
+          throw new Error(`Invalid else_if expression: ${currentPath}`);
+        }
+        nextIndex = branchResult.nextIndex;
+        continue;
+      }
+
+      if (branchResult.stopTag === 'if') {
+        nextIndex = branchResult.nextIndex;
+        break;
+      }
+
+      throw new Error('Unclosed if block');
+    }
+
+    return {
+      node: {
+        type: 'if',
+        branches,
+        alternate,
+      },
+      nextIndex,
+    };
+  }
+
+  parseIfEqBlock(source, startIndex, expression) {
+    const initialBranch = this.parseIfEqBranchExpression(expression, 'if_eq');
+    const branches = [];
+    let alternate = [];
+    let nextIndex = startIndex;
+    let currentBranch = initialBranch;
+
+    while (true) {
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if_eq', 'if_eq']));
+      branches.push({
+        path: currentBranch.path,
+        literal: currentBranch.literal,
+        consequent: branchResult.nodes,
+      });
+
+      if (branchResult.stopTag === 'else') {
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if_eq']));
+        if (elseResult.stopTag !== 'if_eq') {
+          throw new Error('Unclosed if_eq block after else');
+        }
+        alternate = elseResult.nodes;
+        nextIndex = elseResult.nextIndex;
+        break;
+      }
+
+      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith('#else_if_eq ')) {
+        currentBranch = this.parseIfEqBranchExpression(
+          branchResult.stopTag.slice('#else_if_eq '.length).trim(),
+          'else_if_eq',
+        );
+        nextIndex = branchResult.nextIndex;
+        continue;
+      }
+
+      if (branchResult.stopTag === 'if_eq') {
+        nextIndex = branchResult.nextIndex;
+        break;
+      }
+
+      throw new Error('Unclosed if_eq block');
+    }
+
+    return {
+      node: {
+        type: 'if_eq',
+        branches,
+        alternate,
+      },
+      nextIndex,
+    };
+  }
+
+  parseIfEqBranchExpression(expression, tagName) {
+    const match = IF_EQ_EXPRESSION_REGEX.exec(expression);
+    if (!match) {
+      throw new Error(`Invalid ${tagName} expression: ${expression}`);
+    }
+
+    const [, path, literalSource] = match;
+    return {
+      path,
+      literal: JSON.parse(literalSource),
+    };
+  }
+
   renderNodes(nodes, data, renderOptions) {
     return nodes.map((node) => this.renderNode(node, data, renderOptions)).join('');
   }
@@ -180,15 +296,15 @@ export class ControlFlowRenderer {
       case 'text':
         return this.renderText(node.value, data, renderOptions);
       case 'if': {
-        const value = this.resolvePath(data, node.path);
-        return this.isTruthy(value)
-          ? this.renderNodes(node.consequent, data, renderOptions)
+        const branch = node.branches.find((entry) => this.isTruthy(this.resolvePath(data, entry.path)));
+        return branch
+          ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
       }
       case 'if_eq': {
-        const value = this.resolvePath(data, node.path);
-        return value === node.literal
-          ? this.renderNodes(node.consequent, data, renderOptions)
+        const branch = node.branches.find((entry) => this.resolvePath(data, entry.path) === entry.literal);
+        return branch
+          ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
       }
       case 'for': {
@@ -200,15 +316,45 @@ export class ControlFlowRenderer {
           .map((item, index) => this.renderNodes(node.body, {
             ...data,
             [node.itemName]: item,
-            $index: index,
+            loop: {
+              first: index === 0,
+              last: index === items.length - 1,
+              index,
+            },
           }, renderOptions))
           .join('');
       }
+      case 'partial':
+        return this.renderPartial(node, data, renderOptions);
       default:
         return '';
     }
   }
 
+  renderPartial(node, data, renderOptions) {
+    const partials = renderOptions?.partials;
+    if (!partials || !partials.has(node.name)) {
+      throw new Error(`Partial "${node.name}" not found`);
+    }
+
+    const activeStack = Array.isArray(renderOptions?.partialStack) ? renderOptions.partialStack : [];
+    if (activeStack.includes(node.name)) {
+      const cycle = [...activeStack, node.name].join(' -> ');
+      throw new Error(`Circular partial reference detected: ${cycle}`);
+    }
+
+    const partialTemplate = String(partials.get(node.name) || '');
+    const partialData = {
+      ...data,
+      partial: { ...node.args },
+    };
+
+    return this.renderTemplate(partialTemplate, partialData, {
+      ...renderOptions,
+      partialStack: [...activeStack, node.name],
+    });
+  }
+
   isTruthy(value) {
     if (Array.isArray(value)) {
       return value.length > 0;

package/src/render/partial-resolver.js

@@ -0,0 +1,114 @@
+const PARTIAL_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*$/;
+const IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+export function parsePartialToken(token) {
+  const source = String(token || '').trim();
+  if (!source.startsWith('partial:')) {
+    throw new Error(`Invalid partial token: ${source}`);
+  }
+
+  const expression = source.slice('partial:'.length).trim();
+  const nameMatch = /^([a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*)(?:\s+|$)/.exec(expression);
+  if (!nameMatch) {
+    throw new Error(`Invalid partial reference: ${source}`);
+  }
+
+  const name = nameMatch[1];
+  if (!PARTIAL_NAME_REGEX.test(name)) {
+    throw new Error(`Invalid partial name: ${name}`);
+  }
+
+  const argsSource = expression.slice(name.length).trim();
+  const args = parsePartialArgs(argsSource);
+
+  return { name, args };
+}
+
+function parsePartialArgs(source) {
+  if (!source) {
+    return {};
+  }
+
+  const args = {};
+  let index = 0;
+
+  while (index < source.length) {
+    while (index < source.length && /\s/.test(source[index])) {
+      index += 1;
+    }
+
+    if (index >= source.length) {
+      break;
+    }
+
+    const keyMatch = /^[a-zA-Z_][a-zA-Z0-9_]*/.exec(source.slice(index));
+    if (!keyMatch) {
+      throw new Error(`Invalid partial argument syntax near "${source.slice(index)}"`);
+    }
+
+    const key = keyMatch[0];
+    if (!IDENTIFIER_REGEX.test(key)) {
+      throw new Error(`Invalid partial argument key: ${key}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(args, key)) {
+      throw new Error(`Duplicate partial argument: ${key}`);
+    }
+
+    index += key.length;
+    if (source[index] !== '=') {
+      throw new Error(`Expected "=" after partial argument "${key}"`);
+    }
+    index += 1;
+
+    if (source[index] === '"') {
+      let cursor = index + 1;
+      let escaped = false;
+
+      while (cursor < source.length) {
+        const char = source[cursor];
+        if (escaped) {
+          escaped = false;
+          cursor += 1;
+          continue;
+        }
+        if (char === '\\') {
+          escaped = true;
+          cursor += 1;
+          continue;
+        }
+        if (char === '"') {
+          break;
+        }
+        cursor += 1;
+      }
+
+      if (cursor >= source.length || source[cursor] !== '"') {
+        throw new Error(`Unclosed string literal for partial argument "${key}"`);
+      }
+
+      args[key] = JSON.parse(source.slice(index, cursor + 1));
+      index = cursor + 1;
+      continue;
+    }
+
+    if (source.startsWith('true', index) && isValueBoundary(source, index + 4)) {
+      args[key] = true;
+      index += 4;
+      continue;
+    }
+
+    if (source.startsWith('false', index) && isValueBoundary(source, index + 5)) {
+      args[key] = false;
+      index += 5;
+      continue;
+    }
+
+    throw new Error(`Unsupported partial argument value for "${key}"`);
+  }
+
+  return args;
+}
+
+function isValueBoundary(source, index) {
+  return index >= source.length || /\s/.test(source[index]);
+}

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

@@ -48,14 +48,15 @@ export class ZeroPressEngine {
   }
 
   renderTemplate(template, data) {
-    if (this.themePackage?.metadata?.runtime === '0.4') {
-      return this.controlFlowRenderer.render(template, data, {
-        escapeValues: true,
-        rawPaths: new Set(['meta.head_tags']),
-        rawPathPrefixes: new Set(['meta']),
-      });
+    if (this.themePackage?.metadata?.runtime !== '0.5') {
+      throw new Error(`Unsupported theme runtime: ${this.themePackage?.metadata?.runtime || 'unknown'}`);
     }
 
-    return this.variableResolver.resolve(template, data);
+    return this.controlFlowRenderer.render(template, data, {
+      escapeValues: true,
+      rawPaths: new Set(['meta.head_tags']),
+      rawPathPrefixes: new Set(['meta']),
+      partials: 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,