@zeropress/build-pages 0.5.5 → 0.6.1

package/dist/action.js

@@ -52242,15 +52242,25 @@ function invalidSlugValidationResult(value, code2) {
 }
 
 // node_modules/@zeropress/preview-data-validator/src/index.js
-var PREVIEW_DATA_VERSION = "0.5";
+var PREVIEW_DATA_VERSION = "0.6";
 var PREVIEW_DOCUMENT_TYPES = ["plaintext", "markdown", "html"];
 var PREVIEW_MENU_ITEM_TYPES = ["custom", "page", "post", "category"];
 var PREVIEW_MENU_TARGETS = ["_self", "_blank"];
 var PREVIEW_MENU_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
 var PREVIEW_WIDGET_AREA_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var PREVIEW_COLLECTION_ID_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var PREVIEW_COLLECTION_ITEM_TYPES = ["post", "page"];
+var PREVIEW_MEDIA_DELIVERY_MODES = ["none", "media_domain"];
+var PREVIEW_DATETIME_DISPLAY_MODES = ["static", "client"];
+var PREVIEW_DATETIME_STYLES = ["none", "short", "medium", "long", "full"];
+var PREVIEW_DISCOVERABILITY_VALUES = ["default", "noindex", "delist"];
 var PREVIEW_PERMALINK_OUTPUT_STYLES = ["directory", "html-extension"];
 var PREVIEW_PERMALINK_FIELDS = ["posts", "pages", "categories", "tags"];
 var PREVIEW_FRONT_PAGE_TYPES = ["theme_index", "page", "standalone_html"];
+var PREVIEW_DATA_KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*$/;
+var PREVIEW_DATA_MAX_DEPTH = 4;
+var PREVIEW_DATA_MAX_KEYS = 64;
+var PREVIEW_DATA_MAX_ARRAY_LENGTH = 256;
 var PREVIEW_PERMALINK_TOKENS = Object.freeze({
   posts: /* @__PURE__ */ new Set(["slug", "public_id", "year", "month", "day"]),
   pages: /* @__PURE__ */ new Set(["slug"]),
@@ -52259,7 +52269,7 @@ var PREVIEW_PERMALINK_TOKENS = Object.freeze({
 });
 function validatePreviewData(data) {
   const errors = [];
-  validateClosedObject(data, "", errors, ["$schema", "version", "generator", "generated_at", "site", "content", "menus", "widgets", "custom_css", "custom_html"]);
+  validateClosedObject(data, "", errors, ["$schema", "version", "generator", "generated_at", "site", "content", "menus", "widgets", "collections", "custom_css", "custom_html"]);
   if (isObject(data)) {
     if (data.$schema !== void 0) {
       validateString(data.$schema, "$schema", "INVALID_SCHEMA_HINT", errors);
@@ -52269,8 +52279,15 @@ function validatePreviewData(data) {
     validateDateTimeString(data.generated_at, "generated_at", "INVALID_GENERATED_AT", errors);
     validateSite(data.site, "site", errors);
     validateContent(data.content, "content", errors);
-    validateMenus(data.menus, "menus", errors);
-    validateWidgets(data.widgets, "widgets", errors);
+    if (data.menus !== void 0) {
+      validateMenus(data.menus, "menus", errors);
+    }
+    if (data.widgets !== void 0) {
+      validateWidgets(data.widgets, "widgets", errors);
+    }
+    if (data.collections !== void 0) {
+      validateCollections(data.collections, "collections", errors);
+    }
     if (data.custom_css !== void 0) {
       validateCustomCss(data.custom_css, "custom_css", errors);
     }
@@ -52293,23 +52310,58 @@ function assertPreviewData(data) {
   return data;
 }
 function validateSite(site, path4, errors) {
-  validateObject(site, path4, "INVALID_SITE", errors);
+  validateClosedObject(site, path4, errors, [
+    "title",
+    "description",
+    "url",
+    "media_base_url",
+    "media_delivery_mode",
+    "favicon",
+    "expose_generator",
+    "locale",
+    "posts_per_page",
+    "datetime_display",
+    "date_style",
+    "time_style",
+    "timezone",
+    "disallow_comments",
+    "indexing",
+    "permalinks",
+    "front_page",
+    "post_index",
+    "footer",
+    "meta"
+  ]);
   if (!isObject(site)) {
     return;
   }
   validateNonEmptyString(site.title, `${path4}.title`, "INVALID_SITE_TITLE", errors);
   validateString(site.description, `${path4}.description`, "INVALID_SITE_DESCRIPTION", errors);
   validateSiteUri(site.url, `${path4}.url`, "INVALID_SITE_URL", errors);
-  validateSiteUri(site.mediaBaseUrl, `${path4}.mediaBaseUrl`, "INVALID_SITE_MEDIA_BASE_URL", errors);
+  validateSiteUri(site.media_base_url, `${path4}.media_base_url`, "INVALID_SITE_MEDIA_BASE_URL", errors);
+  if (site.media_delivery_mode !== void 0) {
+    validateEnum(site.media_delivery_mode, `${path4}.media_delivery_mode`, "INVALID_SITE_MEDIA_DELIVERY_MODE", errors, PREVIEW_MEDIA_DELIVERY_MODES);
+  }
+  if (site.favicon !== void 0) {
+    validateSiteFavicon(site.favicon, `${path4}.favicon`, errors);
+  }
+  if (site.expose_generator !== void 0) {
+    validateBoolean(site.expose_generator, `${path4}.expose_generator`, "INVALID_SITE_EXPOSE_GENERATOR", errors);
+  }
   validateNonEmptyString(site.locale, `${path4}.locale`, "INVALID_SITE_LOCALE", errors);
-  validateInteger(site.postsPerPage, `${path4}.postsPerPage`, "INVALID_SITE_POSTS_PER_PAGE", errors, { minimum: 1 });
-  validateNonEmptyString(site.dateFormat, `${path4}.dateFormat`, "INVALID_SITE_DATE_FORMAT", errors);
-  validateString(site.timeFormat, `${path4}.timeFormat`, "INVALID_SITE_TIME_FORMAT", errors);
+  validateInteger(site.posts_per_page, `${path4}.posts_per_page`, "INVALID_SITE_POSTS_PER_PAGE", errors, { minimum: 1 });
+  validateEnum(site.datetime_display, `${path4}.datetime_display`, "INVALID_SITE_DATETIME_DISPLAY", errors, PREVIEW_DATETIME_DISPLAY_MODES);
+  validateEnum(site.date_style, `${path4}.date_style`, "INVALID_SITE_DATE_STYLE", errors, PREVIEW_DATETIME_STYLES);
+  validateEnum(site.time_style, `${path4}.time_style`, "INVALID_SITE_TIME_STYLE", errors, PREVIEW_DATETIME_STYLES);
   validateNonEmptyString(site.timezone, `${path4}.timezone`, "INVALID_SITE_TIMEZONE", errors);
-  validateBoolean(site.disallowComments, `${path4}.disallowComments`, "INVALID_SITE_DISALLOW_COMMENTS", errors);
+  validateBoolean(site.disallow_comments, `${path4}.disallow_comments`, "INVALID_SITE_DISALLOW_COMMENTS", errors);
+  if (site.indexing !== void 0) {
+    validateBoolean(site.indexing, `${path4}.indexing`, "INVALID_SITE_INDEXING", errors);
+  }
   validatePermalinks(site.permalinks, `${path4}.permalinks`, errors);
   validateFrontPage(site.front_page, `${path4}.front_page`, errors);
   validatePostIndex(site.post_index, `${path4}.post_index`, errors);
+  validatePreviewMeta(site.meta, `${path4}.meta`, errors);
   if (site.footer !== void 0) {
     validateSiteFooter(site.footer, `${path4}.footer`, errors);
   }
@@ -52318,7 +52370,6 @@ function validateSite(site, path4, errors) {
     "site_description",
     "site_url",
     "metadata",
-    "media_delivery_mode",
     "media_delivery_base_url",
     "language",
     "siteLocale",
@@ -52328,7 +52379,7 @@ function validateSite(site, path4, errors) {
   ], "INVALID_LEGACY_SITE_FIELD");
 }
 function validateContent(content, path4, errors) {
-  validateClosedObject(content, path4, errors, ["authors", "posts", "pages", "categories", "tags"]);
+  validateClosedObject(content, path4, errors, ["authors", "posts", "pages", "categories", "tags", "media"]);
   if (!isObject(content)) {
     return;
   }
@@ -52343,6 +52394,9 @@ function validateContent(content, path4, errors) {
   validateArray(content.tags, `${path4}.tags`, "INVALID_TAGS", errors, (entry, index) => {
     validatePreviewTag(entry, `${path4}.tags[${index}]`, errors);
   });
+  if (content.media !== void 0) {
+    validateMediaArray(content.media, `${path4}.media`, errors);
+  }
 }
 function validateSiteFooter(footer, path4, errors) {
   validateClosedObject(footer, path4, errors, ["copyright_text", "attribution"]);
@@ -52353,10 +52407,7 @@ function validateSiteFooter(footer, path4, errors) {
     validateNonEmptyString(footer.copyright_text, `${path4}.copyright_text`, "INVALID_SITE_FOOTER_COPYRIGHT_TEXT", errors);
   }
   if (footer.attribution !== void 0) {
-    validateClosedObject(footer.attribution, `${path4}.attribution`, errors, ["enabled"]);
-    if (isObject(footer.attribution) && footer.attribution.enabled !== void 0) {
-      validateBoolean(footer.attribution.enabled, `${path4}.attribution.enabled`, "INVALID_SITE_FOOTER_ATTRIBUTION_ENABLED", errors);
-    }
+    validateBoolean(footer.attribution, `${path4}.attribution`, "INVALID_SITE_FOOTER_ATTRIBUTION", errors);
   }
 }
 function validateMenus(menus, path4, errors) {
@@ -52382,7 +52433,7 @@ function validatePreviewMenu(menu, path4, errors) {
   });
 }
 function validatePreviewMenuItem(item, path4, errors) {
-  validateClosedObject(item, path4, errors, ["title", "url", "type", "target", "children"]);
+  validateClosedObject(item, path4, errors, ["title", "url", "type", "target", "meta", "children"]);
   if (!isObject(item)) {
     return;
   }
@@ -52390,6 +52441,7 @@ function validatePreviewMenuItem(item, path4, errors) {
   validateUrlLike(item.url, `${path4}.url`, "INVALID_MENU_ITEM_URL", errors);
   validateEnum(item.type, `${path4}.type`, "INVALID_MENU_ITEM_TYPE", errors, PREVIEW_MENU_ITEM_TYPES);
   validateEnum(item.target, `${path4}.target`, "INVALID_MENU_ITEM_TARGET", errors, PREVIEW_MENU_TARGETS);
+  validatePreviewMeta(item.meta, `${path4}.meta`, errors);
   validateArray(item.children, `${path4}.children`, "INVALID_MENU_ITEM_CHILDREN", errors, (entry, index) => {
     validatePreviewMenuItem(entry, `${path4}.children[${index}]`, errors);
   });
@@ -52407,6 +52459,49 @@ function validateWidgets(widgets, path4, errors) {
     validatePreviewWidgetArea(widgetArea, `${path4}.${widgetAreaId}`, errors);
   }
 }
+function validateCollections(collections, path4, errors) {
+  validateObject(collections, path4, "INVALID_COLLECTIONS", errors);
+  if (!isObject(collections)) {
+    return;
+  }
+  for (const [collectionId, collection] of Object.entries(collections)) {
+    if (!PREVIEW_COLLECTION_ID_PATTERN.test(collectionId)) {
+      errors.push(issue("INVALID_COLLECTION_ID", `${path4}.${collectionId}`, "Collection ids must match ^[a-z][a-z0-9_-]{0,63}$"));
+    }
+    validatePreviewCollection(collection, `${path4}.${collectionId}`, errors);
+  }
+}
+function validatePreviewCollection(collection, path4, errors) {
+  validateClosedObject(collection, path4, errors, ["title", "description", "items"]);
+  if (!isObject(collection)) {
+    return;
+  }
+  if (collection.title !== void 0) {
+    validateNonEmptyString(collection.title, `${path4}.title`, "INVALID_COLLECTION_TITLE", errors);
+  }
+  if (collection.description !== void 0) {
+    validateString(collection.description, `${path4}.description`, "INVALID_COLLECTION_DESCRIPTION", errors);
+  }
+  const seenItems = /* @__PURE__ */ new Set();
+  validateArray(collection.items, `${path4}.items`, "INVALID_COLLECTION_ITEMS", errors, (entry, index) => {
+    validatePreviewCollectionItem(entry, `${path4}.items[${index}]`, errors, seenItems);
+  });
+}
+function validatePreviewCollectionItem(item, path4, errors, seenItems) {
+  validateClosedObject(item, path4, errors, ["type", "slug"]);
+  if (!isObject(item)) {
+    return;
+  }
+  validateEnum(item.type, `${path4}.type`, "INVALID_COLLECTION_ITEM_TYPE", errors, PREVIEW_COLLECTION_ITEM_TYPES);
+  validateSlugSegment2(item.slug, `${path4}.slug`, "INVALID_COLLECTION_ITEM_SLUG", errors);
+  if (typeof item.type === "string" && PREVIEW_COLLECTION_ITEM_TYPES.includes(item.type) && typeof item.slug === "string") {
+    const key = `${item.type}:${item.slug}`;
+    if (seenItems.has(key)) {
+      errors.push(issue("DUPLICATE_COLLECTION_ITEM", `${path4}.slug`, "Duplicate collection item in the same collection"));
+    }
+    seenItems.add(key);
+  }
+}
 function validatePreviewWidgetArea(widgetArea, path4, errors) {
   validateClosedObject(widgetArea, path4, errors, ["name", "items"]);
   if (!isObject(widgetArea)) {
@@ -52498,6 +52593,46 @@ function validatePreviewAuthor(author, path4, errors) {
     validateUrlLike(author.avatar, `${path4}.avatar`, "INVALID_AUTHOR_AVATAR", errors);
   }
 }
+function validateMediaArray(value, path4, errors) {
+  const sources = /* @__PURE__ */ new Set();
+  validateArray(value, path4, "INVALID_MEDIA", errors, (entry, index) => {
+    validatePreviewMedia(entry, `${path4}[${index}]`, errors);
+    if (!isObject(entry) || typeof entry.src !== "string") {
+      return;
+    }
+    if (sources.has(entry.src)) {
+      errors.push(issue("DUPLICATE_MEDIA_SRC", `${path4}[${index}].src`, "Media src values must be unique"));
+      return;
+    }
+    sources.add(entry.src);
+  });
+}
+function validateSiteFavicon(favicon, path4, errors) {
+  validateClosedObject(favicon, path4, errors, ["icon", "svg", "png", "apple_touch_icon"]);
+  if (!isObject(favicon)) {
+    return;
+  }
+  if (favicon.icon === void 0 && favicon.svg === void 0 && favicon.png === void 0 && favicon.apple_touch_icon === void 0) {
+    errors.push(issue("INVALID_SITE_FAVICON", path4, "site.favicon must include at least one favicon URL"));
+  }
+  for (const key of ["icon", "svg", "png", "apple_touch_icon"]) {
+    if (favicon[key] !== void 0) {
+      validateUrlLike(favicon[key], `${path4}.${key}`, "INVALID_SITE_FAVICON_URL", errors);
+    }
+  }
+}
+function validatePreviewMedia(media, path4, errors) {
+  validateClosedObject(media, path4, errors, ["src", "width", "height", "alt"]);
+  if (!isObject(media)) {
+    return;
+  }
+  validateUrlLike(media.src, `${path4}.src`, "INVALID_MEDIA_SRC", errors);
+  validateInteger(media.width, `${path4}.width`, "INVALID_MEDIA_WIDTH", errors, { minimum: 1 });
+  validateInteger(media.height, `${path4}.height`, "INVALID_MEDIA_HEIGHT", errors, { minimum: 1 });
+  if (media.alt !== void 0) {
+    validateString(media.alt, `${path4}.alt`, "INVALID_MEDIA_ALT", errors);
+  }
+}
 function validatePreviewPost(post, path4, errors, authorIds) {
   validateClosedObject(post, path4, errors, [
     "id",
@@ -52512,7 +52647,9 @@ function validatePreviewPost(post, path4, errors, authorIds) {
     "author_id",
     "featured_image",
     "meta",
+    "data",
     "status",
+    "discoverability",
     "allow_comments",
     "category_slugs",
     "tag_slugs"
@@ -52530,6 +52667,9 @@ function validatePreviewPost(post, path4, errors, authorIds) {
   validateDateTimeString(post.updated_at_iso, `${path4}.updated_at_iso`, "INVALID_POST_UPDATED_AT_ISO", errors);
   validateNonEmptyString(post.author_id, `${path4}.author_id`, "INVALID_POST_AUTHOR_ID", errors);
   validateEnum(post.status, `${path4}.status`, "INVALID_POST_STATUS", errors, ["published", "draft"]);
+  if (post.discoverability !== void 0) {
+    validateEnum(post.discoverability, `${path4}.discoverability`, "INVALID_POST_DISCOVERABILITY", errors, PREVIEW_DISCOVERABILITY_VALUES);
+  }
   validateBoolean(post.allow_comments, `${path4}.allow_comments`, "INVALID_POST_ALLOW_COMMENTS", errors);
   validateSlugArray(post.category_slugs, `${path4}.category_slugs`, "INVALID_POST_CATEGORY_SLUGS", errors);
   validateSlugArray(post.tag_slugs, `${path4}.tag_slugs`, "INVALID_POST_TAG_SLUGS", errors);
@@ -52537,12 +52677,13 @@ function validatePreviewPost(post, path4, errors, authorIds) {
     validateUrlLike(post.featured_image, `${path4}.featured_image`, "INVALID_POST_FEATURED_IMAGE", errors);
   }
   validatePreviewMeta(post.meta, `${path4}.meta`, errors);
+  validatePreviewStructuredData(post.data, `${path4}.data`, errors);
   if (typeof post.author_id === "string" && post.author_id.trim() !== "" && !authorIds.has(post.author_id)) {
     errors.push(issue("INVALID_POST_AUTHOR_REFERENCE", `${path4}.author_id`, "Referenced author_id does not exist"));
   }
 }
 function validatePreviewPage(page, path4, errors) {
-  validateClosedObject(page, path4, errors, ["title", "slug", "path", "content", "document_type", "excerpt", "featured_image", "meta", "status"]);
+  validateClosedObject(page, path4, errors, ["title", "slug", "path", "content", "document_type", "excerpt", "featured_image", "meta", "data", "status", "discoverability"]);
   if (!isObject(page)) {
     return;
   }
@@ -52558,7 +52699,11 @@ function validatePreviewPage(page, path4, errors) {
     validateUrlLike(page.featured_image, `${path4}.featured_image`, "INVALID_PAGE_FEATURED_IMAGE", errors);
   }
   validatePreviewMeta(page.meta, `${path4}.meta`, errors);
+  validatePreviewStructuredData(page.data, `${path4}.data`, errors);
   validateEnum(page.status, `${path4}.status`, "INVALID_PAGE_STATUS", errors, ["published", "draft"]);
+  if (page.discoverability !== void 0) {
+    validateEnum(page.discoverability, `${path4}.discoverability`, "INVALID_PAGE_DISCOVERABILITY", errors, PREVIEW_DISCOVERABILITY_VALUES);
+  }
 }
 function validatePreviewMeta(meta, path4, errors) {
   if (meta === void 0) {
@@ -52575,6 +52720,66 @@ function validatePreviewMeta(meta, path4, errors) {
     errors.push(issue("INVALID_META_VALUE", `${path4}.${key}`, "meta values must be strings, numbers, booleans, or null"));
   }
 }
+function validatePreviewStructuredData(data, path4, errors) {
+  if (data === void 0) {
+    return;
+  }
+  if (!isObject(data)) {
+    errors.push(issue("INVALID_DATA", path4, "data must be an object"));
+    return;
+  }
+  validatePreviewDataObject(data, path4, errors, 0);
+}
+function validatePreviewDataValue(value, path4, errors, depth) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      errors.push(issue("INVALID_DATA_VALUE", path4, "data numbers must be finite"));
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    validatePreviewDataArray(value, path4, errors, depth);
+    return;
+  }
+  if (isObject(value)) {
+    validatePreviewDataObject(value, path4, errors, depth);
+    return;
+  }
+  errors.push(issue("INVALID_DATA_VALUE", path4, "data values must be JSON-safe strings, numbers, booleans, null, arrays, or objects"));
+}
+function validatePreviewDataObject(object, path4, errors, depth) {
+  if (depth > PREVIEW_DATA_MAX_DEPTH) {
+    errors.push(issue("INVALID_DATA_DEPTH", path4, `data nesting must not exceed ${PREVIEW_DATA_MAX_DEPTH} container levels`));
+    return;
+  }
+  const entries = Object.entries(object);
+  if (entries.length > PREVIEW_DATA_MAX_KEYS) {
+    errors.push(issue("INVALID_DATA_OBJECT_SIZE", path4, `data objects must not contain more than ${PREVIEW_DATA_MAX_KEYS} keys`));
+  }
+  for (const [key, value] of entries) {
+    const childPath = `${path4}.${key}`;
+    if (!PREVIEW_DATA_KEY_PATTERN.test(key)) {
+      errors.push(issue("INVALID_DATA_KEY", childPath, "data keys must be valid template path segments"));
+      continue;
+    }
+    validatePreviewDataValue(value, childPath, errors, depth + 1);
+  }
+}
+function validatePreviewDataArray(array, path4, errors, depth) {
+  if (depth > PREVIEW_DATA_MAX_DEPTH) {
+    errors.push(issue("INVALID_DATA_DEPTH", path4, `data nesting must not exceed ${PREVIEW_DATA_MAX_DEPTH} container levels`));
+    return;
+  }
+  if (array.length > PREVIEW_DATA_MAX_ARRAY_LENGTH) {
+    errors.push(issue("INVALID_DATA_ARRAY_SIZE", path4, `data arrays must not contain more than ${PREVIEW_DATA_MAX_ARRAY_LENGTH} items`));
+  }
+  array.forEach((value, index) => {
+    validatePreviewDataValue(value, `${path4}[${index}]`, errors, depth + 1);
+  });
+}
 function validatePermalinks(permalinks, path4, errors) {
   if (permalinks === void 0) {
     return;
@@ -52787,7 +52992,7 @@ function validateClosedObject(value, path4, errors, allowedKeys) {
     return;
   }
   for (const key of Object.keys(value)) {
-    if (!allowedKeys.includes(key) && !isSiteExtensionKey(path4, key)) {
+    if (!allowedKeys.includes(key)) {
       errors.push(issue("UNKNOWN_PROPERTY", path4 ? `${path4}.${key}` : key, "Unexpected property"));
     }
   }
@@ -52799,20 +53004,20 @@ function validateClosedObject(value, path4, errors, allowedKeys) {
 }
 function isOptionalKey(path4, key) {
   if (path4 === "") {
-    return key === "$schema" || key === "custom_css" || key === "custom_html";
+    return key === "$schema" || key === "menus" || key === "widgets" || key === "collections" || key === "custom_css" || key === "custom_html";
   }
   if (path4 === "custom_html") {
     return key === "head_end" || key === "body_end";
   }
   if (path4 === "site") {
-    return key === "permalinks" || key === "front_page" || key === "post_index" || key === "footer";
+    return key === "media_delivery_mode" || key === "favicon" || key === "expose_generator" || key === "indexing" || key === "permalinks" || key === "front_page" || key === "post_index" || key === "footer" || key === "meta";
+  }
+  if (path4 === "site.favicon") {
+    return key === "icon" || key === "svg" || key === "png" || key === "apple_touch_icon";
   }
   if (path4 === "site.footer") {
     return key === "copyright_text" || key === "attribution";
   }
-  if (path4 === "site.footer.attribution") {
-    return key === "enabled";
-  }
   if (path4 === "site.front_page") {
     return key === "page_slug" || key === "html";
   }
@@ -52822,38 +53027,35 @@ function isOptionalKey(path4, key) {
   if (path4 === "site.permalinks") {
     return key === "output_style" || PREVIEW_PERMALINK_FIELDS.includes(key);
   }
+  if (path4 === "content") {
+    return key === "media";
+  }
   if (path4.startsWith("content.authors[")) {
     return key === "avatar";
   }
+  if (path4.startsWith("content.media[")) {
+    return key === "alt";
+  }
+  if (path4.startsWith("menus.") && (path4.includes(".items[") || path4.includes(".children["))) {
+    return key === "meta";
+  }
   if (path4.startsWith("widgets.") && path4.includes(".items[")) {
     return key === "settings";
   }
+  if (path4.startsWith("collections.") && !path4.includes(".items[")) {
+    return key === "title" || key === "description";
+  }
   if (path4.startsWith("content.posts[")) {
-    return key === "id" || key === "featured_image" || key === "meta";
+    return key === "id" || key === "featured_image" || key === "meta" || key === "data" || key === "discoverability";
   }
   if (path4.startsWith("content.pages[")) {
-    return key === "path" || key === "excerpt" || key === "featured_image" || key === "meta";
+    return key === "path" || key === "excerpt" || key === "featured_image" || key === "meta" || key === "data" || key === "discoverability";
   }
   if (path4.startsWith("content.categories[") || path4.startsWith("content.tags[")) {
     return key === "description";
   }
   return false;
 }
-function isSiteExtensionKey(path4, key) {
-  if (path4 !== "site") {
-    return false;
-  }
-  return ![
-    "site_name",
-    "site_description",
-    "site_url",
-    "metadata",
-    "media_delivery_mode",
-    "media_delivery_base_url",
-    "site_timezone",
-    "site_locale"
-  ].includes(key);
-}
 function validateSlugArray(value, path4, code2, errors) {
   if (!Array.isArray(value)) {
     errors.push(issue(code2, path4, "Expected an array"));
@@ -52892,7 +53094,7 @@ function mapSlugValidationMessage(issueCode) {
 function rejectLegacyKeys(value, path4, errors, keys, code2) {
   for (const key of keys) {
     if (key in value) {
-      errors.push(issue(code2, `${path4}.${key}`, "Legacy field is not allowed in preview-data v0.5"));
+      errors.push(issue(code2, `${path4}.${key}`, "Legacy field is not allowed in preview-data v0.6"));
     }
   }
 }
@@ -53002,9 +53204,46 @@ var PARTIAL_TAG_REGEX = /\{\{(partial:[^}]+)\}\}/g;
 var TEMPLATE_PATH_SEGMENT_SOURCE = "[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*";
 var TEMPLATE_PATH_REGEX = new RegExp(`^${TEMPLATE_PATH_SEGMENT_SOURCE}(?:\\.${TEMPLATE_PATH_SEGMENT_SOURCE})*$`);
 var FOR_TAG_REGEX = new RegExp(`^#for ([a-zA-Z_][a-zA-Z0-9_]*) in (${TEMPLATE_PATH_SEGMENT_SOURCE}(?:\\.${TEMPLATE_PATH_SEGMENT_SOURCE})*)$`);
-var IF_EQ_EXPRESSION_REGEX = new RegExp(`^(${TEMPLATE_PATH_SEGMENT_SOURCE}(?:\\.${TEMPLATE_PATH_SEGMENT_SOURCE})*)\\s+("(?:[^"\\\\]|\\\\.)*")$`);
+var NUMBER_LITERAL_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var COMPARISON_BLOCK_TAGS = /* @__PURE__ */ new Set(["if_eq", "if_neq", "if_in", "if_starts_with"]);
+var COMPARISON_ELSE_IF_TAGS = /* @__PURE__ */ new Set(["else_if_eq", "else_if_neq", "else_if_in", "else_if_starts_with"]);
+var COMPARISON_TAG_OPERATORS = {
+  if_eq: "eq",
+  else_if_eq: "eq",
+  if_neq: "neq",
+  else_if_neq: "neq",
+  if_in: "in",
+  else_if_in: "in",
+  if_starts_with: "starts_with",
+  else_if_starts_with: "starts_with"
+};
+var PARTIAL_ARG_ROOT_PATHS = /* @__PURE__ */ new Set([
+  "archive",
+  "author",
+  "category",
+  "collection",
+  "collections",
+  "currentUrl",
+  "language",
+  "menu",
+  "menus",
+  "meta",
+  "page",
+  "pagination",
+  "partial",
+  "post",
+  "posts",
+  "route",
+  "site",
+  "tag",
+  "taxonomies",
+  "taxonomy",
+  "widget",
+  "widgets"
+]);
 var PARTIAL_ARG_KEY_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var LICENSE_REF_REGEX = /^LicenseRef-[A-Za-z0-9][A-Za-z0-9.-]*$/;
 var NAMESPACE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var SLUG_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var ALLOWED_LICENSES = [
@@ -53015,7 +53254,10 @@ var ALLOWED_LICENSES = [
   "GPL-3.0-or-later"
 ];
 var LICENSES = new Set(ALLOWED_LICENSES);
-var DEFAULT_RUNTIME = "0.5";
+var THEME_LINK_KEYS = /* @__PURE__ */ new Set(["homepage", "repository", "documentation", "support", "marketplace", "license"]);
+var THEME_LINK_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
+var DEFAULT_RUNTIME = "0.6";
+var THEME_RUNTIME_V0_6 = DEFAULT_RUNTIME;
 var SUPPORTED_RUNTIMES = [DEFAULT_RUNTIME];
 var SUPPORTED_RUNTIME_SET = new Set(SUPPORTED_RUNTIMES);
 var NAMESPACE_MIN_LENGTH = 3;
@@ -53030,7 +53272,29 @@ var MENU_SLOT_ID_MAX_LENGTH = 32;
 var MENU_SLOT_COUNT_MAX = 12;
 var MENU_SLOT_TITLE_MAX_LENGTH = 80;
 var MENU_SLOT_DESCRIPTION_MAX_LENGTH = 160;
-var SUPPORTED_THEME_FEATURES = /* @__PURE__ */ new Set(["comments", "newsletter", "postIndex"]);
+var SUPPORTED_THEME_FEATURES = /* @__PURE__ */ new Set(["comments", "newsletter", "post_index"]);
+var THEME_MANIFEST_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "name",
+  "namespace",
+  "slug",
+  "version",
+  "license",
+  "runtime",
+  "author",
+  "description",
+  "thumbnail",
+  "links",
+  "features",
+  "menu_slots",
+  "widget_areas",
+  "site_meta",
+  "collection_slots"
+]);
+var SITE_META_KEY_REGEX = /^[a-z][a-z0-9_]*(?:-[a-z0-9_]+)*$/;
+var SITE_META_KEY_MAX_LENGTH = 64;
+var SITE_META_COUNT_MAX = 32;
+var SITE_META_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean"]);
 function validateFeatureFlags(rawValue, errors) {
   if (rawValue === void 0) {
     return void 0;
@@ -53051,7 +53315,11 @@ function validateFeatureFlags(rawValue, errors) {
         "INVALID_THEME_FEATURE",
         `theme.json.features.${featureName}`,
         `Unknown theme feature '${featureName}'`,
-        "error"
+        "error",
+        {
+          category: "theme_manifest",
+          hint: themeFeatureHint(featureName)
+        }
       ));
       continue;
     }
@@ -53068,6 +53336,80 @@ function validateFeatureFlags(rawValue, errors) {
   }
   return Object.keys(normalizedFeatures).length > 0 ? normalizedFeatures : void 0;
 }
+function themeFeatureHint(featureName) {
+  const hints = {
+    postIndex: "ZeroPress runtime v0.6 uses snake_case keys. Use 'post_index' instead of 'postIndex'."
+  };
+  return hints[featureName] || "";
+}
+function themeManifestFieldHint(fieldName) {
+  const hints = {
+    menuSlots: "ZeroPress runtime v0.6 uses snake_case keys. Use 'menu_slots' instead of 'menuSlots'.",
+    widgetAreas: "ZeroPress runtime v0.6 uses snake_case keys. Use 'widget_areas' instead of 'widgetAreas'.",
+    siteMeta: "ZeroPress runtime v0.6 uses snake_case keys. Use 'site_meta' instead of 'siteMeta'.",
+    collectionSlots: "ZeroPress runtime v0.6 uses snake_case keys. Use 'collection_slots' instead of 'collectionSlots'.",
+    settings: "theme.json.settings was removed in runtime v0.6. Use preview-data site.meta and theme.json site_meta hints for site-level values."
+  };
+  return hints[fieldName] || "";
+}
+function isAllowedLicense(value) {
+  return LICENSES.has(value) || LICENSE_REF_REGEX.test(value);
+}
+function isValidThemeLinkUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return THEME_LINK_PROTOCOLS.has(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function validateThemeLinks(rawValue, errors) {
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  if (!rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) {
+    errors.push(issue2(
+      "INVALID_LINKS",
+      "theme.json.links",
+      "theme.json field 'links' must be an object when present",
+      "error"
+    ));
+    return void 0;
+  }
+  const normalizedLinks = {};
+  for (const [linkKey, value] of Object.entries(rawValue)) {
+    if (!THEME_LINK_KEYS.has(linkKey)) {
+      errors.push(issue2(
+        "INVALID_THEME_LINK",
+        `theme.json.links.${linkKey}`,
+        `Unknown theme link '${linkKey}'`,
+        "error"
+      ));
+      continue;
+    }
+    if (typeof value !== "string" || value.trim() === "") {
+      errors.push(issue2(
+        "INVALID_THEME_LINK_VALUE",
+        `theme.json.links.${linkKey}`,
+        `theme link '${linkKey}' must be a non-empty URL string`,
+        "error"
+      ));
+      continue;
+    }
+    const normalizedValue = value.trim();
+    if (!isValidThemeLinkUrl(normalizedValue)) {
+      errors.push(issue2(
+        "INVALID_THEME_LINK_VALUE",
+        `theme.json.links.${linkKey}`,
+        `theme link '${linkKey}' must be an absolute http, https, or mailto URL`,
+        "error"
+      ));
+      continue;
+    }
+    normalizedLinks[linkKey] = normalizedValue;
+  }
+  return Object.keys(normalizedLinks).length > 0 ? normalizedLinks : void 0;
+}
 function validateHelperMetadataMap(rawValue, fieldName, issueCodes, errors) {
   if (rawValue === void 0) {
     return void 0;
@@ -53161,6 +53503,127 @@ function validateHelperMetadataMap(rawValue, fieldName, issueCodes, errors) {
   }
   return Object.keys(normalizedItems).length > 0 ? normalizedItems : void 0;
 }
+function validateSiteMetaMap(rawValue, errors) {
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  if (!rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) {
+    errors.push(issue2(
+      "INVALID_SITE_META",
+      "theme.json",
+      "theme.json field 'site_meta' must be an object when present",
+      "error"
+    ));
+    return void 0;
+  }
+  const entries = Object.entries(rawValue);
+  if (entries.length === 0) {
+    errors.push(issue2(
+      "INVALID_SITE_META",
+      "theme.json",
+      "theme.json field 'site_meta' must not be empty",
+      "error"
+    ));
+  }
+  if (entries.length > SITE_META_COUNT_MAX) {
+    errors.push(issue2(
+      "INVALID_SITE_META",
+      "theme.json",
+      `theme.json field 'site_meta' must contain at most ${SITE_META_COUNT_MAX} keys`,
+      "error"
+    ));
+  }
+  const normalizedItems = {};
+  for (const [metaKey, value] of entries) {
+    if (!SITE_META_KEY_REGEX.test(metaKey) || metaKey.length > SITE_META_KEY_MAX_LENGTH) {
+      errors.push(issue2(
+        "INVALID_SITE_META_KEY",
+        `theme.json.site_meta.${metaKey}`,
+        `site_meta key '${metaKey}' must start with a lowercase letter and use lowercase letters, digits, underscores, or internal hyphens only`,
+        "error"
+      ));
+      continue;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      errors.push(issue2(
+        "INVALID_SITE_META_FIELD",
+        `theme.json.site_meta.${metaKey}`,
+        `site_meta key '${metaKey}' must be an object`,
+        "error"
+      ));
+      continue;
+    }
+    const allowedKeys = /* @__PURE__ */ new Set(["title", "description", "type", "default"]);
+    for (const key of Object.keys(value)) {
+      if (!allowedKeys.has(key)) {
+        errors.push(issue2(
+          "INVALID_SITE_META_PROPERTY",
+          `theme.json.site_meta.${metaKey}.${key}`,
+          `Unknown site_meta property '${key}' in key '${metaKey}'`,
+          "error"
+        ));
+      }
+    }
+    if (typeof value.title !== "string" || value.title.trim() === "") {
+      errors.push(issue2(
+        "INVALID_SITE_META_TITLE",
+        `theme.json.site_meta.${metaKey}.title`,
+        `site_meta key '${metaKey}' must define a non-empty 'title'`,
+        "error"
+      ));
+    } else if (value.title.trim().length > MENU_SLOT_TITLE_MAX_LENGTH) {
+      errors.push(issue2(
+        "INVALID_SITE_META_TITLE",
+        `theme.json.site_meta.${metaKey}.title`,
+        `site_meta key '${metaKey}' title must be at most ${MENU_SLOT_TITLE_MAX_LENGTH} characters`,
+        "error"
+      ));
+    }
+    if (value.description !== void 0 && (typeof value.description !== "string" || value.description.trim().length > MENU_SLOT_DESCRIPTION_MAX_LENGTH)) {
+      errors.push(issue2(
+        "INVALID_SITE_META_DESCRIPTION",
+        `theme.json.site_meta.${metaKey}.description`,
+        `site_meta key '${metaKey}' description must be a string at most ${MENU_SLOT_DESCRIPTION_MAX_LENGTH} characters`,
+        "error"
+      ));
+    }
+    if (value.type !== void 0 && !SITE_META_TYPES.has(value.type)) {
+      errors.push(issue2(
+        "INVALID_SITE_META_TYPE",
+        `theme.json.site_meta.${metaKey}.type`,
+        `site_meta key '${metaKey}' type must be one of: string, number, boolean`,
+        "error"
+      ));
+    }
+    if (value.default !== void 0) {
+      const defaultType = typeof value.default;
+      if (value.default !== null && defaultType !== "string" && defaultType !== "number" && defaultType !== "boolean") {
+        errors.push(issue2(
+          "INVALID_SITE_META_DEFAULT",
+          `theme.json.site_meta.${metaKey}.default`,
+          `site_meta key '${metaKey}' default must be a string, number, boolean, or null`,
+          "error"
+        ));
+      } else if (typeof value.type === "string" && SITE_META_TYPES.has(value.type) && value.default !== null && defaultType !== value.type) {
+        errors.push(issue2(
+          "INVALID_SITE_META_DEFAULT",
+          `theme.json.site_meta.${metaKey}.default`,
+          `site_meta key '${metaKey}' default must match its declared type`,
+          "error"
+        ));
+      }
+    }
+    if (typeof value.title === "string" && value.title.trim() !== "" && value.title.trim().length <= MENU_SLOT_TITLE_MAX_LENGTH && (value.description === void 0 || typeof value.description === "string" && value.description.trim().length <= MENU_SLOT_DESCRIPTION_MAX_LENGTH) && (value.type === void 0 || SITE_META_TYPES.has(value.type)) && (value.default === void 0 || value.default === null || typeof value.default === "string" || typeof value.default === "number" || typeof value.default === "boolean")) {
+      normalizedItems[metaKey] = {
+        title: value.title.trim(),
+        ...typeof value.description === "string" && value.description.trim() !== "" ? { description: value.description.trim() } : {},
+        ...typeof value.type === "string" && SITE_META_TYPES.has(value.type) ? { type: value.type } : {},
+        ...value.default !== void 0 ? { default: value.default } : {}
+      };
+    }
+  }
+  return Object.keys(normalizedItems).length > 0 ? normalizedItems : void 0;
+}
 async function validateThemeFiles(fileMap, options2 = {}) {
   const files = normalizeFileMap(fileMap);
   const errors = [];
@@ -53190,11 +53653,16 @@ async function validateThemeFiles(fileMap, options2 = {}) {
       manifest = manifestResult.manifest;
       errors.push(...manifestResult.errors);
     } catch (error) {
+      const rawThemeJson = getText(files.get("theme.json"));
       errors.push(issue2(
         "INVALID_THEME_JSON",
         "theme.json",
         `Invalid theme.json: ${error instanceof Error ? error.message : String(error)}`,
-        "error"
+        "error",
+        {
+          ...locationForJsonParseError(error, rawThemeJson),
+          category: "json_syntax"
+        }
       ));
     }
   }
@@ -53254,6 +53722,20 @@ function validateManifest(themeJson) {
     license: "",
     runtime: ""
   };
+  for (const key of Object.keys(themeJson)) {
+    if (!THEME_MANIFEST_KEYS.has(key)) {
+      errors.push(issue2(
+        "UNKNOWN_THEME_MANIFEST_FIELD",
+        `theme.json.${key}`,
+        `Unknown theme.json field '${key}'`,
+        "error",
+        {
+          category: "theme_manifest",
+          hint: themeManifestFieldHint(key)
+        }
+      ));
+    }
+  }
   if (themeJson.$schema !== void 0 && typeof themeJson.$schema !== "string") {
     errors.push(issue2(
       "INVALID_SCHEMA_HINT",
@@ -53281,13 +53763,24 @@ function validateManifest(themeJson) {
     errors.push(issue2("INVALID_SEMVER", "theme.json", "Theme version must follow semantic versioning (e.g. 1.0.0)", "error"));
   }
   if (typeof themeJson.runtime === "string" && !SUPPORTED_RUNTIME_SET.has(themeJson.runtime.trim())) {
-    errors.push(issue2("INVALID_RUNTIME_VERSION", "theme.json", `theme.json field 'runtime' must be one of: ${SUPPORTED_RUNTIMES.join(", ")}`, "error"));
+    errors.push(issue2(
+      "INVALID_RUNTIME_VERSION",
+      "theme.json",
+      `theme.json field 'runtime' must be one of: ${SUPPORTED_RUNTIMES.join(", ")}`,
+      "error",
+      {
+        category: "theme_manifest",
+        hint: `Update theme.json:
+
+"runtime": "${THEME_RUNTIME_V0_6}"`
+      }
+    ));
   }
-  if (typeof themeJson.license === "string" && !LICENSES.has(themeJson.license.trim())) {
+  if (typeof themeJson.license === "string" && !isAllowedLicense(themeJson.license.trim())) {
     errors.push(issue2(
       "INVALID_LICENSE",
       "theme.json",
-      "theme.json field 'license' must be one of: MIT, Apache-2.0, BSD-3-Clause, GPL-3.0-only, GPL-3.0-or-later",
+      "theme.json field 'license' must be one of: MIT, Apache-2.0, BSD-3-Clause, GPL-3.0-only, GPL-3.0-or-later, or a LicenseRef-* identifier",
       "error"
     ));
   }
@@ -53339,11 +53832,27 @@ function validateManifest(themeJson) {
       manifest.description = description;
     }
   }
+  if (themeJson.thumbnail !== void 0) {
+    if (typeof themeJson.thumbnail !== "string") {
+      errors.push(issue2(
+        "INVALID_THUMBNAIL",
+        "theme.json.thumbnail",
+        "theme.json field 'thumbnail' must be a string when present",
+        "error"
+      ));
+    } else {
+      manifest.thumbnail = themeJson.thumbnail;
+    }
+  }
+  const links = validateThemeLinks(themeJson.links, errors);
+  if (links) {
+    manifest.links = links;
+  }
   const features = validateFeatureFlags(themeJson.features, errors);
   if (features) {
     manifest.features = features;
   }
-  const menuSlots = validateHelperMetadataMap(themeJson.menuSlots, "menuSlots", {
+  const menu_slots = validateHelperMetadataMap(themeJson.menu_slots, "menu_slots", {
     itemLabel: "Menu slot",
     propertyLabel: "menu slot property",
     collectionLabel: "slots",
@@ -53354,10 +53863,10 @@ function validateManifest(themeJson) {
     invalidTitleCode: "INVALID_MENU_SLOT_TITLE",
     invalidDescriptionCode: "INVALID_MENU_SLOT_DESCRIPTION"
   }, errors);
-  if (menuSlots) {
-    manifest.menuSlots = menuSlots;
+  if (menu_slots) {
+    manifest.menu_slots = menu_slots;
   }
-  const widgetAreas = validateHelperMetadataMap(themeJson.widgetAreas, "widgetAreas", {
+  const widget_areas = validateHelperMetadataMap(themeJson.widget_areas, "widget_areas", {
     itemLabel: "Widget area",
     propertyLabel: "widget area property",
     collectionLabel: "areas",
@@ -53368,8 +53877,26 @@ function validateManifest(themeJson) {
     invalidTitleCode: "INVALID_WIDGET_AREA_TITLE",
     invalidDescriptionCode: "INVALID_WIDGET_AREA_DESCRIPTION"
   }, errors);
-  if (widgetAreas) {
-    manifest.widgetAreas = widgetAreas;
+  if (widget_areas) {
+    manifest.widget_areas = widget_areas;
+  }
+  const site_meta = validateSiteMetaMap(themeJson.site_meta, errors);
+  if (site_meta) {
+    manifest.site_meta = site_meta;
+  }
+  const collection_slots = validateHelperMetadataMap(themeJson.collection_slots, "collection_slots", {
+    itemLabel: "Collection slot",
+    propertyLabel: "collection slot property",
+    collectionLabel: "slots",
+    invalidCollectionCode: "INVALID_COLLECTION_SLOTS",
+    invalidIdCode: "INVALID_COLLECTION_SLOT_ID",
+    invalidItemCode: "INVALID_COLLECTION_SLOT",
+    invalidPropertyCode: "INVALID_COLLECTION_SLOT_PROPERTY",
+    invalidTitleCode: "INVALID_COLLECTION_SLOT_TITLE",
+    invalidDescriptionCode: "INVALID_COLLECTION_SLOT_DESCRIPTION"
+  }, errors);
+  if (collection_slots) {
+    manifest.collection_slots = collection_slots;
   }
   return { errors, manifest: errors.length > 0 ? void 0 : manifest };
 }
@@ -53381,8 +53908,20 @@ function validateTemplateSyntax(templatePath, content, context) {
     if (contentSlotMatches.length !== 1) {
       errors.push(issue2("INVALID_LAYOUT_SLOT", "layout.html", "layout.html must contain exactly one {{slot:content}}", "error"));
     }
-    if (/<script\b/i.test(content)) {
-      errors.push(issue2("LAYOUT_SCRIPT_NOT_ALLOWED", "layout.html", "layout.html must not contain <script> tags", "error"));
+    const scriptMatch = /<script\b/i.exec(content);
+    if (scriptMatch) {
+      errors.push(issue2(
+        "LAYOUT_SCRIPT_NOT_ALLOWED",
+        "layout.html",
+        "layout.html must not contain <script> tags",
+        "error",
+        {
+          ...locationForIndex(content, scriptMatch.index),
+          category: "theme_validation",
+          hint: "Move shared scripts into a partial such as {{partial:content-enhancements}}, then include that partial from layout.html.",
+          snippet: snippetForIndex(content, scriptMatch.index)
+        }
+      ));
     }
   }
   let match2;
@@ -53433,7 +53972,9 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
     index = end + 2;
     if (token.startsWith("partial:")) {
       try {
-        parsePartialReferenceToken(token);
+        parsePartialReferenceToken(token, {
+          allowedSingleSegmentPaths: getPartialArgScope(stack)
+        });
       } catch (error) {
         errors.push(issue2(
           "INVALID_PARTIAL_REFERENCE",
@@ -53458,7 +53999,7 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
     }
     if (token === "#else") {
       const current = stack[stack.length - 1];
-      if (!current || current.tag !== "if" && current.tag !== "if_eq") {
+      if (!current || current.tag !== "if" && !COMPARISON_BLOCK_TAGS.has(current.tag)) {
         errors.push(issue2("UNEXPECTED_TEMPLATE_ELSE", templatePath, `Unexpected {{#else}} in ${templatePath}`, "error"));
         return;
       }
@@ -53469,9 +54010,11 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
       current.hasElse = true;
       continue;
     }
-    if (token.startsWith("#else_if_eq ")) {
+    const comparisonElseIfTag = getComparisonElseIfTag(token);
+    if (comparisonElseIfTag) {
       const current = stack[stack.length - 1];
-      if (!current || current.tag !== "if_eq") {
+      const expectedBlockTag = comparisonElseIfTag.replace(/^else_/, "");
+      if (!current || current.tag !== expectedBlockTag) {
         errors.push(issue2("UNEXPECTED_TEMPLATE_ELSE_IF", templatePath, `Unexpected {{${token}}} in ${templatePath}`, "error"));
         return;
       }
@@ -53479,13 +54022,13 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
         errors.push(issue2("INVALID_TEMPLATE_BRANCH_ORDER", templatePath, `{{${token}}} cannot appear after {{#else}} in ${templatePath}`, "error"));
         return;
       }
-      const expression = token.slice("#else_if_eq ".length).trim();
-      const parsed = parseIfEqExpression(expression);
+      const expression = token.slice(`#${comparisonElseIfTag} `.length).trim();
+      const parsed = parseComparisonExpression(expression, comparisonElseIfTag);
       if (!parsed) {
         errors.push(issue2("UNSUPPORTED_TEMPLATE_TAG", templatePath, `Unsupported template tag '{{${token}}}' in ${templatePath}`, "error"));
         return;
       }
-      validateReservedPathUsage(parsed.path, templatePath, errors, stack, { isPartialFile });
+      validateComparisonPathUsage(parsed, templatePath, errors, stack, { isPartialFile });
       continue;
     }
     if (token.startsWith("#else_if ")) {
@@ -53508,7 +54051,7 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
     }
     if (token.startsWith("/")) {
       const closingTag = token.slice(1).trim();
-      if (!["if", "if_eq", "for"].includes(closingTag)) {
+      if (!["if", "for", ...COMPARISON_BLOCK_TAGS].includes(closingTag)) {
         errors.push(issue2("UNSUPPORTED_TEMPLATE_TAG", templatePath, `Unsupported template closing tag '{{${token}}}' in ${templatePath}`, "error"));
         return;
       }
@@ -53529,22 +54072,23 @@ function validateRuntimeV05TemplateSyntax(templatePath, content, errors) {
       stack.push({ tag: "if", hasElse: false });
       continue;
     }
-    if (token.startsWith("#if_eq ")) {
-      const expression = token.slice("#if_eq ".length).trim();
-      const parsed = parseIfEqExpression(expression);
+    const comparisonBlockTag = getComparisonBlockTag(token);
+    if (comparisonBlockTag) {
+      const expression = token.slice(`#${comparisonBlockTag} `.length).trim();
+      const parsed = parseComparisonExpression(expression, comparisonBlockTag);
       if (!parsed) {
         errors.push(issue2("UNSUPPORTED_TEMPLATE_TAG", templatePath, `Unsupported template tag '{{${token}}}' in ${templatePath}`, "error"));
         return;
       }
-      validateReservedPathUsage(parsed.path, templatePath, errors, stack, { isPartialFile });
-      stack.push({ tag: "if_eq", hasElse: false });
+      validateComparisonPathUsage(parsed, templatePath, errors, stack, { isPartialFile });
+      stack.push({ tag: comparisonBlockTag, hasElse: false });
       continue;
     }
     const forMatch = FOR_TAG_REGEX.exec(token);
     if (forMatch) {
       const path4 = forMatch[2];
       validateReservedPathUsage(path4, templatePath, errors, stack, { isPartialFile });
-      stack.push({ tag: "for", hasElse: false });
+      stack.push({ tag: "for", itemName: forMatch[1], hasElse: false });
       continue;
     }
     errors.push(issue2("UNSUPPORTED_TEMPLATE_TAG", templatePath, `Unsupported template tag '{{${token}}}' in ${templatePath}`, "error"));
@@ -53577,16 +54121,124 @@ function validateReservedPathUsage(path4, templatePath, errors, stack, options2
     ));
   }
 }
-function parseIfEqExpression(expression) {
-  const match2 = IF_EQ_EXPRESSION_REGEX.exec(expression);
-  if (!match2) {
+function validateComparisonPathUsage(parsed, templatePath, errors, stack, options2) {
+  for (const operand of [parsed.left, ...parsed.operands]) {
+    if (operand.kind === "path") {
+      validateReservedPathUsage(operand.path, templatePath, errors, stack, options2);
+    }
+  }
+}
+function getComparisonBlockTag(token) {
+  for (const tagName of COMPARISON_BLOCK_TAGS) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return "";
+}
+function getComparisonElseIfTag(token) {
+  for (const tagName of COMPARISON_ELSE_IF_TAGS) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return "";
+}
+function parseComparisonExpression(expression, tagName) {
+  const operator = COMPARISON_TAG_OPERATORS[tagName];
+  let tokens;
+  try {
+    tokens = tokenizeExpression(expression);
+  } catch {
+    return null;
+  }
+  if (!operator || operator === "in" && tokens.length < 2 || operator !== "in" && tokens.length !== 2) {
     return null;
   }
+  const left = parsePathOperand(tokens[0]);
+  if (!left) {
+    return null;
+  }
+  const operands = [];
+  for (const token of tokens.slice(1)) {
+    const operand = parseComparisonOperand(token);
+    if (!operand) {
+      return null;
+    }
+    operands.push(operand);
+  }
   return {
-    path: match2[1],
-    literal: match2[2]
+    operator,
+    left,
+    operands
   };
 }
+function tokenizeExpression(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    while (/\s/.test(expression[index] || "")) {
+      index += 1;
+    }
+    if (index >= expression.length) {
+      break;
+    }
+    if (expression[index] === '"') {
+      const start2 = index;
+      index += 1;
+      let escaped = false;
+      while (index < expression.length) {
+        const char = expression[index];
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          index += 1;
+          tokens.push(expression.slice(start2, index));
+          break;
+        }
+        index += 1;
+      }
+      if (tokens[tokens.length - 1] !== expression.slice(start2, index)) {
+        throw new Error(`Unclosed string literal in expression: ${expression}`);
+      }
+      continue;
+    }
+    const start = index;
+    while (index < expression.length && !/\s/.test(expression[index])) {
+      index += 1;
+    }
+    tokens.push(expression.slice(start, index));
+  }
+  return tokens;
+}
+function parsePathOperand(token) {
+  return TEMPLATE_PATH_REGEX.test(token) ? { kind: "path", path: token } : null;
+}
+function parseComparisonOperand(token) {
+  if (token.startsWith('"')) {
+    try {
+      const value = JSON.parse(token);
+      return typeof value === "string" ? { kind: "literal", value } : null;
+    } catch {
+      return null;
+    }
+  }
+  if (token === "true") {
+    return { kind: "literal", value: true };
+  }
+  if (token === "false") {
+    return { kind: "literal", value: false };
+  }
+  if (token === "null") {
+    return { kind: "literal", value: null };
+  }
+  if (NUMBER_LITERAL_REGEX.test(token)) {
+    return { kind: "literal", value: Number(token) };
+  }
+  return parsePathOperand(token);
+}
 function validatePartialReferences(templateContents, partialContents, context) {
   const { errors } = context;
   for (const [templatePath, content] of templateContents.entries()) {
@@ -53652,7 +54304,7 @@ function getReferencedPartialNames(content) {
   let match2;
   while ((match2 = PARTIAL_TAG_REGEX.exec(content)) !== null) {
     try {
-      const { name } = parsePartialReferenceToken(match2[1]);
+      const { name } = parsePartialReferenceToken(match2[1], { validateArgs: false });
       matches.add(name);
     } catch {
     }
@@ -53660,7 +54312,7 @@ function getReferencedPartialNames(content) {
   PARTIAL_TAG_REGEX.lastIndex = 0;
   return matches;
 }
-function parsePartialReferenceToken(token) {
+function parsePartialReferenceToken(token, options2 = {}) {
   const source = String(token || "").trim();
   if (!source.startsWith("partial:")) {
     throw new Error("Partial token must start with partial:");
@@ -53675,10 +54327,12 @@ function parsePartialReferenceToken(token) {
     throw new Error(`Invalid partial name '${name}'`);
   }
   const argsSource = expression.slice(name.length).trim();
-  parsePartialArgs(argsSource);
+  if (options2.validateArgs !== false) {
+    parsePartialArgs(argsSource, options2);
+  }
   return { name };
 }
-function parsePartialArgs(source) {
+function parsePartialArgs(source, options2 = {}) {
   if (!source) {
     return {};
   }
@@ -53730,7 +54384,8 @@ function parsePartialArgs(source) {
       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));
+      JSON.parse(source.slice(index, cursor + 1));
+      args[key] = true;
       index = cursor + 1;
       continue;
     }
@@ -53740,10 +54395,25 @@ function parsePartialArgs(source) {
       continue;
     }
     if (source.startsWith("false", index) && isValueBoundary(source, index + 5)) {
-      args[key] = false;
+      args[key] = true;
       index += 5;
       continue;
     }
+    if (source.startsWith("null", index) && isValueBoundary(source, index + 4)) {
+      args[key] = true;
+      index += 4;
+      continue;
+    }
+    const valueMatch = /^\S+/.exec(source.slice(index));
+    if (!valueMatch) {
+      throw new Error(`Missing partial argument value for '${key}'`);
+    }
+    const valueToken = valueMatch[0];
+    if (NUMBER_LITERAL_REGEX.test(valueToken) || TEMPLATE_PATH_REGEX.test(valueToken) && isAllowedPartialArgPath(valueToken, options2)) {
+      args[key] = true;
+      index += valueToken.length;
+      continue;
+    }
     throw new Error(`Unsupported partial argument value for '${key}'`);
   }
   return args;
@@ -53751,6 +54421,23 @@ function parsePartialArgs(source) {
 function isValueBoundary(source, index) {
   return index >= source.length || /\s/.test(source[index]);
 }
+function isAllowedPartialArgPath(valueToken, options2) {
+  if (valueToken.includes(".")) {
+    return true;
+  }
+  const allowedSingleSegmentPaths = options2?.allowedSingleSegmentPaths;
+  return allowedSingleSegmentPaths instanceof Set && allowedSingleSegmentPaths.has(valueToken);
+}
+function getPartialArgScope(stack) {
+  const scope = new Set(PARTIAL_ARG_ROOT_PATHS);
+  for (const entry of stack) {
+    if (entry.tag === "for" && typeof entry.itemName === "string") {
+      scope.add(entry.itemName);
+      scope.add("loop");
+    }
+  }
+  return scope;
+}
 function validatePathSafety(pathEntries, errors) {
   for (const entry of pathEntries) {
     const entryPath = normalizePath(String(entry.path || ""));
@@ -53798,13 +54485,71 @@ function normalizeAbsolutePath(value) {
 function isPathInsideRoot(candidate, root) {
   return candidate === root || candidate.startsWith(`${root}/`);
 }
-function issue2(code2, filePath, message, severity) {
-  return {
+function issue2(code2, filePath, message, severity, details = {}) {
+  const nextIssue = {
     code: code2,
     path: filePath,
     message,
     severity
   };
+  if (Number.isInteger(details.line) && details.line > 0) {
+    nextIssue.line = details.line;
+  }
+  if (Number.isInteger(details.column) && details.column > 0) {
+    nextIssue.column = details.column;
+  }
+  if (typeof details.hint === "string" && details.hint.trim()) {
+    nextIssue.hint = details.hint;
+  }
+  if (typeof details.category === "string" && details.category.trim()) {
+    nextIssue.category = details.category;
+  }
+  if (details.snippet && typeof details.snippet === "object" && typeof details.snippet.line === "string" && typeof details.snippet.pointer === "string") {
+    nextIssue.snippet = {
+      line: details.snippet.line,
+      pointer: details.snippet.pointer
+    };
+  }
+  return nextIssue;
+}
+function locationForJsonParseError(error, source) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lineColumnMatch = /\bline\s+(\d+)\s+column\s+(\d+)/i.exec(message);
+  if (lineColumnMatch) {
+    return {
+      line: Number(lineColumnMatch[1]),
+      column: Number(lineColumnMatch[2])
+    };
+  }
+  const positionMatch = /\bposition\s+(\d+)/i.exec(message);
+  if (positionMatch) {
+    return locationForIndex(source, Number(positionMatch[1]));
+  }
+  if (/Unexpected end of JSON input/i.test(message)) {
+    return locationForIndex(source, source.length);
+  }
+  return {};
+}
+function locationForIndex(source, index) {
+  const boundedIndex = Math.max(0, Math.min(Number.isInteger(index) ? index : 0, source.length));
+  let line = 1;
+  let column = 1;
+  for (let cursor = 0; cursor < boundedIndex; cursor += 1) {
+    if (source[cursor] === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+function snippetForIndex(source, index) {
+  const location = locationForIndex(source, index);
+  const lines = String(source).split(/\r?\n/);
+  const line = lines[location.line - 1] || "";
+  const pointer = `${" ".repeat(Math.max(location.column - 1, 0))}^`;
+  return { line, pointer };
 }
 
 // node_modules/@zeropress/build-core/src/assets/asset-processor.js
@@ -53814,7 +54559,7 @@ var AssetProcessor = class {
     return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~])\s*/g, "$1").replace(/;}/g, "}").trim();
   }
   async processJavaScript(js) {
-    return js.replace(/\/\/(?![^\r\n]*https?:)[^\r\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}();,=+\-*/<>!&|])\s*/g, "$1").trim();
+    return js;
   }
   generateAssetHash(content) {
     const hash = createHash("sha256");
@@ -59270,6 +60015,10 @@ function sanitizeHtml(html) {
     "li",
     "blockquote",
     "aside",
+    "figure",
+    "figcaption",
+    "picture",
+    "source",
     "table",
     "thead",
     "tbody",
@@ -59285,9 +60034,10 @@ function sanitizeHtml(html) {
   const allowedAttributes = {
     a: /* @__PURE__ */ new Set(["href", "title", "class", "id"]),
     aside: /* @__PURE__ */ new Set(["role", "class", "id"]),
-    img: /* @__PURE__ */ new Set(["src", "alt", "title", "class", "id", "width", "height"]),
+    img: /* @__PURE__ */ new Set(["src", "srcset", "sizes", "alt", "title", "class", "id", "width", "height", "loading", "decoding"]),
     iframe: /* @__PURE__ */ new Set(["src", "width", "height", "frameborder", "allowfullscreen", "class"]),
     input: /* @__PURE__ */ new Set(["type", "checked", "disabled", "class", "id"]),
+    source: /* @__PURE__ */ new Set(["src", "srcset", "sizes", "type", "media", "width", "height", "class", "id"]),
     "*": /* @__PURE__ */ new Set(["class", "id"])
   };
   const safeUriPattern = /^(?:(?:https?|mailto|tel):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
@@ -59315,13 +60065,16 @@ function sanitizeHtml(html) {
         if ((attributeName === "href" || attributeName === "src") && !safeUriPattern.test(attributeValue)) {
           continue;
         }
+        if (attributeName === "srcset" && !isSafeSrcset(attributeValue, safeUriPattern)) {
+          continue;
+        }
         if (normalizedTag === "input" && attributeName === "type" && attributeValue !== "checkbox") {
           continue;
         }
         filteredAttributes.push(`${attributeName}="${attributeValue}"`);
       }
     }
-    const isSelfClosing = match2.endsWith("/>") || normalizedTag === "br" || normalizedTag === "hr" || normalizedTag === "img" || normalizedTag === "input";
+    const isSelfClosing = match2.endsWith("/>") || normalizedTag === "br" || normalizedTag === "hr" || normalizedTag === "img" || normalizedTag === "input" || normalizedTag === "source";
     const attributeSuffix = filteredAttributes.length > 0 ? ` ${filteredAttributes.join(" ")}` : "";
     return isSelfClosing ? `<${normalizedTag}${attributeSuffix} />` : `<${normalizedTag}${attributeSuffix}>`;
   });
@@ -59332,6 +60085,13 @@ function sanitizeHtml(html) {
     return part.replace(/&(?!(?:[a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);)/g, "&amp;");
   }).join("");
 }
+function isSafeSrcset(value, safeUriPattern) {
+  const candidates = String(value).split(",").map((candidate) => candidate.trim()).filter(Boolean);
+  return candidates.length > 0 && candidates.every((candidate) => {
+    const [url] = candidate.split(/\s+/);
+    return Boolean(url) && safeUriPattern.test(url);
+  });
+}
 function slugify(value) {
   return String(value || "").toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -59424,6 +60184,9 @@ var VariableResolver = class _VariableResolver {
         }
       }
     }
+    if (variablePath === "data" || variablePath.startsWith("data.") || variablePath.includes(".data.")) {
+      return false;
+    }
     const lastSegment = variablePath.split(".").pop();
     if (lastSegment === "html" || lastSegment?.endsWith("_html")) {
       return true;
@@ -59441,7 +60204,10 @@ var VariableResolver = class _VariableResolver {
 // node_modules/@zeropress/build-core/src/render/partial-resolver.js
 var PARTIAL_NAME_REGEX2 = /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*$/;
 var IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function parsePartialToken(token) {
+var PATH_SEGMENT_SOURCE = "[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*";
+var PATH_REGEX = new RegExp(`^${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*$`);
+var NUMBER_LITERAL_REGEX2 = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function parsePartialToken(token, options2 = {}) {
   const source = String(token || "").trim();
   if (!source.startsWith("partial:")) {
     throw new Error(`Invalid partial token: ${source}`);
@@ -59456,10 +60222,10 @@ function parsePartialToken(token) {
     throw new Error(`Invalid partial name: ${name}`);
   }
   const argsSource = expression.slice(name.length).trim();
-  const args = parsePartialArgs2(argsSource);
+  const args = parsePartialArgs2(argsSource, options2);
   return { name, args };
 }
-function parsePartialArgs2(source) {
+function parsePartialArgs2(source, options2 = {}) {
   if (!source) {
     return {};
   }
@@ -59511,20 +60277,40 @@ function parsePartialArgs2(source) {
       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));
+      args[key] = { kind: "literal", value: JSON.parse(source.slice(index, cursor + 1)) };
       index = cursor + 1;
       continue;
     }
     if (source.startsWith("true", index) && isValueBoundary2(source, index + 4)) {
-      args[key] = true;
+      args[key] = { kind: "literal", value: true };
       index += 4;
       continue;
     }
     if (source.startsWith("false", index) && isValueBoundary2(source, index + 5)) {
-      args[key] = false;
+      args[key] = { kind: "literal", value: false };
       index += 5;
       continue;
     }
+    if (source.startsWith("null", index) && isValueBoundary2(source, index + 4)) {
+      args[key] = { kind: "literal", value: null };
+      index += 4;
+      continue;
+    }
+    const valueMatch = /^\S+/.exec(source.slice(index));
+    if (!valueMatch) {
+      throw new Error(`Missing partial argument value for "${key}"`);
+    }
+    const valueToken = valueMatch[0];
+    if (NUMBER_LITERAL_REGEX2.test(valueToken)) {
+      args[key] = { kind: "literal", value: Number(valueToken) };
+      index += valueToken.length;
+      continue;
+    }
+    if (PATH_REGEX.test(valueToken) && isAllowedPathArgument(valueToken, options2)) {
+      args[key] = { kind: "path", path: valueToken };
+      index += valueToken.length;
+      continue;
+    }
     throw new Error(`Unsupported partial argument value for "${key}"`);
   }
   return args;
@@ -59532,12 +60318,146 @@ function parsePartialArgs2(source) {
 function isValueBoundary2(source, index) {
   return index >= source.length || /\s/.test(source[index]);
 }
+function isAllowedPathArgument(valueToken, options2) {
+  if (valueToken.includes(".")) {
+    return true;
+  }
+  const allowedSingleSegmentPaths = options2?.allowedSingleSegmentPaths;
+  return allowedSingleSegmentPaths instanceof Set && allowedSingleSegmentPaths.has(valueToken);
+}
 
 // node_modules/@zeropress/build-core/src/render/control-flow-renderer.js
-var PATH_SEGMENT_SOURCE = "[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*";
-var PATH_REGEX = new RegExp(`^${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*$`);
-var FOR_EXPRESSION_REGEX = new RegExp(`^([a-zA-Z_][a-zA-Z0-9_]*)\\s+in\\s+(${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*)$`);
-var IF_EQ_EXPRESSION_REGEX2 = new RegExp(`^(${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*)\\s+("(?:[^"\\\\]|\\\\.)*")$`);
+var PATH_SEGMENT_SOURCE2 = "[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*";
+var PATH_REGEX2 = new RegExp(`^${PATH_SEGMENT_SOURCE2}(?:\\.${PATH_SEGMENT_SOURCE2})*$`);
+var FOR_EXPRESSION_REGEX = new RegExp(`^([a-zA-Z_][a-zA-Z0-9_]*)\\s+in\\s+(${PATH_SEGMENT_SOURCE2}(?:\\.${PATH_SEGMENT_SOURCE2})*)$`);
+var NUMBER_LITERAL_REGEX3 = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var COMPARISON_BLOCK_TAGS2 = /* @__PURE__ */ new Set(["if_eq", "if_neq", "if_in", "if_starts_with"]);
+var COMPARISON_ELSE_IF_TAGS2 = /* @__PURE__ */ new Set(["else_if_eq", "else_if_neq", "else_if_in", "else_if_starts_with"]);
+var COMPARISON_TAG_OPERATORS2 = {
+  if_eq: "eq",
+  else_if_eq: "eq",
+  if_neq: "neq",
+  else_if_neq: "neq",
+  if_in: "in",
+  else_if_in: "in",
+  if_starts_with: "starts_with",
+  else_if_starts_with: "starts_with"
+};
+var PARTIAL_ARG_ROOT_PATHS2 = /* @__PURE__ */ new Set([
+  "archive",
+  "author",
+  "category",
+  "collection",
+  "collections",
+  "currentUrl",
+  "language",
+  "menu",
+  "menus",
+  "meta",
+  "page",
+  "pagination",
+  "partial",
+  "post",
+  "posts",
+  "route",
+  "site",
+  "tag",
+  "taxonomies",
+  "taxonomy",
+  "widget",
+  "widgets"
+]);
+function getComparisonBlockTag2(token) {
+  for (const tagName of COMPARISON_BLOCK_TAGS2) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return "";
+}
+function getComparisonElseIfTag2(token) {
+  for (const tagName of COMPARISON_ELSE_IF_TAGS2) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return "";
+}
+function tokenizeExpression2(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    while (/\s/.test(expression[index] || "")) {
+      index += 1;
+    }
+    if (index >= expression.length) {
+      break;
+    }
+    if (expression[index] === '"') {
+      const start2 = index;
+      index += 1;
+      let escaped = false;
+      while (index < expression.length) {
+        const char = expression[index];
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          index += 1;
+          tokens.push(expression.slice(start2, index));
+          break;
+        }
+        index += 1;
+      }
+      if (tokens[tokens.length - 1] !== expression.slice(start2, index)) {
+        throw new Error(`Unclosed string literal in expression: ${expression}`);
+      }
+      continue;
+    }
+    const start = index;
+    while (index < expression.length && !/\s/.test(expression[index])) {
+      index += 1;
+    }
+    tokens.push(expression.slice(start, index));
+  }
+  return tokens;
+}
+function parsePathOperand2(token, tagName, expression) {
+  if (!PATH_REGEX2.test(token)) {
+    throw new Error(`Invalid ${tagName} expression: ${expression}`);
+  }
+  return { kind: "path", path: token };
+}
+function parseComparisonOperand2(token, tagName, expression) {
+  if (token.startsWith('"')) {
+    try {
+      const value = JSON.parse(token);
+      if (typeof value !== "string") {
+        throw new Error("Expected string literal");
+      }
+      return { kind: "literal", value };
+    } catch {
+      throw new Error(`Invalid ${tagName} expression: ${expression}`);
+    }
+  }
+  if (token === "true") {
+    return { kind: "literal", value: true };
+  }
+  if (token === "false") {
+    return { kind: "literal", value: false };
+  }
+  if (token === "null") {
+    return { kind: "literal", value: null };
+  }
+  if (NUMBER_LITERAL_REGEX3.test(token)) {
+    return { kind: "literal", value: Number(token) };
+  }
+  if (PATH_REGEX2.test(token)) {
+    return { kind: "path", path: token };
+  }
+  throw new Error(`Invalid ${tagName} expression: ${expression}`);
+}
 var ControlFlowRenderer = class {
   constructor(options2 = {}) {
     this.resolvePath = typeof options2.resolvePath === "function" ? options2.resolvePath : ((data, path4) => path4.split(".").reduce((current, segment) => {
@@ -59560,7 +60480,7 @@ var ControlFlowRenderer = class {
   }
   parse(template) {
     const source = String(template || "");
-    const { nodes, nextIndex, stopTag } = this.parseNodes(source, 0, /* @__PURE__ */ new Set());
+    const { nodes, nextIndex, stopTag } = this.parseNodes(source, 0, /* @__PURE__ */ new Set(), PARTIAL_ARG_ROOT_PATHS2);
     if (stopTag) {
       throw new Error(`Unexpected closing tag ${stopTag}`);
     }
@@ -59569,7 +60489,7 @@ var ControlFlowRenderer = class {
     }
     return nodes;
   }
-  parseNodes(source, startIndex, stopTags) {
+  parseNodes(source, startIndex, stopTags, partialArgScope) {
     const nodes = [];
     let index = startIndex;
     while (index < source.length) {
@@ -59620,9 +60540,10 @@ var ControlFlowRenderer = class {
         }
         return { nodes, nextIndex: tokenEnd + 2, stopTag: "else" };
       }
-      if (token.startsWith("#else_if_eq ")) {
-        if (!stopTags.has("else_if_eq")) {
-          throw new Error("Unexpected else_if_eq tag");
+      const comparisonElseIfTag = getComparisonElseIfTag2(token);
+      if (comparisonElseIfTag) {
+        if (!stopTags.has(comparisonElseIfTag)) {
+          throw new Error(`Unexpected ${comparisonElseIfTag} tag`);
         }
         return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
       }
@@ -59633,21 +60554,22 @@ var ControlFlowRenderer = class {
         return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
       }
       if (token.startsWith("partial:")) {
-        const { name, args } = parsePartialToken(token);
+        const { name, args } = parsePartialToken(token, { allowedSingleSegmentPaths: partialArgScope });
         nodes.push({ type: "partial", name, args });
         index = tokenEnd + 2;
         continue;
       }
-      if (token.startsWith("#if_eq ")) {
-        const expression = token.slice("#if_eq ".length).trim();
-        const block2 = this.parseIfEqBlock(source, tokenEnd + 2, expression);
+      const comparisonBlockTag = getComparisonBlockTag2(token);
+      if (comparisonBlockTag) {
+        const expression = token.slice(`#${comparisonBlockTag} `.length).trim();
+        const block2 = this.parseComparisonBlock(source, tokenEnd + 2, comparisonBlockTag, expression, partialArgScope);
         nodes.push(block2.node);
         index = block2.nextIndex;
         continue;
       }
       if (token.startsWith("#if ")) {
         const expression = token.slice("#if ".length).trim();
-        const block2 = this.parseIfBlock(source, tokenEnd + 2, expression);
+        const block2 = this.parseIfBlock(source, tokenEnd + 2, expression, partialArgScope);
         nodes.push(block2.node);
         index = block2.nextIndex;
         continue;
@@ -59659,7 +60581,8 @@ var ControlFlowRenderer = class {
           throw new Error(`Invalid for expression: ${expression}`);
         }
         const [, itemName, path4] = match2;
-        const forResult = this.parseNodes(source, tokenEnd + 2, /* @__PURE__ */ new Set(["for"]));
+        const forScope = /* @__PURE__ */ new Set([...partialArgScope, itemName, "loop"]);
+        const forResult = this.parseNodes(source, tokenEnd + 2, /* @__PURE__ */ new Set(["for"]), forScope);
         if (forResult.stopTag !== "for") {
           throw new Error("Unclosed for block");
         }
@@ -59676,8 +60599,8 @@ var ControlFlowRenderer = class {
     }
     return { nodes, nextIndex: source.length, stopTag: null };
   }
-  parseIfBlock(source, startIndex, initialPath) {
-    if (!PATH_REGEX.test(initialPath)) {
+  parseIfBlock(source, startIndex, initialPath, partialArgScope) {
+    if (!PATH_REGEX2.test(initialPath)) {
       throw new Error(`Invalid if expression: ${initialPath}`);
     }
     const branches = [];
@@ -59685,13 +60608,13 @@ var ControlFlowRenderer = class {
     let nextIndex = startIndex;
     let currentPath = initialPath;
     while (true) {
-      const branchResult = this.parseNodes(source, nextIndex, /* @__PURE__ */ new Set(["else", "else_if", "if"]));
+      const branchResult = this.parseNodes(source, nextIndex, /* @__PURE__ */ new Set(["else", "else_if", "if"]), partialArgScope);
       branches.push({
         path: currentPath,
         consequent: branchResult.nodes
       });
       if (branchResult.stopTag === "else") {
-        const elseResult = this.parseNodes(source, branchResult.nextIndex, /* @__PURE__ */ new Set(["if"]));
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, /* @__PURE__ */ new Set(["if"]), partialArgScope);
         if (elseResult.stopTag !== "if") {
           throw new Error("Unclosed if block after else");
         }
@@ -59701,7 +60624,7 @@ var ControlFlowRenderer = class {
       }
       if (typeof branchResult.stopTag === "string" && branchResult.stopTag.startsWith("#else_if ")) {
         currentPath = branchResult.stopTag.slice("#else_if ".length).trim();
-        if (!PATH_REGEX.test(currentPath)) {
+        if (!PATH_REGEX2.test(currentPath)) {
           throw new Error(`Invalid else_if expression: ${currentPath}`);
         }
         nextIndex = branchResult.nextIndex;
@@ -59722,60 +60645,65 @@ var ControlFlowRenderer = class {
       nextIndex
     };
   }
-  parseIfEqBlock(source, startIndex, expression) {
-    const initialBranch = this.parseIfEqBranchExpression(expression, "if_eq");
+  parseComparisonBlock(source, startIndex, tagName, expression, partialArgScope) {
+    const initialBranch = this.parseComparisonBranchExpression(expression, tagName);
     const branches = [];
     let alternate = [];
     let nextIndex = startIndex;
     let currentBranch = initialBranch;
+    const elseIfTag = `else_${tagName}`;
     while (true) {
-      const branchResult = this.parseNodes(source, nextIndex, /* @__PURE__ */ new Set(["else", "else_if_eq", "if_eq"]));
+      const branchResult = this.parseNodes(source, nextIndex, /* @__PURE__ */ new Set(["else", elseIfTag, tagName]), partialArgScope);
       branches.push({
-        path: currentBranch.path,
-        literal: currentBranch.literal,
+        operator: currentBranch.operator,
+        left: currentBranch.left,
+        operands: currentBranch.operands,
         consequent: branchResult.nodes
       });
       if (branchResult.stopTag === "else") {
-        const elseResult = this.parseNodes(source, branchResult.nextIndex, /* @__PURE__ */ new Set(["if_eq"]));
-        if (elseResult.stopTag !== "if_eq") {
-          throw new Error("Unclosed if_eq block after else");
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, /* @__PURE__ */ new Set([tagName]), partialArgScope);
+        if (elseResult.stopTag !== tagName) {
+          throw new Error(`Unclosed ${tagName} 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"
+      if (typeof branchResult.stopTag === "string" && branchResult.stopTag.startsWith(`#${elseIfTag} `)) {
+        currentBranch = this.parseComparisonBranchExpression(
+          branchResult.stopTag.slice(`#${elseIfTag} `.length).trim(),
+          elseIfTag
         );
         nextIndex = branchResult.nextIndex;
         continue;
       }
-      if (branchResult.stopTag === "if_eq") {
+      if (branchResult.stopTag === tagName) {
         nextIndex = branchResult.nextIndex;
         break;
       }
-      throw new Error("Unclosed if_eq block");
+      throw new Error(`Unclosed ${tagName} block`);
     }
     return {
       node: {
-        type: "if_eq",
+        type: "comparison",
         branches,
         alternate
       },
       nextIndex
     };
   }
-  parseIfEqBranchExpression(expression, tagName) {
-    const match2 = IF_EQ_EXPRESSION_REGEX2.exec(expression);
-    if (!match2) {
+  parseComparisonBranchExpression(expression, tagName) {
+    const operator = COMPARISON_TAG_OPERATORS2[tagName];
+    const tokens = tokenizeExpression2(expression);
+    if (!operator || operator === "in" && tokens.length < 2 || operator !== "in" && tokens.length !== 2) {
       throw new Error(`Invalid ${tagName} expression: ${expression}`);
     }
-    const [, path4, literalSource] = match2;
+    const left = parsePathOperand2(tokens[0], tagName, expression);
+    const operands = tokens.slice(1).map((token) => parseComparisonOperand2(token, tagName, expression));
     return {
-      path: path4,
-      literal: JSON.parse(literalSource)
+      operator,
+      left,
+      operands
     };
   }
   renderNodes(nodes, data, renderOptions) {
@@ -59789,8 +60717,8 @@ var ControlFlowRenderer = class {
         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 branch = node.branches.find((entry) => this.resolvePath(data, entry.path) === entry.literal);
+      case "comparison": {
+        const branch = node.branches.find((entry) => this.evaluateComparison(entry, data));
         return branch ? this.renderNodes(branch.consequent, data, renderOptions) : this.renderNodes(node.alternate, data, renderOptions);
       }
       case "for": {
@@ -59825,15 +60753,62 @@ var ControlFlowRenderer = class {
       throw new Error(`Circular partial reference detected: ${cycle}`);
     }
     const partialTemplate = String(partials.get(node.name) || "");
+    const partialArgs = this.resolvePartialArgs(node.args, data);
     const partialData = {
       ...data,
-      partial: { ...node.args }
+      partial: {
+        ...data?.partial && typeof data.partial === "object" ? data.partial : {},
+        ...partialArgs
+      }
     };
     return this.renderTemplate(partialTemplate, partialData, {
       ...renderOptions,
       partialStack: [...activeStack, node.name]
     });
   }
+  resolvePartialArgs(args, data) {
+    const resolved = {};
+    for (const [key, operand] of Object.entries(args || {})) {
+      if (operand?.kind === "literal") {
+        resolved[key] = operand.value;
+        continue;
+      }
+      if (operand?.kind === "path") {
+        resolved[key] = this.resolvePath(data, operand.path);
+      }
+    }
+    return resolved;
+  }
+  evaluateComparison(entry, data) {
+    const left = this.evaluateOperand(entry.left, data);
+    const operands = entry.operands.map((operand) => this.evaluateOperand(operand, data));
+    if (entry.operator === "eq") {
+      const right = operands[0];
+      return !left.missing && !right.missing && left.value === right.value;
+    }
+    if (entry.operator === "neq") {
+      const right = operands[0];
+      return left.missing || right.missing || left.value !== right.value;
+    }
+    if (entry.operator === "in") {
+      if (left.missing) {
+        return false;
+      }
+      return operands.some((operand) => !operand.missing && left.value === operand.value);
+    }
+    if (entry.operator === "starts_with") {
+      const right = operands[0];
+      return !left.missing && !right.missing && typeof left.value === "string" && typeof right.value === "string" && left.value.startsWith(right.value);
+    }
+    return false;
+  }
+  evaluateOperand(operand, data) {
+    if (operand.kind === "literal") {
+      return { value: operand.value, missing: false };
+    }
+    const value = this.resolvePath(data, operand.path);
+    return { value, missing: value === void 0 };
+  }
   isTruthy(value) {
     if (Array.isArray(value)) {
       return value.length > 0;
@@ -59875,7 +60850,7 @@ var ZeroPressEngine = class {
     const renderData = this.combineRenderData(data, context);
     const renderedContent = this.renderTemplate(template, renderData);
     const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, CONTENT_SLOT_PLACEHOLDER);
-    return this.renderTemplate(layoutWithSlots, renderData).replaceAll(CONTENT_SLOT_PLACEHOLDER, renderedContent);
+    return this.renderTemplate(layoutWithSlots, renderData).replaceAll(CONTENT_SLOT_PLACEHOLDER, () => renderedContent);
   }
   combineRenderData(data, context) {
     return {
@@ -59886,7 +60861,7 @@ var ZeroPressEngine = class {
     };
   }
   renderTemplate(template, data) {
-    if (this.themePackage?.metadata?.runtime !== "0.5") {
+    if (this.themePackage?.metadata?.runtime !== "0.6") {
       throw new Error(`Unsupported theme runtime: ${this.themePackage?.metadata?.runtime || "unknown"}`);
     }
     return this.controlFlowRenderer.render(template, data, {
@@ -59902,13 +60877,17 @@ var ZeroPressEngine = class {
 var DEFAULT_OPTIONS = {
   assetHashing: true,
   generateSpecialFiles: true,
+  generateRobotsTxt: true,
   writeManifest: false
 };
 var DEFAULT_POSTS_PER_PAGE = 10;
-var DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
-var DEFAULT_TIME_FORMAT = "HH:mm";
+var DEFAULT_DATETIME_DISPLAY = "static";
+var DEFAULT_DATE_STYLE = "medium";
+var DEFAULT_TIME_STYLE = "none";
 var DEFAULT_TIMEZONE = "UTC";
 var DEFAULT_LOCALE = "en-US";
+var DATETIME_DISPLAY_MODES = /* @__PURE__ */ new Set(["static", "client"]);
+var DATETIME_STYLES = /* @__PURE__ */ new Set(["none", "short", "medium", "long", "full"]);
 var DEFAULT_PERMALINKS = Object.freeze({
   output_style: "directory",
   posts: "/posts/:slug/",
@@ -59926,9 +60905,24 @@ var DEFAULT_POST_INDEX = Object.freeze({
 });
 var PERMALINK_OUTPUT_STYLES = /* @__PURE__ */ new Set(["directory", "html-extension"]);
 var COMMENT_POLICY_OUTPUT_PATH = "_zeropress/comment-policy.json";
+var SEARCH_INDEX_OUTPUT_PATH = "_zeropress/search.json";
+var SEARCH_ADAPTER_OUTPUT_PATH = "_zeropress/search.js";
 var OUTPUT_PATH_CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
 var SAFE_MEDIA_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
 var SAFE_LINK_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+var MEDIA_DELIVERY_MODES = /* @__PURE__ */ new Set(["none", "media_domain"]);
+var DISCOVERABILITY_VALUES = /* @__PURE__ */ new Set(["default", "noindex", "delist"]);
+var RESPONSIVE_IMAGE_WIDTHS = [320, 480, 768, 1024, 1280, 1600, 1920];
+var RESPONSIVE_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["jpg", "jpeg", "png", "webp", "avif"]);
+var SEARCH_FIELD_WEIGHTS = Object.freeze({
+  title: 5,
+  headings: 3,
+  tags: 2.5,
+  categories: 2,
+  excerpt: 1.5,
+  content_text: 1
+});
+var SEARCH_RECENCY_BOOST_MAX = 0.15;
 async function buildSite(input2) {
   const options2 = { ...DEFAULT_OPTIONS, ...input2.options || {} };
   const state = await createBuildState(input2, options2);
@@ -59971,12 +60965,22 @@ async function buildSite(input2) {
     "application/json"
   );
   if (options2.generateSpecialFiles) {
+    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 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, options2.sitemapStylesheetHref),
+        "application/xml"
+      );
       await writeOutput(state.writer, state.summaries, "feed.xml", buildFeedXml(state.previewData.site, state.emitted, state.generatedAt), "application/rss+xml");
     }
-    await writeOutput(state.writer, state.summaries, "robots.txt", buildRobotsTxt(state.previewData.site), "text/plain");
+    if (shouldGenerateRobotsTxt(options2)) {
+      await writeOutput(state.writer, state.summaries, "robots.txt", buildRobotsTxt(state.previewData.site), "text/plain");
+    }
   }
   return finalizeBuildResult(state.writer, state.summaries, options2);
 }
@@ -59989,7 +60993,7 @@ async function createBuildState(input2, options2) {
   const engine = new ZeroPressEngine();
   const assetProcessor = new AssetProcessor();
   const summaries = [];
-  const previewData = normalizePreviewData(input2.previewData);
+  const previewData = normalizePreviewData(input2.previewData, options2);
   const renderData = createRenderData(previewData, themePackage.metadata);
   engine.initialize(themePackage);
   const assetOutputs = await buildAssetOutputs(themePackage.assets, assetProcessor, options2);
@@ -60012,6 +61016,8 @@ async function createBuildState(input2, options2) {
     assetMap,
     customCssHref: customCssAsset ? `/${customCssAsset.path}` : "",
     customHtml: previewData.custom_html,
+    favicon: previewData.site.favicon,
+    exposeGenerator: previewData.site.expose_generator !== false,
     commentPolicyContent: buildCommentPolicyManifest(renderData.posts),
     options: options2,
     generatedAt: /* @__PURE__ */ new Date(),
@@ -60068,6 +61074,7 @@ async function renderRoute(state, templateName, route) {
     {
       menus: state.previewData.menus,
       widgets: state.widgets,
+      collections: state.renderData.collections,
       taxonomies: state.renderData.taxonomies,
       ...route,
       route: routeContext,
@@ -60111,6 +61118,7 @@ async function renderFrontPage(state, route) {
       {
         menus: state.previewData.menus,
         widgets: state.widgets,
+        collections: state.renderData.collections,
         taxonomies: state.renderData.taxonomies,
         page,
         route: routeContext,
@@ -60119,7 +61127,8 @@ async function renderFrontPage(state, route) {
           title: buildDocumentTitle(page.title, state.previewData.site.title),
           description: page.excerpt,
           ogType: "website",
-          image: page.featured_image
+          image: page.featured_image,
+          robotsNoindex: shouldNoindexDocument(page)
         })
       },
       createRenderContext(state.previewData.site, currentUrl)
@@ -60131,7 +61140,8 @@ async function renderFrontPage(state, route) {
       url: currentUrl,
       title: page.title,
       description: page.excerpt,
-      includeInFeed: false
+      includeInFeed: false,
+      includeInSitemap: !isDelistedDocument(page)
     };
     return;
   }
@@ -60140,6 +61150,7 @@ async function renderFrontPage(state, route) {
     {
       menus: state.previewData.menus,
       widgets: state.widgets,
+      collections: state.renderData.collections,
       taxonomies: state.renderData.taxonomies,
       ...route,
       route: routeContext,
@@ -60169,6 +61180,7 @@ async function renderPost(state, post) {
     {
       menus: state.previewData.menus,
       widgets: state.widgets,
+      collections: state.renderData.collections,
       taxonomies: state.renderData.taxonomies,
       post,
       route: buildRouteContext("post", currentUrl),
@@ -60179,7 +61191,8 @@ async function renderPost(state, post) {
         ogType: "article",
         image: post.featured_image,
         publishedTime: post.published_at_iso,
-        modifiedTime: post.updated_at_iso
+        modifiedTime: post.updated_at_iso,
+        robotsNoindex: shouldNoindexDocument(post)
       })
     },
     createRenderContext(state.previewData.site, currentUrl)
@@ -60187,14 +61200,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) {
   const currentUrl = page.url;
@@ -60205,6 +61220,7 @@ async function renderPage(state, page) {
     {
       menus: state.previewData.menus,
       widgets: state.widgets,
+      collections: state.renderData.collections,
       taxonomies: state.renderData.taxonomies,
       page,
       route: buildRouteContext("page", currentUrl),
@@ -60214,7 +61230,8 @@ async function renderPage(state, page) {
         title: buildDocumentTitle(page.title, state.previewData.site.title),
         description: page.excerpt,
         ogType: "website",
-        image: page.featured_image
+        image: page.featured_image,
+        robotsNoindex: shouldNoindexDocument(page)
       })
     },
     createRenderContext(state.previewData.site, currentUrl)
@@ -60227,7 +61244,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)
   });
 }
 async function maybeRenderNotFoundPage(state) {
@@ -60239,6 +61256,7 @@ async function maybeRenderNotFoundPage(state) {
     {
       menus: state.previewData.menus,
       widgets: state.widgets,
+      collections: state.renderData.collections,
       taxonomies: state.renderData.taxonomies,
       route: buildRouteContext("not_found", "/404.html"),
       meta: buildPageMeta(state.previewData.site, {
@@ -60254,76 +61272,220 @@ async function maybeRenderNotFoundPage(state) {
   html = injectSiteCustomizations(html, state);
   await writeOutput(state.writer, state.summaries, "404.html", html, "text/html");
 }
-function normalizePreviewData(previewData) {
+function normalizePreviewData(previewData, options2 = {}) {
   const normalizedSite = {
     ...previewData.site,
-    mediaBaseUrl: normalizeOptionalString(previewData.site.mediaBaseUrl),
-    postsPerPage: Number.isInteger(previewData.site.postsPerPage) && previewData.site.postsPerPage > 0 ? previewData.site.postsPerPage : DEFAULT_POSTS_PER_PAGE,
-    dateFormat: normalizeNonEmptyString(previewData.site.dateFormat, DEFAULT_DATE_FORMAT),
-    timeFormat: typeof previewData.site.timeFormat === "string" ? previewData.site.timeFormat : DEFAULT_TIME_FORMAT,
+    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 || options2.favicon),
+    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,
+    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,
+    indexing: previewData.site.indexing !== false,
     permalinks: normalizePermalinks(previewData.site.permalinks),
     front_page: normalizeFrontPage(previewData.site.front_page),
     post_index: normalizePostIndex(previewData.site.post_index),
     footer: normalizeSiteFooter(previewData.site.footer)
   };
+  const media = normalizeContentMedia(previewData.content.media, normalizedSite);
+  const mediaRegistry = buildMediaRegistry(media);
   return {
     ...previewData,
     site: normalizedSite,
-    widgets: normalizeWidgetAreas(previewData.widgets, normalizedSite.mediaBaseUrl),
+    menus: normalizeRecordMap(previewData.menus),
+    collections: normalizeCollections(previewData.collections),
+    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) => ({
-        ...author,
-        avatar: normalizeMediaField(author.avatar, normalizedSite.mediaBaseUrl)
-      })),
-      posts: previewData.content.posts.map((post) => ({
-        ...post,
-        published_at_iso: normalizeIsoTimestamp(post.published_at_iso),
-        updated_at_iso: normalizeIsoTimestamp(post.updated_at_iso),
-        featured_image: normalizeMediaField(post.featured_image, normalizedSite.mediaBaseUrl)
-      })).sort((left, right) => toDate(right.published_at_iso).getTime() - toDate(left.published_at_iso).getTime()),
-      pages: previewData.content.pages.map((page) => ({
-        ...page,
-        featured_image: normalizeMediaField(page.featured_image, normalizedSite.mediaBaseUrl)
-      })),
+      authors: previewData.content.authors.map((author) => {
+        const avatar = normalizeMediaField(author.avatar, normalizedSite.media_base_url);
+        const avatarMedia = deriveManagedMedia(avatar, mediaRegistry, normalizedSite);
+        return {
+          ...author,
+          avatar,
+          ...avatarMedia ? { avatar_media: avatarMedia } : {}
+        };
+      }),
+      posts: previewData.content.posts.map((post) => {
+        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.media_base_url);
+        const featuredMedia = deriveManagedMedia(featuredImage, mediaRegistry, normalizedSite);
+        return {
+          ...page,
+          discoverability: normalizeDiscoverability(page.discoverability),
+          featured_image: featuredImage,
+          ...featuredMedia ? { featured_media: featuredMedia } : {}
+        };
+      }),
       categories: [...previewData.content.categories],
-      tags: [...previewData.content.tags]
+      tags: [...previewData.content.tags],
+      media
     }
   };
 }
-function normalizeWidgetAreas(widgetAreas, mediaBaseUrl) {
-  if (!widgetAreas || typeof widgetAreas !== "object") {
+function normalizeRecordMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function normalizeDiscoverability(value) {
+  return DISCOVERABILITY_VALUES.has(value) ? value : "default";
+}
+function isDelistedDocument(document2) {
+  return document2?.discoverability === "delist";
+}
+function shouldNoindexDocument(document2) {
+  return document2?.discoverability === "noindex" || document2?.discoverability === "delist";
+}
+function normalizeContentMedia(mediaItems, site) {
+  if (!Array.isArray(mediaItems)) {
+    return [];
+  }
+  return mediaItems.map((item) => {
+    if (!item || typeof item !== "object") {
+      return null;
+    }
+    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) {
+      return null;
+    }
+    return {
+      src,
+      width,
+      height,
+      alt: typeof item.alt === "string" ? item.alt : ""
+    };
+  }).filter(Boolean);
+}
+function buildMediaRegistry(mediaItems) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const item of mediaItems) {
+    if (!registry.has(item.src)) {
+      registry.set(item.src, item);
+    }
+  }
+  return registry;
+}
+function deriveManagedMedia(src, mediaRegistry, site) {
+  const normalizedSrc = normalizeOptionalString(src);
+  if (!normalizedSrc) {
+    return null;
+  }
+  const media = mediaRegistry.get(normalizedSrc);
+  if (!media) {
+    return null;
+  }
+  return {
+    ...media,
+    srcset: buildResponsiveImageSrcset(media, site)
+  };
+}
+function buildResponsiveImageSrcset(media, site) {
+  if (site.media_delivery_mode !== "media_domain") {
+    return "";
+  }
+  const media_base_url = normalizeOptionalString(site.media_base_url);
+  if (!media_base_url || !isUrlUnderMediaBase(media.src, media_base_url) || !isResponsiveRasterImage(media.src)) {
+    return "";
+  }
+  const widths = RESPONSIVE_IMAGE_WIDTHS.filter((width) => width <= media.width);
+  if (!widths.includes(media.width)) {
+    widths.push(media.width);
+  }
+  return widths.filter((width, index, values) => width > 0 && values.indexOf(width) === index).map((width) => `${buildResponsiveImageVariantUrl(media.src, width)} ${width}w`).join(", ");
+}
+function buildResponsiveImageVariantUrl(src, width) {
+  try {
+    const url = new URL(src);
+    url.searchParams.set("w", String(width));
+    url.searchParams.set("fit", "scale-down");
+    url.searchParams.set("format", "auto");
+    return decodeURI(url.toString());
+  } catch {
+    return src;
+  }
+}
+function isUrlUnderMediaBase(src, media_base_url) {
+  try {
+    const sourceUrl = new URL(src);
+    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 {
+    return false;
+  }
+}
+function isResponsiveRasterImage(src) {
+  try {
+    const url = new URL(src);
+    const lastSegment = url.pathname.split("/").pop() || "";
+    const extension = lastSegment.includes(".") ? lastSegment.split(".").pop().toLowerCase() : "";
+    return RESPONSIVE_IMAGE_EXTENSIONS.has(extension);
+  } catch {
+    return false;
+  }
+}
+function normalizeCollections(collections) {
+  if (!collections || typeof collections !== "object" || Array.isArray(collections)) {
     return {};
   }
   return Object.fromEntries(
-    Object.entries(widgetAreas).map(([widgetAreaId, widgetArea]) => [
+    Object.entries(collections).map(([collectionId, collection]) => [
+      collectionId,
+      {
+        ...collection,
+        title: normalizeOptionalString(collection?.title),
+        description: normalizeOptionalString(collection?.description),
+        items: Array.isArray(collection?.items) ? collection.items.map((item) => ({ ...item })) : []
+      }
+    ])
+  );
+}
+function normalizeWidgetAreas(widget_areas, media_base_url) {
+  if (!widget_areas || typeof widget_areas !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    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)) : []
+        items: Array.isArray(widgetArea?.items) ? widgetArea.items.map((item) => normalizeWidgetItem(item, media_base_url)) : []
       }
     ])
   );
 }
 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() : ""
@@ -60333,7 +61495,7 @@ function normalizeWidgetItem(item, mediaBaseUrl) {
       ...normalizedItem,
       settings: {
         ...item.settings,
-        avatar: normalizeMediaField(item.settings.avatar, mediaBaseUrl)
+        avatar: normalizeMediaField(item.settings.avatar, media_base_url)
       }
     };
   }
@@ -60357,6 +61519,19 @@ function normalizeCustomHtml(customHtml) {
     ...bodyEnd ? { body_end: { content: bodyEnd } } : {}
   };
 }
+function normalizeSiteFavicon(favicon) {
+  if (!favicon || typeof favicon !== "object") {
+    return void 0;
+  }
+  const normalized = {};
+  for (const key of ["icon", "svg", "png", "apple_touch_icon"]) {
+    const value = normalizeOptionalString(favicon[key]);
+    if (value) {
+      normalized[key] = value;
+    }
+  }
+  return Object.keys(normalized).length ? normalized : void 0;
+}
 function normalizePermalinks(permalinks) {
   const source = permalinks && typeof permalinks === "object" ? permalinks : {};
   const outputStyle = typeof source.output_style === "string" && PERMALINK_OUTPUT_STYLES.has(source.output_style) ? source.output_style : DEFAULT_PERMALINKS.output_style;
@@ -60379,19 +61554,19 @@ function normalizeFrontPage(frontPage) {
     ...type === "standalone_html" ? { html: normalizeOptionalRawString(frontPage.html) } : {}
   };
 }
-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 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]));
@@ -60399,7 +61574,8 @@ function createRenderData(previewData, themeMetadata = {}) {
   const tagPostsBySlug = /* @__PURE__ */ new Map();
   const categoryCountBySlug = /* @__PURE__ */ new Map();
   const tagCountBySlug = /* @__PURE__ */ new Map();
-  for (const post of previewData.content.posts) {
+  const discoverableSourcePosts = previewData.content.posts.filter((post) => !isDelistedDocument(post));
+  for (const post of discoverableSourcePosts) {
     for (const slug of post.category_slugs) {
       pushToSlugMap(categoryPostsBySlug, slug, post);
       categoryCountBySlug.set(slug, (categoryCountBySlug.get(slug) || 0) + 1);
@@ -60410,43 +61586,54 @@ 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) : pages;
   return {
     posts,
     pages: preparedPages,
     postBySlug,
+    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) => ({
@@ -60462,7 +61649,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) => ({
@@ -60473,7 +61660,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) => ({
@@ -60488,9 +61675,113 @@ function buildGlobalTaxonomies(previewData, categoryCountBySlug, tagCountBySlug)
     tags: buildGlobalTaxonomyItems(previewData.site, "tags", previewData.content.tags, tagCountBySlug)
   };
 }
-function buildFrontPageRoute(frontPage, pages, effectivePostIndexEnabled, postIndexBasePath) {
+function resolveCollections(collections, postBySlug, pageBySlug, frontPage) {
+  if (!collections || typeof collections !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    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
+        }
+      ];
+    })
+  );
+}
+function resolveCollectionItems(collectionId, items, postBySlug, pageBySlug, frontPage) {
+  if (!Array.isArray(items)) {
+    return [];
+  }
+  return items.map((item, index) => resolveCollectionItem(collectionId, item, index, postBySlug, pageBySlug, frontPage));
+}
+function resolveCollectionItem(collectionId, item, index, postBySlug, pageBySlug, frontPage) {
+  if (item?.type === "post") {
+    const post = postBySlug.get(item.slug);
+    if (!post) {
+      throw new Error(`Invalid collection "${collectionId}": item ${index + 1} references missing post slug "${item.slug}".`);
+    }
+    return {
+      type: "post",
+      meta: post.meta,
+      ...buildStructuredPostSummary(post)
+    };
+  }
+  if (item?.type === "page") {
+    const page = pageBySlug.get(item.slug);
+    if (!page) {
+      throw new Error(`Invalid collection "${collectionId}": item ${index + 1} references missing page slug "${item.slug}".`);
+    }
+    return buildCollectionPageSummary(page, frontPage);
+  }
+  throw new Error(`Invalid collection "${collectionId}": item ${index + 1} has unsupported type "${item?.type}".`);
+}
+function buildCollectionPageSummary(page, frontPage) {
+  return {
+    type: "page",
+    title: page.title,
+    slug: page.slug,
+    url: frontPage?.type === "page" && frontPage.page_slug === page.slug ? "/" : page.url,
+    excerpt: page.excerpt || "",
+    featured_image: page.featured_image || "",
+    ...page.featured_media ? { featured_media: { ...page.featured_media } } : {},
+    meta: page.meta,
+    data: page.data
+  };
+}
+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;
     }
     return {
@@ -60528,7 +61819,7 @@ function buildPostIndexRoutes(options2) {
     return [];
   }
   if (!options2.paginate) {
-    const items = options2.items.slice(0, options2.postsPerPage);
+    const items = options2.items.slice(0, options2.posts_per_page);
     return [{
       path: options2.basePath,
       route_type: "post_index",
@@ -60542,7 +61833,7 @@ function buildPostIndexRoutes(options2) {
   }
   return buildPaginatedCollection({
     items: options2.items,
-    postsPerPage: options2.postsPerPage,
+    posts_per_page: options2.posts_per_page,
     basePath: options2.basePath,
     outputStyle: options2.outputStyle
   }).map((entry) => ({
@@ -60621,7 +61912,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.slice(0, limit).map((post) => ({
+  const items = renderData.posts.filter((post) => !isDelistedDocument(post)).slice(0, limit).map((post) => ({
     title: post.title,
     url: `/posts/${encodeSlugSegment(post.slug)}/`,
     published_at: post.published_at,
@@ -60788,15 +62079,19 @@ function preparePost(post, site, authorsById, categoriesBySlug, tagsBySlug, them
     updated_at_iso: post.updated_at_iso,
     author_id: post.author_id,
     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,
     author: {
       id: post.author_id,
       display_name: normalizeNonEmptyString(author?.display_name, post.author_id),
-      avatar: author?.avatar || ""
+      avatar: author?.avatar || "",
+      ...author?.avatar_media ? { avatar_media: { ...author.avatar_media } } : {}
     },
     categories,
     tags,
@@ -60805,7 +62100,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
   };
 }
 function buildCommentPolicyManifest(posts) {
@@ -60824,7 +62119,7 @@ function buildTaxonomyRoutes(options2) {
     }
     const paginated = buildPaginatedCollection({
       items: matchedPosts,
-      postsPerPage: options2.postsPerPage,
+      posts_per_page: options2.posts_per_page,
       basePath: options2.buildBasePath(item),
       outputStyle: options2.outputStyle
     });
@@ -60845,13 +62140,13 @@ function buildTaxonomyRoutes(options2) {
 function buildPaginatedCollection(options2) {
   const basePath = normalizePaginationBasePath(options2.basePath);
   const outputStyle = PERMALINK_OUTPUT_STYLES.has(options2.outputStyle) ? options2.outputStyle : DEFAULT_PERMALINKS.output_style;
-  const postsPerPage = Number.isInteger(options2.postsPerPage) && options2.postsPerPage > 0 ? options2.postsPerPage : DEFAULT_POSTS_PER_PAGE;
+  const posts_per_page = Number.isInteger(options2.posts_per_page) && options2.posts_per_page > 0 ? options2.posts_per_page : DEFAULT_POSTS_PER_PAGE;
   const totalPosts = options2.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),
       page,
@@ -60998,9 +62293,13 @@ function buildStructuredPostSummary(post) {
     published_at_iso: post.published_at_iso,
     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 || ""
+      avatar: post.author?.avatar || "",
+      ...post.author?.avatar_media ? { avatar_media: { ...post.author.avatar_media } } : {}
     },
     categories: Array.isArray(post.categories) ? post.categories.map((category) => ({ ...category })) : [],
     tags: Array.isArray(post.tags) ? post.tags.map((tag) => ({ ...tag })) : []
@@ -61016,7 +62315,8 @@ function buildAdjacentPostSummary(post) {
     url: post.url,
     excerpt: post.excerpt,
     published_at: post.published_at,
-    published_at_iso: post.published_at_iso
+    published_at_iso: post.published_at_iso,
+    data: post.data
   };
 }
 function buildArchiveGroups(posts, postBySlug) {
@@ -61089,40 +62389,22 @@ 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;
-  }
-  const timeParts = new Intl.DateTimeFormat(locale, {
-    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}`;
-  return `${formattedDate} ${formattedTime}`.trim();
+  if (dateStyle === "none" && timeStyle === "none") {
+    return "";
+  }
+  const options2 = {
+    timeZone: siteTimezone
+  };
+  if (dateStyle !== "none") {
+    options2.dateStyle = dateStyle;
+  }
+  if (timeStyle !== "none") {
+    options2.timeStyle = timeStyle;
+  }
+  return new Intl.DateTimeFormat(locale, options2).format(date);
 }
 function calculateReadingTime(html) {
   const plainText = String(html || "").replace(/<[^>]*>/g, " ");
@@ -61203,10 +62485,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 } : {},
-    settings: themePackage.metadata.settings || {}
+    ...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()) {
     fileMap.set(`${templateName}.html`, templateContent);
@@ -61219,7 +62503,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) {
     throw new Error("Theme validation failed: normalized manifest not available");
@@ -61231,11 +62515,59 @@ async function normalizeAndValidateThemePackage(themePackage) {
     assets: themePackage.assets
   };
 }
+function formatThemeValidationFailure(validation) {
+  const blocks = [
+    [
+      "Theme validation failed",
+      `Errors: ${validation.errors.length}`,
+      `Checked files: ${validation.checkedFiles}`
+    ].join("\n"),
+    ...validation.errors.map((issue3) => formatThemeValidationIssue(issue3))
+  ];
+  return blocks.join("\n\n");
+}
+function formatThemeValidationIssue(issue3) {
+  if (!issue3) {
+    return "Reason: Unknown error";
+  }
+  const lines = [`ERROR ${issue3.code || "THEME_VALIDATION_ERROR"}`];
+  const location = splitIssuePath(issue3.path);
+  if (location.file) {
+    lines.push(`File: ${location.file}`);
+  }
+  if (location.path) {
+    lines.push(`Path: ${location.path}`);
+  }
+  if (Number.isInteger(issue3.line) && Number.isInteger(issue3.column)) {
+    lines.push(`Line: ${issue3.line}, Column: ${issue3.column}`);
+  }
+  if (issue3.category) {
+    lines.push(`Category: ${issue3.category}`);
+  }
+  lines.push(`Reason: ${issue3.message || "Unknown error"}`);
+  if (issue3.snippet) {
+    const lineLabel = Number.isInteger(issue3.line) ? String(issue3.line) : "";
+    lines.push("", `${lineLabel} | ${issue3.snippet.line}`, `${" ".repeat(lineLabel.length)} | ${issue3.snippet.pointer}`);
+  }
+  if (issue3.hint) {
+    lines.push("", "Hint:", issue3.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,
-    ...sourceMetadata?.thumbnail ? { thumbnail: sourceMetadata.thumbnail } : {},
-    settings: sourceMetadata?.settings || {}
+    ...sourceMetadata?.thumbnail ? { thumbnail: sourceMetadata.thumbnail } : {}
   };
 }
 async function buildAssetOutputs(assets, assetProcessor, options2) {
@@ -61301,6 +62633,7 @@ function buildPageMeta(site, options2 = {}) {
   const ogType = normalizeNonEmptyString(options2.ogType, "website");
   const publishedTime = normalizeOptionalString(options2.publishedTime);
   const modifiedTime = normalizeOptionalString(options2.modifiedTime);
+  const robotsNoindex = options2.robotsNoindex === true;
   const meta = {
     title: escapeHtml2(resolvedTitle),
     description: resolvedDescription ? escapeHtml2(resolvedDescription) : "",
@@ -61312,7 +62645,8 @@ function buildPageMeta(site, options2 = {}) {
     og_site_name: escapeHtml2(site.title),
     og_image: ogImage ? escapeHtml2(ogImage) : "",
     article_published_time: publishedTime ? escapeHtml2(publishedTime) : "",
-    article_modified_time: modifiedTime ? escapeHtml2(modifiedTime) : ""
+    article_modified_time: modifiedTime ? escapeHtml2(modifiedTime) : "",
+    robots_noindex: robotsNoindex
   };
   return {
     ...meta,
@@ -61329,6 +62663,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}">`);
   }
@@ -61369,7 +62706,7 @@ function resolveMetaImageUrl(image2) {
   }
   return "";
 }
-function normalizeMediaField(value, mediaBaseUrl) {
+function normalizeMediaField(value, media_base_url) {
   if (value === void 0) {
     return void 0;
   }
@@ -61380,9 +62717,9 @@ function normalizeMediaField(value, mediaBaseUrl) {
   if (isAbsoluteUrl(normalizedValue)) {
     return normalizeAbsoluteUrl(normalizedValue, SAFE_MEDIA_PROTOCOLS);
   }
-  const normalizedBaseUrl = normalizeOptionalString(mediaBaseUrl);
+  const normalizedBaseUrl = normalizeOptionalString(media_base_url);
   if (!normalizedBaseUrl) {
-    return "";
+    return normalizedValue;
   }
   try {
     return decodeURI(new URL(normalizedValue, normalizedBaseUrl).toString());
@@ -61586,7 +62923,11 @@ function assertPlannedOutputPathsSafe(state) {
     COMMENT_POLICY_OUTPUT_PATH
   ];
   if (state.options.generateSpecialFiles) {
-    plannedPaths.push("404.html", "robots.txt");
+    plannedPaths.push(SEARCH_INDEX_OUTPUT_PATH, SEARCH_ADAPTER_OUTPUT_PATH);
+    plannedPaths.push("404.html");
+    if (shouldGenerateRobotsTxt(state.options)) {
+      plannedPaths.push("robots.txt");
+    }
     if (hasCanonicalSiteUrl(state.previewData.site.url)) {
       plannedPaths.push("sitemap.xml", "feed.xml");
     }
@@ -61661,10 +63002,45 @@ function sha256(content) {
   return hash.digest("hex");
 }
 function injectSiteCustomizations(html, state) {
-  let next = injectCustomCssAssetLink(html, state.customCssHref);
+  let next = injectFaviconLinks(html, state.favicon);
+  next = injectGeneratorMeta(next, state.exposeGenerator);
+  next = injectCustomCssAssetLink(next, state.customCssHref);
   next = injectCustomHtml(next, state.customHtml);
   return next;
 }
+function injectFaviconLinks(html, favicon) {
+  const links = buildFaviconLinks(favicon);
+  if (!links) {
+    return html;
+  }
+  return html.replace("</head>", `${links}
+</head>`);
+}
+function buildFaviconLinks(favicon) {
+  if (!favicon || typeof favicon !== "object") {
+    return "";
+  }
+  const lines = [];
+  if (normalizeOptionalString(favicon.icon)) {
+    lines.push(`  <link rel="icon" href="${escapeHtml2(favicon.icon)}" sizes="any">`);
+  }
+  if (normalizeOptionalString(favicon.svg)) {
+    lines.push(`  <link rel="icon" href="${escapeHtml2(favicon.svg)}" type="image/svg+xml">`);
+  }
+  if (normalizeOptionalString(favicon.png)) {
+    lines.push(`  <link rel="icon" href="${escapeHtml2(favicon.png)}" type="image/png">`);
+  }
+  if (normalizeOptionalString(favicon.apple_touch_icon)) {
+    lines.push(`  <link rel="apple-touch-icon" href="${escapeHtml2(favicon.apple_touch_icon)}">`);
+  }
+  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;
@@ -61686,9 +63062,383 @@ function injectCustomHtml(html, customHtml) {
   }
   return next;
 }
-function buildSitemapXml(site, emitted, generatedAt) {
+function buildSearchIndexJson(state) {
+  return `${JSON.stringify(buildSearchIndexItems(state), null, 2)}
+`;
+}
+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, (match2, entity2) => {
+    if (entity2.startsWith("#x")) {
+      const codePoint = Number.parseInt(entity2.slice(2), 16);
+      return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : match2;
+    }
+    if (entity2.startsWith("#")) {
+      const codePoint = Number.parseInt(entity2.slice(1), 10);
+      return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : match2;
+    }
+    return Object.prototype.hasOwnProperty.call(namedEntities, entity2) ? namedEntities[entity2] : match2;
+  });
+}
+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 buildSitemapXml(site, emitted, generatedAt, stylesheetHref = "") {
   const entries = [
-    ...emitted.frontPage ? [{
+    ...emitted.frontPage && emitted.frontPage.includeInSitemap !== false ? [{
       url: emitted.frontPage.url,
       changefreq: "daily",
       priority: 1
@@ -61720,7 +63470,10 @@ function buildSitemapXml(site, emitted, generatedAt) {
     <priority>${entry.priority.toFixed(1)}</priority>
   </url>`;
   }).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
+  const normalizedStylesheetHref = normalizeOptionalString(stylesheetHref);
+  const stylesheet = normalizedStylesheetHref ? `
+<?xml-stylesheet type="text/xsl" href="${escapeXml(normalizedStylesheetHref)}"?>` : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>${stylesheet}
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${body}
 </urlset>`;
@@ -61752,13 +63505,22 @@ ${items}
 </rss>`;
 }
 function buildRobotsTxt(site) {
-  const lines = ["User-agent: *", "Allow: /"];
+  const lines = ["User-agent: *"];
+  if (site.indexing === false) {
+    lines.push("Disallow: /");
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("Allow: /");
   if (site.url) {
     lines.push("", `Sitemap: ${resolveSiteUrl(site.url, "/sitemap.xml")}`);
   }
   return `${lines.join("\n")}
 `;
 }
+function shouldGenerateRobotsTxt(options2) {
+  return options2.generateSpecialFiles && options2.generateRobotsTxt !== false;
+}
 function getContentType(assetPath) {
   const ext = assetPath.split(".").pop()?.toLowerCase();
   const contentTypes = {
@@ -61834,7 +63596,7 @@ async function loadThemePackageFromDir(themeDir) {
   await readThemeDir(fs4, path4, themeDir, themeDir, fileMap);
   const validation = await validateThemeFiles(fileMap);
   if (!validation.ok) {
-    throw new Error(`Theme validation failed: ${validation.errors[0]?.message || "Unknown error"}`);
+    throw new Error(formatThemeValidationFailure2(validation));
   }
   const rawThemeJson = String(fileMap.get("theme.json"));
   const themeJson = JSON.parse(rawThemeJson);
@@ -61867,14 +63629,62 @@ async function loadThemePackageFromDir(themeDir) {
   return {
     metadata: {
       ...manifest,
-      thumbnail: themeJson.thumbnail,
-      settings: themeJson.settings || {}
+      thumbnail: themeJson.thumbnail
     },
     templates,
     partials,
     assets
   };
 }
+function formatThemeValidationFailure2(validation) {
+  const blocks = [
+    [
+      "Theme validation failed",
+      `Errors: ${validation.errors.length}`,
+      `Checked files: ${validation.checkedFiles}`
+    ].join("\n"),
+    ...validation.errors.map((issue3) => formatThemeValidationIssue2(issue3))
+  ];
+  return blocks.join("\n\n");
+}
+function formatThemeValidationIssue2(issue3) {
+  if (!issue3) {
+    return "Reason: Unknown error";
+  }
+  const lines = [`ERROR ${issue3.code || "THEME_VALIDATION_ERROR"}`];
+  const location = splitIssuePath2(issue3.path);
+  if (location.file) {
+    lines.push(`File: ${location.file}`);
+  }
+  if (location.path) {
+    lines.push(`Path: ${location.path}`);
+  }
+  if (Number.isInteger(issue3.line) && Number.isInteger(issue3.column)) {
+    lines.push(`Line: ${issue3.line}, Column: ${issue3.column}`);
+  }
+  if (issue3.category) {
+    lines.push(`Category: ${issue3.category}`);
+  }
+  lines.push(`Reason: ${issue3.message || "Unknown error"}`);
+  if (issue3.snippet) {
+    const lineLabel = Number.isInteger(issue3.line) ? String(issue3.line) : "";
+    lines.push("", `${lineLabel} | ${issue3.snippet.line}`, `${" ".repeat(lineLabel.length)} | ${issue3.snippet.pointer}`);
+  }
+  if (issue3.hint) {
+    lines.push("", "Hint:", issue3.hint);
+  }
+  return lines.join("\n");
+}
+function splitIssuePath2(issuePath) {
+  const normalizedPath = String(issuePath || "");
+  if (normalizedPath.startsWith("theme.json.")) {
+    return {
+      file: "theme.json",
+      path: normalizedPath.slice("theme.json.".length)
+    };
+  }
+  return { file: normalizedPath, path: "" };
+}
 async function readThemeDir(fs4, path4, rootDir, currentDir, fileMap) {
   const entries = await fs4.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
@@ -61915,6 +63725,13 @@ var require2 = createRequire(import.meta.url);
 var { version: PACKAGE_VERSION } = require2("../package.json");
 var DEFAULT_PUBLIC_DIR_NAME = "public";
 var PUBLIC_DIR_ENV_NAME = "ZEROPRESS_PUBLIC_DIR";
+var PUBLIC_FAVICON_FILES = Object.freeze({
+  icon: "favicon.ico",
+  svg: "favicon.svg",
+  png: "favicon.png",
+  apple_touch_icon: "apple-touch-icon.png"
+});
+var PUBLIC_SITEMAP_STYLESHEET_FILE = "sitemap.xsl";
 async function assertThemeDirectory(themeDir) {
   let stat;
   try {
@@ -61929,17 +63746,26 @@ async function assertThemeDirectory(themeDir) {
     throw new Error(`Theme path is not a directory: ${themeDir}`);
   }
 }
-async function runBuild(themeDir, previewData, outDir) {
-  assertPublicPathDoesNotOverlap("Theme directory", themeDir);
-  assertPublicPathDoesNotOverlap("Output directory", outDir);
+async function runBuild(themeDir, previewData, outDir, options2 = {}) {
+  const publicDir = resolvePublicDir(process.cwd(), options2.publicDir);
+  assertPublicPathDoesNotOverlap("Theme directory", themeDir, process.cwd(), publicDir);
+  assertPublicPathDoesNotOverlap("Output directory", outDir, process.cwd(), publicDir);
   await assertThemeDirectory(themeDir);
   await assertEmptyOutputDirectory(outDir);
-  await copyPublicDirectory(resolvePublicDir(), outDir);
+  const hasPublicRobotsTxt = await publicRobotsTxtExists(publicDir);
+  const publicFavicon = await discoverPublicFavicon(publicDir);
+  const sitemapStylesheetHref = await discoverPublicSitemapStylesheet(publicDir);
+  await copyPublicDirectory(publicDir, outDir);
   const writer = new GeneratedOutputWriter({ outDir });
   return buildSiteFromThemeDir({
     previewData,
     themeDir,
-    writer
+    writer,
+    options: {
+      favicon: publicFavicon,
+      sitemapStylesheetHref,
+      generateRobotsTxt: !hasPublicRobotsTxt
+    }
   });
 }
 var GeneratedOutputWriter = class {
@@ -61977,7 +63803,10 @@ async function assertEmptyOutputDirectory(outDir) {
     throw error;
   }
 }
-function resolvePublicDir(cwd = process.cwd()) {
+function resolvePublicDir(cwd = process.cwd(), publicDir) {
+  if (publicDir) {
+    return path.resolve(cwd, publicDir);
+  }
   const envValue = process.env[PUBLIC_DIR_ENV_NAME]?.trim();
   return path.resolve(cwd, envValue || DEFAULT_PUBLIC_DIR_NAME);
 }
@@ -61996,6 +63825,48 @@ async function copyPublicDirectory(publicDir, outDir) {
   }
   await copyPublicEntries(publicDir, outDir);
 }
+async function publicRobotsTxtExists(publicDir) {
+  let stat;
+  try {
+    stat = await fs.lstat(path.join(publicDir, "robots.txt"));
+  } catch (error) {
+    if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return false;
+    }
+    throw error;
+  }
+  return stat.isFile();
+}
+async function discoverPublicFavicon(publicDir) {
+  const favicon = {};
+  for (const [key, filename] of Object.entries(PUBLIC_FAVICON_FILES)) {
+    let stat;
+    try {
+      stat = await fs.lstat(path.join(publicDir, filename));
+    } catch (error) {
+      if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+        continue;
+      }
+      throw error;
+    }
+    if (stat.isFile()) {
+      favicon[key] = `/${filename}`;
+    }
+  }
+  return Object.keys(favicon).length ? favicon : void 0;
+}
+async function discoverPublicSitemapStylesheet(publicDir) {
+  let stat;
+  try {
+    stat = await fs.lstat(path.join(publicDir, PUBLIC_SITEMAP_STYLESHEET_FILE));
+  } catch (error) {
+    if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return void 0;
+    }
+    throw error;
+  }
+  return stat.isFile() ? `/${PUBLIC_SITEMAP_STYLESHEET_FILE}` : void 0;
+}
 async function copyPublicEntries(sourceDir, targetDir) {
   const entries = await fs.readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
@@ -62020,8 +63891,7 @@ function shouldIgnorePublicEntry(name) {
   const lowerName = basename.toLowerCase();
   return basename.startsWith(".") || lowerName === "node_modules" || lowerName === "thumbs.db" || lowerName.endsWith(".key") || lowerName.endsWith(".pem");
 }
-function assertPublicPathDoesNotOverlap(label, candidatePath, cwd = process.cwd()) {
-  const publicDir = resolvePublicDir(cwd);
+function assertPublicPathDoesNotOverlap(label, candidatePath, cwd = process.cwd(), publicDir = resolvePublicDir(cwd)) {
   const resolvedCandidate = path.resolve(cwd, candidatePath);
   if (!pathsOverlap(publicDir, resolvedCandidate)) {
     return;
@@ -62332,7 +64202,7 @@ try {
   process.exitCode = 1;
 }
 function input(name) {
-  return process.env[`INPUT_${name.toUpperCase().replace(/-/g, "_")}`]?.trim() || "";
+  return process.env[`INPUT_${name.toUpperCase()}`]?.trim() || "";
 }
 function booleanInput(name, fallback) {
   const value = input(name);