@aranova/tracking-next 0.20.0 → 0.20.2

package/dist/blog.js

@@ -0,0 +1,1045 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/blog.ts
+var blog_exports = {};
+__export(blog_exports, {
+  BASE_BLOG_THEME: () => BASE_BLOG_THEME,
+  BLOG_BREAKPOINTS: () => BLOG_BREAKPOINTS,
+  BLOG_BREAKPOINT_MIN_WIDTHS_PX: () => BLOG_BREAKPOINT_MIN_WIDTHS_PX,
+  BLOG_MDX_ALLOWED_COMPONENTS: () => BLOG_MDX_ALLOWED_COMPONENTS,
+  BLOG_MDX_COMPONENT_GRAMMAR: () => BLOG_MDX_COMPONENT_GRAMMAR,
+  BLOG_MDX_MAX_DEPTH: () => BLOG_MDX_MAX_DEPTH,
+  BLOG_MDX_MAX_NODES: () => BLOG_MDX_MAX_NODES,
+  BLOG_MDX_MAX_SIZE: () => BLOG_MDX_MAX_SIZE,
+  BLOG_THEME_PRESETS: () => BLOG_THEME_PRESETS,
+  blogHeroImageSchema: () => blogHeroImageSchema,
+  blogImageSchema: () => blogImageSchema,
+  blogManifestEntrySchema: () => blogManifestEntrySchema,
+  blogManifestSchema: () => blogManifestSchema,
+  blogManifestWireSchema: () => blogManifestWireSchema,
+  blogPostContentSchema: () => blogPostContentSchema,
+  blogPostContentWireSchema: () => blogPostContentWireSchema,
+  blogSeoSchema: () => blogSeoSchema,
+  blogThemeColorsSchema: () => blogThemeColorsSchema,
+  blogThemeOverrideSchema: () => blogThemeOverrideSchema,
+  blogThemeSchema: () => blogThemeSchema,
+  blogThemeSpacingSchema: () => blogThemeSpacingSchema,
+  blogThemeToCssVars: () => blogThemeToCssVars,
+  blogThemeTypographySchema: () => blogThemeTypographySchema,
+  buildBlogPostMetadata: () => buildBlogPostMetadata,
+  buildBlogPostingJsonLd: () => buildBlogPostingJsonLd,
+  buildBlogSitemapEntries: () => buildBlogSitemapEntries,
+  buildFaqJsonLd: () => buildFaqJsonLd,
+  createBlogClient: () => createBlogClient,
+  createBlogFontTheme: () => createBlogFontTheme,
+  estimateReadingTime: () => estimateReadingTime,
+  extractBlogHeadings: () => extractBlogHeadings,
+  extractFaqPairs: () => extractFaqPairs,
+  joinClassNames: () => joinClassNames,
+  nullishField: () => nullishField,
+  parseBlogManifest: () => parseBlogManifest,
+  parseBlogPostContent: () => parseBlogPostContent,
+  resolveBlogTheme: () => resolveBlogTheme,
+  responsive: () => responsive,
+  sanitizeBlogTheme: () => sanitizeBlogTheme,
+  serializeJsonLd: () => serializeJsonLd,
+  toBlogBreakpointMap: () => toBlogBreakpointMap,
+  validateBlogMdx: () => validateBlogMdx
+});
+module.exports = __toCommonJS(blog_exports);
+
+// ../tracking-core/src/resources/blog/schema.ts
+var import_zod2 = require("zod");
+
+// ../tracking-core/src/resources/blog/theme.ts
+var import_zod = require("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 = import_zod.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 = import_zod.z.string().regex(LENGTH, {
+  message: "must be a CSS length (px|rem|em|%|ch|vw)"
+});
+var lineHeightValueSchema = import_zod.z.string().regex(LINE_HEIGHT, {
+  message: "must be a CSS length or unitless line-height"
+});
+var fontWeightSchema = import_zod.z.number().int().min(100).max(1e3);
+var alignValueSchema = import_zod.z.enum(["left", "center", "right"]);
+var fontFamilySchema = import_zod.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 import_zod.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 import_zod.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 = import_zod.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 = import_zod.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 = import_zod.z.object({
+  content_max_width: responsive(lengthValueSchema),
+  block_gap: responsive(lengthValueSchema),
+  section_gap: responsive(lengthValueSchema)
+});
+var blogThemeColorsPartialSchema = import_zod.z.object(
+  Object.fromEntries(
+    Object.keys(blogThemeColorsShape).map((key) => [key, nullishField(colorValueSchema)])
+  )
+);
+var blogThemeSchema = import_zod.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 import_zod.z.ZodUnion) {
+    const options = schema.options;
+    return import_zod.z.union([...options, import_zod.z.null()]).optional().transform((v) => v ?? void 0);
+  }
+  return nullishField(schema);
+}
+var blogThemeColorsOverrideSchema = import_zod.z.object(dropInvalidFields(blogThemeColorsShape));
+var blogThemeTypographyOverrideSchema = import_zod.z.object(
+  dropInvalidFields(blogThemeTypographySchema.shape)
+);
+var blogThemeSpacingOverrideSchema = import_zod.z.object(dropInvalidFields(blogThemeSpacingSchema.shape));
+var blogThemeOverrideSchema = import_zod.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 = import_zod2.z.literal(1);
+var blogHeroImageSchema = import_zod2.z.object({
+  url: import_zod2.z.string(),
+  alt: import_zod2.z.string().catch(""),
+  width: import_zod2.z.number().int(),
+  height: import_zod2.z.number().int()
+});
+var blogManifestEntrySchema = import_zod2.z.object({
+  slug: import_zod2.z.string(),
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string().catch(""),
+  content_hash: import_zod2.z.string(),
+  content_key: import_zod2.z.string(),
+  published_at: import_zod2.z.string(),
+  updated_at: import_zod2.z.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: import_zod2.z.number().int().catch(0),
+  // A malformed tags array / hero_image degrades gracefully instead of
+  // dropping the whole entry.
+  tags: import_zod2.z.array(import_zod2.z.string()).catch([]),
+  hero_image: blogHeroImageSchema.nullable().catch(null)
+});
+var blogManifestWireSchema = import_zod2.z.object({
+  schema_version: schemaVersionSchema,
+  namespace: import_zod2.z.string(),
+  generated_at: import_zod2.z.string(),
+  posts: import_zod2.z.array(blogManifestEntrySchema).catch([])
+});
+var blogManifestSchema = blogManifestWireSchema.extend({
+  // A single malformed entry is dropped; the rest of the manifest survives.
+  posts: import_zod2.z.array(blogManifestEntrySchema.nullable().catch(null)).transform((entries) => entries.filter((e) => e !== null)).catch([])
+});
+var blogImageSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  url: import_zod2.z.string(),
+  alt: import_zod2.z.string().catch(""),
+  caption: import_zod2.z.string().nullable().catch(null),
+  role: import_zod2.z.enum(["hero", "inline"]).catch("inline"),
+  width: import_zod2.z.number().int(),
+  height: import_zod2.z.number().int(),
+  mime: import_zod2.z.string().catch("")
+});
+var blogSeoSchema = import_zod2.z.object({
+  meta_title: import_zod2.z.string().catch(""),
+  meta_description: import_zod2.z.string().catch(""),
+  canonical_path: import_zod2.z.string().catch(""),
+  og_image: import_zod2.z.string().nullable().catch(null)
+});
+var blogPostContentWireSchema = import_zod2.z.object({
+  schema_version: schemaVersionSchema,
+  slug: import_zod2.z.string(),
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string().catch(""),
+  mdx: import_zod2.z.string(),
+  images: import_zod2.z.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: import_zod2.z.record(import_zod2.z.unknown()).catch({}),
+  published_at: import_zod2.z.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: import_zod2.z.string().nullish().transform((v) => v ?? null).catch(null),
+  version_number: import_zod2.z.number().int().catch(0),
+  content_hash: import_zod2.z.string()
+});
+var blogPostContentSchema = blogPostContentWireSchema.extend({
+  // A single malformed image record is dropped; the post survives.
+  images: import_zod2.z.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
+var import_github_slugger = __toESM(require("github-slugger"));
+var import_remark_gfm = __toESM(require("remark-gfm"));
+var import_remark_mdx = __toESM(require("remark-mdx"));
+var import_remark_parse = __toESM(require("remark-parse"));
+var import_unified = require("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 = (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_mdx.default).parse(mdx);
+  } catch {
+    return [];
+  }
+  const slugger = new import_github_slugger.default();
+  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
+var import_remark_gfm2 = __toESM(require("remark-gfm"));
+var import_remark_mdx2 = __toESM(require("remark-mdx"));
+var import_remark_parse2 = __toESM(require("remark-parse"));
+var import_unified2 = require("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 = (0, import_unified2.unified)().use(import_remark_parse2.default).use(import_remark_gfm2.default).use(import_remark_mdx2.default).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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.js.map