@roottale/cms-core 0.65.1 → 0.67.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @roottale/cms-core
 
+## 0.67.0
+
+### Minor Changes
+
+- 30d26ac: 공통 메타데이터 해석기·고유 경로 조회·Next SSR 빌더와 캐시 태그를 추가합니다. 기존 canonical과 강제 robots 정책을 보존하고 공유 이미지 대체 텍스트를 OG·X에 동일하게 적용합니다. 분류의 공유 전용 설정과 메타데이터 조회·수정 MCP 도구, Pro 하향 후 공개 적용 유지 계약을 문서와 예제에 반영합니다. 분류 색인 전환을 선언한 사이트가 공개 분류 응답의 `category_index_activated`를 확인한 뒤에만 분류 검색 제외를 적용하도록 안내합니다.
+
+## 0.66.0
+
+### Minor Changes
+
+- a58c5d2: 계층형 분류 모델(`category_tree`)에 `entryCategory: "leaf"`를 추가한다. 하위 분류가 없는
+  분류면 단계와 무관하게 글을 붙일 수 있고(`categoryDepth`는 최대 단계), 새로 고를 때는
+  `resolveCategoryTreeSelection`으로 하위가 없는지 확인한다. 생략하면 기존처럼
+  `categoryDepth` 단계 말단에만 붙는다.
+
+### Patch Changes
+
+- d5ef48e: `basePath: "/"`인 계층형 분류 모델(`category_tree`)도 허브·상세 주소를 계산합니다. 이전에는 루트를 빈 basePath(주소 없음)와 같게 보아 `resolveCategoryTreeHubPaths`·`resolveCategoryTreeEntryPath`·`resolvePostPublicPath`가 `null`을 돌려주었고, 웹훅에 상세 경로가 빠져 글 상세 캐시가 갱신되지 않았습니다.
+
 ## 0.65.1
 
 ## 0.65.0

package/dist/index.cjs

@@ -45,6 +45,14 @@ __export(src_exports, {
   INTERNAL_CONTENT_LINK_PENDING_CLASS: () => INTERNAL_CONTENT_LINK_PENDING_CLASS,
   INTERNAL_CONTENT_LINK_TOKEN_SOURCE: () => INTERNAL_CONTENT_LINK_TOKEN_SOURCE,
   LEGACY_BLOG_DETAIL_PATH: () => LEGACY_BLOG_DETAIL_PATH,
+  METADATA_FIELDS: () => METADATA_FIELDS,
+  MetadataDefaultRulesSchema: () => MetadataDefaultRulesSchema,
+  MetadataFieldSchema: () => MetadataFieldSchema,
+  MetadataPatchSchema: () => MetadataPatchSchema,
+  MetadataRobotsPolicySchema: () => MetadataRobotsPolicySchema,
+  MetadataTargetKindSchema: () => MetadataTargetKindSchema,
+  MetadataTextRuleSchema: () => MetadataTextRuleSchema,
+  MetadataValuesSchema: () => MetadataValuesSchema,
   PHASE_1_CORE_BLOCKS: () => PHASE_1_CORE_BLOCKS,
   PHASE_1_CSP: () => PHASE_1_CSP,
   POST_FOOTER_SLOT: () => POST_FOOTER_SLOT,
@@ -73,6 +81,7 @@ __export(src_exports, {
   findInternalContentLinkTokens: () => findInternalContentLinkTokens,
   findSectionLockViolations: () => findSectionLockViolations,
   findSitePatternPlacementRule: () => findSitePatternPlacementRule,
+  formatMetadataDefaults: () => formatMetadataDefaults,
   formatSectionLockViolations: () => formatSectionLockViolations,
   htmlToPlainText: () => htmlToPlainText,
   injectStableIdsTree: () => injectStableIdsTree,
@@ -82,18 +91,25 @@ __export(src_exports, {
   isAllowedEmbedSrc: () => isAllowedEmbedSrc,
   isAllowedMapEmbedSrc: () => isAllowedMapEmbedSrc,
   isInCollectionMode: () => isInCollectionMode,
+  isProtectedRedirectPath: () => isProtectedRedirectPath,
   isSectionContentPropPath: () => isSectionContentPropPath,
   isSitePatternSlotKey: () => isSitePatternSlotKey,
   isValidBlock: () => isValidBlock,
   isValidSitePatternKey: () => isValidSitePatternKey,
   issuePreviewToken: () => issuePreviewToken,
+  mergeMetadataPatch: () => mergeMetadataPatch,
+  metadataContentImageUrl: () => metadataContentImageUrl,
   normalizeEmbed: () => normalizeEmbed,
   normalizeHexColor: () => normalizeHexColor,
   normalizeImageAlt: () => normalizeImageAlt,
+  normalizeRedirectPath: () => normalizeRedirectPath,
+  normalizeRedirectSource: () => normalizeRedirectSource,
+  normalizeRedirectTarget: () => normalizeRedirectTarget,
   parseBlock: () => parseBlock,
   postsForCollection: () => postsForCollection,
   postsInAnyCollection: () => postsInAnyCollection,
   postsNotInAnyCollection: () => postsNotInAnyCollection,
+  readMetadataValues: () => readMetadataValues,
   readSitePatternPlacements: () => readSitePatternPlacements,
   readSitePatternPresentation: () => readSitePatternPresentation,
   referencedSitePatternKeys: () => referencedSitePatternKeys,
@@ -103,6 +119,8 @@ __export(src_exports, {
   resolveCategoryTreeChain: () => resolveCategoryTreeChain,
   resolveCategoryTreeEntryPath: () => resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths: () => resolveCategoryTreeHubPaths,
+  resolveCategoryTreeSelection: () => resolveCategoryTreeSelection,
+  resolveMetadata: () => resolveMetadata,
   resolvePatternSlots: () => resolvePatternSlots,
   resolvePostCategorySlug: () => resolvePostCategorySlug,
   resolvePostCollection: () => resolvePostCollection,
@@ -349,39 +367,51 @@ function validateCollections(collections) {
 }
 
 // src/category-tree.ts
-function normalizeBasePath(basePath) {
+function basePathPrefix(basePath) {
+  if (!basePath.trim()) return null;
   return basePath.replace(/\/+$/, "");
 }
-function resolveCategoryTreeChain(presentation, leafId, terms) {
-  if (!Number.isInteger(presentation.categoryDepth) || presentation.categoryDepth < 1) {
-    return null;
-  }
+function categoryTreeAncestry(categoryDepth, termId, terms) {
+  if (!Number.isInteger(categoryDepth) || categoryDepth < 1) return null;
   const termsById = new Map(terms.map((term) => [term.id, term]));
   if (termsById.size !== terms.length) return null;
-  if (terms.some((term) => term.parentId === leafId)) return null;
   const reversed = [];
   const visited = /* @__PURE__ */ new Set();
-  let currentId = leafId;
+  let currentId = termId;
   while (currentId) {
     if (visited.has(currentId)) return null;
     visited.add(currentId);
     const current = termsById.get(currentId);
     if (!current || !current.slug) return null;
     reversed.push(current);
+    if (reversed.length > categoryDepth) return null;
     currentId = current.parentId ?? null;
   }
-  if (reversed.length !== presentation.categoryDepth) return null;
   return reversed.reverse();
 }
+function hasChildCategory(termId, terms) {
+  return terms.some((term) => term.parentId === termId);
+}
+function resolveCategoryTreeChain(presentation, termId, terms) {
+  const chain = categoryTreeAncestry(presentation.categoryDepth, termId, terms);
+  if (!chain) return null;
+  if (presentation.entryCategory === "leaf") return chain;
+  if (hasChildCategory(termId, terms)) return null;
+  return chain.length === presentation.categoryDepth ? chain : null;
+}
+function resolveCategoryTreeSelection(presentation, termId, terms) {
+  if (hasChildCategory(termId, terms)) return null;
+  return resolveCategoryTreeChain(presentation, termId, terms);
+}
 function resolveCategoryTreeHubPaths(presentation, termId, terms) {
   const chain = resolveCategoryTreeChain(presentation, termId, terms);
-  const basePath = normalizeBasePath(presentation.basePath);
-  if (!chain || !basePath) return null;
-  const paths = [basePath];
+  const prefix = basePathPrefix(presentation.basePath);
+  if (!chain || prefix === null) return null;
+  const paths = [prefix || "/"];
   const segments = [];
   for (const term of chain) {
     segments.push(encodeURIComponent(term.slug));
-    paths.push(`${basePath}/${segments.join("/")}`);
+    paths.push(`${prefix}/${segments.join("/")}`);
   }
   return paths;
 }
@@ -1085,10 +1115,10 @@ function scopeImportedCss(css, scope, allowedAssetUrls = []) {
 
 // src/internal-content-links.ts
 var INTERNAL_CONTENT_LINK_TOKEN_SOURCE = String.raw`\[\[internal:([a-z0-9가-힣]+(?:[.-][a-z0-9가-힣]+)*)\|([^\]\n|]+)\]\]`;
-function findInternalContentLinkTokens(text) {
+function findInternalContentLinkTokens(text2) {
   const pattern = new RegExp(INTERNAL_CONTENT_LINK_TOKEN_SOURCE, "giu");
   const tokens = [];
-  for (const match of text.matchAll(pattern)) {
+  for (const match of text2.matchAll(pattern)) {
     const [raw, key, label] = match;
     if (!key || !label || match.index === void 0) continue;
     tokens.push({
@@ -1147,19 +1177,19 @@ function escapeHtmlText(value) {
 var INTERNAL_CONTENT_LINK_CLASS = "rt-internal-link";
 var INTERNAL_CONTENT_LINK_PENDING_CLASS = "rt-internal-link--pending";
 var INTERNAL_CONTENT_LINK_PENDING_ATTR = "data-rt-internal-link-pending";
-function renderInternalContentLinksInText(text, resolve) {
-  const tokens = findInternalContentLinkTokens(text);
-  if (tokens.length === 0) return { html: text, hasTokens: false };
+function renderInternalContentLinksInText(text2, resolve) {
+  const tokens = findInternalContentLinkTokens(text2);
+  if (tokens.length === 0) return { html: text2, hasTokens: false };
   let cursor = 0;
   let html = "";
   for (const token of tokens) {
-    html += text.slice(cursor, token.index);
+    html += text2.slice(cursor, token.index);
     const path = resolve(token.key);
     const label = escapeHtmlText(token.label);
     html += isSafeInternalPath(path) ? `<a href="${escapeHtmlText(path)}" class="${INTERNAL_CONTENT_LINK_CLASS}">${label}</a>` : `<span class="${INTERNAL_CONTENT_LINK_CLASS} ${INTERNAL_CONTENT_LINK_PENDING_CLASS}" ${INTERNAL_CONTENT_LINK_PENDING_ATTR}="${escapeHtmlText(token.key)}">${label}</span>`;
     cursor = token.index + token.raw.length;
   }
-  html += text.slice(cursor);
+  html += text2.slice(cursor);
   return { html, hasTokens: true };
 }
 var INTERNAL_LINK_BLOCKED_HTML_TAGS = /* @__PURE__ */ new Set([
@@ -1193,12 +1223,12 @@ function renderInternalContentLinksInHtml(html, resolve) {
   let cursor = 0;
   let out = "";
   let hasTokens = false;
-  const emitText = (text) => {
-    if (blockedDepth > 0 || !text) {
-      out += text;
+  const emitText = (text2) => {
+    if (blockedDepth > 0 || !text2) {
+      out += text2;
       return;
     }
-    const rendered = renderInternalContentLinksInText(text, resolve);
+    const rendered = renderInternalContentLinksInText(text2, resolve);
     hasTokens ||= rendered.hasTokens;
     out += rendered.html;
   };
@@ -1337,8 +1367,8 @@ function fromCodePointSafe2(n) {
   }
 }
 function decodeUrlProbe(value) {
-  const decoded = value.replace(/&#x([0-9a-f]+);?/gi, (_, h) => fromCodePointSafe2(parseInt(h, 16))).replace(/&#(\d+);?/g, (_, d) => fromCodePointSafe2(parseInt(d, 10))).replace(/&([a-z]+);/gi, (m, name) => NAMED_ENTITY[name.toLowerCase()] ?? m);
-  return [...decoded].filter((c) => {
+  const decoded2 = value.replace(/&#x([0-9a-f]+);?/gi, (_, h) => fromCodePointSafe2(parseInt(h, 16))).replace(/&#(\d+);?/g, (_, d) => fromCodePointSafe2(parseInt(d, 10))).replace(/&([a-z]+);/gi, (m, name) => NAMED_ENTITY[name.toLowerCase()] ?? m);
+  return [...decoded2].filter((c) => {
     const n = c.codePointAt(0) ?? 0;
     return n > 32 && n !== 127;
   }).join("").toLowerCase();
@@ -1962,6 +1992,287 @@ function formatSectionLockViolations(violations) {
     return `${label} \uAD6C\uC870 \uBCC0\uACBD(${violation.field})`;
   }).join(" / ");
 }
+
+// src/metadata-resolver.ts
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function imageUrl(value, base) {
+  const candidate = text(value);
+  if (!candidate || candidate.startsWith("//") || /[\\\u0000-\u0020\u007f]/u.test(candidate)) return void 0;
+  if (candidate.startsWith("/") && !base) return candidate;
+  try {
+    const url = new URL(candidate, base);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) return void 0;
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+function resolveMetadata(input) {
+  const layers = [input.overrides, input.defaults, input.siteDefaults, input.fallback];
+  const result = {};
+  for (const field of ["title", "description", "ogImageAlt"]) {
+    for (const layer of layers) {
+      const value = text(layer?.[field]);
+      if (value !== void 0) {
+        result[field] = value;
+        break;
+      }
+    }
+  }
+  for (const layer of layers) {
+    const value = imageUrl(layer?.ogImage, input.imageBaseUrl);
+    if (value !== void 0) {
+      result.ogImage = value;
+      break;
+    }
+  }
+  for (const field of ["noindex", "nofollow"]) {
+    for (const layer of layers) {
+      const value = layer?.[field];
+      if (typeof value === "boolean") {
+        result[field] = value;
+        break;
+      }
+    }
+  }
+  if (input.robots?.forceNoindex) result.noindex = true;
+  if (input.robots?.forceNofollow) result.nofollow = true;
+  return result;
+}
+
+// src/metadata-contract.ts
+var import_zod2 = require("zod");
+var METADATA_FIELDS = ["title", "description", "ogImage", "ogImageAlt", "noindex", "nofollow"];
+var MetadataFieldSchema = import_zod2.z.enum(METADATA_FIELDS);
+var MetadataTargetKindSchema = import_zod2.z.enum(["route", "post", "term"]);
+var textValue = (max) => import_zod2.z.string().trim().min(1).max(max);
+var imageValue = textValue(2048).refine((value) => {
+  if (/[\\\u0000-\u0020\u007f]/u.test(value) || value.startsWith("//")) return false;
+  if (value.startsWith("/")) return true;
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}, "\uACF5\uC720 \uC774\uBBF8\uC9C0\uC5D0\uB294 \uC0AC\uC774\uD2B8 \uB0B4\uBD80 \uACBD\uB85C\uB098 HTTP/HTTPS \uC8FC\uC18C\uB97C \uC785\uB825\uD574 \uC8FC\uC138\uC694");
+var metadataFields = {
+  // Existing content titles (500) plus a site title template (400) remain valid automatic values.
+  title: textValue(1e3),
+  description: textValue(2e3),
+  ogImage: imageValue,
+  // Automatic alt text may use the complete automatic title and its site suffix.
+  ogImageAlt: textValue(1e3),
+  noindex: import_zod2.z.boolean(),
+  nofollow: import_zod2.z.boolean()
+};
+var MetadataValuesSchema = import_zod2.z.object(metadataFields).partial().strict();
+var MetadataPatchSchema = import_zod2.z.object({
+  title: textValue(300).nullable().optional(),
+  description: metadataFields.description.nullable().optional(),
+  ogImage: metadataFields.ogImage.nullable().optional(),
+  ogImageAlt: textValue(500).nullable().optional(),
+  noindex: metadataFields.noindex.nullable().optional(),
+  nofollow: metadataFields.nofollow.nullable().optional()
+}).strict();
+var MetadataRobotsPolicySchema = import_zod2.z.object({
+  forceNoindex: import_zod2.z.boolean().optional(),
+  forceNofollow: import_zod2.z.boolean().optional()
+}).strict();
+function readMetadataValues(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+  const record = input;
+  const output = {};
+  for (const field of METADATA_FIELDS) {
+    const parsed = metadataFields[field].safeParse(record[field]);
+    if (parsed.success) output[field] = parsed.data;
+  }
+  return MetadataValuesSchema.parse(output);
+}
+function mergeMetadataPatch(current, input) {
+  const patch = MetadataPatchSchema.parse(input);
+  const next = { ...current };
+  for (const field of METADATA_FIELDS) {
+    if (patch[field] === null) delete next[field];
+    else if (patch[field] !== void 0) next[field] = patch[field];
+  }
+  return next;
+}
+
+// src/metadata-defaults.ts
+var import_zod3 = require("zod");
+var fallbackText = import_zod3.z.string().max(2e3);
+var imageOrigin = import_zod3.z.string().max(2048).refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.origin === value;
+  } catch {
+    return false;
+  }
+}, "\uC774\uBBF8\uC9C0 \uD5C8\uC6A9 \uBAA9\uB85D\uC5D0\uB294 \uACBD\uB85C \uC5C6\uB294 HTTPS origin\uB9CC \uC120\uC5B8\uD569\uB2C8\uB2E4");
+var MetadataTextRuleSchema = import_zod3.z.object({
+  source: import_zod3.z.enum(["content", "fallback"]).optional(),
+  stripLeadingLabel: import_zod3.z.enum(["question", "answer"]).optional(),
+  replaceLineBreakTokens: import_zod3.z.boolean().optional(),
+  removeEmDashes: import_zod3.z.boolean().optional(),
+  normalizeWhitespace: import_zod3.z.boolean().optional(),
+  maxLength: import_zod3.z.number().int().min(1).max(2e3).optional(),
+  ellipsis: import_zod3.z.string().max(10).optional(),
+  fallback: fallbackText.optional(),
+  fallbackWithParent: fallbackText.optional(),
+  fallbackWithoutParent: fallbackText.optional(),
+  fallbackBySlug: import_zod3.z.record(import_zod3.z.string().max(200), fallbackText).optional()
+}).strict().refine((rule) => !rule.ellipsis || rule.maxLength !== void 0 && rule.ellipsis.length < rule.maxLength, "\uB9D0\uC904\uC784\uD45C\uC5D0\uB294 \uB354 \uAE34 \uCD5C\uB300 \uAE38\uC774\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4");
+var MetadataDefaultRulesSchema = import_zod3.z.object({
+  title: MetadataTextRuleSchema.optional(),
+  description: MetadataTextRuleSchema.optional(),
+  useFirstBodyImage: import_zod3.z.boolean().optional(),
+  useTermImage: import_zod3.z.boolean().optional(),
+  imageAltSource: import_zod3.z.enum(["content", "title"]).optional(),
+  legacyImageSource: import_zod3.z.literal("legacy-thumbnail").optional(),
+  imageAllowedOrigins: import_zod3.z.array(imageOrigin).min(1).max(32).optional(),
+  legacyImageAllowedOrigins: import_zod3.z.array(imageOrigin).min(1).max(32).optional(),
+  normalizeCloudflareImages: import_zod3.z.boolean().optional(),
+  fallback: MetadataValuesSchema.optional()
+}).strict().refine((rule) => !rule.legacyImageSource || Boolean(rule.legacyImageAllowedOrigins?.length), "\uC774\uC804 \uC774\uBBF8\uC9C0 \uC6D0\uBCF8\uC5D0\uB294 \uD5C8\uC6A9 origin \uC120\uC5B8\uC774 \uD544\uC694\uD569\uB2C8\uB2E4");
+function cleanText(value, rule) {
+  let text2 = value.trim();
+  if (rule?.stripLeadingLabel === "question") text2 = text2.replace(/^\s*Q[.．:]?\s*/iu, "");
+  if (rule?.stripLeadingLabel === "answer") text2 = text2.replace(/^\s*A[.．:]?\s*/iu, "");
+  if (rule?.replaceLineBreakTokens) text2 = text2.replace(/\[\[br(?::[^\]]*)?\]\]/giu, " ");
+  if (rule?.removeEmDashes) text2 = text2.replaceAll("\u2014", "");
+  if (rule?.normalizeWhitespace) text2 = text2.replace(/\s+/gu, " ");
+  return text2.trim();
+}
+function formatText(value, rule, input, name) {
+  let text2 = rule?.source === "fallback" ? "" : cleanText(value ?? "", rule);
+  if (!text2) {
+    const fallback = input.parentId ? rule?.fallbackWithParent ?? rule?.fallback : (input.slug ? rule?.fallbackBySlug?.[input.slug] : void 0) ?? rule?.fallbackWithoutParent ?? rule?.fallback;
+    text2 = cleanText((fallback ?? "").replaceAll("%s", () => name), rule);
+  }
+  if (!text2) return void 0;
+  if (rule?.maxLength && text2.length > rule.maxLength) {
+    const suffix = rule.ellipsis ?? "";
+    const head = text2.slice(0, rule.maxLength - suffix.length);
+    return suffix ? head.trimEnd() + suffix : head;
+  }
+  return text2;
+}
+function metadataContentImageUrl(value, normalizeCloudflareImages = false) {
+  if (!normalizeCloudflareImages) return value;
+  try {
+    const url = new URL(value);
+    const [account, id, variant] = url.pathname.split("/").filter(Boolean);
+    if (url.protocol === "https:" && url.hostname === "imagedelivery.net" && account && id && variant) {
+      url.pathname = `/${account}/${id}/lg`;
+      return url.href;
+    }
+  } catch {
+  }
+  return value;
+}
+function legacyImageUrl(value, rule) {
+  if (!value || rule?.legacyImageSource !== "legacy-thumbnail") return void 0;
+  try {
+    const url = new URL(value);
+    if (!rule.legacyImageAllowedOrigins?.includes(url.origin)) return void 0;
+    return readMetadataValues({ ogImage: url.href }).ogImage;
+  } catch {
+    return void 0;
+  }
+}
+function contentCandidateAllowed(value, input, rule) {
+  if (!rule?.imageAllowedOrigins) return true;
+  if (value.startsWith("/") && !value.startsWith("//")) return true;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:") return false;
+    const origins = [...rule.imageAllowedOrigins];
+    if (input.imageBaseUrl) origins.push(new URL(input.imageBaseUrl).origin);
+    return origins.includes(url.origin);
+  } catch {
+    return false;
+  }
+}
+function formatMetadataDefaults(input, declaration) {
+  const dynamic = declaration[input.kind];
+  const rule = dynamic?.defaultRules?.[input.modelKey];
+  const name = cleanText(input.title, rule?.title);
+  const title = formatText(input.title, rule?.title, input, name);
+  const template = dynamic?.titleTemplates?.[input.modelKey];
+  const description = formatText(input.description, rule?.description, input, name);
+  const bodyImage = input.firstBodyImage && (input.firstBodyImage.startsWith("https://") || /^\/(?!\/)/u.test(input.firstBodyImage)) ? input.firstBodyImage : void 0;
+  const candidateImage = input.kind === "terms" && rule?.useTermImage === false ? void 0 : input.featuredImage || (rule?.useFirstBodyImage ? bodyImage : void 0) || legacyImageUrl(input.legacyImage, rule);
+  const ogImage = candidateImage && contentCandidateAllowed(candidateImage, input, rule) ? readMetadataValues({ ogImage: metadataContentImageUrl(candidateImage, rule?.normalizeCloudflareImages) }).ogImage : void 0;
+  return {
+    ...title ? { title: template ? template.replace("%s", () => title) : title } : {},
+    ...description ? { description } : {},
+    ...ogImage ? { ogImage } : {}
+  };
+}
+
+// src/redirect-paths.ts
+var CONTROL_OR_BACKSLASH = /[\\\u0000-\u001f\u007f]/u;
+var PROTECTED_PREFIX = /^\/(?:api|_next|_vercel|auth|admin|login|logout|revalidate|preview|assets|static|images|fonts|\.well-known)(?:\/|$)/i;
+var STATIC_EXTENSION = /\.(?:ico|png|jpe?g|gif|svg|webp|avif|css|js|txt|xml|json|woff2?|map)$/i;
+function decoded(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+}
+function trimInternalPath(path) {
+  if (!path.startsWith("/")) path = `/${path}`;
+  if (path.length > 1) path = path.replace(/\/+$/, "");
+  return path || "/";
+}
+function normalizeRedirectPath(raw) {
+  return trimInternalPath((decoded(raw) ?? raw).split(/[?#]/, 1)[0] ?? "");
+}
+function isProtectedRedirectPath(path) {
+  const normalized = normalizeRedirectPath(path);
+  return PROTECTED_PREFIX.test(normalized) || STATIC_EXTENSION.test(normalized);
+}
+function unsafePath(path) {
+  return CONTROL_OR_BACKSLASH.test(path) || path.startsWith("//") || /(?:^|\/)\.{1,2}(?:\/|$)/.test(path) || /[%](?:2f|5c|0[0-9a-f]|1[0-9a-f]|7f)/i.test(path);
+}
+function normalizeRedirectSource(raw) {
+  const invalid = { ok: false, code: "invalid_source_path" };
+  if (CONTROL_OR_BACKSLASH.test(raw)) return invalid;
+  const trimmed = raw.trim();
+  if (!trimmed || /^[a-z][a-z\d+.-]*:/i.test(trimmed) || trimmed.startsWith("//")) return invalid;
+  const rawPath = trimmed.split(/[?#]/, 1)[0] ?? "";
+  const path = decoded(rawPath);
+  if (!path || unsafePath(path) || /[?#*]/.test(path)) return invalid;
+  const normalized = trimInternalPath(path);
+  if (isProtectedRedirectPath(normalized)) return invalid;
+  return { ok: true, value: normalized };
+}
+function normalizeRedirectTarget(raw) {
+  const invalid = { ok: false, code: "invalid_target" };
+  const decodedRaw = decoded(raw);
+  if (decodedRaw === null || CONTROL_OR_BACKSLASH.test(raw) || CONTROL_OR_BACKSLASH.test(decodedRaw)) return invalid;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.startsWith("//")) return invalid;
+  if (trimmed.startsWith("/")) {
+    const suffixIndex = trimmed.search(/[?#]/);
+    const rawPath = suffixIndex === -1 ? trimmed : trimmed.slice(0, suffixIndex);
+    const path = decoded(rawPath);
+    if (!path || unsafePath(path) || /[?#]/.test(path)) return invalid;
+    const suffix = suffixIndex === -1 ? "" : trimmed.slice(suffixIndex);
+    return { ok: true, value: `${trimInternalPath(path)}${suffix}`, kind: "internal" };
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password) return invalid;
+    return { ok: true, value: url.toString(), kind: "external" };
+  } catch {
+    return invalid;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOCK_NAME_PATTERN,
@@ -1979,6 +2290,14 @@ function formatSectionLockViolations(violations) {
   INTERNAL_CONTENT_LINK_PENDING_CLASS,
   INTERNAL_CONTENT_LINK_TOKEN_SOURCE,
   LEGACY_BLOG_DETAIL_PATH,
+  METADATA_FIELDS,
+  MetadataDefaultRulesSchema,
+  MetadataFieldSchema,
+  MetadataPatchSchema,
+  MetadataRobotsPolicySchema,
+  MetadataTargetKindSchema,
+  MetadataTextRuleSchema,
+  MetadataValuesSchema,
   PHASE_1_CORE_BLOCKS,
   PHASE_1_CSP,
   POST_FOOTER_SLOT,
@@ -2007,6 +2326,7 @@ function formatSectionLockViolations(violations) {
   findInternalContentLinkTokens,
   findSectionLockViolations,
   findSitePatternPlacementRule,
+  formatMetadataDefaults,
   formatSectionLockViolations,
   htmlToPlainText,
   injectStableIdsTree,
@@ -2016,18 +2336,25 @@ function formatSectionLockViolations(violations) {
   isAllowedEmbedSrc,
   isAllowedMapEmbedSrc,
   isInCollectionMode,
+  isProtectedRedirectPath,
   isSectionContentPropPath,
   isSitePatternSlotKey,
   isValidBlock,
   isValidSitePatternKey,
   issuePreviewToken,
+  mergeMetadataPatch,
+  metadataContentImageUrl,
   normalizeEmbed,
   normalizeHexColor,
   normalizeImageAlt,
+  normalizeRedirectPath,
+  normalizeRedirectSource,
+  normalizeRedirectTarget,
   parseBlock,
   postsForCollection,
   postsInAnyCollection,
   postsNotInAnyCollection,
+  readMetadataValues,
   readSitePatternPlacements,
   readSitePatternPresentation,
   referencedSitePatternKeys,
@@ -2037,6 +2364,8 @@ function formatSectionLockViolations(violations) {
   resolveCategoryTreeChain,
   resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths,
+  resolveCategoryTreeSelection,
+  resolveMetadata,
   resolvePatternSlots,
   resolvePostCategorySlug,
   resolvePostCollection,