@universalcms/connect 0.1.0 → 0.13.0

package/dist/website-model.mjs

@@ -0,0 +1,155 @@
+/** Public browser presentation helpers. No key, API origin or private settings. */
+export const WEBSITE_SECTIONS = Object.freeze(['branding', 'social', 'seo', 'languages', 'analytics', 'navigation', 'experience', 'scripts', 'redirects', 'authors', 'templates', 'taxonomies']);
+export const record = value => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+export const text = (value, limit = 2000) => typeof value === 'string' ? value.slice(0, limit) : '';
+const states = new Set(['ready', 'missing', 'denied', 'unavailable']);
+export function emptyWebsiteSettings() {
+  return { version: 1, state: 'unavailable', sections: Object.fromEntries(WEBSITE_SECTIONS.map(name => [name, { state: 'unavailable', version: 0 }])) };
+}
+export function parseWebsiteSettings(value) {
+  const input = record(value);
+  if (input.version !== 1 || !['ready', 'unavailable'].includes(input.state) || Object.keys(record(input.sections)).some(name => !WEBSITE_SECTIONS.includes(name))) throw Error('Invalid website settings');
+  const sections = {};
+  for (const name of WEBSITE_SECTIONS) {
+    const section = record(record(input.sections)[name]);
+    if (!states.has(section.state) || !Number.isSafeInteger(section.version) || section.version < 0 || (section.state === 'ready' && (!section.data || Array.isArray(section.data) || typeof section.data !== 'object'))) throw Error('Invalid website settings');
+    // Never retain data after an access denial or failed read.
+    sections[name] = { state: section.state, version: section.version, ...(section.state === 'ready' && input.state === 'ready' ? { data: section.data } : {}) };
+  }
+  return { version: 1, state: input.state, sections };
+}
+export function sectionData(settings, name) {
+  const section = record(record(record(settings).sections)[name]);
+  return record(settings).state === 'ready' && section.state === 'ready' ? record(section.data) : null;
+}
+export function publicHref(value, { mail = false, relative = true } = {}) {
+  if (typeof value !== 'string' || !value || value.length > 2048 || /[\s\\\u0000-\u001f\u007f]|%(?:0[0-9a-f]|1[0-9a-f]|7f|5c)/i.test(value)) return null;
+  if (mail && /^mailto:/i.test(value)) {
+    const address = value.slice(7);
+    if (address.length > 254 || /[?#%,;]/.test(address)) return null;
+    const [local, domain, extra] = address.split('@');
+    return !extra && local?.length <= 64 && /^[A-Za-z0-9!$&'*+/=^_`{|}~-]+(?:\.[A-Za-z0-9!$&'*+/=^_`{|}~-]+)*$/.test(local) && /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$/.test(domain ?? '') ? `mailto:${address}` : null;
+  }
+  if (relative && (/^\/(?!\/)/.test(value) || /^#[a-zA-Z0-9_-]+$/.test(value))) {
+    if (/(?:^|\/)(?:\.|\.\.)(?:\/|$)/.test(value) || /%2[ef]/i.test(value)) return null;
+    return value;
+  }
+  try {
+    const url = new URL(value);
+    return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password ? url.href : null;
+  } catch { return null; }
+}
+function link(value) {
+  const row = record(value), url = publicHref(row.url), label = text(row.label, 80);
+  return url && label ? { label, url } : null;
+}
+export function navigationLinks(settings, location, originalLinks = [], excludeUrls = []) {
+  const original = (Array.isArray(originalLinks) ? originalLinks : []).slice(0, 200).map(link).filter(Boolean);
+  const nativeUrls = new Set([...original.map(item => item.url), ...(Array.isArray(excludeUrls) ? excludeUrls.slice(0, 200).map(value => publicHref(value)).filter(Boolean) : [])]);
+  const data = sectionData(settings, 'navigation'), saved = data && Array.isArray(data[location]) ? data[location].slice(0, 40) : [];
+  const extra = saved.flatMap(value => {
+    const row = record(value), label = text(row.label, 80);
+    if (!label) return [];
+    const children = location === 'header' && Array.isArray(row.children) ? row.children.slice(0, 20).map(link).filter(item => item && !nativeUrls.has(item.url)) : [];
+    const direct = link(row);
+    if (Array.isArray(row.children) && row.children.length) return children.length ? [{ label, ...(direct && !nativeUrls.has(direct.url) ? { url: direct.url } : {}), children }] : [];
+    return direct && !nativeUrls.has(direct.url) ? [direct] : [];
+  });
+  return [...original, ...extra];
+}
+function locale(value) { try { return typeof value === 'string' && value.length <= 35 ? Intl.getCanonicalLocales(value)[0] : null; } catch { return null; } }
+export function languageLinks(settings, entry) {
+  const languages = sectionData(settings, 'languages');
+  if (!languages || !Array.isArray(languages.enabled)) return [];
+  const enabled = new Set(languages.enabled.map(locale).filter(Boolean)), current = record(entry), rows = [current, ...(Array.isArray(current.translations) ? current.translations.slice(0, 100) : [])], seen = new Set();
+  return rows.flatMap(value => {
+    const row = record(value), language = locale(row.locale), path = publicHref(row.path);
+    if (!language || !enabled.has(language) || !path?.startsWith('/') || seen.has(language)) return [];
+    seen.add(language); return [{ locale: language, path, title: text(row.title || record(row.document).title, 200), current: language === locale(current.locale) }];
+  });
+}
+export function experienceCopy(settings, language) {
+  const base = sectionData(settings, 'experience');
+  if (!base) return null;
+  const canonical = locale(language), translation = Array.isArray(base.translations) ? base.translations.find(value => locale(record(value).locale) === canonical) : null;
+  return { ...base, ...record(translation) };
+}
+export function consentPolicy(settings) {
+  const experience = sectionData(settings, 'experience');
+  if (!experience || experience.cookieConsentEnabled !== true) return null;
+  return { version: text(experience.consentVersion, 80) || '1', maxAgeDays: Number.isInteger(experience.consentMaxAgeDays) && experience.consentMaxAgeDays >= 1 && experience.consentMaxAgeDays <= 365 ? experience.consentMaxAgeDays : 180 };
+}
+export function parseConsent(value, policy, now = Date.now()) {
+  if (!policy || typeof value !== 'string' || value.length > 1024) return null;
+  try {
+    const parsed = record(JSON.parse(value));
+    if (parsed.version !== policy.version || typeof parsed.analytics !== 'boolean' || typeof parsed.marketing !== 'boolean' || !Number.isSafeInteger(parsed.savedAt) || !Number.isSafeInteger(parsed.expiresAt) || parsed.savedAt > now || parsed.expiresAt <= now || parsed.expiresAt <= parsed.savedAt || parsed.expiresAt - parsed.savedAt > policy.maxAgeDays * 86400000 || now - parsed.savedAt >= policy.maxAgeDays * 86400000) return null;
+    return { version: parsed.version, analytics: parsed.analytics, marketing: parsed.marketing, savedAt: parsed.savedAt, expiresAt: parsed.expiresAt };
+  } catch { return null; }
+}
+export function createConsent(policy, choices, now = Date.now()) {
+  if (!policy) return null;
+  return { version: policy.version, analytics: choices.analytics === true, marketing: choices.marketing === true, savedAt: now, expiresAt: now + policy.maxAgeDays * 86400000 };
+}
+/** Configuration only: never accepts inline text, event handlers or arbitrary attributes. */
+export function scriptDescriptors(settings, decision, privacySignal = false, now = Date.now()) {
+  const policy = consentPolicy(settings), consent = parseConsent(JSON.stringify(decision), policy, now), result = [];
+  const scripts = sectionData(settings, 'scripts');
+  for (const value of Array.isArray(scripts?.entries) ? scripts.entries.slice(0, 20) : []) {
+    const row = record(value), src = publicHref(row.src, { relative: false });
+    if (row.enabled !== true || !src || !['head', 'body'].includes(row.placement) || !['essential', 'analytics', 'marketing'].includes(row.category)) continue;
+    if (row.category !== 'essential' && (privacySignal || consent?.[row.category] !== true)) continue;
+    result.push({ src, placement: row.placement, category: row.category, provider: 'external', attributes: {} });
+  }
+  const analytics = sectionData(settings, 'analytics');
+  const experienceState = settings?.sections?.experience?.state;
+  const policyKnown = experienceState === 'ready' || experienceState === 'missing';
+  if (analytics && !privacySignal && (consent?.analytics === true || analytics.requireConsent === false && policyKnown && !policy)) {
+    const google = text(analytics.googleMeasurementId, 50), clarity = text(analytics.clarityProjectId, 50), domain = text(analytics.plausibleDomain, 253), matomo = publicHref(analytics.matomoUrl, { relative: false }), site = text(analytics.matomoSiteId, 20);
+    if (/^G-[A-Z0-9]+$/.test(google)) result.push({ src: `https://www.googletagmanager.com/gtag/js?id=${google}`, placement: 'head', category: 'analytics', provider: 'google', id: google, attributes: {} });
+    if (/^[a-zA-Z0-9]+$/.test(clarity)) result.push({ src: `https://www.clarity.ms/tag/${clarity}`, placement: 'head', category: 'analytics', provider: 'clarity', id: clarity, attributes: {} });
+    if (/^(?=.{1,253}$)(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\.)+[A-Za-z]{2,63}$/.test(domain)) result.push({ src: 'https://plausible.io/js/script.js', placement: 'head', category: 'analytics', provider: 'plausible', attributes: { 'data-domain': domain } });
+    if (matomo && /^\d+$/.test(site) && !new URL(matomo).search && !new URL(matomo).hash) { const base = matomo.replace(/\/?$/, '/'); result.push({ src: `${base}matomo.js`, placement: 'head', category: 'analytics', provider: 'matomo', id: site, tracker: `${base}matomo.php`, attributes: {} }); }
+  }
+  const seen = new Set(); return result.filter(item => { if (seen.has(item.src)) return false; seen.add(item.src); return true; });
+}
+export function pagePresentation(settings, entry) {
+  const row = record(entry), templates = sectionData(settings, 'templates'), template = record(templates?.[row.kind === 'post' ? 'post' : 'page']);
+  const seo = record(row.seo), image = record(seo.featuredImage), authors = sectionData(settings, 'authors'), taxonomies = sectionData(settings, 'taxonomies');
+  const author = authors && Array.isArray(authors.entries) ? authors.entries.find(value => record(value).id === (record(row.author).id || seo.authorId)) : null;
+  const terms = name => taxonomies && Array.isArray(taxonomies[name]) && Array.isArray(row[name]) ? row[name].slice(0, 100).flatMap(value => { const term = record(value), saved = taxonomies[name].find(item => record(item).id === term.id), path = publicHref(term.path); return saved && path?.startsWith('/') ? [{ id: text(term.id, 80), name: text(record(saved).name, 80), path }] : []; }) : [];
+  return { layout: ['standard', 'narrow', 'wide'].includes(template.layout) ? template.layout : 'standard', showFeaturedImage: template.showFeaturedImage === true, featuredImage: { url: publicHref(image.url, { relative: false }), alt: text(image.alt, 300) }, showTableOfContents: template.showTableOfContents === true, showBreadcrumbs: template.showBreadcrumbs === true, showShare: template.showShare === true, showRelated: template.showRelated === true, showDate: template.showDate === true, author: template.showAuthor === true && author ? { id: text(author.id, 80), name: text(author.name, 100), bio: text(author.bio, 1000), jobTitle: text(author.jobTitle, 100), avatarUrl: publicHref(author.avatarUrl, { relative: false }), url: publicHref(author.url) } : null, categories: terms('categories'), tags: terms('tags') };
+}
+export function websiteJsonLd(settings, entry, { title, description, canonical, image } = {}) {
+  if (!sectionData(settings, 'seo')) return null;
+  const row = record(entry), schema = record(record(row.seo).schema), templates = sectionData(settings, 'templates');
+  const kind = schema.type && schema.type !== 'none' ? schema.type : record(templates?.[row.kind]).schemaType;
+  if (kind === 'custom') {
+    const value = record(schema.json), serialized = JSON.stringify(value);
+    return Object.keys(value).length && serialized.length <= 20000 && !/<\/?script/i.test(serialized) ? value : null;
+  }
+  if (!['WebPage', 'Article', 'BlogPosting', 'NewsArticle', 'FAQPage', 'HowTo', 'Product', 'Organization'].includes(kind)) return null;
+  const data = { '@context': 'https://schema.org', '@type': kind, name: text(title, 500), description: text(description, 2000), ...(canonical && publicHref(canonical, { relative: false }) ? { url: canonical } : {}), ...(image && publicHref(image, { relative: false }) ? { image } : {}) };
+  const authors = sectionData(settings, 'authors'), author = Array.isArray(authors?.entries) ? authors.entries.find(item => record(item).id === (record(row.author).id || record(row.seo).authorId)) : null;
+  if (author) data.author = { '@type': 'Person', name: text(author.name, 100), ...(publicHref(author.url) ? { url: author.url } : {}) };
+  return data;
+}
+/** Stream bound and abort-aware so a stalled body cannot keep old settings active. */
+export async function readWebsiteJson(response, signal, limit = 2 * 1024 * 1024) {
+  if (response.status !== 200 || response.redirected || !/^application\/json(?:;|$)/i.test(response.headers.get('content-type') ?? '') || Number(response.headers.get('content-length')) > limit || !response.body) throw Error('Website response unavailable');
+  const reader = response.body.getReader(), chunks = []; let size = 0;
+  const abort = () => { void reader.cancel().catch(() => {}); };
+  signal?.addEventListener('abort', abort, { once: true });
+  try {
+    while (true) {
+      if (signal?.aborted) throw Error('Website response canceled');
+      const { done, value } = await reader.read();
+      if (signal?.aborted) throw Error('Website response canceled');
+      if (done) break;
+      size += value.byteLength; if (size > limit) throw Error('Website response too large'); chunks.push(value);
+    }
+    const bytes = new Uint8Array(size); let offset = 0;
+    for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } finally { signal?.removeEventListener('abort', abort); await reader.cancel().catch(() => {}); reader.releaseLock(); }
+}

package/dist/website-next.d.mts

@@ -0,0 +1,2 @@
+import type { WebsiteSection } from './website-runtime.mjs';
+export function createNextWebsiteProxy(options: {configuration:unknown;sourceConfiguration?:unknown;contentBindings?:unknown;env?:Record<string,string|undefined>;fetcher?:typeof fetch;nativePathPrefixes?:string[];installedSections?:readonly WebsiteSection[]}): (request:Request)=>Promise<{response?:Response;requestHeaders:Headers;headers:Readonly<Record<string,string>>}>;

package/dist/website-next.mjs

@@ -0,0 +1,29 @@
+import { createWebsiteRequestHandler } from './website-http.mjs';
+import { createNextPublicationProxy, nextPublicationPath } from './next-publication.mjs';
+/** Compose settings/new public routes ahead of the original publication guard. */
+export function createNextWebsiteProxy(options) {
+  const website=createWebsiteRequestHandler(options),publication=createNextPublicationProxy(options);
+  return async request=>{
+    let target=request,layoutPath=null;
+    try {
+      const url=new URL(request.url),pathname=nextPublicationPath(url.pathname,options.configuration.routes.some(route=>route.path==='/index'));
+      layoutPath=encodeURIComponent(pathname);
+      if(pathname!==url.pathname){url.pathname=pathname;target=new Request(url,request);}
+    }catch{/* The original guard retains invalid-path rejection. */}
+    const result=await website(target);
+    if(result instanceof Response){
+      // Next's proxy transport requires an absolute Location, including when
+      // the saved CMS redirect deliberately stays within this website.
+      if([301,302,307,308].includes(result.status)&&result.headers.get('location')?.startsWith('/'))result.headers.set('Location',new URL(result.headers.get('location'),options.configuration.websiteOrigin).href);
+      return {response:result,requestHeaders:new Headers(),headers:{}};
+    }
+    if(result?.pass){const cleaned=new Headers(request.headers);for(const name of [...cleaned.keys()])if(/^(x-universalcms-|x-cms-publication|x-middleware-subrequest$)/i.test(name))cleaned.delete(name);if(layoutPath!==null)cleaned.set('x-universalcms-layout-path',layoutPath);return {requestHeaders:cleaned,headers:{'Cache-Control':'private, no-store, max-age=0','CDN-Cache-Control':'no-store','Vercel-CDN-Cache-Control':'no-store'}};}
+    const checked=await publication(request);
+    // The root layout cannot obtain its pathname from route params. Supply it
+    // only after the proxy has removed all incoming integration headers and
+    // retained the actual normalized request path. This is display context;
+    // runtime.page still enforces current publication and native ownership.
+    if(!checked.response&&layoutPath!==null)checked.requestHeaders.set('x-universalcms-layout-path',layoutPath);
+    return checked;
+  };
+}

package/dist/website-node.d.mts

@@ -0,0 +1,3 @@
+export function universalCmsWebsite(options:{configuration:unknown;sourceConfiguration?:unknown;contentBindings?:unknown}):unknown;
+export function createWebsiteServer(options:{root:string;configuration:unknown;sourceConfiguration?:unknown;contentBindings?:unknown;env?:Record<string,string|undefined>;fetcher?:typeof fetch}): import('node:http').Server;
+export function readWebsiteHtml(root:string,built?:boolean):Promise<string>;

package/dist/website-node.mjs

@@ -0,0 +1,50 @@
+import { constants } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { createServer } from 'node:http';
+import { createWebsiteRequestHandler } from './website-http.mjs';
+import { readServerEnvironment } from './vite-publication.mjs';
+import { createVitePublicationServer } from './vite-publication-server.mjs';
+const stamp=stat=>[stat.dev,stat.ino,stat.size,stat.mtimeMs,stat.ctimeMs,stat.nlink].join(':');
+export async function readWebsiteHtml(root,built=false) {
+  const actual=await realpath(root);let filename=actual;
+  for(const part of built?['dist','index.html']:['index.html']) {
+    filename=path.join(filename,part);const stat=await lstat(filename);
+    if(stat.isSymbolicLink()||await realpath(filename)!==filename||(part==='index.html'? !stat.isFile()||stat.nlink!==1:!stat.isDirectory())) throw Error('Invalid website HTML');
+  }
+  const file=await open(filename,constants.O_RDONLY|constants.O_NOFOLLOW);
+  try {
+    const before=await file.stat();
+    if(!before.isFile()||before.nlink!==1||before.size>2*1024*1024)throw Error('Invalid website HTML');
+    // Allocate only the measured, bounded size. An append during the read must
+    // fail the final stamp check rather than grow an unbounded readFile buffer.
+    const body=Buffer.alloc(before.size);let size=0;
+    while(size<body.length){const read=await file.read(body,size,body.length-size,size);if(!read.bytesRead)break;size+=read.bytesRead;}
+    if(size!==before.size||stamp(before)!==stamp(await file.stat())||stamp(before)!==stamp(await lstat(filename)))throw Error('Website HTML changed');
+    return new TextDecoder('utf-8',{fatal:true}).decode(body);
+  }finally{await file.close();}
+}
+export function createWebsiteNodeHandler({root,configuration,sourceConfiguration,contentBindings,env,fetcher,renderHtml}) {
+  const handle=createWebsiteRequestHandler({configuration,sourceConfiguration,contentBindings,env:env??(()=>readServerEnvironment(root)),fetcher,renderHtml});
+  return async(request,response)=>{
+    if(!request.url?.startsWith('/')||request.url.startsWith('//')||/[\\\s#]|%(?:2e|2f|5c|25|3f|23)/i.test(request.url.split('?')[0])||request.headers.host!==new URL(configuration.websiteOrigin).host) {
+      response.writeHead(400,{'Cache-Control':'no-store'});response.end();return true;
+    }
+    const result=await handle(new Request(new URL(request.url,configuration.websiteOrigin),{method:request.method,headers:new Headers(Object.entries(request.headers).flatMap(([name,value])=>value===undefined?[]:[[name,Array.isArray(value)?value.join(', '):value]]))}));
+    if(!result||result.pass)return false;
+    response.writeHead(result.status,Object.fromEntries(result.headers));response.end(Buffer.from(await result.arrayBuffer()));return true;
+  };
+}
+export function universalCmsWebsite({configuration,sourceConfiguration,contentBindings}) {
+  let root;
+  function install(server,built) {
+    const handler=createWebsiteNodeHandler({root,configuration,sourceConfiguration,contentBindings,renderHtml:async pathname=>{const html=await readWebsiteHtml(root,built);return built?html:server.transformIndexHtml(pathname,html);}});
+    server.middlewares.use((request,response,next)=>{void handler(request,response).then(handled=>{if(!handled)next();},()=>{if(!response.writableEnded){response.writeHead(503,{'Cache-Control':'no-store'});response.end('Website unavailable');}});});
+  }
+  return {name:'universalcms-website-settings',enforce:'pre',configResolved(config){root=config.root;},configureServer(server){install(server,false);},configurePreviewServer(server){install(server,true);}};
+}
+export function createWebsiteServer(options) {
+  const original=createVitePublicationServer(options);
+  const handler=createWebsiteNodeHandler({...options,renderHtml:()=>readWebsiteHtml(options.root,true)});
+  return createServer({requestTimeout:15000,headersTimeout:10000,maxHeaderSize:8192},(request,response)=>{void handler(request,response).then(handled=>{if(!handled)original.emit('request',request,response);},()=>{if(!response.writableEnded){response.writeHead(503,{'Cache-Control':'no-store'});response.end('Website unavailable');}});});
+}

package/dist/website-runtime.d.mts

@@ -0,0 +1,13 @@
+import type { PublicationConfiguration, PublishedDocumentEntry } from './publication.mjs';
+export type WebsiteSection = 'branding' | 'social' | 'seo' | 'languages' | 'analytics' | 'navigation' | 'experience' | 'scripts' | 'redirects' | 'authors' | 'templates' | 'taxonomies';
+export const websiteSections: readonly WebsiteSection[];
+export type WebsiteSectionState = { state: 'ready' | 'missing' | 'denied' | 'unavailable'; version: number; data?: Record<string, unknown> };
+export type WebsiteSnapshot = { version: 1; state: 'ready' | 'unavailable'; sections: Record<WebsiteSection, WebsiteSectionState> };
+export type WebsiteEntry = PublishedDocumentEntry & { path: string; canonicalUrl?: string; seo?: Record<string, unknown>; author?: Record<string, unknown> | null; categories?: Array<{ id: string; name: string; slug: string; path: string }>; tags?: Array<{ id: string; name: string; slug: string; path: string }>; translations?: Array<{ id: string; locale: string; path: string; title: string }> };
+export type WebsiteSummary = { id: string; kind: string; slug: string; locale: string; path: string; title: string; excerpt: string; publishedAt: string };
+export type WebsiteResult = { state: 'published'; status: 200; path: string; entry: WebsiteEntry; revision: string; related: WebsiteSummary[] } | { state: 'archive'; status: 200; kind: 'category' | 'tag'; path: string; title: string; description: string; entries: WebsiteEntry[] } | { state: 'redirect'; status: 301 | 302 | 307 | 308; path: string; location: string } | { state: 'gone'; status: 410; path: string } | { state: 'missing' | 'unmanaged' | 'unavailable'; status: 200 | 404 | 503 };
+export type WebsiteRuntimeOptions = { configuration: PublicationConfiguration; env?: Record<string, string | undefined> | (() => Record<string, string | undefined> | Promise<Record<string, string | undefined>>); fetcher?: typeof fetch; nativePaths?: string[]; nativePatterns?: string[]; nativePathPrefixes?: string[]; installedSections?: readonly WebsiteSection[]; timeoutMs?: number; maxResponseBytes?: number; maxConcurrent?: number };
+export type WebsiteSeoResponse = { state: 'missing' | 'denied' | 'unavailable' };
+export function createWebsiteRuntime(options: WebsiteRuntimeOptions): { settings(): Promise<WebsiteSnapshot>; resolve(pathname: string): Promise<WebsiteResult>; page(pathname: string): Promise<WebsiteResult>; sitemap(): Promise<WebsiteSeoResponse | { state: 'ready'; enabled: boolean; canonicalBase: string; entries: Array<{ url: string; path: string; lastModified: string; locale: string }> }>; robots(): Promise<WebsiteSeoResponse | { state: 'ready'; body: string }> };
+export type WebsiteMetadata = { title: string; description: string; canonical?: string; robots: { index: boolean; follow: boolean }; openGraph?: { title: string; description: string; type: string; url?: string; image?: string; imageAlt?: string }; twitter?: { card: string; site?: string }; alternates?: Array<{ locale: string; url: string }>; jsonLd?: Record<string, unknown> };
+export function websiteMetadata(entry: PublishedDocumentEntry | WebsiteEntry | null, snapshot: WebsiteSnapshot, pathname: string, websiteOrigin?: string): WebsiteMetadata;