@universalcms/connect 0.0.0-stage → 0.13.0

package/dist/website-runtime.mjs

@@ -0,0 +1,396 @@
+/** Private, fixed-scope website configuration and new-page delivery. No cache. */
+import { nativePatternMatches, validateNativeRoutes } from './native-routes.mjs';
+import { validatePublicationConfig, normalizePublicationPath, isExcludedPublicationPath, publicPublishedEntry, publicationRevision } from './publication.mjs';
+import { websiteSections, parseWebsiteSection, parseWebsiteEntryMetadata } from './website-schema.mjs';
+
+export { websiteSections };
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const keyPattern = /^cms_server\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.[A-Za-z0-9_-]{43}$/;
+const fail = () => { throw new Error('Website configuration is unavailable.'); };
+const integer = (value, min, max) => Number.isSafeInteger(value) && value >= min && value <= max;
+const state = (value, version = 0, data) => ({ state: value, version, ...(data === undefined ? {} : { data }) });
+const unavailableSnapshot = () => ({ version: 1, state: 'unavailable', sections: Object.fromEntries(websiteSections.map(section => [section, state('unavailable')])) });
+const result = (value, extra = {}) => ({ state: value, status: value === 'missing' ? 404 : value === 'gone' ? 410 : value === 'unavailable' ? 503 : 200, ...extra });
+const secret = /cms_server\.|sk-[A-Za-z0-9_-]{12,}|AIza[A-Za-z0-9_-]{20,}/i;
+function canonicalLocale(value) { try { const values = Intl.getCanonicalLocales(value); if (typeof value !== 'string' || value.length > 35 || values.length !== 1) return fail(); return values[0]; } catch { return fail(); } }
+function safeOrigin(value) {
+  if (typeof value !== 'string' || value.length > 2048 || /[\\\s]/.test(value) || secret.test(value)) return fail();
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || url.pathname !== '/' || !(url.protocol === 'https:' || url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))) return fail();
+  return url.origin;
+}
+function publicPath(value) {
+  const path = normalizePublicationPath(value);
+  if (isExcludedPublicationPath(path) || secret.test(path)) return fail();
+  return path;
+}
+function publicUrl(value, websiteOrigin, { absolute = false, page = true } = {}) {
+  if (typeof value !== 'string' || value.length > 2048 || /[\\\s\u0000-\u001f\u007f]|%(?:0[0-9a-f]|1[0-9a-f]|7f|5c)/i.test(value) || secret.test(value)) return fail();
+  if (!absolute && value.startsWith('/') && !value.startsWith('//')) return publicPath(value);
+  const url = new URL(value);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return fail();
+  if (page) publicPath(url.pathname);
+  if (url.origin === websiteOrigin && !url.search && !url.hash) return absolute ? url.href : publicPath(url.pathname);
+  return url.href;
+}
+function cancel(response) { try { if (response?.body && !response.body.locked) void response.body.cancel().catch(() => {}); } catch { /* Cleanup only. */ } }
+function untilAborted(pending, signal) {
+  return new Promise((resolve, reject) => {
+    const aborted = () => reject(new Error('Website configuration is unavailable.'));
+    signal.addEventListener('abort', aborted, { once: true });
+    if (signal.aborted) aborted();
+    Promise.resolve(pending).then(value => { signal.removeEventListener('abort', aborted); resolve(value); }, error => { signal.removeEventListener('abort', aborted); reject(error); });
+  });
+}
+function publicEntry(raw, config) {
+  if (!record(raw) || !uuid.test(raw.id ?? '') || !['page', 'post'].includes(raw.kind) || typeof raw.slug !== 'string' || raw.slug.length > 160 || !/^[a-z0-9]+(?:[-/][a-z0-9]+)*$/.test(raw.slug) ||
+      typeof raw.publishedAt !== 'string' || !Number.isFinite(Date.parse(raw.publishedAt)) || Object.hasOwn(raw, 'preview') || raw.status !== undefined && raw.status !== 'published' ||
+      raw.siteId !== undefined && raw.siteId !== config.siteId || raw.environmentId !== undefined && raw.environmentId !== config.environmentId) return fail();
+  const path = publicPath(raw.path), locale = canonicalLocale(raw.locale), entry = publicPublishedEntry({ ...raw, locale });
+  const metadata = parseWebsiteEntryMetadata(raw);
+  if (metadata.canonicalUrl) metadata.canonicalUrl = publicUrl(metadata.canonicalUrl, config.websiteOrigin, { absolute: true });
+  for (const key of ['categories', 'tags']) if (metadata[key]) metadata[key] = metadata[key].map(term => ({ ...term, path: publicPath(term.path) }));
+  if (metadata.translations) metadata.translations = metadata.translations.filter(translation => translation.path).map(translation => ({ ...translation, locale: canonicalLocale(translation.locale), path: publicPath(translation.path) }));
+  return { ...entry, ...metadata, path };
+}
+const summary = entry => ({ id: entry.id, kind: entry.kind, slug: entry.slug, locale: entry.locale, path: entry.path, title: entry.document.title, excerpt: entry.document.excerpt, publishedAt: entry.publishedAt });
+
+export function createWebsiteRuntime({ configuration, env = process.env, fetcher = globalThis.fetch, nativePaths = [], nativePatterns = [], nativePathPrefixes = [], installedSections = websiteSections, timeoutMs = 10_000, maxResponseBytes = 8 * 1024 * 1024, maxConcurrent = 16 } = {}) {
+  if (typeof window !== 'undefined') throw new Error('Website configuration requires a private server runtime.');
+  const config = validatePublicationConfig(configuration);
+  if (typeof fetcher !== 'function' || !Array.isArray(nativePaths) || nativePaths.length > 1000 || !integer(timeoutMs, 1, 10000) || !integer(maxResponseBytes, 1, 8 * 1024 * 1024) || !integer(maxConcurrent, 1, 16)) return fail();
+  const native = new Set(nativePaths.map(normalizePublicationPath));
+  if (!Array.isArray(nativePatterns)) return fail();
+  if (nativePatterns.length) validateNativeRoutes({nativePaths:[...native],nativePatterns},config.routes);
+  if (!Array.isArray(nativePathPrefixes) || nativePathPrefixes.length > 100 || !Array.isArray(installedSections) || installedSections.length > websiteSections.length || new Set(installedSections).size !== installedSections.length || installedSections.some(name => !websiteSections.includes(name))) return fail();
+  const prefixes = nativePathPrefixes.map(value => {
+    if (typeof value !== 'string' || !value.endsWith('/') || value === '/' || normalizePublicationPath(value.slice(0, -1)) !== value.slice(0, -1)) return fail();
+    return value;
+  });
+  const isNative = path => native.has(path) || nativePatterns.some(pattern => nativePatternMatches(pattern, path)) || prefixes.some(prefix => path.startsWith(prefix));
+  const installed = new Set(installedSections);
+  const original = new Set(config.routes.map(route => route.path));
+  if (original.has('/')) original.add('/index.html');
+  const unclaimed = path => !original.has(path) && !isNative(path) && !isExcludedPublicationPath(path);
+  let active = 0;
+  async function operation(work) {
+    if (typeof window !== 'undefined' || active >= maxConcurrent) return fail();
+    active++;
+    let controller, timer;
+    try {
+      // Read the caller's private env on every operation; rotation needs no cached client.
+      const values = typeof env === 'function' ? await env() : env;
+      if (!values || typeof values !== 'object' || Array.isArray(values) || typeof values.CMS_API_KEY !== 'string' || !keyPattern.test(values.CMS_API_KEY) ||
+          values.CMS_API_BASE_URL !== undefined && safeOrigin(values.CMS_API_BASE_URL) !== config.apiOrigin ||
+          values.CMS_SITE_ID !== undefined && String(values.CMS_SITE_ID).toLowerCase() !== config.siteId ||
+          values.CMS_ENVIRONMENT_ID !== undefined && String(values.CMS_ENVIRONMENT_ID).toLowerCase() !== config.environmentId ||
+          values.CMS_WEBSITE_ORIGIN !== undefined && safeOrigin(values.CMS_WEBSITE_ORIGIN) !== config.websiteOrigin) {
+        if (!values?.CMS_API_KEY || typeof values.CMS_API_KEY !== 'string' || !keyPattern.test(values.CMS_API_KEY)) {
+          console.warn('[UniversalCMS] Delivery check failed: CMS_API_KEY is missing or invalid in private environment.');
+        }
+        return fail();
+      }
+      const locale = values.CMS_LOCALE === undefined ? undefined : canonicalLocale(values.CMS_LOCALE);
+      const key = values.CMS_API_KEY;
+      controller = new AbortController(); timer = setTimeout(() => controller.abort(), timeoutMs);
+      let bytes = 0, invalidAuthority = false;
+      async function read(resource, query = {}) {
+        if (controller.signal.aborted || invalidAuthority || bytes >= maxResponseBytes) return fail();
+        const url = new URL(`/api/v1/delivery/sites/${config.siteId}/${resource}`, config.apiOrigin);
+        url.search = new URLSearchParams({ ...query, environmentId: config.environmentId }).toString();
+        let response;
+        try {
+          const pending = Promise.resolve(fetcher(url, { method: 'GET', headers: { Accept: 'application/json', Authorization: `Bearer ${key}` }, credentials: 'omit', redirect: 'error', cache: 'no-store', referrerPolicy: 'no-referrer', signal: controller.signal }))
+            .then(value => { if (controller.signal.aborted) cancel(value); return value; });
+          response = await untilAborted(pending, controller.signal);
+          if (!(response instanceof Response) || response.redirected || ['opaque', 'opaqueredirect'].includes(response.type) || response.url && response.url !== url.href) return fail();
+          if (response.status === 401) {
+            invalidAuthority = true;
+            console.warn(`[UniversalCMS] Delivery API rejected CMS_API_KEY (HTTP 401 Unauthorized) for site ${config.siteId} and environment ${config.environmentId}. Verify private server key in .env.local.`);
+          }
+          if ([403, 404].includes(response.status)) return { denied: true };
+          if (response.status !== 200 || response.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase() !== 'application/json' || !response.body) return fail();
+          const declared = response.headers.get('content-length');
+          if (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > maxResponseBytes - bytes)) return fail();
+          const reader = response.body.getReader(), decoder = new TextDecoder('utf-8', { fatal: true });
+          let text = '';
+          try {
+            for (;;) {
+              const chunk = await untilAborted(reader.read(), controller.signal);
+              if (controller.signal.aborted) return fail();
+              if (chunk.done) break;
+              if (!(chunk.value instanceof Uint8Array) || (bytes += chunk.value.byteLength) > maxResponseBytes) return fail();
+              text += decoder.decode(chunk.value, { stream: true });
+            }
+            const envelope = JSON.parse(text + decoder.decode());
+            if (!record(envelope) || !Object.hasOwn(envelope, 'data') || Object.hasOwn(envelope, 'preview') || record(envelope.data) && Object.hasOwn(envelope.data, 'preview')) return fail();
+            return { data: envelope.data };
+          } finally { void reader.cancel().catch(() => {}); reader.releaseLock(); }
+        } finally { cancel(response); }
+      }
+      async function section(name) {
+        // An adapter cannot activate settings it does not consume merely because
+        // a replacement key grants broader access.
+        if (!installed.has(name)) return state('missing');
+        try {
+          const reply = await read(`settings/${name}`);
+          if (reply.denied) return state('denied');
+          const value = parseWebsiteSection(name, reply.data);
+          return value.version === 0 ? state('missing') : state('ready', value.version, value.data);
+        } catch { return state('unavailable'); }
+      }
+      async function inventory() {
+        const entries = [], ids = new Set(); let total, count = 0;
+        for (let offset = 0; offset < 1000; offset += 100) {
+          const reply = await read('content', { limit: '100', offset: String(offset) });
+          const page = reply.data;
+          if (reply.denied || !record(page) || !integer(page.total, 0, 1000) || !Array.isArray(page.items) || page.items.length > 100 || page.items.length > page.total || total !== undefined && page.total !== total) return fail();
+          total = page.total;
+          for (const raw of page.items) {
+            if (!record(raw) || !uuid.test(raw.id ?? '') || ids.has(raw.id) || typeof raw.kind !== 'string' || !/^[a-z][a-z0-9_-]{0,39}$/.test(raw.kind) || Object.hasOwn(raw, 'preview') || raw.status !== undefined && raw.status !== 'published' || raw.siteId !== undefined && raw.siteId !== config.siteId || raw.environmentId !== undefined && raw.environmentId !== config.environmentId) return fail();
+            ids.add(raw.id); count++;
+            if (['page', 'post'].includes(raw.kind)) {
+              if (isExcludedPublicationPath(normalizePublicationPath(raw.path))) continue;
+              const entry = publicEntry(raw, config);
+              entries.push(entry);
+            }
+          }
+          if (count === total) return entries;
+          if (count > total || page.items.length !== 100) return fail();
+        }
+        return fail();
+      }
+      const value = await work({ read, section, inventory, locale });
+      if (invalidAuthority) return fail();
+      return value;
+    } finally { active--; clearTimeout(timer); controller?.abort(); }
+  }
+  function paths(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+      if (!unclaimed(entry.path) || config.routes.some(route => route.kind === entry.kind && route.slug === entry.slug && route.locale === entry.locale)) continue;
+      if (map.has(entry.path)) return fail();
+      map.set(entry.path, entry);
+    }
+    return map;
+  }
+  function redirect(path, section) {
+    if (section.state !== 'ready') return null;
+    const mappings = new Map(section.data.entries.filter(entry => entry.enabled).map(entry => [normalizePublicationPath(entry.from), entry]));
+    const first = mappings.get(path); if (!first) return null;
+    if (first.status === 410) return result('gone', { path });
+    let current = path; const seen = new Set([path]);
+    for (let count = 0; count < 500; count++) {
+      const next = mappings.get(current); if (!next || next.status === 410) break;
+      const location = publicUrl(next.to, config.websiteOrigin);
+      if (!location.startsWith('/')) break;
+      if (seen.has(location)) return fail();
+      seen.add(location); current = location;
+    }
+    return result('redirect', { path, status: first.status, location: publicUrl(first.to, config.websiteOrigin) });
+  }
+  function archives(taxonomies, entries, current, dynamic) {
+    if (taxonomies.state !== 'ready') return null;
+    const found = [];
+    for (const [kind, key, pattern] of [['category', 'categories', taxonomies.data.categoryPath], ['tag', 'tags', taxonomies.data.tagPath]]) {
+      for (const term of taxonomies.data[key]) {
+        const path = publicPath(pattern.replaceAll('{slug}', term.slug));
+        if (!unclaimed(path) || path !== current) continue;
+        if (dynamic.has(path)) return fail();
+        found.push(result('archive', { path, kind, title: term.name, description: term.description ?? '', entries: entries.filter(entry => entry[key]?.some(value => value.id === term.id) || entry.document.taxonomy?.[key]?.includes(term.id)).filter(entry => dynamic.has(entry.path) || config.routes.some(route => route.kind === entry.kind && route.slug === entry.slug && route.locale === entry.locale)).map(entry => ({ ...entry, path: config.routes.find(route => route.kind === entry.kind && route.slug === entry.slug && route.locale === entry.locale)?.path ?? entry.path })) }));
+      }
+    }
+    if (found.length > 1) return fail();
+    return found[0] ?? null;
+  }
+  function navigationTarget(value) {
+    try {
+      const url=new URL(value,config.websiteOrigin);
+      if(url.origin!==config.websiteOrigin)return {external:true};
+      const path=normalizePublicationPath(url.pathname);
+      return {path,native:isNative(path)||isExcludedPublicationPath(path)};
+    }catch{return null;}
+  }
+  async function publishedNavigation(sections,inventory) {
+    const navigation=sections.navigation;
+    if(navigation.state!=='ready')return;
+    const data=navigation.data;
+    const links=[...data.header.flatMap(link=>[link,...(link.children??[])]),...data.footer,...(data.footerGroups??[]).flatMap(group=>group.links)];
+    // External links, reviewed native routes and intentionally empty menus do
+    // not need a content read. Only CMS-controlled destinations are filtered.
+    const needsInventory=links.some(link=>{const target=link.url&&navigationTarget(link.url);return target&&!target.external&&!target.native;});
+    if(!links.length)return;
+    try {
+      const {languages,taxonomies,redirects}=sections;
+      if(needsInventory&&[languages,taxonomies,redirects].some(section=>section.state==='unavailable'))return fail();
+      const entries=needsInventory?(await inventory()).filter(entry=>languages.state!=='ready'||languages.data.enabled.some(locale=>canonicalLocale(locale)===entry.locale)):[];
+      const dynamic=paths(entries),available=new Set(dynamic.keys());
+      for(const route of config.routes){
+        const matches=entries.filter(entry=>entry.kind===route.kind&&entry.slug===route.slug&&entry.locale===route.locale);
+        if(matches.length>1)return fail();
+        if(matches.length===1){available.add(route.path);if(route.path==='/')available.add('/index.html');}
+      }
+      // A collision has no valid rendered destination, even if one individual
+      // content or taxonomy record otherwise appears published.
+      if(needsInventory&&taxonomies.state==='ready'){
+        const archivePaths=new Map();
+        for(const [terms,pattern] of [[taxonomies.data.categories,taxonomies.data.categoryPath],[taxonomies.data.tags,taxonomies.data.tagPath]])for(const term of terms){
+          const path=publicPath(pattern.replaceAll('{slug}',term.slug));
+          if(unclaimed(path))archivePaths.set(path,(archivePaths.get(path)??0)+1);
+        }
+        for(const [path,count] of archivePaths)if(count===1&&!dynamic.has(path))available.add(path);else available.delete(path);
+      }
+      const keep=(value,seen=new Set())=>{
+        const target=navigationTarget(value);
+        if(!target)return false;
+        if(target.external||target.native)return true;
+        if(seen.has(target.path)||seen.size>=500)return false;
+        seen.add(target.path);
+        const redirected=redirect(target.path,redirects);
+        if(redirected?.state==='gone')return false;
+        if(redirected?.state==='redirect')return keep(redirected.location,seen);
+        return available.has(target.path);
+      };
+      const header=data.header.flatMap(link=>{
+        const children=link.children?.filter(child=>keep(child.url)),allowed=link.url!==undefined&&keep(link.url);
+        if(!allowed&&!children?.length)return [];
+        return [{label:link.label,...(allowed?{url:link.url}:{}),...(children===undefined?{}:{children})}];
+      });
+      sections.navigation=state('ready',navigation.version,{...data,header,footer:data.footer.filter(link=>keep(link.url)),...(data.footerGroups===undefined?{}:{footerGroups:data.footerGroups.map(group=>({...group,links:group.links.filter(link=>keep(link.url))})).filter(group=>group.links.length)})});
+    }catch{sections.navigation=state('unavailable');}
+  }
+  const runtime = {
+    async settings() {
+      try {
+        return await operation(async ({ section, inventory }) => {
+          const sections = {}; let cursor = 0;
+          await Promise.all(Array.from({ length: 4 }, async () => {
+            while (cursor < websiteSections.length) { const name = websiteSections[cursor++]; sections[name] = await section(name); }
+          }));
+          await publishedNavigation(sections,inventory);
+          return { version: 1, state: Object.values(sections).some(value => value.state === 'unavailable') ? 'unavailable' : 'ready', sections };
+        });
+      } catch { return unavailableSnapshot(); }
+    },
+    async resolve(pathname) {
+      let path;
+      try { path = normalizePublicationPath(pathname); if (isNative(path) || isExcludedPublicationPath(path)) return result('unmanaged'); } catch { return result('missing'); }
+      try {
+        return await operation(async ({ section, inventory }) => {
+          const redirects = await section('redirects');
+          // A failed authorized redirect read must not expose the old content.
+          if (redirects.state === 'unavailable') return result('unavailable');
+          const redirected = redirect(path, redirects); if (redirected) return redirected;
+          if (original.has(path)) return result('unmanaged');
+          const languages = await section('languages');
+          if (languages.state === 'unavailable') return result('unavailable');
+          const entries = (await inventory()).filter(entry => languages.state !== 'ready' || languages.data.enabled.some(locale => canonicalLocale(locale) === entry.locale)), dynamic = paths(entries);
+          const taxonomies = await section('taxonomies');
+          if (taxonomies.state === 'unavailable') return result('unavailable');
+          const archive = archives(taxonomies, entries, path, dynamic); if (archive) return archive;
+          const entry = dynamic.get(path);
+          if (!entry) return result('missing');
+          return result('published', { path, entry, revision: publicationRevision(entry), related: [...dynamic.values()].filter(other => other.id !== entry.id && other.kind === entry.kind && other.locale === entry.locale).slice(0, 6).map(summary) });
+        });
+      } catch { return result('unavailable'); }
+    },
+    async page(pathname) {
+      let path;
+      try { path = normalizePublicationPath(pathname); if (isNative(path) || isExcludedPublicationPath(path)) return result('unmanaged'); } catch { return result('missing'); }
+      const route = config.routes.find(route => route.path === (path === '/index.html' ? '/' : path));
+      if (!route) return runtime.resolve(path);
+      try {
+        return await operation(async ({ section, inventory }) => {
+          const redirects = await section('redirects');
+          if (redirects.state === 'unavailable') return result('unavailable');
+          const redirected = redirect(path, redirects); if (redirected) return redirected;
+          const entries = await inventory(), matches = entries.filter(entry => entry.kind === route.kind && entry.slug === route.slug && entry.locale === route.locale);
+          if (matches.length > 1) return result('unavailable');
+          if (!matches.length) return result('missing');
+          const entry = { ...matches[0], path: route.path };
+          return result('published', { path: route.path, entry, revision: publicationRevision(entry), related: [...paths(entries).values()].filter(other => other.kind === entry.kind && other.locale === entry.locale).slice(0, 6).map(summary) });
+        });
+      } catch { return result('unavailable'); }
+    },
+    async sitemap() {
+      try {
+        return await operation(async ({ section, inventory }) => {
+          const setting = await section('seo');
+          if (setting.state !== 'ready') return { state: setting.state };
+          const seo = setting.data, canonicalBase = seo.canonicalBase || config.websiteOrigin;
+          publicUrl(canonicalBase, config.websiteOrigin, { absolute: true });
+          if (!seo.sitemapEnabled || !seo.indexable) return { state: 'ready', enabled: false, canonicalBase, entries: [] };
+          const languageSetting = await section('languages');
+          if (languageSetting.state === 'unavailable') return { state: 'unavailable' };
+          const locales = languageSetting.state === 'ready' ? languageSetting.data.enabled.map(canonicalLocale) : null;
+          const entries = await inventory(), dynamic = paths(entries), mapped = new Map();
+          for (const entry of entries) {
+            if (locales && !locales.includes(entry.locale) || entry.seo?.robots.index === false || entry.seo?.canonical && !['', 'self'].includes(entry.seo.canonical)) continue;
+            const path = config.routes.find(route => route.kind === entry.kind && route.slug === entry.slug && route.locale === entry.locale)?.path ?? (dynamic.has(entry.path) ? entry.path : null);
+            if (!path || isNative(path)) continue;
+            if (mapped.has(path)) return fail();
+            mapped.set(path, { url: absolutePath(canonicalBase, path), path, locale: entry.locale, lastModified: entry.publishedAt });
+          }
+          return { state: 'ready', enabled: true, canonicalBase, entries: [...mapped.values()] };
+        });
+      } catch { return { state: 'unavailable' }; }
+    },
+    async robots() {
+      try {
+        return await operation(async ({ section }) => {
+          const setting = await section('seo');
+          if (setting.state !== 'ready') return { state: setting.state };
+          const seo = setting.data;
+          if (seo.robotsTxt.trim()) return { state: 'ready', body: `${seo.robotsTxt.trim()}\n` };
+          const lines = ['User-agent: *', seo.indexable ? 'Allow: /' : 'Disallow: /', ...seo.robotsDisallow.map(path => `Disallow: ${path}`)];
+          if (seo.indexable && seo.sitemapEnabled) lines.push('', `Sitemap: ${absolutePath(seo.canonicalBase || config.websiteOrigin, '/sitemap.xml')}`);
+          return { state: 'ready', body: `${lines.join('\n')}\n` };
+        });
+      } catch { return { state: 'unavailable' }; }
+    },
+  };
+  return runtime;
+}
+
+function absolutePath(base, pathname) {
+  const url = new URL(base);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return fail();
+  url.pathname = `${url.pathname.replace(/\/+$/, '')}${pathname}`; url.search = ''; url.hash = '';
+  return url.href;
+}
+
+/** Plain public metadata only. Adapters escape attributes/JSON when serializing. */
+export function websiteMetadata(entry, snapshot, pathname, websiteOrigin) {
+  const path = publicPath(pathname), base = websiteOrigin === undefined ? undefined : safeOrigin(websiteOrigin);
+  const get = name => snapshot?.version === 1 && snapshot.sections?.[name]?.state === 'ready' ? parseWebsiteSection(name, { section: name, version: snapshot.sections[name].version, data: snapshot.sections[name].data }).data : null;
+  const seo = get('seo'), templates = get('templates'), authors = get('authors');
+  const metadata = parseWebsiteEntryMetadata(entry ?? {}), published = entry?.document;
+  const editorial = seo ? metadata.seo : undefined;
+  let title = editorial?.title || published?.title || '';
+  if (typeof title !== 'string' || title.length > 500) return fail();
+  if (seo?.titleTemplate) title = seo.titleTemplate.replace(/%s|%title%|\{title\}/g, () => title);
+  const description = editorial?.description || published?.excerpt || seo?.description || '';
+  if (typeof description !== 'string' || description.length > 2000) return fail();
+  let canonical;
+  if (seo) {
+    if (editorial?.canonical && !['self', ''].includes(editorial.canonical)) canonical = publicUrl(editorial.canonical, base, { absolute: true });
+    else if (seo.canonicalBase || base) canonical = absolutePath(seo.canonicalBase || base, path);
+  }
+  const robots = { index: seo ? seo.indexable && (editorial?.robots.index ?? true) : false, follow: seo ? seo.followLinks && (editorial?.robots.follow ?? true) : true };
+  const output = { title, description, robots, ...(canonical ? { canonical } : {}) };
+  if (!seo) return output;
+  const og = editorial?.openGraph;
+  const image = og?.imageUrl || editorial?.featuredImage.url || seo.socialImageUrl;
+  output.openGraph = { title: og?.title || title, description: og?.description || description, type: og?.type || (entry?.kind === 'post' ? 'article' : 'website'), ...(canonical ? { url: canonical } : {}), ...(image ? { image: publicUrl(image, base, { absolute: true, page: false }), imageAlt: og?.imageAlt || editorial?.featuredImage.alt || '' } : {}) };
+  output.twitter = { card: editorial?.twitterCard || 'summary_large_image', ...(seo.twitterHandle ? { site: seo.twitterHandle } : {}) };
+  const languages = get('languages');
+  if (languages && metadata.translations) output.alternates = metadata.translations.filter(value => languages.enabled.some(locale => canonicalLocale(locale) === canonicalLocale(value.locale))).map(value => ({ locale: canonicalLocale(value.locale), url: seo.canonicalBase || base ? absolutePath(seo.canonicalBase || base, publicPath(value.path)) : publicPath(value.path) }));
+  const schemaType = editorial && editorial.schema.type !== 'none' ? editorial.schema.type : templates?.[entry?.kind]?.schemaType;
+  if (schemaType === 'custom' && editorial?.schema.json) output.jsonLd = editorial.schema.json;
+  else if (schemaType && schemaType !== 'none') {
+    output.jsonLd = { '@context': 'https://schema.org', '@type': schemaType, name: title, description, ...(canonical ? { url: canonical } : {}), ...(image ? { image } : {}) };
+    if (authors && metadata.author) output.jsonLd.author = { '@type': 'Person', name: metadata.author.name, ...(metadata.author.url ? { url: metadata.author.url } : {}) };
+  }
+  return output;
+}