hexo-theme-stellar 1.44.0 → 2.0.0-rc.2

package/scripts/schema/content-config-rules.js

@@ -0,0 +1,264 @@
+/* global hexo */
+"use strict";
+
+const { deepFreeze } = require("./schema-utils");
+const { SHARE_SERVICE_IDS } = require("../lib/share-services");
+
+const COLLECTION_SCOPE = Object.freeze(["collection"]);
+const FRONT_MATTER_SCOPE = Object.freeze(["front_matter"]);
+const COLLECTION_CASCADE = Object.freeze(["schema default", "theme profile", "collection"]);
+const FRONT_MATTER_CASCADE = Object.freeze(["schema default", "theme profile", "collection", "front matter"]);
+
+function literal(value) {
+  return { kind: "literal", value };
+}
+
+function derived(...sources) {
+  return { kind: "derived", sources };
+}
+
+function runtimePath(path) {
+  const segments = path.split(".");
+  return segments.map((segment, index) => {
+    if (segment.startsWith("<")) return segment;
+    if (segments[index - 1] === "providers") return segment;
+    return segment.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }).join(".");
+}
+
+function targetField(path, options) {
+  const scopes = options.scopes;
+  const types = Array.isArray(options.type) ? options.type : [options.type];
+  const boundary = options.boundary || "sealed";
+  const hasMergeableUnion = types.length > 1 && (types.includes("array") || types.includes("object"));
+  return {
+    path,
+    type: types,
+    default: options.default,
+    scopes,
+    cascade: options.cascade,
+    normalization: options.normalization || "validate the declared type; preserve the value; deep-freeze the result",
+    mergeStrategy: options.mergeStrategy || (hasMergeableUnion ? "by_value_type" : (types.includes("array") ? "replace" : (types.includes("object") ? (boundary === "parameter_bag" ? "merge_keys" : "merge_declared_keys") : "replace"))),
+    runtimePath: options.runtimePath || runtimePath(path),
+    consumers: options.consumers,
+    migration: options.migration || `configuration/${path.split(".")[0]}`,
+    status: options.status || "planned",
+    boundary,
+    ...(options.items ? { items: options.items } : {}),
+    ...(options.values ? { values: options.values } : {}),
+    ...(options.minimum !== undefined ? { minimum: options.minimum } : {}),
+    ...(options.maximum !== undefined ? { maximum: options.maximum } : {}),
+    ...(options.exclusiveMinimum !== undefined ? { exclusiveMinimum: options.exclusiveMinimum } : {})
+  };
+}
+
+function fields(consumers, definitions, options = {}) {
+  return definitions.map(definition => {
+    const resolvedOptions = {
+      ...options,
+      cascade: typeof options.cascade === "function" ? options.cascade(definition[0]) : options.cascade
+    };
+    return targetField(definition[0], {
+      type: definition[1],
+      default: definition[2],
+      consumers,
+      ...resolvedOptions,
+      ...(definition[3] || {})
+    });
+  });
+}
+
+
+const CONTENT_CONSUMERS = Object.freeze(["CollectionModel", "PageViewModel", "article renderer", "listing renderer"]);
+const REGION_NORMALIZATION = "accept a Region object; validate children and deep-freeze the normalized object";
+const MENU_ITEMS = { type: ["object"], boundary: "parameter_bag" };
+const ACTION_ITEMS = { type: ["object"], boundary: "parameter_bag" };
+
+function contentOverrideCascade(scope, path) {
+  const page = scope === "front_matter";
+  if (/^(?:topbar|leftbar|rightbar)(?:\.|$)/.test(path)) {
+    return page
+      ? ["theme global", "theme profile", "collection", "front matter"]
+      : ["theme global", "theme profile", "collection"];
+  }
+  if (path === "active_menu") {
+    return page ? ["theme profile", "collection", "front matter"] : ["theme profile", "collection"];
+  }
+  if (path === "breadcrumb") {
+    return page ? ["collection", "front matter"] : ["collection"];
+  }
+  if (/^article(?:\.|$)/.test(path)) {
+    return page ? ["theme article defaults", "collection", "front matter"] : ["theme article defaults", "collection"];
+  }
+  if (/^footer(?:\.|$)/.test(path)) {
+    return page ? ["theme article footer defaults", "collection", "front matter"] : ["theme article footer defaults", "collection"];
+  }
+  if (/^comments(?:\.|$)/.test(path)) {
+    return page ? ["theme comments defaults", "collection", "front matter"] : ["theme comments defaults", "collection"];
+  }
+  if (/^source(?:\.|$)/.test(path)) {
+    return page ? ["collection", "front matter"] : ["collection"];
+  }
+  return page ? FRONT_MATTER_CASCADE : COLLECTION_CASCADE;
+}
+
+const CONTENT_OVERRIDE_DEFINITIONS = [
+  ["topbar", "object", derived("theme or collection topbar"), { boundary: "sealed", normalization: REGION_NORMALIZATION }],
+  ["topbar.enabled", ["boolean", "null"], literal(null)],
+  ["topbar.brand", ["object", "boolean", "null"], literal(null), { boundary: "sealed" }],
+  ["topbar.brand.image", "object", literal({}), { boundary: "sealed" }],
+  ["topbar.brand.image.src", ["string", "null"], literal(null)],
+  ["topbar.brand.image.variant", ["string", "null"], literal(null), { values: ["avatar", "icon", "plain", null] }],
+  ["topbar.brand.name", ["string", "null"], literal(null)],
+  ["topbar.brand.tagline", ["string", "null"], literal(null)],
+  ["topbar.brand.href", ["string", "null"], literal(null)],
+  ["topbar.menu", ["array", "null"], literal(null), { items: MENU_ITEMS }],
+  ["topbar.widgets", "array", literal([]), { items: { type: ["string", "object"], boundary: "parameter_bag" } }],
+  ["leftbar", "object", derived("theme or collection leftbar"), { boundary: "sealed", normalization: REGION_NORMALIZATION }],
+  ["leftbar.enabled", ["boolean", "null"], literal(null)],
+  ["leftbar.brand", ["object", "boolean", "null"], literal(null), { boundary: "sealed" }],
+  ["leftbar.brand.style", ["string", "null"], literal(null), { values: ["regular", "compact", null] }],
+  ["leftbar.brand.image", "object", literal({}), { boundary: "sealed" }],
+  ["leftbar.brand.image.src", ["string", "null"], literal(null)],
+  ["leftbar.brand.image.variant", ["string", "null"], literal(null), { values: ["avatar", "icon", "plain", null] }],
+  ["leftbar.brand.name", ["string", "null"], literal(null)],
+  ["leftbar.brand.tagline", ["string", "null"], literal(null)],
+  ["leftbar.brand.href", ["string", "null"], literal(null)],
+  ["leftbar.menu", ["array", "null"], literal(null), { items: MENU_ITEMS }],
+  ["leftbar.footer", "object", literal({}), { boundary: "sealed" }],
+  ["leftbar.footer.actions", ["array", "null"], literal(null), { items: ACTION_ITEMS }],
+  ["leftbar.widgets", "array", literal([]), { items: { type: ["string", "object"], boundary: "parameter_bag" } }],
+  ["rightbar", "object", derived("theme or collection rightbar"), { boundary: "sealed", normalization: REGION_NORMALIZATION }],
+  ["rightbar.enabled", ["boolean", "null"], literal(null)],
+  ["rightbar.widgets", "array", literal([]), { items: { type: ["string", "object"], boundary: "parameter_bag" } }],
+  ["active_menu", ["string", "null"], literal(null)],
+  ["breadcrumb", ["boolean", "null"], literal(null)],
+  ["article", "object", derived("theme article defaults"), { boundary: "sealed" }],
+  ["article.style", ["string", "null"], literal(null), { values: ["tech", "story"] }],
+  ["article.paragraph_indent", ["string", "null"], literal(null), { values: ["auto", "always", "never"] }],
+  ["article.author", ["string", "null"], literal(null)],
+  ["article.ai_label", ["string", "null"], literal(null), { values: ["manual", "reviewed", "polished", "generated"] }],
+  ["footer", "object", derived("content defaults footer"), { boundary: "sealed" }],
+  ["footer.references", "array", literal([]), { items: { type: ["object", "string"] } }],
+  ["footer.license", ["boolean", "string", "null"], literal(null)],
+  ["footer.share", ["boolean", "array", "null"], literal(null), { items: { type: ["string"], values: SHARE_SERVICE_IDS } }],
+  ["footer.show_tags", ["boolean", "null"], literal(null)],
+  ["comments", "object", derived("theme comments and broader content scope"), { boundary: "sealed" }],
+  ["comments.enabled", ["boolean", "null"], literal(null)],
+  ["comments.title", ["string", "null"], literal(null)],
+  ["comments.id", ["string", "null"], literal(null)],
+  ["comments.provider", ["string", "null"], literal(null)],
+  ["comments.options", "object", literal({}), { boundary: "parameter_bag" }],
+  ["source", "object", literal({}), { boundary: "sealed" }],
+  ["source.repository", ["string", "null"], literal(null)],
+  ["source.branch", ["string", "null"], literal(null)]
+];
+
+const COLLECTION_TARGET_DEFINITIONS = [
+  ["leftbar.brand.source", ["string", "null"], literal(null), { values: ["site", "collection", null] }],
+  ["leftbar.brand.back_button", ["boolean", "null"], literal(null)],
+  ["leftbar.brand.search", ["boolean", "null"], literal(null)],
+  ["name", "string", derived("required collection identity")],
+  ["headline", ["string", "null"], literal(null)],
+  ["tagline", ["string", "null"], literal(null)],
+  ["description", ["string", "null"], literal(null)],
+  ["tags", "array", literal([]), { items: { type: ["string"] } }],
+  ["audience", ["string", "null"], literal(null)],
+  ["icon", ["string", "null"], literal(null)],
+  ["cover", ["string", "null"], literal(null)],
+  ["banner", "object", derived("collection banner"), { boundary: "sealed" }],
+  ["banner.enabled", ["boolean", "null"], literal(null)],
+  ["banner.image", ["string", "null"], literal(null)],
+  ["banner.avatar", ["string", "null"], literal(null)],
+  ["banner.headline", ["string", "null"], literal(null)],
+  ["banner.tagline", ["string", "null"], literal(null)],
+  ["hero", "object", literal({}), { boundary: "sealed" }],
+  ["hero.enabled", ["boolean", "null"], literal(null)],
+  ["hero.background", "object", literal({}), { boundary: "sealed" }],
+  ["hero.background.image", ["string", "null"], literal(null)],
+  ["hero.background.effect", ["object", "null"], literal(null), { boundary: "registered_schema" }],
+  ["hero.preview", ["object", "null"], literal(null), { boundary: "sealed" }],
+  ["hero.preview.type", ["string", "null"], literal(null), { values: ["terminal", "image"] }],
+  ["hero.preview.src", ["string", "null"], literal(null)],
+  ["hero.preview.alt", ["string", "null"], literal(null)],
+  ["hero.preview.commands", "array", literal([]), { items: { type: ["object"] } }],
+  ["hero.preview.commands[].label", ["string", "null"], literal(null)],
+  ["hero.preview.commands[].codes", ["string", "null"], literal(null)],
+  ["hero.actions", "array", literal([]), { items: { type: ["object"] } }],
+  ["hero.actions[].title", ["string", "null"], literal(null)],
+  ["hero.actions[].url", ["string", "null"], literal(null)],
+  ["hero.actions[].icon", ["string", "null"], literal(null)],
+  ["route", "object", literal({}), { boundary: "sealed" }],
+  ["route.path", "string", derived("collection route"), { normalization: "normalize to a collection-relative path" }],
+  ["route.start", ["string", "null"], literal(null)],
+  ["listing", "object", literal({}), { boundary: "sealed" }],
+  ["listing.priority", ["number", "null"], literal(null), { minimum: 0 }],
+  ["listing.order", ["number", "null"], literal(null), { minimum: 0 }],
+  ["listing.excerpt_length", ["number", "null"], literal(null), { minimum: 0 }],
+  ["listing.per_page", ["number", "null"], literal(null), { minimum: 0 }],
+  ["listing.sort", ["object", "null"], literal(null), { boundary: "sealed" }],
+  ["listing.sort.field", ["string", "null"], literal(null), { values: ["date", "updated", "title"] }],
+  ["listing.sort.direction", ["string", "null"], literal(null), { values: ["asc", "desc"] }],
+  ["visibility", "object", literal({}), { boundary: "sealed" }],
+  ["visibility.listed", "boolean", literal(true)],
+  ["visibility.searchable", "boolean", literal(true)],
+  ["navigation.tree", ["array", "object"], literal([]), { boundary: "record" }]
+];
+
+const FRONT_MATTER_TARGET_DEFINITIONS = [
+  ["collection", "object", literal({}), { boundary: "sealed" }],
+  ["collection.profile", "string", derived("required collection profile"), { values: ["wiki", "topic", "notebook"] }],
+  ["collection.id", "string", derived("required collection ID")],
+  ["cover", ["string", "null"], literal(null)],
+  ["tagline", ["string", "null"], literal(null)],
+  ["banner", "object", derived("collection or theme banner"), { boundary: "sealed" }],
+  ["banner.enabled", ["boolean", "null"], literal(null)],
+  ["banner.image", ["string", "null"], literal(null)],
+  ["banner.avatar", ["string", "null"], literal(null)],
+  ["banner.headline", ["string", "null"], literal(null)],
+  ["banner.tagline", ["string", "null"], literal(null)],
+  ["visibility", "object", literal({}), { boundary: "sealed" }],
+  ["visibility.listed", "boolean", literal(true)],
+  ["visibility.searchable", "boolean", literal(true)],
+  ["listing", "object", literal({}), { boundary: "sealed" }],
+  ["listing.priority", "number", literal(0), { minimum: 0 }],
+  ["render", "object", literal({}), { boundary: "sealed" }],
+  ["render.math", ["boolean", "string"], literal(false), { values: [false, "katex", "mathjax"] }],
+  ["render.diagrams", ["boolean", "string", "object"], literal(false), { boundary: "parameter_bag" }],
+  ["seo", "object", literal({}), { boundary: "sealed" }],
+  ["seo.open_graph", "object", literal({}), { boundary: "parameter_bag" }],
+  ["inject", "object", literal({}), { boundary: "sealed" }],
+  ["inject.head_begin", "string", literal("")],
+  ["inject.head_end", "string", literal("")],
+  ["inject.body_begin", "string", literal("")],
+  ["inject.body_end", "string", literal("")]
+];
+
+const CONFIG_TARGET_FIELDS = deepFreeze([
+  ...fields(CONTENT_CONSUMERS, CONTENT_OVERRIDE_DEFINITIONS, {
+    scopes: COLLECTION_SCOPE,
+    cascade: path => contentOverrideCascade("collection", path),
+    migration: "content-schema/collection",
+    status: "delivered"
+  }),
+  ...fields(CONTENT_CONSUMERS, CONTENT_OVERRIDE_DEFINITIONS, {
+    scopes: FRONT_MATTER_SCOPE,
+    cascade: path => contentOverrideCascade("front_matter", path),
+    migration: "content-schema/front-matter",
+    status: "delivered"
+  }),
+  ...fields(CONTENT_CONSUMERS, COLLECTION_TARGET_DEFINITIONS, {
+    scopes: COLLECTION_SCOPE,
+    cascade: COLLECTION_CASCADE,
+    migration: "content-schema/collection",
+    status: "delivered"
+  }),
+  ...fields(CONTENT_CONSUMERS, FRONT_MATTER_TARGET_DEFINITIONS, {
+    scopes: FRONT_MATTER_SCOPE,
+    cascade: FRONT_MATTER_CASCADE,
+    migration: "content-schema/front-matter",
+    status: "delivered"
+  })
+]);
+
+module.exports = { CONFIG_TARGET_FIELDS };

package/scripts/schema/content-config-schema.js

@@ -0,0 +1,321 @@
+/* global hexo */
+"use strict";
+
+const { literal } = require("./config-schema");
+const { CONFIG_TARGET_FIELDS } = require("./content-config-rules");
+const { deepFreeze } = require("./schema-utils");
+
+const HEXO_FRONT_MATTER_FIELDS = Object.freeze([
+  "_content",
+  "abbrlink",
+  "categories",
+  "date",
+  "description",
+  "disableNunjucks",
+  "excerpt",
+  "keywords",
+  "lang",
+  "language",
+  "layout",
+  "link",
+  "permalink",
+  "photos",
+  "published",
+  "robots",
+  "sitemap",
+  "tags",
+  "title",
+  "updated"
+]);
+
+const LEGACY_COLLECTION_ROOTS = Object.freeze({
+  title: "name",
+  subtitle: "tagline",
+  logo: "leftbar.brand",
+  wiki_home: "leftbar.brand.back_button",
+  coverpage: "hero.enabled",
+  background: "hero.background.image",
+  animation: "hero.background.effect",
+  menu_id: "active_menu",
+  search: "leftbar.brand.search",
+  menu: "leftbar.menu",
+  type: "article.style",
+  indent: "article.paragraph_indent",
+  author: "article.author",
+  ai_label: "article.ai_label",
+  references: "footer.references",
+  license: "footer.license",
+  share: "footer.share",
+  comment_title: "comments.title",
+  repo: "source.repository",
+  branch: "source.branch",
+  available: "audience",
+  start: "route.start",
+  base_dir: "route.path",
+  path: "route.path",
+  homepage: "navigation.tree",
+  sort: "listing.order",
+  pin: "listing.priority",
+  order_by: "listing.sort",
+  auto_excerpt: "listing.excerpt_length",
+  per_page: "listing.per_page",
+  note_leftbar: "profiles.note.leftbar.widgets | front matter leftbar.widgets",
+  note_rightbar: "profiles.note.rightbar.widgets | front matter rightbar.widgets",
+  preview: "hero.preview",
+  actions: "hero.actions",
+  tree: "navigation.tree"
+});
+
+const LEGACY_FRONT_MATTER_ROOTS = Object.freeze({
+  wiki: "collection.id",
+  topic: "collection.id",
+  notebook: "collection.id",
+  h1: "banner.headline",
+  subtitle: "banner.tagline",
+  banner_info: "banner",
+  menu_id: "active_menu",
+  header: "topbar.enabled",
+  search: "leftbar.menu search item",
+  menu: "leftbar.menu",
+  logo: "topbar.brand | leftbar.brand",
+  type: "article.style",
+  indent: "article.paragraph_indent",
+  author: "article.author",
+  ai_label: "article.ai_label",
+  references: "footer.references",
+  license: "footer.license",
+  share: "footer.share",
+  comment_title: "comments.title",
+  comment_id: "comments.id",
+  comments_service: "comments.provider",
+  beaudar: "comments.options",
+  utterances: "comments.options",
+  giscus: "comments.options",
+  twikoo: "comments.options",
+  waline: "comments.options",
+  artalk: "comments.options",
+  indexing: "visibility.searchable",
+  pin: "listing.priority",
+  sticky: "listing.priority",
+  repo: "source.repository",
+  branch: "source.branch",
+  nav_tabs: "profiles.blog_index.listing_nav | profiles.wiki_index.listing_nav",
+  wiki_home: "collection leftbar.brand.back_button",
+  open_graph: "seo.open_graph",
+  katex: "render.math",
+  mathjax: "render.math",
+  mermaid: "render.diagrams"
+});
+
+const COMMENT_PROVIDER_FIELDS = Object.freeze([
+  "service",
+  "beaudar",
+  "utterances",
+  "giscus",
+  "twikoo",
+  "waline",
+  "artalk"
+]);
+
+function clone(value) {
+  if (Array.isArray(value)) return value.map(clone);
+  if (value == null || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, clone(child)]));
+}
+
+function camelCase(value) {
+  return value.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function exampleFor(target) {
+  if (target.default?.kind === "literal") return clone(target.default.value);
+  if (target.type.includes("object")) return {};
+  if (target.type.includes("array")) return [];
+  if (target.type.includes("string")) return "";
+  if (target.type.includes("boolean")) return false;
+  if (target.type.includes("number")) return 0;
+  return null;
+}
+
+function normalizerFor(target) {
+  if (target.path === "route.path") return "collection_path";
+  if (target.path === "footer.share") return "share_override";
+  if (target.boundary === "parameter_bag" || target.boundary === "record") return "parameter_bag";
+  if (target.type.includes("object")) return "object";
+  if (target.type.includes("array")) return "array";
+  return "identity";
+}
+
+function runtimeKeyFor(target) {
+  return target.runtimePath.split(".").at(-1).replace(/\[\]$/, "");
+}
+
+function targetNode(target) {
+  return {
+    type: clone(target.type),
+    default: clone(target.default),
+    scope: target.scopes[0],
+    cascade: clone(target.cascade),
+    normalizer: normalizerFor(target),
+    normalization: target.normalization,
+    consumers: clone(target.consumers),
+    example: exampleFor(target),
+    migration: target.migration,
+    runtimeKey: runtimeKeyFor(target),
+    ...(target.boundary === "sealed" ? { sealed: true } : {}),
+    ...(target.values ? { values: clone(target.values) } : {}),
+    ...(target.minimum !== undefined ? { minimum: target.minimum } : {}),
+    ...(target.exclusiveMinimum !== undefined ? { exclusiveMinimum: target.exclusiveMinimum } : {})
+  };
+}
+
+function syntheticObject(scope, path) {
+  return {
+    type: ["object"],
+    default: literal({}),
+    scope,
+    cascade: scope === "collection"
+      ? ["schema default", "theme profile", "collection"]
+      : ["schema default", "theme profile", "collection", "front matter"],
+    normalizer: "object",
+    normalization: "merge declared child fields; deep-freeze the normalized JavaScript object",
+    consumers: ["CollectionModel", "PageViewModel"],
+    example: {},
+    migration: `content-schema/${scope.replace("_", "-")}`,
+    runtimeKey: camelCase(path.split(".").at(-1).replace(/\[\]$/, "")),
+    sealed: true,
+    properties: {}
+  };
+}
+
+function itemNode(scope, path, item) {
+  const types = clone(item?.type || ["object"]);
+  const parameterBag = item?.boundary === "parameter_bag";
+  return {
+    type: types,
+    default: types.includes("object") ? literal({}) : undefined,
+    scope,
+    cascade: scope === "collection"
+      ? ["schema default", "theme profile", "collection"]
+      : ["schema default", "theme profile", "collection", "front matter"],
+    normalizer: parameterBag ? "parameter_bag" : (types.includes("object") ? "object" : "identity"),
+    normalization: "validate the declared item type; preserve the value; deep-freeze the result",
+    consumers: ["CollectionModel", "PageViewModel"],
+    example: types.includes("object") ? {} : "",
+    migration: `content-schema/${scope.replace("_", "-")}`,
+    runtimeKey: path,
+    ...(item?.values ? { values: clone(item.values) } : {}),
+    ...(types.includes("object") && !parameterBag ? { sealed: true, properties: {} } : {})
+  };
+}
+
+function mergeTargetNode(existing, target) {
+  const properties = existing?.properties;
+  const items = existing?.items;
+  const result = { ...targetNode(target) };
+  if (properties) result.properties = properties;
+  if (items) result.items = items;
+  if (target.items && !result.items) result.items = itemNode(target.scopes[0], target.path, target.items);
+  return result;
+}
+
+function insertTarget(root, target) {
+  const segments = target.path.split(".");
+  let node = root;
+  let currentPath = "";
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    const array = segment.endsWith("[]");
+    const key = array ? segment.slice(0, -2) : segment;
+    currentPath = currentPath ? `${currentPath}.${segment}` : segment;
+    node.properties ||= {};
+    const last = index === segments.length - 1;
+    const existing = node.properties[key];
+    node.properties[key] = last
+      ? mergeTargetNode(existing, target)
+      : existing || syntheticObject(target.scopes[0], currentPath);
+    const child = node.properties[key];
+    if (array) {
+      child.items ||= itemNode(target.scopes[0], currentPath, target.items);
+      node = child.items;
+    } else {
+      node = child;
+    }
+  }
+}
+
+function schemaForScope(scope) {
+  const root = syntheticObject(scope, scope);
+  root.runtimeKey = scope;
+  root.applyDefaults = false;
+  root.sealed = true;
+  for (const target of CONFIG_TARGET_FIELDS.filter(field => field.scopes.includes(scope))) {
+    if (target.status !== "delivered") throw new Error(`配置目标 ${scope}:${target.path} 尚未交付`);
+    insertTarget(root, target);
+  }
+  return root;
+}
+
+function decorateSharedSchemas(schema) {
+  for (const region of ["topbar", "leftbar", "rightbar"]) {
+    schema.properties[region].normalizer = "object";
+    schema.properties[region].normalization = "accept a Region object; validate children and deep-freeze the normalized object";
+  }
+  for (const region of ["topbar", "leftbar"]) {
+    schema.properties[region].properties.brand.validator = "brand";
+    schema.properties[region].properties.brand.properties.href.validator = "nullable_safe_navigation_url";
+    schema.properties[region].properties.menu.validator = "menu_items";
+  }
+  schema.properties.leftbar.properties.footer.properties.actions.validator = "footer_actions";
+
+  const effect = schema.properties.hero?.properties.background?.properties.effect;
+  if (effect) {
+    effect.validator = "effect";
+    effect.normalizer = "effect";
+  }
+
+  const tree = schema.properties.navigation?.properties.tree;
+  if (tree) tree.validator = "string_tree";
+}
+
+function decorateCommon(schema) {
+  schema.properties.comments.properties.provider.validator = "nullable_non_empty_string";
+  schema.properties.article.properties.style.values = ["tech", "story"];
+  schema.properties.article.properties.paragraph_indent.values = ["auto", "always", "never"];
+  schema.properties.article.properties.ai_label.values = ["manual", "reviewed", "polished", "generated", null];
+  schema.properties.footer.properties.license.validator = "license_override";
+  schema.properties.footer.properties.share.validator = "share_override";
+  if (schema.properties.listing?.properties?.priority) {
+    schema.properties.listing.properties.priority.validator = "non_negative_integer";
+  }
+  if (schema.properties.render?.properties?.diagrams) {
+    schema.properties.render.properties.diagrams.validator = "diagrams_override";
+  }
+}
+
+const COLLECTION_CONFIG_SCHEMA = schemaForScope("collection");
+COLLECTION_CONFIG_SCHEMA.requiredProperties = ["name"];
+COLLECTION_CONFIG_SCHEMA.removedProperties = clone(LEGACY_COLLECTION_ROOTS);
+COLLECTION_CONFIG_SCHEMA.properties.name.validator = "non_empty_string";
+COLLECTION_CONFIG_SCHEMA.properties.listing.properties.order.validator = "nullable_non_negative_integer";
+COLLECTION_CONFIG_SCHEMA.properties.listing.properties.excerpt_length.validator = "nullable_non_negative_integer";
+COLLECTION_CONFIG_SCHEMA.properties.listing.properties.per_page.validator = "nullable_non_negative_integer";
+decorateSharedSchemas(COLLECTION_CONFIG_SCHEMA);
+COLLECTION_CONFIG_SCHEMA.properties.comments.removedProperties = Object.fromEntries(
+  COMMENT_PROVIDER_FIELDS.map(field => [field, field === "service" ? "provider" : "options"])
+);
+decorateCommon(COLLECTION_CONFIG_SCHEMA);
+
+const FRONT_MATTER_CONFIG_SCHEMA = schemaForScope("front_matter");
+FRONT_MATTER_CONFIG_SCHEMA.externalProperties = HEXO_FRONT_MATTER_FIELDS;
+FRONT_MATTER_CONFIG_SCHEMA.removedProperties = clone(LEGACY_FRONT_MATTER_ROOTS);
+FRONT_MATTER_CONFIG_SCHEMA.properties.collection.requiredProperties = ["profile", "id"];
+FRONT_MATTER_CONFIG_SCHEMA.properties.collection.properties.id.validator = "non_empty_string";
+decorateSharedSchemas(FRONT_MATTER_CONFIG_SCHEMA);
+decorateCommon(FRONT_MATTER_CONFIG_SCHEMA);
+
+module.exports = {
+  COLLECTION_CONFIG_SCHEMA: deepFreeze(COLLECTION_CONFIG_SCHEMA),
+  FRONT_MATTER_CONFIG_SCHEMA: deepFreeze(FRONT_MATTER_CONFIG_SCHEMA),
+  HEXO_FRONT_MATTER_FIELDS
+};