@marktiderman/genesis-sites 0.0.0-stage → 0.2.0

package/dist/chunk-ZGWGQGT2.js

@@ -0,0 +1,595 @@
+import { MAX_URL_LENGTH, isSafeHref, isSafeImageSrc, PAGE_PATH } from './chunk-3VKTBE7S.js';
+import { z } from 'zod';
+
+if (typeof z.toJSONSchema !== "function") {
+  throw new Error("@marktiderman/genesis-sites needs zod 4 (zod@^4.0.0): z.toJSONSchema is missing.");
+}
+var Href = z.string().max(MAX_URL_LENGTH).refine(isSafeHref, { message: "Use a site path (/about), a #section, or an https, mailto or tel link." }).meta({ title: "Link", format: "uri-reference" });
+var LinkEvent = z.string().regex(/^[a-z0-9][a-z0-9_.:-]{0,47}$/, "An event name is lowercase letters, digits and _ . : -").meta({ title: "Analytics event" });
+var Link = z.object({
+  label: z.string().trim().min(1).max(80),
+  href: Href,
+  /** Opens in a new tab (http(s) links only). The same as `target: "_blank"`. */
+  newTab: z.boolean().optional(),
+  /** Where an http(s) link opens: this tab (`_self`, the default) or a new one (`_blank`). */
+  target: z.enum(["_self", "_blank"]).optional().meta({ title: "Opens in" }),
+  /** A link that leaves the site (a booking system): http(s) only, `rel="noopener noreferrer"`. */
+  external: z.boolean().optional().meta({ title: "Outbound link" }),
+  event: LinkEvent.optional()
+}).refine((link) => !link.external || /^https?:\/\//i.test(link.href), { message: "An outbound link is an http(s) URL.", path: ["href"] }).meta({ title: "Link" });
+var opensInNewTab = (link) => /^https?:\/\//i.test(link.href) && (link.target === "_blank" || link.target === void 0 && link.newTab === true);
+var FileRef = z.object({
+  src: z.string().max(MAX_URL_LENGTH).refine(isSafeImageSrc, { message: "A file loads from a site path or an https URL." }),
+  /** The file's type; PDF unless it is an image. */
+  mime: z.enum(["application/pdf", "image/png", "image/jpeg", "image/webp", "image/avif", "image/gif"]).default("application/pdf"),
+  /** Its size, shown beside the link ("PDF, 1.2 MB"). */
+  bytes: z.number().int().positive().max(100 * 1024 * 1024).optional()
+}).meta({ title: "File", "x-genesis-kind": "file" });
+var Image = z.object({
+  src: z.string().max(MAX_URL_LENGTH).refine(isSafeImageSrc, { message: "An image loads from a site path or an https URL." }),
+  alt: z.string().max(300).default(""),
+  decorative: z.boolean().optional(),
+  width: z.number().int().positive().max(1e4).optional(),
+  height: z.number().int().positive().max(1e4).optional(),
+  /** Where the subject is, for cropping: 0–100 from the left and top. */
+  focal: z.object({ x: z.number().min(0).max(100), y: z.number().min(0).max(100) }).optional()
+}).meta({ title: "Image", "x-genesis-kind": "image" });
+var RichText = z.object({
+  type: z.literal("doc"),
+  content: z.array(z.record(z.string(), z.unknown())).max(2e3).optional()
+}).meta({ title: "Rich text", "x-genesis-kind": "rich-text" });
+var Surface = z.enum(["base", "muted", "accent", "inverse"]).meta({ title: "Background" });
+var Line = (max = 120) => z.string().trim().min(1).max(max);
+var Copy = (max = 600) => z.string().trim().max(max);
+var SectionId = z.string().regex(/^[A-Za-z0-9_-]{1,64}$/, "A section id is 1\u201364 letters, digits, - or _.");
+var SectionNode = z.object({
+  id: SectionId,
+  /** The section's registry key, such as `hero`. */
+  type: z.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+  /** The props version the props were written at; `migrateNode` brings them up to date. */
+  v: z.number().int().min(1),
+  variant: z.string().max(64).optional(),
+  /** Kept in the page, not rendered (Shopify's `disabled`). */
+  hidden: z.boolean().optional(),
+  /** Hidden on phones or on wider screens. */
+  hideOn: z.array(z.enum(["mobile", "desktop"])).max(2).optional(),
+  /**
+   * Set by a template on content someone must replace (a sample quote). The
+   * publish check refuses a visible section that still has it; the editor
+   * clears it once the section is edited.
+   */
+  placeholder: z.boolean().optional(),
+  props: z.record(z.string(), z.unknown())
+});
+var Seo = z.object({
+  title: z.string().trim().max(70).optional(),
+  description: z.string().trim().max(200).optional(),
+  ogImage: Image.optional(),
+  /** An absolute canonical URL, when this page's content lives elsewhere. */
+  canonical: z.url({ protocol: /^https?$/ }).max(MAX_URL_LENGTH).optional(),
+  noindex: z.boolean().optional()
+});
+var PageDoc = z.object({
+  schemaVersion: z.literal(1),
+  root: z.object({
+    props: z.looseObject({
+      title: z.string().trim().min(1).max(120),
+      /** Leave out the site's header and footer (a focused landing page). */
+      hideSiteChrome: z.boolean().optional()
+    })
+  }),
+  content: z.array(SectionNode).max(60),
+  seo: Seo.optional()
+});
+var PageKind = z.enum(["page", "landing", "post"]);
+var PagePath = z.string().max(200).regex(PAGE_PATH, 'A page path looks like "/" or "/about".');
+var MenuItem = z.object({
+  label: z.string().trim().min(1).max(40),
+  href: Href
+});
+var Redirect = z.object({
+  from: PagePath,
+  to: Href,
+  status: z.union([z.literal(301), z.literal(302)])
+});
+var FontChoice = z.enum([
+  "system",
+  "inter",
+  "dm-sans",
+  "work-sans",
+  "montserrat",
+  "poppins",
+  "space-grotesk",
+  "source-serif",
+  "merriweather",
+  "playfair-display",
+  "lora"
+]);
+var TokenOverrides = z.object({
+  radius: z.enum(["none", "sm", "md", "lg", "full"]).optional(),
+  headingFont: FontChoice.optional(),
+  bodyFont: FontChoice.optional()
+});
+var SeoDefaults = z.object({
+  /** `%s` is the page's title: `"%s · Riverside Gym"`. */
+  titleTemplate: z.string().max(80).optional(),
+  description: z.string().trim().max(200).optional(),
+  ogImage: Image.optional(),
+  /** Organization facts for JSON-LD. */
+  organization: z.object({
+    name: z.string().trim().min(1).max(120),
+    logo: z.string().max(MAX_URL_LENGTH).refine(isSafeImageSrc).optional(),
+    sameAs: z.array(z.url({ protocol: /^https$/ }).max(MAX_URL_LENGTH)).max(10).optional()
+  }).optional(),
+  noindex: z.boolean().optional()
+});
+var SiteDoc = z.object({
+  schemaVersion: z.literal(1),
+  name: z.string().trim().min(1).max(120),
+  /** BCP 47 language of the site's pages. */
+  lang: z.string().regex(/^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/).default("en"),
+  theme: z.object({
+    colorScheme: z.enum(["light", "dark", "auto"]).default("light"),
+    overrides: TokenOverrides.optional()
+  }).default({ colorScheme: "light" }),
+  /** The site's header: usually one `nav` section. */
+  header: z.array(SectionNode).max(2).default([]),
+  /** The header's menu. */
+  nav: z.array(MenuItem).max(12).default([]),
+  /** The site's footer: usually one `footer` section. */
+  footer: z.array(SectionNode).max(3).default([]),
+  seo: SeoDefaults.default({}),
+  redirects: z.array(Redirect).max(500).default([])
+});
+var ReleasePage = z.object({
+  id: z.string().min(1),
+  path: PagePath,
+  kind: PageKind,
+  doc: PageDoc
+});
+var ReleaseSnapshot = z.object({
+  schemaVersion: z.literal(1),
+  site: SiteDoc,
+  pages: z.array(ReleasePage).max(500)
+});
+function parseSnapshot(value, report = (m) => console.error(`[genesis-sites] ${m}`)) {
+  const raw = value && typeof value === "object" ? value : {};
+  if (raw.schemaVersion !== 1) {
+    report("the snapshot isn't schemaVersion 1.");
+    return null;
+  }
+  const site = SiteDoc.safeParse(raw.site);
+  if (!site.success) {
+    report(`the snapshot's site document doesn't parse: ${site.error.message}`);
+    return null;
+  }
+  const pages = [];
+  for (const page of Array.isArray(raw.pages) ? raw.pages.slice(0, 500) : []) {
+    const parsed = ReleasePage.safeParse(page);
+    if (parsed.success) pages.push(parsed.data);
+    else report(`the page ${JSON.stringify(page?.path ?? "?")} doesn't parse and is left out: ${parsed.error.message}`);
+  }
+  return { schemaVersion: 1, site: site.data, pages };
+}
+var MAX_DOC_BYTES = 512 * 1024;
+var SECTION_CATEGORIES = ["header", "intro", "content", "social-proof", "conversion", "footer"];
+var SectionDefinitionError = class extends Error {
+  constructor(problems) {
+    super(`Invalid section definition:
+${problems.map((p) => `  - ${p}`).join("\n")}`);
+    this.problems = problems;
+    this.name = "SectionDefinitionError";
+  }
+  problems;
+};
+var TYPE = /^[a-z][a-z0-9-]{0,63}$/;
+function definitionProblems(def) {
+  const problems = [];
+  if (!def || typeof def !== "object") return ["a section definition is an object"];
+  const at = typeof def.type === "string" ? `"${def.type}"` : "a section";
+  if (typeof def.type !== "string" || !TYPE.test(def.type)) problems.push(`${at}: \`type\` is lowercase letters, digits and -`);
+  if (!Number.isInteger(def.version) || def.version < 1) problems.push(`${at}: \`version\` is a whole number from 1`);
+  if (typeof def.label !== "string" || !def.label.trim()) problems.push(`${at}: needs a \`label\``);
+  if (!SECTION_CATEGORIES.includes(def.category)) problems.push(`${at}: \`category\` is one of ${SECTION_CATEGORIES.join(", ")}`);
+  if (!def.schema || typeof def.schema.safeParse !== "function") problems.push(`${at}: \`schema\` is a zod schema`);
+  if (typeof def.render !== "function") problems.push(`${at}: \`render\` is a function`);
+  const ids = /* @__PURE__ */ new Set();
+  if (!Array.isArray(def.variants) || def.variants.length === 0) problems.push(`${at}: needs at least one variant`);
+  else
+    for (const v of def.variants) {
+      if (!v || typeof v.id !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(v.id) || typeof v.label !== "string") problems.push(`${at}: a variant is { id, label }`);
+      else if (ids.has(v.id)) problems.push(`${at}: variant "${v.id}" is listed twice`);
+      else ids.add(v.id);
+    }
+  if (!ids.has(def.defaultVariant)) problems.push(`${at}: \`defaultVariant\` "${String(def.defaultVariant)}" is not one of its variants`);
+  if (def.limit !== void 0 && (!Number.isInteger(def.limit) || def.limit < 1)) problems.push(`${at}: \`limit\` is a whole number from 1`);
+  if (def.placement !== void 0 && !["header", "body", "footer"].includes(def.placement)) problems.push(`${at}: \`placement\` is header, body or footer`);
+  if (def.frameOrigins !== void 0 && typeof def.frameOrigins !== "function") problems.push(`${at}: \`frameOrigins\` is a function`);
+  for (const [key, fn] of Object.entries(def.migrations ?? {})) {
+    const n = Number(key);
+    if (!Number.isInteger(n) || n < 2 || n > def.version) problems.push(`${at}: migration ${key} must be between 2 and the version (${def.version})`);
+    if (typeof fn !== "function") problems.push(`${at}: migration ${key} is a function`);
+  }
+  for (let n = 2; n <= (Number.isInteger(def.version) ? def.version : 0); n++) {
+    if (!def.migrations?.[n]) problems.push(`${at}: version ${def.version} needs a migration to ${n}`);
+  }
+  if (!Array.isArray(def.presets) || def.presets.length === 0) problems.push(`${at}: needs at least one preset (the editor's Add picker)`);
+  else if (def.schema && typeof def.schema.safeParse === "function")
+    for (const preset of def.presets) {
+      if (!preset || typeof preset.name !== "string" || !ids.has(preset.variant)) {
+        problems.push(`${at}: preset ${JSON.stringify(preset?.name)} needs a name and one of its variants`);
+        continue;
+      }
+      const parsed = def.schema.safeParse(preset.props);
+      if (!parsed.success) problems.push(`${at}: preset "${preset.name}" doesn't match the schema: ${parsed.error.issues.map((i) => `${i.path.join(".") || "props"} ${i.message}`).join("; ")}`);
+    }
+  return problems;
+}
+function defineSection(def) {
+  const problems = definitionProblems(def);
+  if (problems.length) throw new SectionDefinitionError(problems);
+  return Object.freeze({
+    ...def,
+    variants: Object.freeze(def.variants.map((v) => Object.freeze({ ...v }))),
+    presets: Object.freeze(def.presets.map((p) => Object.freeze({ ...p }))),
+    ...def.enabledOn ? { enabledOn: Object.freeze([...def.enabledOn]) } : {},
+    ...def.migrations ? { migrations: Object.freeze({ ...def.migrations }) } : {}
+  });
+}
+var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-sites/sections@1");
+var BUILT_IN = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-sites/built-in-sections@1");
+var scope = globalThis;
+var registry = scope[REGISTRY] ??= /* @__PURE__ */ new Map();
+var builtIns = scope[BUILT_IN] ??= /* @__PURE__ */ new Set();
+var BUILT_IN_SECTION_TYPES = Object.freeze([
+  "nav",
+  "hero",
+  "features",
+  "cta",
+  "testimonials",
+  "faq",
+  "pricing",
+  "logos",
+  "stats",
+  "gallery",
+  "rich-text",
+  "form-embed",
+  "footer",
+  "schedule",
+  "team",
+  "blog-list",
+  "post-body",
+  "map",
+  "timeline",
+  "file"
+]);
+function registerSection(def, options = {}) {
+  const frozen = Object.isFrozen(def) && definitionProblems(def).length === 0 ? def : defineSection(def);
+  if (BUILT_IN_SECTION_TYPES.includes(frozen.type) && options.replace !== true) {
+    throw new Error(
+      `registerSection: "${frozen.type}" is a built-in section; pass { replace: true } to replace it for every site in this process.`
+    );
+  }
+  registry.set(frozen.type, frozen);
+}
+function registerBuiltInSection(def) {
+  if (!registry.has(def.type)) registry.set(def.type, def);
+  builtIns.add(def.type);
+}
+function getSection(type) {
+  return registry.get(type);
+}
+function listSections() {
+  return [...registry.values()];
+}
+function unregisterSection(type) {
+  if (BUILT_IN_SECTION_TYPES.includes(type)) throw new Error(`unregisterSection: "${type}" is built in; replace it with registerSection(\u2026, { replace: true }).`);
+  return registry.delete(type);
+}
+var jsonSchemas = /* @__PURE__ */ new WeakMap();
+function sectionJsonSchema(typeOrDef) {
+  const def = typeof typeOrDef === "string" ? registry.get(typeOrDef) : typeOrDef;
+  if (!def) throw new Error(`sectionJsonSchema: no section "${String(typeOrDef)}" is registered.`);
+  let schema = jsonSchemas.get(def.schema);
+  if (!schema) {
+    schema = z.toJSONSchema(def.schema, { io: "input", unrepresentable: "any" });
+    jsonSchemas.set(def.schema, schema);
+  }
+  return schema;
+}
+function sectionManifests() {
+  return listSections().map((def) => ({
+    type: def.type,
+    version: def.version,
+    label: def.label,
+    ...def.description ? { description: def.description } : {},
+    category: def.category,
+    placement: def.placement ?? "body",
+    variants: def.variants,
+    defaultVariant: def.defaultVariant,
+    presets: def.presets,
+    ...def.limit ? { limit: def.limit } : {},
+    ...def.enabledOn ? { enabledOn: def.enabledOn } : {},
+    jsonSchema: sectionJsonSchema(def)
+  }));
+}
+var counter = 0;
+function newSectionId(prefix = "s") {
+  counter = (counter + 1) % 1e6;
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${prefix}${Date.now().toString(36)}${counter.toString(36)}${random}`.slice(0, 64);
+}
+function nodeFromPreset(type, presetName, id = newSectionId(type.replace(/-/g, "").slice(0, 6))) {
+  const def = registry.get(type);
+  if (!def) throw new Error(`nodeFromPreset: no section "${type}" is registered.`);
+  const preset = presetName ? def.presets.find((p) => p.name === presetName) : def.presets[0];
+  if (!preset) throw new Error(`nodeFromPreset: "${type}" has no preset "${presetName}".`);
+  return { id, type, v: def.version, variant: preset.variant, props: structuredClone(preset.props) };
+}
+var PostSlug = z.string().max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "A post slug is lowercase letters, digits and single hyphens.");
+var PostAuthor = z.object({
+  name: Line(80),
+  /** Their page: a site path or an http(s) URL. */
+  url: Href.optional()
+});
+var PostDoc = z.object({
+  schemaVersion: z.literal(1),
+  title: Line(160),
+  /** A sentence or two for the list, search results and the feed. */
+  excerpt: Copy(400).optional(),
+  body: RichText,
+  cover: Image.optional(),
+  author: PostAuthor.optional(),
+  category: Line(60).optional(),
+  tags: z.array(Line(40)).max(12).optional(),
+  seo: Seo.optional()
+});
+var PostSummarySchema = z.object({
+  slug: PostSlug,
+  title: Line(160),
+  excerpt: Copy(400).optional(),
+  cover: Image.optional(),
+  author: PostAuthor.optional(),
+  category: Line(60).optional(),
+  noindex: z.boolean().optional(),
+  publishedAt: z.string().refine((s) => !Number.isNaN(Date.parse(s)), "a date"),
+  updatedAt: z.string().refine((s) => !Number.isNaN(Date.parse(s)), "a date")
+});
+var MAX_LIVE_POSTS = 500;
+var MAX_IMPORT_POSTS = 500;
+function postSummary(post) {
+  const d = post.doc;
+  return {
+    slug: post.slug,
+    title: d.title,
+    ...d.excerpt ? { excerpt: d.excerpt } : {},
+    ...d.cover ? { cover: d.cover } : {},
+    ...d.author ? { author: d.author } : {},
+    ...d.category ? { category: d.category } : {},
+    ...d.seo?.noindex || d.seo?.canonical ? { noindex: true } : {},
+    publishedAt: post.publishedAt,
+    updatedAt: post.updatedAt
+  };
+}
+function richTextPlain(value, max = 400) {
+  const out = [];
+  const walk = (node) => {
+    if (out.join(" ").length > max || !node || typeof node !== "object") return;
+    const n = node;
+    if (n.type === "text" && typeof n.text === "string") out.push(n.text);
+    if (Array.isArray(n.content)) n.content.forEach(walk);
+  };
+  walk(value);
+  const text = out.join(" ").replace(/\s+/g, " ").trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}\u2026` : text;
+}
+function validatePostSlug(slug) {
+  const parsed = PostSlug.safeParse(slug);
+  if (!parsed.success) throw new Error(`"${slug}": ${parsed.error.issues[0]?.message ?? "not a post slug"}`);
+  return slug;
+}
+
+// src/core/seo.ts
+function absoluteUrl(origin, basePath, path) {
+  const base = origin.replace(/\/+$/, "") + (basePath ?? "").replace(/\/+$/, "");
+  return path === "/" ? `${base}/` : `${base}${path}`;
+}
+function imageUrl(image, origin, basePath) {
+  if (!image) return void 0;
+  return image.src.startsWith("/") ? absoluteUrl(origin, basePath, image.src) : image.src;
+}
+function pageTitle(site, doc, _path) {
+  const own = doc.seo?.title?.trim();
+  if (own) return own;
+  const title = doc.root.props.title;
+  const template = site.seo.titleTemplate;
+  if (!template || !template.includes("%s")) return title;
+  return template.replace("%s", title);
+}
+function pageMeta({ site, page, origin, basePath = "", preview = false, article }) {
+  const doc = page.doc;
+  const title = pageTitle(site, doc, page.path);
+  const description = doc.seo?.description?.trim() || site.seo.description?.trim() || void 0;
+  const canonical = doc.seo?.canonical ?? absoluteUrl(origin, basePath, page.path);
+  const noindex = preview || site.seo.noindex === true || doc.seo?.noindex === true;
+  const image = doc.seo?.ogImage ?? site.seo.ogImage;
+  const img = imageUrl(image, origin, basePath);
+  const openGraph = {
+    "og:type": "website",
+    "og:title": title,
+    "og:url": canonical,
+    "og:site_name": site.name,
+    "og:locale": site.lang.replace("-", "_")
+  };
+  if (description) openGraph["og:description"] = description;
+  if (article) {
+    openGraph["og:type"] = "article";
+    openGraph["article:published_time"] = new Date(article.publishedTime).toISOString();
+    if (article.modifiedTime) openGraph["article:modified_time"] = new Date(article.modifiedTime).toISOString();
+    if (article.author) openGraph["article:author"] = article.author;
+    if (article.section) openGraph["article:section"] = article.section;
+  }
+  if (img) {
+    openGraph["og:image"] = img;
+    if (image?.alt) openGraph["og:image:alt"] = image.alt;
+    if (image?.width) openGraph["og:image:width"] = String(image.width);
+    if (image?.height) openGraph["og:image:height"] = String(image.height);
+  }
+  const twitter = { "twitter:card": img ? "summary_large_image" : "summary", "twitter:title": title };
+  if (description) twitter["twitter:description"] = description;
+  if (img) twitter["twitter:image"] = img;
+  return {
+    title,
+    ...description ? { description } : {},
+    canonical,
+    robots: noindex ? "noindex, nofollow" : "index, follow",
+    openGraph,
+    twitter
+  };
+}
+function organizationJsonLd(site, origin, basePath = "") {
+  const org = site.seo.organization;
+  const out = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: org?.name ?? site.name,
+    url: absoluteUrl(origin, basePath, "/")
+  };
+  if (org?.logo) out.logo = org.logo.startsWith("/") ? absoluteUrl(origin, basePath, org.logo) : org.logo;
+  if (org?.sameAs?.length) out.sameAs = org.sameAs;
+  return out;
+}
+function websiteJsonLd(site, origin, basePath = "") {
+  return {
+    "@context": "https://schema.org",
+    "@type": "WebSite",
+    name: site.name,
+    url: absoluteUrl(origin, basePath, "/"),
+    inLanguage: site.lang
+  };
+}
+function breadcrumbJsonLd(pages, page, origin, basePath = "") {
+  if (page.path === "/") return null;
+  const byPath = new Map(pages.map((p) => [p.path, p]));
+  const trail = [];
+  const home = byPath.get("/");
+  if (home) trail.push(home);
+  const segments = page.path.split("/").filter(Boolean);
+  for (let i = 1; i <= segments.length; i++) {
+    const ancestor = byPath.get(`/${segments.slice(0, i).join("/")}`);
+    if (ancestor) trail.push(ancestor);
+  }
+  if (trail.length < 2) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: trail.map((p, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      name: p.doc.root.props.title,
+      item: absoluteUrl(origin, basePath, p.path)
+    }))
+  };
+}
+function isoDate(value) {
+  if (typeof value !== "string" && typeof value !== "number") return null;
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+var textOf = (value) => typeof value === "string" && value ? value : void 0;
+function postPath(postsPath, slug) {
+  return `${postsPath === "/" ? "" : postsPath}/${slug}`;
+}
+function articleJsonLd(site, post, url, origin, basePath = "") {
+  const d = post.doc;
+  const org = site.seo.organization;
+  const publisher = { "@type": "Organization", name: org?.name ?? site.name, url: absoluteUrl(origin, basePath, "/") };
+  if (org?.logo) publisher.logo = { "@type": "ImageObject", url: org.logo.startsWith("/") ? absoluteUrl(origin, basePath, org.logo) : org.logo };
+  const description = d.excerpt ?? d.seo?.description;
+  const image = imageUrl(d.cover ?? d.seo?.ogImage, origin, basePath);
+  return {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: d.title.slice(0, 110),
+    ...description ? { description } : {},
+    ...image ? { image: [image] } : {},
+    datePublished: new Date(post.publishedAt).toISOString(),
+    dateModified: new Date(post.updatedAt).toISOString(),
+    author: d.author ? { "@type": "Person", name: d.author.name, ...d.author.url && isSafeHref(d.author.url) ? { url: d.author.url.startsWith("/") ? absoluteUrl(origin, basePath, d.author.url) : d.author.url } : {} } : { "@type": "Organization", name: org?.name ?? site.name },
+    publisher,
+    mainEntityOfPage: { "@type": "WebPage", "@id": url },
+    ...d.category ? { articleSection: d.category } : {},
+    ...d.tags?.length ? { keywords: d.tags.join(", ") } : {},
+    inLanguage: site.lang
+  };
+}
+function rssXml({ site, posts, postsPath, title, origin, basePath = "", limit = 20 }) {
+  const link = absoluteUrl(origin, basePath, postsPath);
+  const self = absoluteUrl(origin, basePath, "/rss.xml");
+  const usable = posts.filter((p) => !p.noindex && textOf(p.title) && textOf(p.slug) && isoDate(p.publishedAt));
+  const items = usable.slice(0, limit).map((p) => {
+    const url = absoluteUrl(origin, basePath, postPath(postsPath, p.slug));
+    const excerpt = textOf(p.excerpt);
+    const category = textOf(p.category);
+    const author = textOf(p.author?.name);
+    return [
+      "<item>",
+      `<title>${escapeXml(p.title)}</title>`,
+      `<link>${escapeXml(url)}</link>`,
+      `<guid isPermaLink="true">${escapeXml(url)}</guid>`,
+      `<pubDate>${new Date(isoDate(p.publishedAt)).toUTCString()}</pubDate>`,
+      excerpt ? `<description>${escapeXml(excerpt)}</description>` : "",
+      category ? `<category>${escapeXml(category)}</category>` : "",
+      author ? `<dc:creator>${escapeXml(author)}</dc:creator>` : "",
+      "</item>"
+    ].join("");
+  });
+  const newest = usable[0];
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/"><channel><title>${escapeXml(title ?? site.name)}</title><link>${escapeXml(link)}</link><description>${escapeXml(site.seo.description ?? `Posts from ${site.name}`)}</description><language>${escapeXml(site.lang)}</language><atom:link href="${escapeXml(self)}" rel="self" type="application/rss+xml"/>` + (newest ? `<lastBuildDate>${new Date(isoDate(newest.updatedAt) ?? isoDate(newest.publishedAt)).toUTCString()}</lastBuildDate>` : "") + `${items.join("")}</channel></rss>
+`;
+}
+var postDescription = (doc) => doc.excerpt ?? doc.seo?.description ?? (richTextPlain(doc.body, 200) || void 0);
+function safeJsonForHtml(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escapeXml(text) {
+  return text.replace(/[<>&'"]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", "'": "&apos;", '"': "&quot;" })[c]);
+}
+function sitemapXml({ site, pages, origin, basePath = "", lastModified, posts }) {
+  const urls = site.seo.noindex ? [] : pages.filter((p) => !p.doc.seo?.noindex && !p.doc.seo?.canonical).sort((a, b) => a.path === "/" ? -1 : b.path === "/" ? 1 : a.path.localeCompare(b.path)).map((p) => {
+    const loc = `<loc>${escapeXml(absoluteUrl(origin, basePath, p.path))}</loc>`;
+    const mod = lastModified ? `<lastmod>${escapeXml(new Date(lastModified).toISOString())}</lastmod>` : "";
+    return `<url>${loc}${mod}</url>`;
+  });
+  const blogPage = posts ? pages.find((p) => p.path === posts.path) : void 0;
+  if (posts && !site.seo.noindex && blogPage && !blogPage.doc.seo?.noindex) {
+    for (const p of posts.items) {
+      if (p.noindex) continue;
+      const mod = isoDate(p.updatedAt) ?? isoDate(p.publishedAt);
+      urls.push(`<url><loc>${escapeXml(absoluteUrl(origin, basePath, postPath(posts.path, p.slug)))}</loc>${mod ? `<lastmod>${escapeXml(mod)}</lastmod>` : ""}</url>`);
+    }
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${urls.join("")}</urlset>
+`;
+}
+function robotsTxt({ origin, basePath = "", disallowAll = false }) {
+  const lines = ["User-agent: *", disallowAll ? "Disallow: /" : "Allow: /"];
+  if (!disallowAll) lines.push("", `Sitemap: ${absoluteUrl(origin, basePath, "/sitemap.xml")}`);
+  return `${lines.join("\n")}
+`;
+}
+function redirectsAfterMove(redirects, from, to) {
+  if (from === to) return [...redirects];
+  const next = redirects.filter((r) => r.from !== to && r.from !== from).map((r) => r.to === from ? { ...r, to } : r).filter((r) => r.from !== r.to);
+  next.push({ from, to, status: 301 });
+  return next;
+}
+function matchRedirect(redirects, path) {
+  return redirects.find((r) => r.from === path && isSafeHref(r.to));
+}
+
+export { BUILT_IN_SECTION_TYPES, Copy, FileRef, FontChoice, Href, Image, Line, Link, LinkEvent, MAX_DOC_BYTES, MAX_IMPORT_POSTS, MAX_LIVE_POSTS, MenuItem, PageDoc, PageKind, PagePath, PostAuthor, PostDoc, PostSlug, PostSummarySchema, Redirect, ReleasePage, ReleaseSnapshot, RichText, SECTION_CATEGORIES, SectionDefinitionError, SectionId, SectionNode, Seo, SeoDefaults, SiteDoc, Surface, TokenOverrides, absoluteUrl, articleJsonLd, breadcrumbJsonLd, defineSection, escapeXml, getSection, listSections, matchRedirect, newSectionId, nodeFromPreset, opensInNewTab, organizationJsonLd, pageMeta, pageTitle, parseSnapshot, postDescription, postPath, postSummary, redirectsAfterMove, registerBuiltInSection, registerSection, richTextPlain, robotsTxt, rssXml, safeJsonForHtml, sectionJsonSchema, sectionManifests, sitemapXml, unregisterSection, validatePostSlug, websiteJsonLd };
+//# sourceMappingURL=chunk-ZGWGQGT2.js.map
+//# sourceMappingURL=chunk-ZGWGQGT2.js.map