@aranova/tracking-next 0.20.0 → 0.20.1

package/dist/blog.mjs

@@ -0,0 +1,965 @@
+// ../tracking-core/src/resources/blog/schema.ts
+import { z as z2 } from "zod";
+
+// ../tracking-core/src/resources/blog/theme.ts
+import { z } from "zod";
+var BLOG_BREAKPOINTS = ["sm", "md", "lg", "xl", "2xl", "3xl"];
+var BLOG_BREAKPOINT_MIN_WIDTHS_PX = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536,
+  "3xl": 1920
+};
+function toBlogBreakpointMap(value) {
+  return typeof value === "object" ? value : { base: value };
+}
+var HEX_COLOR = /^#[0-9a-fA-F]{3,8}$/;
+var FUNCTIONAL_COLOR = /^(rgb|rgba|hsl|hsla|oklch)\([0-9a-zA-Z ,.%/-]*\)$/;
+var LENGTH = /^-?\d+(\.\d+)?(px|rem|em|%|ch|vw)$/;
+var LINE_HEIGHT = /^-?\d+(\.\d+)?(px|rem|em|%|ch|vw)?$/;
+var FONT_FAMILY_TOKEN = /^['"]?[a-zA-Z0-9 -]+['"]?$/;
+var FONT_FAMILY_VAR_TOKEN = /^var\(--[a-zA-Z0-9-]+\)$/;
+var colorValueSchema = z.string().refine((v) => HEX_COLOR.test(v) || FUNCTIONAL_COLOR.test(v), {
+  message: "must be a #hex or rgb()/rgba()/hsl()/hsla()/oklch() color"
+});
+var lengthValueSchema = z.string().regex(LENGTH, {
+  message: "must be a CSS length (px|rem|em|%|ch|vw)"
+});
+var lineHeightValueSchema = z.string().regex(LINE_HEIGHT, {
+  message: "must be a CSS length or unitless line-height"
+});
+var fontWeightSchema = z.number().int().min(100).max(1e3);
+var alignValueSchema = z.enum(["left", "center", "right"]);
+var fontFamilySchema = z.string().refine(
+  (v) => {
+    const tokens = v.split(",").map((t) => t.trim());
+    return tokens.length > 0 && tokens.every((t) => FONT_FAMILY_TOKEN.test(t) || FONT_FAMILY_VAR_TOKEN.test(t));
+  },
+  { message: "must be a comma-separated list of font-family or var(--custom-property) tokens" }
+);
+function nullishField(schema) {
+  return schema.nullish().transform((v) => v ?? void 0);
+}
+function breakpointMapSchema(valueSchema) {
+  return z.object({
+    base: valueSchema,
+    sm: nullishField(valueSchema).catch(void 0),
+    md: nullishField(valueSchema).catch(void 0),
+    lg: nullishField(valueSchema).catch(void 0),
+    xl: nullishField(valueSchema).catch(void 0),
+    "2xl": nullishField(valueSchema).catch(void 0),
+    "3xl": nullishField(valueSchema).catch(void 0)
+  });
+}
+function responsive(valueSchema) {
+  return z.union([valueSchema, breakpointMapSchema(valueSchema)]);
+}
+var blogThemeColorsShape = {
+  background: colorValueSchema,
+  surface: colorValueSchema,
+  text: colorValueSchema,
+  text_muted: colorValueSchema,
+  primary: colorValueSchema,
+  primary_foreground: colorValueSchema,
+  link: colorValueSchema,
+  border: colorValueSchema,
+  code_background: colorValueSchema,
+  heading: colorValueSchema
+};
+var blogThemeColorsSchema = z.object({
+  ...blogThemeColorsShape,
+  // The ONE optional color in a resolved theme: when unset, headings fall back
+  // to `text` in the stylesheet (`--_heading-color`), so `blogThemeToCssVars`
+  // only emits `--ara-blog-color-heading` when a theme actually sets it.
+  heading: nullishField(colorValueSchema)
+});
+var blogThemeTypographySchema = z.object({
+  heading_family: fontFamilySchema,
+  body_family: fontFamilySchema,
+  heading_weight: fontWeightSchema,
+  body_weight: fontWeightSchema,
+  h1_size: responsive(lengthValueSchema),
+  h2_size: responsive(lengthValueSchema),
+  h3_size: responsive(lengthValueSchema),
+  h4_size: responsive(lengthValueSchema),
+  body_size: responsive(lengthValueSchema),
+  body_line_height: responsive(lineHeightValueSchema),
+  small_size: responsive(lengthValueSchema),
+  // Scalar (non-responsive) length; the grammar allows negative em values.
+  // h1/h2 consume it directly, h3/h4 at half strength (calc in the base CSS).
+  heading_letter_spacing: lengthValueSchema,
+  // Figure caption text alignment (left/center/right). Site-owner override;
+  // default center in the base CSS if unset.
+  caption_align: alignValueSchema
+});
+var blogThemeSpacingSchema = z.object({
+  content_max_width: responsive(lengthValueSchema),
+  block_gap: responsive(lengthValueSchema),
+  section_gap: responsive(lengthValueSchema)
+});
+var blogThemeColorsPartialSchema = z.object(
+  Object.fromEntries(
+    Object.keys(blogThemeColorsShape).map((key) => [key, nullishField(colorValueSchema)])
+  )
+);
+var blogThemeSchema = z.object({
+  colors: blogThemeColorsSchema,
+  colors_dark: nullishField(blogThemeColorsPartialSchema),
+  typography: blogThemeTypographySchema,
+  spacing: blogThemeSpacingSchema,
+  radius: responsive(lengthValueSchema)
+});
+function dropInvalidFields(shape) {
+  const out = {};
+  for (const [key, schema] of Object.entries(shape)) {
+    out[key] = nullTolerant(schema).catch(void 0);
+  }
+  return out;
+}
+function nullTolerant(schema) {
+  if (schema instanceof z.ZodUnion) {
+    const options = schema.options;
+    return z.union([...options, z.null()]).optional().transform((v) => v ?? void 0);
+  }
+  return nullishField(schema);
+}
+var blogThemeColorsOverrideSchema = z.object(dropInvalidFields(blogThemeColorsShape));
+var blogThemeTypographyOverrideSchema = z.object(
+  dropInvalidFields(blogThemeTypographySchema.shape)
+);
+var blogThemeSpacingOverrideSchema = z.object(dropInvalidFields(blogThemeSpacingSchema.shape));
+var blogThemeOverrideSchema = z.object(
+  dropInvalidFields({
+    colors: blogThemeColorsOverrideSchema,
+    colors_dark: blogThemeColorsOverrideSchema,
+    typography: blogThemeTypographyOverrideSchema,
+    spacing: blogThemeSpacingOverrideSchema,
+    radius: responsive(lengthValueSchema)
+  })
+);
+var BASE_BLOG_THEME = {
+  colors: {
+    background: "#ffffff",
+    surface: "#f5f5f5",
+    text: "#171717",
+    text_muted: "#6b6b6b",
+    primary: "#171717",
+    primary_foreground: "#ffffff",
+    link: "#1d4ed8",
+    border: "#e5e5e5",
+    code_background: "#f5f5f5"
+  },
+  typography: {
+    heading_family: "system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif",
+    body_family: "system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif",
+    heading_weight: 700,
+    body_weight: 400,
+    // Responsive defaults: comfortable mobile sizes, larger from `md` up.
+    // This replaces the hardcoded mobile media query the base CSS used to need.
+    h1_size: { base: "1.9rem", md: "2.25rem" },
+    h2_size: { base: "1.5rem", md: "1.75rem" },
+    h3_size: "1.25rem",
+    h4_size: "1.125rem",
+    body_size: "1rem",
+    body_line_height: "1.7",
+    small_size: "0.875rem",
+    heading_letter_spacing: "-0.02em",
+    caption_align: "center"
+  },
+  spacing: {
+    content_max_width: "42rem",
+    block_gap: "1.25rem",
+    section_gap: "3rem"
+  },
+  radius: "8px"
+};
+function sanitizeBlogTheme(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const parsed = blogThemeOverrideSchema.safeParse(raw);
+  return parsed.success ? parsed.data : {};
+}
+function mergeGroup(base, over) {
+  if (!over) return base;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(over)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function resolveBlogTheme(...layers) {
+  let resolved = {
+    colors: { ...BASE_BLOG_THEME.colors },
+    colors_dark: BASE_BLOG_THEME.colors_dark ? { ...BASE_BLOG_THEME.colors_dark } : void 0,
+    typography: { ...BASE_BLOG_THEME.typography },
+    spacing: { ...BASE_BLOG_THEME.spacing },
+    radius: BASE_BLOG_THEME.radius
+  };
+  for (const layer of layers) {
+    if (!layer) continue;
+    resolved = {
+      colors: mergeGroup(resolved.colors, layer.colors),
+      colors_dark: layer.colors_dark || resolved.colors_dark ? mergeGroup(resolved.colors_dark ?? {}, layer.colors_dark) : void 0,
+      typography: mergeGroup(resolved.typography, layer.typography),
+      spacing: mergeGroup(resolved.spacing, layer.spacing),
+      radius: layer.radius ?? resolved.radius
+    };
+  }
+  return resolved;
+}
+function kebab(key) {
+  return key.split("_").join("-");
+}
+function emitResponsiveVar(vars, name, value) {
+  const map = toBlogBreakpointMap(value);
+  vars[name] = String(map.base);
+  for (const bp of BLOG_BREAKPOINTS) {
+    const bpValue = map[bp];
+    if (bpValue !== void 0) vars[`${name}-${bp}`] = String(bpValue);
+  }
+}
+function blogThemeToCssVars(theme) {
+  const vars = {};
+  const dark = theme.colors_dark;
+  const hasDark = !!dark && Object.values(dark).some((v) => v !== void 0);
+  const colorKeys = /* @__PURE__ */ new Set([...Object.keys(theme.colors), ...dark ? Object.keys(dark) : []]);
+  for (const key of colorKeys) {
+    const light = theme.colors[key];
+    const darkValue = hasDark ? dark?.[key] : void 0;
+    const lightValue = light ?? (darkValue !== void 0 ? theme.colors.text : void 0);
+    if (lightValue === void 0) continue;
+    vars[`--ara-blog-color-${kebab(key)}`] = darkValue ? `light-dark(${lightValue}, ${darkValue})` : lightValue;
+  }
+  if (hasDark) vars.colorScheme = "light dark";
+  for (const [key, value] of Object.entries(theme.typography)) {
+    emitResponsiveVar(vars, `--ara-blog-type-${kebab(key)}`, value);
+  }
+  for (const [key, value] of Object.entries(theme.spacing)) {
+    emitResponsiveVar(vars, `--ara-blog-space-${kebab(key)}`, value);
+  }
+  emitResponsiveVar(vars, "--ara-blog-radius", theme.radius);
+  return vars;
+}
+
+// ../tracking-core/src/resources/blog/schema.ts
+var schemaVersionSchema = z2.literal(1);
+var blogHeroImageSchema = z2.object({
+  url: z2.string(),
+  alt: z2.string().catch(""),
+  width: z2.number().int(),
+  height: z2.number().int()
+});
+var blogManifestEntrySchema = z2.object({
+  slug: z2.string(),
+  title: z2.string(),
+  description: z2.string().catch(""),
+  content_hash: z2.string(),
+  content_key: z2.string(),
+  published_at: z2.string(),
+  updated_at: z2.string(),
+  // Estimated read time in whole minutes (computed at publish from the post
+  // body). 0 when unknown; index cards render "N min read".
+  reading_minutes: z2.number().int().catch(0),
+  // A malformed tags array / hero_image degrades gracefully instead of
+  // dropping the whole entry.
+  tags: z2.array(z2.string()).catch([]),
+  hero_image: blogHeroImageSchema.nullable().catch(null)
+});
+var blogManifestWireSchema = z2.object({
+  schema_version: schemaVersionSchema,
+  namespace: z2.string(),
+  generated_at: z2.string(),
+  posts: z2.array(blogManifestEntrySchema).catch([])
+});
+var blogManifestSchema = blogManifestWireSchema.extend({
+  // A single malformed entry is dropped; the rest of the manifest survives.
+  posts: z2.array(blogManifestEntrySchema.nullable().catch(null)).transform((entries) => entries.filter((e) => e !== null)).catch([])
+});
+var blogImageSchema = z2.object({
+  id: z2.string(),
+  url: z2.string(),
+  alt: z2.string().catch(""),
+  caption: z2.string().nullable().catch(null),
+  role: z2.enum(["hero", "inline"]).catch("inline"),
+  width: z2.number().int(),
+  height: z2.number().int(),
+  mime: z2.string().catch("")
+});
+var blogSeoSchema = z2.object({
+  meta_title: z2.string().catch(""),
+  meta_description: z2.string().catch(""),
+  canonical_path: z2.string().catch(""),
+  og_image: z2.string().nullable().catch(null)
+});
+var blogPostContentWireSchema = z2.object({
+  schema_version: schemaVersionSchema,
+  slug: z2.string(),
+  title: z2.string(),
+  description: z2.string().catch(""),
+  mdx: z2.string(),
+  images: z2.array(blogImageSchema).catch([]),
+  // Already schema-validated at publish time, but re-sanitized on read (and
+  // again before rendering) — the override schema itself drops invalid values.
+  // Nullish: the backend serializes an unset override as an explicit `null`
+  // (Pydantic `model_dump()`); it folds into `undefined` for TS consumers.
+  theme_overrides: nullishField(blogThemeOverrideSchema).catch(void 0),
+  seo: blogSeoSchema.catch({
+    meta_title: "",
+    meta_description: "",
+    canonical_path: "",
+    og_image: null
+  }),
+  jsonld: z2.record(z2.unknown()).catch({}),
+  published_at: z2.string(),
+  // The applied_at of the version this content was published from; `null`
+  // when the backend has no separate modified date. Nullish on the wire
+  // (Pydantic `model_dump()` emits explicit `null`s), folded to `null` for a
+  // single TS sentinel; a malformed value degrades to `null` instead of
+  // dropping the post.
+  updated_at: z2.string().nullish().transform((v) => v ?? null).catch(null),
+  version_number: z2.number().int().catch(0),
+  content_hash: z2.string()
+});
+var blogPostContentSchema = blogPostContentWireSchema.extend({
+  // A single malformed image record is dropped; the post survives.
+  images: z2.array(blogImageSchema.nullable().catch(null)).transform((images) => images.filter((i) => i !== null)).catch([])
+});
+function parseBlogManifest(raw) {
+  const parsed = blogManifestSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+function parseBlogPostContent(raw) {
+  const parsed = blogPostContentSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+// ../tracking-core/src/resources/blog/client.ts
+function createBlogClient(config) {
+  const base = config.cdnBaseUrl.replace(/\/+$/, "");
+  const doFetch = (...args) => (config.fetchImpl ?? fetch)(...args);
+  async function fetchJson(url, init) {
+    try {
+      const response = await doFetch(url, init);
+      if (!response.ok) return null;
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  async function getManifest() {
+    const init = {
+      next: { revalidate: config.manifestRevalidateSeconds ?? 300 }
+    };
+    const raw = await fetchJson(`${base}/blogs/v1/${config.namespace}/manifest.json`, init);
+    return raw === null ? null : parseBlogManifest(raw);
+  }
+  async function listPosts() {
+    const manifest = await getManifest();
+    if (!manifest) return [];
+    return [...manifest.posts].sort((a, b) => b.published_at.localeCompare(a.published_at));
+  }
+  async function getPost(slug) {
+    const manifest = await getManifest();
+    const entry = manifest?.posts.find((post) => post.slug === slug);
+    if (!entry) return null;
+    const init = { cache: "force-cache" };
+    const raw = await fetchJson(`${base}/${entry.content_key.replace(/^\/+/, "")}`, init);
+    return raw === null ? null : parseBlogPostContent(raw);
+  }
+  async function getStaticParams() {
+    const posts = await listPosts();
+    return posts.map((post) => ({ slug: post.slug }));
+  }
+  return { getManifest, listPosts, getPost, getStaticParams };
+}
+
+// ../tracking-core/src/resources/blog/presets.ts
+var BLOG_THEME_PRESETS = {
+  /** Serif display headings over a humanist sans body — long-form magazine feel. */
+  editorial: {
+    typography: {
+      heading_family: "'Source Serif 4', 'Iowan Old Style', 'Palatino Linotype', Georgia, serif",
+      body_family: "'Source Sans 3', 'Segoe UI', 'Helvetica Neue', Arial, sans-serif",
+      heading_weight: 600,
+      body_weight: 400,
+      h1_size: { base: "2rem", md: "2.5rem" },
+      h2_size: { base: "1.5rem", md: "1.875rem" },
+      h3_size: "1.3rem",
+      h4_size: "1.125rem",
+      body_size: "1.0625rem",
+      body_line_height: "1.75",
+      heading_letter_spacing: "-0.015em"
+    },
+    spacing: {
+      block_gap: "1.35rem",
+      section_gap: "3.25rem"
+    },
+    radius: "6px"
+  },
+  /** Geometric sans pairing (Inter-first) — tight, contemporary product voice. */
+  modern: {
+    typography: {
+      heading_family: "'Inter', 'SF Pro Display', 'Segoe UI', Roboto, sans-serif",
+      body_family: "'Inter', 'SF Pro Text', 'Segoe UI', Roboto, sans-serif",
+      heading_weight: 700,
+      body_weight: 400,
+      h1_size: { base: "2.1rem", md: "2.75rem" },
+      h2_size: { base: "1.5rem", md: "1.75rem" },
+      h3_size: "1.25rem",
+      h4_size: "1.125rem",
+      body_size: "1rem",
+      body_line_height: "1.7",
+      heading_letter_spacing: "-0.03em"
+    },
+    spacing: {
+      block_gap: "1.25rem",
+      section_gap: "3rem"
+    },
+    radius: "12px"
+  },
+  /** Rounded-friendly pairing with a softer scale — approachable, human tone. */
+  warm: {
+    typography: {
+      heading_family: "'Nunito', 'Avenir Next', 'Trebuchet MS', Verdana, sans-serif",
+      body_family: "'Nunito Sans', 'Avenir Next', 'Trebuchet MS', Verdana, sans-serif",
+      heading_weight: 700,
+      body_weight: 400,
+      h1_size: { base: "1.9rem", md: "2.35rem" },
+      h2_size: { base: "1.45rem", md: "1.7rem" },
+      h3_size: "1.25rem",
+      h4_size: "1.125rem",
+      body_size: "1.0625rem",
+      body_line_height: "1.75",
+      heading_letter_spacing: "-0.01em"
+    },
+    spacing: {
+      block_gap: "1.35rem",
+      section_gap: "3.25rem"
+    },
+    radius: "16px"
+  },
+  /** Workmanlike sans with a prominent code surface — docs/engineering feel. */
+  technical: {
+    colors: {
+      // The one preset that ships a color: a cool code surface is part of the
+      // "technical" identity. Everything else stays on the site palette.
+      code_background: "#eef1f5"
+    },
+    colors_dark: {
+      code_background: "#1b1f27"
+    },
+    typography: {
+      heading_family: "'IBM Plex Sans', 'Segoe UI', 'Helvetica Neue', Arial, sans-serif",
+      body_family: "'IBM Plex Sans', 'Segoe UI', 'Helvetica Neue', Arial, sans-serif",
+      heading_weight: 600,
+      body_weight: 400,
+      h1_size: { base: "1.85rem", md: "2.25rem" },
+      h2_size: { base: "1.45rem", md: "1.65rem" },
+      h3_size: "1.2rem",
+      h4_size: "1.0625rem",
+      body_size: "1rem",
+      body_line_height: "1.65",
+      heading_letter_spacing: "-0.01em"
+    },
+    spacing: {
+      block_gap: "1.15rem",
+      section_gap: "2.75rem"
+    },
+    radius: "6px"
+  }
+};
+function prependFamily(front, stack) {
+  if (!front) return stack;
+  return stack ? `${front}, ${stack}` : front;
+}
+function createBlogFontTheme(preset, fonts) {
+  const heading_family = prependFamily(fonts.heading, preset.typography?.heading_family);
+  const body_family = prependFamily(fonts.body, preset.typography?.body_family);
+  return {
+    ...preset,
+    typography: {
+      ...preset.typography,
+      ...heading_family !== void 0 ? { heading_family } : {},
+      ...body_family !== void 0 ? { body_family } : {}
+    }
+  };
+}
+
+// ../tracking-core/src/resources/blog/view/class-names.ts
+function joinClassNames(base, extra) {
+  return extra ? `${base} ${extra}` : base;
+}
+
+// ../tracking-core/src/resources/blog/seo.ts
+function joinUrl(base, ...paths) {
+  let out = base.replace(/\/+$/, "");
+  for (const path of paths) {
+    const segment = path?.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (segment) out += `/${segment}`;
+  }
+  return out;
+}
+function canonicalUrl(post, opts) {
+  return joinUrl(opts.siteUrl, opts.basePath ?? "/blog", post.slug);
+}
+function ogImages(post) {
+  if (post.seo.og_image) return [{ url: post.seo.og_image }];
+  const hero = post.images.find((image) => image.role === "hero");
+  if (!hero) return void 0;
+  return [{ url: hero.url, width: hero.width, height: hero.height, alt: hero.alt }];
+}
+function buildBlogPostMetadata(post, opts) {
+  const url = canonicalUrl(post, opts);
+  const title = post.seo.meta_title || post.title;
+  const description = post.seo.meta_description || post.description;
+  const images = ogImages(post);
+  return {
+    title,
+    description,
+    alternates: { canonical: url },
+    openGraph: {
+      title,
+      description,
+      type: "article",
+      url,
+      ...images ? { images } : {},
+      ...post.published_at ? { publishedTime: post.published_at } : {}
+    }
+  };
+}
+function buildBlogPostingJsonLd(post, opts) {
+  const url = canonicalUrl(post, opts);
+  const images = post.images.map((image) => image.url);
+  const doc = {
+    headline: post.title,
+    description: post.seo.meta_description || post.description,
+    datePublished: post.published_at,
+    dateModified: post.updated_at ?? post.published_at,
+    ...images.length > 0 ? { image: images } : {},
+    ...opts.publisherName ? { publisher: { "@type": "Organization", name: opts.publisherName } } : {}
+  };
+  const backend = post.jsonld;
+  const merged = backend && typeof backend === "object" && Object.keys(backend).length > 0 ? { ...doc, ...backend } : doc;
+  return {
+    ...merged,
+    "@context": "https://schema.org",
+    "@type": "BlogPosting",
+    url,
+    mainEntityOfPage: { "@type": "WebPage", "@id": url }
+  };
+}
+var FAQ_ITEM_RE = /<FaqItem\s+question=(?:"([^"]*)"|'([^']*)')\s*>([\s\S]*?)<\/FaqItem>/g;
+var CODE_FENCE_RE = /^ {0,3}(`{3,}|~{3,})[^\n]*\n[\s\S]*?(?:^ {0,3}\1`* *$|(?![\s\S]))/gm;
+var ANSWER_TAG_RE = /<[^>]*>/g;
+function extractFaqPairs(mdx) {
+  const withoutCode = mdx.replaceAll(CODE_FENCE_RE, "");
+  const pairs = [];
+  for (const match of withoutCode.matchAll(FAQ_ITEM_RE)) {
+    const question = (match[1] ?? match[2] ?? "").trim();
+    const answer = match[3].replaceAll(ANSWER_TAG_RE, " ").replaceAll(/\s+/g, " ").trim();
+    if (question && answer) pairs.push({ question, answer });
+  }
+  return pairs;
+}
+function buildFaqJsonLd(pairs) {
+  if (pairs.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: pairs.map((pair) => ({
+      "@type": "Question",
+      name: pair.question,
+      acceptedAnswer: { "@type": "Answer", text: pair.answer }
+    }))
+  };
+}
+var JSONLD_ESCAPES = {
+  "<": "\\u003c",
+  ">": "\\u003e",
+  "&": "\\u0026",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+function serializeJsonLd(data) {
+  return JSON.stringify(data).replaceAll(/[<>&\u2028\u2029]/g, (ch) => JSONLD_ESCAPES[ch] ?? ch);
+}
+function buildBlogSitemapEntries(posts, opts) {
+  return posts.map((post) => ({
+    url: joinUrl(opts.siteUrl, opts.basePath ?? "/blog", post.slug),
+    lastModified: post.updated_at
+  }));
+}
+
+// ../tracking-core/src/resources/blog/toc.ts
+import GithubSlugger from "github-slugger";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var TEXT_LEAF_TYPES = /* @__PURE__ */ new Set(["text", "inlineCode"]);
+function headingText(node) {
+  let text = "";
+  const stack = [];
+  const roots = node.children ?? [];
+  for (let i = roots.length - 1; i >= 0; i--) {
+    stack.push(roots[i]);
+  }
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) break;
+    if (TEXT_LEAF_TYPES.has(current.type) && typeof current.value === "string") {
+      text += current.value;
+    }
+    if (Array.isArray(current.children)) {
+      for (let i = current.children.length - 1; i >= 0; i--) {
+        stack.push(current.children[i]);
+      }
+    }
+  }
+  return text;
+}
+function extractBlogHeadings(mdx) {
+  let tree;
+  try {
+    tree = unified().use(remarkParse).use(remarkMdx).parse(mdx);
+  } catch {
+    return [];
+  }
+  const slugger = new GithubSlugger();
+  const headings = [];
+  const stack = [tree];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) break;
+    if (node.type === "heading" && typeof node.depth === "number") {
+      const text = headingText(node);
+      const id = slugger.slug(text);
+      if (node.depth === 2 || node.depth === 3) {
+        headings.push({ depth: node.depth, text, id });
+      }
+    }
+    if (Array.isArray(node.children)) {
+      for (let i = node.children.length - 1; i >= 0; i--) {
+        stack.push(node.children[i]);
+      }
+    }
+  }
+  return headings;
+}
+var WORDS_PER_MINUTE = 220;
+var MDX_SYNTAX_RE = /<[^>]*>|```[^`]*```|`|^[#>\-*+\s]+|\]\([^)]*\)|[[\]!]/gm;
+function estimateReadingTime(mdx) {
+  const words = mdx.replaceAll(MDX_SYNTAX_RE, " ").split(/\s+/).filter((w) => w.length > 0).length;
+  return Math.max(1, Math.round(words / WORDS_PER_MINUTE));
+}
+
+// ../tracking-core/src/resources/blog/validate-mdx.ts
+import remarkMdx2 from "remark-mdx";
+import remarkParse2 from "remark-parse";
+import { unified as unified2 } from "unified";
+var BLOG_MDX_MAX_SIZE = 5e5;
+var BLOG_MDX_MAX_DEPTH = 64;
+var BLOG_MDX_MAX_NODES = 1e5;
+var MAX_VIOLATIONS = 50;
+var BLOG_MDX_COMPONENT_GRAMMAR = [
+  {
+    name: "Callout",
+    attrs: [],
+    urlAttrs: [],
+    selfClosing: false,
+    cssClass: "aranova-blog-callout",
+    promptUsage: "<Callout>...</Callout>",
+    promptDescription: "a highlighted tip/note block; no attributes."
+  },
+  {
+    name: "Cta",
+    attrs: ["href", "label"],
+    urlAttrs: ["href"],
+    selfClosing: true,
+    cssClass: "aranova-blog-cta",
+    promptUsage: '<Cta href="..." label="..." />',
+    promptDescription: "a call-to-action button (self-closing)."
+  },
+  {
+    name: "BlogImage",
+    attrs: ["id"],
+    urlAttrs: [],
+    selfClosing: true,
+    promptUsage: '<BlogImage id="..." />',
+    promptDescription: "a generated image placeholder (self-closing). The `id` references an image brief id from the plan; the renderer resolves it."
+  },
+  {
+    name: "FaqItem",
+    attrs: ["question"],
+    urlAttrs: [],
+    selfClosing: false,
+    cssClass: "aranova-blog-faq-item",
+    promptUsage: '<FaqItem question="...">...</FaqItem>',
+    promptDescription: "one FAQ entry: the required `question` attribute carries the question, the children are the prose answer. Group consecutive `<FaqItem>`s under an FAQ heading near the end of the post when the topic suits a Q&A section."
+  },
+  {
+    name: "KeyTakeaways",
+    attrs: [],
+    urlAttrs: [],
+    selfClosing: false,
+    cssClass: "aranova-blog-key-takeaways",
+    promptUsage: "<KeyTakeaways>...</KeyTakeaways>",
+    promptDescription: "a TL;DR box containing a standard markdown bullet list of 3-5 takeaways; place it right after the H1 (and hero image)."
+  }
+];
+var BLOG_MDX_ALLOWED_COMPONENTS = BLOG_MDX_COMPONENT_GRAMMAR.map((entry) => entry.name);
+var ALLOWED_NODE_TYPES = /* @__PURE__ */ new Set([
+  "root",
+  "heading",
+  "paragraph",
+  "text",
+  "emphasis",
+  "strong",
+  "delete",
+  "link",
+  "image",
+  "linkReference",
+  "imageReference",
+  "definition",
+  "list",
+  "listItem",
+  "blockquote",
+  "code",
+  "inlineCode",
+  "table",
+  "tableRow",
+  "tableCell",
+  "thematicBreak",
+  "break"
+]);
+var FORBIDDEN_NODE_TYPES = {
+  html: { rule: "raw-html", message: "Raw HTML is not allowed" },
+  mdxjsEsm: { rule: "esm", message: "import/export statements are not allowed" },
+  mdxFlowExpression: { rule: "expression", message: "JSX expressions ({\u2026}) are not allowed" },
+  mdxTextExpression: { rule: "expression", message: "JSX expressions ({\u2026}) are not allowed" }
+};
+var COMPONENT_SPECS = Object.fromEntries(
+  BLOG_MDX_COMPONENT_GRAMMAR.map((entry) => [
+    entry.name,
+    { attrs: entry.attrs, urlAttrs: entry.urlAttrs, allowChildren: !entry.selfClosing }
+  ])
+);
+var URL_SCHEME_RE = /^([A-Za-z][A-Za-z0-9+.-]*):/;
+var ALLOWED_URL_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+function forbiddenUrlScheme(rawUrl) {
+  const cleaned = rawUrl.replaceAll(/[\u0000-\u0020\u007F]/g, "");
+  const match = URL_SCHEME_RE.exec(cleaned);
+  if (!match) return null;
+  const scheme = match[1].toLowerCase();
+  return ALLOWED_URL_SCHEMES.has(scheme) ? null : scheme;
+}
+function nodeLine(node) {
+  return node.position?.start?.line;
+}
+function checkComponent(node, violations) {
+  const line = nodeLine(node);
+  const name = node.name;
+  if (!name) {
+    violations.push({
+      rule: "unknown-component",
+      message: "JSX fragments (<>\u2026</>) are not allowed",
+      line
+    });
+    return;
+  }
+  const spec = COMPONENT_SPECS[name];
+  if (!spec) {
+    violations.push({
+      rule: "unknown-component",
+      message: `<${name}> is not an allowed element (allowed: ${BLOG_MDX_ALLOWED_COMPONENTS.join(", ")})`,
+      line
+    });
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const attr of node.attributes ?? []) {
+    if (attr.type !== "mdxJsxAttribute" || typeof attr.name !== "string") {
+      violations.push({
+        rule: "component-attribute",
+        message: `<${name}> has a non-literal attribute`,
+        line
+      });
+      continue;
+    }
+    if (!spec.attrs.includes(attr.name)) {
+      violations.push({
+        rule: "component-attribute",
+        message: `<${name}> does not accept attribute "${attr.name}"`,
+        line
+      });
+      continue;
+    }
+    if (typeof attr.value !== "string") {
+      violations.push({
+        rule: "component-attribute",
+        message: `<${name} ${attr.name}> must be a quoted string literal`,
+        line
+      });
+      continue;
+    }
+    seen.add(attr.name);
+    if (spec.urlAttrs.includes(attr.name)) {
+      const scheme = forbiddenUrlScheme(attr.value);
+      if (scheme !== null) {
+        violations.push({
+          rule: "url-scheme",
+          message: `<${name} ${attr.name}> uses forbidden URL scheme "${scheme}:"`,
+          line
+        });
+      }
+    }
+  }
+  for (const required of spec.attrs) {
+    if (!seen.has(required)) {
+      violations.push({
+        rule: "component-attribute",
+        message: `<${name}> requires attribute "${required}"`,
+        line
+      });
+    }
+  }
+  if (!spec.allowChildren && (node.children?.length ?? 0) > 0) {
+    violations.push({
+      rule: "component-attribute",
+      message: `<${name}> must be self-closing (no children)`,
+      line
+    });
+  }
+}
+function validateBlogMdx(mdx, options) {
+  const violations = [];
+  if (typeof mdx !== "string" || mdx.length > BLOG_MDX_MAX_SIZE) {
+    return {
+      ok: false,
+      violations: [
+        {
+          rule: "size-limit",
+          message: `Document exceeds the ${BLOG_MDX_MAX_SIZE}-character limit`
+        }
+      ]
+    };
+  }
+  let tree;
+  try {
+    tree = unified2().use(remarkParse2).use(remarkMdx2).parse(mdx);
+  } catch (error) {
+    const line = error.line;
+    return {
+      ok: false,
+      violations: [
+        {
+          rule: "parse-error",
+          message: "Document is not valid MDX",
+          ...typeof line === "number" ? { line } : {}
+        }
+      ]
+    };
+  }
+  if (options?.requireLeadingH1) {
+    const firstChild = tree.children?.[0];
+    if (!firstChild || firstChild.type !== "heading" || firstChild.depth !== 1) {
+      violations.push({
+        rule: "leading-h1",
+        message: "Document must start with the H1 title (`# ...`) \u2014 no frontmatter or metadata block before it",
+        line: nodeLine(firstChild ?? tree)
+      });
+    }
+  }
+  let nodeCount = 0;
+  const stack = [{ node: tree, depth: 0 }];
+  while (stack.length > 0 && violations.length < MAX_VIOLATIONS) {
+    const item = stack.pop();
+    if (!item) break;
+    const { node, depth } = item;
+    nodeCount += 1;
+    if (nodeCount > BLOG_MDX_MAX_NODES) {
+      violations.push({ rule: "size-limit", message: "Document has too many nodes" });
+      break;
+    }
+    if (depth > BLOG_MDX_MAX_DEPTH) {
+      violations.push({ rule: "depth-limit", message: "Document nests too deeply" });
+      break;
+    }
+    const forbidden = FORBIDDEN_NODE_TYPES[node.type];
+    if (forbidden) {
+      violations.push({ ...forbidden, line: nodeLine(node) });
+      continue;
+    }
+    if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+      checkComponent(node, violations);
+    } else if (!ALLOWED_NODE_TYPES.has(node.type)) {
+      violations.push({
+        rule: "disallowed-node",
+        message: `Markdown construct "${node.type}" is not allowed`,
+        line: nodeLine(node)
+      });
+      continue;
+    }
+    if ((node.type === "link" || node.type === "image" || node.type === "definition") && typeof node.url === "string") {
+      const scheme = forbiddenUrlScheme(node.url);
+      if (scheme !== null) {
+        violations.push({
+          rule: "url-scheme",
+          message: `${node.type} uses forbidden URL scheme "${scheme}:"`,
+          line: nodeLine(node)
+        });
+      }
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        stack.push({ node: child, depth: depth + 1 });
+      }
+    }
+  }
+  return violations.length === 0 ? { ok: true } : { ok: false, violations };
+}
+export {
+  BASE_BLOG_THEME,
+  BLOG_BREAKPOINTS,
+  BLOG_BREAKPOINT_MIN_WIDTHS_PX,
+  BLOG_MDX_ALLOWED_COMPONENTS,
+  BLOG_MDX_COMPONENT_GRAMMAR,
+  BLOG_MDX_MAX_DEPTH,
+  BLOG_MDX_MAX_NODES,
+  BLOG_MDX_MAX_SIZE,
+  BLOG_THEME_PRESETS,
+  blogHeroImageSchema,
+  blogImageSchema,
+  blogManifestEntrySchema,
+  blogManifestSchema,
+  blogManifestWireSchema,
+  blogPostContentSchema,
+  blogPostContentWireSchema,
+  blogSeoSchema,
+  blogThemeColorsSchema,
+  blogThemeOverrideSchema,
+  blogThemeSchema,
+  blogThemeSpacingSchema,
+  blogThemeToCssVars,
+  blogThemeTypographySchema,
+  buildBlogPostMetadata,
+  buildBlogPostingJsonLd,
+  buildBlogSitemapEntries,
+  buildFaqJsonLd,
+  createBlogClient,
+  createBlogFontTheme,
+  estimateReadingTime,
+  extractBlogHeadings,
+  extractFaqPairs,
+  joinClassNames,
+  nullishField,
+  parseBlogManifest,
+  parseBlogPostContent,
+  resolveBlogTheme,
+  responsive,
+  sanitizeBlogTheme,
+  serializeJsonLd,
+  toBlogBreakpointMap,
+  validateBlogMdx
+};
+//# sourceMappingURL=blog.mjs.map