@raystack/chronicle 0.12.3 → 0.12.5

package/dist/cli/index.js

@@ -46,6 +46,257 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/types/config.ts
+import { uniqBy } from "lodash-es";
+import { z } from "zod";
+var logoSchema, themeSchema, navLinkSchema, socialLinkSchema, navigationSchema, searchSchema, apiServerSchema, apiAuthSchema, apiSchema, googleAnalyticsSchema, analyticsSchema, telemetrySchema, siteSchema, DIR_NAME_PATTERN, dirNameSchema, contentEntrySchema, badgeVariantSchema, badgeSchema, latestSchema, versionSchema, allUnique = (items, key) => uniqBy(items, key).length === items.length, RESERVED_ROUTE_SEGMENTS, redirectSchema, chronicleConfigSchema;
+var init_config = __esm(() => {
+  logoSchema = z.object({
+    light: z.string().optional(),
+    dark: z.string().optional()
+  });
+  themeSchema = z.object({
+    name: z.enum(["default", "paper"]),
+    colors: z.record(z.string(), z.string()).optional()
+  });
+  navLinkSchema = z.object({
+    label: z.string(),
+    href: z.string()
+  });
+  socialLinkSchema = z.object({
+    type: z.string(),
+    href: z.string()
+  });
+  navigationSchema = z.object({
+    links: z.array(navLinkSchema).optional(),
+    social: z.array(socialLinkSchema).optional()
+  });
+  searchSchema = z.object({
+    enabled: z.boolean().optional(),
+    placeholder: z.string().optional()
+  });
+  apiServerSchema = z.object({
+    url: z.string(),
+    description: z.string().optional()
+  });
+  apiAuthSchema = z.object({
+    type: z.string(),
+    header: z.string(),
+    placeholder: z.string().optional()
+  });
+  apiSchema = z.object({
+    name: z.string(),
+    spec: z.string(),
+    basePath: z.string(),
+    icon: z.string().optional(),
+    server: apiServerSchema,
+    auth: apiAuthSchema.optional()
+  });
+  googleAnalyticsSchema = z.object({
+    measurementId: z.string()
+  });
+  analyticsSchema = z.object({
+    enabled: z.boolean().optional(),
+    googleAnalytics: googleAnalyticsSchema.optional()
+  });
+  telemetrySchema = z.object({
+    enabled: z.boolean().optional(),
+    serviceName: z.string().optional(),
+    port: z.number().int().min(1).max(65535).default(9090)
+  });
+  siteSchema = z.object({
+    title: z.string(),
+    description: z.string().optional()
+  });
+  DIR_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+  dirNameSchema = z.string().min(1).refine((s) => DIR_NAME_PATTERN.test(s) && s !== "." && s !== "..", {
+    message: 'dir must start with a letter or digit and contain only letters, digits, ".", "_", or "-"'
+  });
+  contentEntrySchema = z.object({
+    dir: dirNameSchema,
+    label: z.string().min(1),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    index_page: z.string().optional()
+  });
+  badgeVariantSchema = z.enum([
+    "accent",
+    "warning",
+    "danger",
+    "success",
+    "neutral",
+    "gradient"
+  ]);
+  badgeSchema = z.object({
+    label: z.string().min(1),
+    variant: badgeVariantSchema.default("accent")
+  });
+  latestSchema = z.object({
+    label: z.string().min(1),
+    landing: z.boolean().optional()
+  });
+  versionSchema = z.object({
+    dir: dirNameSchema,
+    label: z.string().min(1),
+    badge: badgeSchema.optional(),
+    landing: z.boolean().optional(),
+    content: z.array(contentEntrySchema).min(1),
+    api: z.array(apiSchema).optional()
+  });
+  RESERVED_ROUTE_SEGMENTS = [
+    "api",
+    "apis",
+    "og",
+    "llms.txt",
+    "robots.txt",
+    "sitemap.xml"
+  ];
+  redirectSchema = z.object({
+    from: z.string(),
+    to: z.string(),
+    permanent: z.boolean().optional()
+  });
+  chronicleConfigSchema = z.object({
+    site: siteSchema,
+    url: z.string().optional(),
+    content: z.array(contentEntrySchema).min(1),
+    latest: latestSchema.optional(),
+    versions: z.array(versionSchema).optional(),
+    preset: z.string().optional(),
+    logo: logoSchema.optional(),
+    theme: themeSchema.optional(),
+    navigation: navigationSchema.optional(),
+    search: searchSchema.optional(),
+    api: z.array(apiSchema).optional(),
+    redirects: z.array(redirectSchema).optional(),
+    analytics: analyticsSchema.optional(),
+    telemetry: telemetrySchema.optional()
+  }).strict().refine((cfg) => allUnique(cfg.content, (c) => c.dir), {
+    message: "content[].dir must be unique",
+    path: ["content"]
+  }).refine((cfg) => !cfg.versions || allUnique(cfg.versions, (v) => v.dir), {
+    message: "versions[].dir must be unique",
+    path: ["versions"]
+  }).refine((cfg) => !cfg.versions || cfg.versions.every((v) => allUnique(v.content, (c) => c.dir)), {
+    message: "versions[].content[].dir must be unique within each version",
+    path: ["versions"]
+  }).refine((cfg) => !cfg.versions || cfg.versions.length === 0 || !!cfg.latest, {
+    message: "latest is required when versions are declared",
+    path: ["latest"]
+  }).refine((cfg) => {
+    if (!cfg.versions)
+      return true;
+    const contentDirs = new Set(cfg.content.map((c) => c.dir));
+    return !cfg.versions.some((v) => contentDirs.has(v.dir));
+  }, {
+    message: "versions[].dir must not overlap with content[].dir — the URL segment would be shadowed",
+    path: ["versions"]
+  }).superRefine((cfg, ctx) => {
+    const reserved = new Set(RESERVED_ROUTE_SEGMENTS);
+    const message = `dir must not be a reserved route segment: ${RESERVED_ROUTE_SEGMENTS.join(", ")}`;
+    cfg.content.forEach((c, i) => {
+      if (reserved.has(c.dir)) {
+        ctx.addIssue({ code: "custom", message, path: ["content", i, "dir"] });
+      }
+    });
+    cfg.versions?.forEach((v, vi) => {
+      if (reserved.has(v.dir)) {
+        ctx.addIssue({
+          code: "custom",
+          message,
+          path: ["versions", vi, "dir"]
+        });
+      }
+      v.content.forEach((c, ci) => {
+        if (reserved.has(c.dir)) {
+          ctx.addIssue({
+            code: "custom",
+            message,
+            path: ["versions", vi, "content", ci, "dir"]
+          });
+        }
+      });
+    });
+  });
+});
+
+// src/types/content.ts
+var SearchResultType;
+var init_content = __esm(() => {
+  SearchResultType = {
+    Page: "page",
+    Api: "api"
+  };
+});
+// src/types/index.ts
+var init_types = __esm(() => {
+  init_config();
+  init_content();
+});
+
+// src/lib/config.ts
+import { parse as parse2 } from "yaml";
+function getLatestContentRoots(config2) {
+  return config2.content.map((c) => ({
+    versionDir: null,
+    versionLabel: config2.latest?.label ?? null,
+    contentDir: c.dir,
+    contentLabel: c.label,
+    contentDescription: c.description,
+    contentIcon: c.icon,
+    fsPath: `content/${c.dir}`,
+    urlPrefix: `/${c.dir}`
+  }));
+}
+function getVersionContentRoots(config2, versionDir) {
+  const version = config2.versions?.find((v) => v.dir === versionDir);
+  if (!version)
+    return [];
+  return version.content.map((c) => ({
+    versionDir: version.dir,
+    versionLabel: version.label,
+    contentDir: c.dir,
+    contentLabel: c.label,
+    contentDescription: c.description,
+    contentIcon: c.icon,
+    fsPath: `versions/${version.dir}/${c.dir}`,
+    urlPrefix: `/${version.dir}/${c.dir}`
+  }));
+}
+function getApiConfigsForVersion(config2, versionDir) {
+  if (versionDir === null)
+    return config2.api ?? [];
+  return config2.versions?.find((v) => v.dir === versionDir)?.api ?? [];
+}
+function getAllVersions(config2) {
+  const result = [
+    {
+      dir: null,
+      label: config2.latest?.label ?? "",
+      isLatest: true
+    }
+  ];
+  for (const v of config2.versions ?? []) {
+    result.push({
+      dir: v.dir,
+      label: v.label,
+      badge: v.badge,
+      isLatest: false
+    });
+  }
+  return result;
+}
+var defaultConfig;
+var init_config2 = __esm(() => {
+  init_types();
+  defaultConfig = chronicleConfigSchema.parse({
+    site: { title: "Documentation" },
+    content: [{ dir: "docs", label: "Docs" }],
+    theme: { name: "default" },
+    search: { enabled: true, placeholder: "Search..." }
+  });
+});
+
 // src/lib/mdx-utils.ts
 var MdxNodeType;
 var init_mdx_utils = __esm(() => {
@@ -379,9 +630,82 @@ var init_remark_unused_directives = __esm(() => {
   remark_unused_directives_default = remarkUnusedDirectives;
 });
 
+// src/lib/mdx-component-names.ts
+import { htmlTagNames } from "html-tag-names";
+import { svgTagNames } from "svg-tag-names";
+var MDX_COMPONENT_NAMES, KNOWN_TAGS;
+var init_mdx_component_names = __esm(() => {
+  MDX_COMPONENT_NAMES = [
+    "Callout",
+    "CalloutTitle",
+    "CalloutDescription",
+    "Tabs",
+    "Mermaid"
+  ];
+  KNOWN_TAGS = new Set([...htmlTagNames, ...svgTagNames]);
+});
+
+// src/lib/remark-validate-mdx.ts
+import { visit as visit5 } from "unist-util-visit";
+function collectLocalNames(tree) {
+  const names = new Set;
+  visit5(tree, "mdxjsEsm", (node) => {
+    const program = node.data?.estree;
+    for (const stmt of program?.body ?? []) {
+      if (stmt.type === "ImportDeclaration") {
+        for (const spec of stmt.specifiers ?? []) {
+          if (spec.local?.name)
+            names.add(spec.local.name);
+        }
+      }
+      const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+      if (!decl)
+        continue;
+      if (decl.type === "VariableDeclaration") {
+        for (const d of decl.declarations ?? []) {
+          if (d.id?.name)
+            names.add(d.id.name);
+        }
+      } else if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && decl.id?.name) {
+        names.add(decl.id.name);
+      }
+    }
+  });
+  return names;
+}
+var remarkValidateMdx = (options = {}) => {
+  const allowed = new Set(options.components ?? MDX_COMPONENT_NAMES);
+  return (tree, file) => {
+    const locals = collectLocalNames(tree);
+    visit5(tree, [MdxNodeType.JsxFlow, MdxNodeType.JsxText], (node) => {
+      const { name, position } = node;
+      if (!name)
+        return;
+      const root = name.split(".")[0];
+      if (root.includes("-"))
+        return;
+      if (locals.has(root))
+        return;
+      if (/^[a-z]/.test(root)) {
+        if (KNOWN_TAGS.has(root))
+          return;
+        file.fail(`Unknown HTML tag <${name}> — not a standard HTML/SVG element. If it is a custom component, register it in Chronicle's MDX components.`, position);
+      } else if (!allowed.has(root)) {
+        file.fail(`Unknown component <${name}> — available components: ${[...allowed].join(", ")}. Import it in this file or register it in Chronicle's MDX components.`, position);
+      }
+    });
+  };
+}, remark_validate_mdx_default;
+var init_remark_validate_mdx = __esm(() => {
+  init_mdx_component_names();
+  init_mdx_utils();
+  remark_validate_mdx_default = remarkValidateMdx;
+});
+
 // src/server/vite-config.ts
 var exports_vite_config = {};
 __export(exports_vite_config, {
+  isStaticPreset: () => isStaticPreset,
   createViteConfig: () => createViteConfig
 });
 import react from "@vitejs/plugin-react";
@@ -437,8 +761,9 @@ async function createViteConfig(options) {
     plugins: [
       nitro({
         serverDir: path6.resolve(packageRoot, "src/server"),
-        ...preset && { preset },
-        ignore: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx"]
+        ...!isStaticPreset(preset) && preset && { preset },
+        ignore: ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx"],
+        ...isStaticPreset(preset) && { prerender: { routes: [] } }
       }),
       mdx({
         default: defineFumadocsConfig({
@@ -468,7 +793,8 @@ async function createViteConfig(options) {
               remark_resolve_links_default,
               [remark_resolve_images_default, { optimize: !isStaticPreset(preset) }],
               remarkMdxMermaid,
-              readingTime
+              readingTime,
+              remark_validate_mdx_default
             ]
           }
         })
@@ -511,8 +837,9 @@ async function createViteConfig(options) {
     environments: {
       client: {
         build: {
+          manifest: isStaticPreset(preset),
           rollupOptions: {
-            input: path6.resolve(packageRoot, "src/server/entry-client.tsx")
+            input: path6.resolve(packageRoot, isStaticPreset(preset) ? "src/server/entry-static.tsx" : "src/server/entry-client.tsx")
           }
         }
       }
@@ -531,11 +858,13 @@ async function createViteConfig(options) {
           base: path6.resolve(projectRoot, ".cache/images")
         }
       },
-      experimental: {
-        database: true
-      },
-      database: {
-        default: getDatabaseConnector(preset)
+      ...isStaticPreset(preset) ? {} : {
+        experimental: {
+          database: true
+        },
+        database: {
+          default: getDatabaseConnector(preset)
+        }
       }
     }
   };
@@ -546,194 +875,1387 @@ var init_vite_config = __esm(() => {
   init_remark_resolve_links();
   init_remark_reading_time();
   init_remark_unused_directives();
+  init_remark_validate_mdx();
   STATIC_PRESETS = new Set(["static", "vercel-static", "cloudflare-pages", "github-pages"]);
 });
 
-// src/cli/index.ts
-import { Command as Command6 } from "commander";
-
-// src/cli/commands/build.ts
-import chalk2 from "chalk";
-import { Command } from "commander";
-
-// src/cli/utils/config.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import chalk from "chalk";
-import { parse } from "yaml";
+// src/lib/env.ts
+function substituteEnvVars(value) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => {
+    const val = process.env[name];
+    if (val === undefined) {
+      throw new Error(`Environment variable '${name}' is not set`);
+    }
+    return val;
+  });
+}
 
-// src/types/config.ts
-import { uniqBy } from "lodash-es";
-import { z } from "zod";
-var logoSchema = z.object({
-  light: z.string().optional(),
-  dark: z.string().optional()
-});
-var themeSchema = z.object({
-  name: z.enum(["default", "paper"]),
-  colors: z.record(z.string(), z.string()).optional()
-});
-var navLinkSchema = z.object({
-  label: z.string(),
-  href: z.string()
-});
-var socialLinkSchema = z.object({
-  type: z.string(),
-  href: z.string()
-});
-var navigationSchema = z.object({
-  links: z.array(navLinkSchema).optional(),
-  social: z.array(socialLinkSchema).optional()
-});
-var searchSchema = z.object({
-  enabled: z.boolean().optional(),
-  placeholder: z.string().optional()
-});
-var apiServerSchema = z.object({
-  url: z.string(),
-  description: z.string().optional()
-});
-var apiAuthSchema = z.object({
-  type: z.string(),
-  header: z.string(),
-  placeholder: z.string().optional()
+// src/lib/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  toKind: () => toKind,
+  generateExampleJson: () => generateExampleJson,
+  flattenSchema: () => flattenSchema
 });
-var apiSchema = z.object({
-  name: z.string(),
-  spec: z.string(),
-  basePath: z.string(),
-  icon: z.string().optional(),
-  server: apiServerSchema,
-  auth: apiAuthSchema.optional()
-});
-var googleAnalyticsSchema = z.object({
-  measurementId: z.string()
-});
-var analyticsSchema = z.object({
-  enabled: z.boolean().optional(),
-  googleAnalytics: googleAnalyticsSchema.optional()
-});
-var telemetrySchema = z.object({
-  enabled: z.boolean().optional(),
-  serviceName: z.string().optional(),
-  port: z.number().int().min(1).max(65535).default(9090)
-});
-var siteSchema = z.object({
-  title: z.string(),
-  description: z.string().optional()
-});
-var DIR_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var dirNameSchema = z.string().min(1).refine((s) => DIR_NAME_PATTERN.test(s) && s !== "." && s !== "..", {
-  message: 'dir must start with a letter or digit and contain only letters, digits, ".", "_", or "-"'
+function toKind(type) {
+  if (typeof type === "string" && type in schemaFieldKinds)
+    return type;
+  return "object";
+}
+function mergeAllOf(schema) {
+  const composed = schema.allOf ?? schema.oneOf ?? schema.anyOf;
+  if (!composed)
+    return schema;
+  const merged = { ...schema };
+  delete merged.allOf;
+  delete merged.oneOf;
+  delete merged.anyOf;
+  for (const sub of composed) {
+    if (sub.type)
+      merged.type = sub.type;
+    if (sub.properties) {
+      merged.properties = { ...merged.properties ?? {}, ...sub.properties };
+    }
+    if (sub.required) {
+      merged.required = [...merged.required ?? [], ...sub.required];
+    }
+    if (sub.description && !merged.description)
+      merged.description = sub.description;
+  }
+  return merged;
+}
+function flattenSchema(schema, requiredFields = []) {
+  const resolved = mergeAllOf(schema);
+  if (resolved !== schema)
+    return flattenSchema(resolved, requiredFields);
+  if (schema.type === "array" && schema.items) {
+    const items = schema.items;
+    const itemType = inferType(items);
+    const children = itemType === "object" || items.properties ? flattenSchema(items, items.required ?? []) : itemType.endsWith("[]") && items.items ? flattenSchema(items.items) : undefined;
+    return [{
+      name: "items",
+      type: `${itemType}[]`,
+      kind: "array",
+      required: true,
+      description: items.description,
+      children: children?.length ? children : undefined
+    }];
+  }
+  if (schema.type === "object" || schema.properties) {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? requiredFields;
+    return Object.entries(properties).map(([name, rawProp]) => {
+      const prop = mergeAllOf(rawProp);
+      const fieldType = inferType(prop);
+      const children = fieldType === "object" || prop.properties ? flattenSchema(prop, prop.required) : fieldType.endsWith("[]") && prop.items ? flattenSchema(prop.items) : undefined;
+      return {
+        name,
+        type: fieldType,
+        kind: toKind(prop.type),
+        required: required.includes(name),
+        description: rawProp.description ?? prop.description,
+        default: prop.default,
+        example: prop.example,
+        enum: prop.enum,
+        children: children?.length ? children : undefined
+      };
+    });
+  }
+  return [];
+}
+function generateExampleJson(schema) {
+  if (schema.example !== undefined)
+    return schema.example;
+  if (schema.default !== undefined)
+    return schema.default;
+  if (schema.type === "array") {
+    const items = schema.items;
+    return items ? [generateExampleJson(items)] : [];
+  }
+  if (schema.type === "object" || schema.properties) {
+    const properties = schema.properties ?? {};
+    const result = {};
+    for (const [name, prop] of Object.entries(properties)) {
+      result[name] = generateExampleJson(prop);
+    }
+    return result;
+  }
+  const defaults = {
+    string: "string",
+    integer: 0,
+    number: 0,
+    boolean: true
+  };
+  return defaults[schema.type] ?? null;
+}
+function inferType(rawSchema) {
+  const schema = mergeAllOf(rawSchema);
+  if (schema.type === "array") {
+    const items = schema.items;
+    const itemType = items ? inferType(items) : "unknown";
+    return `${itemType}[]`;
+  }
+  if (schema.format)
+    return `${schema.type}(${schema.format})`;
+  return schema.type ?? "object";
+}
+var schemaFieldKinds;
+var init_schema = __esm(() => {
+  schemaFieldKinds = {
+    string: "string",
+    integer: "integer",
+    number: "number",
+    boolean: "boolean",
+    array: "array",
+    object: "object"
+  };
 });
-var contentEntrySchema = z.object({
-  dir: dirNameSchema,
-  label: z.string().min(1),
-  description: z.string().optional(),
-  icon: z.string().optional(),
-  index_page: z.string().optional()
+
+// src/lib/openapi.ts
+import fs4 from "node:fs/promises";
+import path7 from "node:path";
+import { parse as parseYaml } from "yaml";
+async function loadApiSpec(config2, projectRoot) {
+  const specPath = path7.resolve(projectRoot, config2.spec);
+  const raw = await fs4.readFile(specPath, "utf-8");
+  const isYaml = specPath.endsWith(".yaml") || specPath.endsWith(".yml");
+  const doc = isYaml ? parseYaml(raw) : JSON.parse(raw);
+  let v3Doc;
+  if ("swagger" in doc && doc.swagger === "2.0") {
+    v3Doc = convertV2toV3(doc);
+  } else if ("openapi" in doc && doc.openapi.startsWith("3.")) {
+    v3Doc = resolveDocument(doc);
+  } else {
+    throw new Error(`Unsupported spec version in ${config2.spec}`);
+  }
+  return {
+    name: config2.name,
+    basePath: config2.basePath,
+    server: { ...config2.server, url: substituteEnvVars(config2.server.url) },
+    auth: config2.auth,
+    document: v3Doc
+  };
+}
+function resolveRef(ref, root) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  let current = root;
+  for (const part of parts) {
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      current = current[part];
+    } else {
+      throw new Error(`Cannot resolve $ref: ${ref}`);
+    }
+  }
+  return current;
+}
+function deepResolveRefs(obj, root, stack = new Set, cache = new Map) {
+  if (obj === null || obj === undefined || typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepResolveRefs(item, root, stack, cache));
+  }
+  const record = obj;
+  if (typeof record.$ref === "string") {
+    const ref = record.$ref;
+    if (cache.has(ref))
+      return cache.get(ref);
+    if (stack.has(ref))
+      return { type: "object", description: "[circular]" };
+    stack.add(ref);
+    const resolved = deepResolveRefs(resolveRef(ref, root), root, stack, cache);
+    stack.delete(ref);
+    cache.set(ref, resolved);
+    return resolved;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = deepResolveRefs(value, root, stack, cache);
+  }
+  return result;
+}
+function resolveDocument(doc) {
+  const root = doc;
+  return deepResolveRefs(doc, root);
+}
+function convertV2toV3(doc) {
+  const root = doc;
+  const resolved = deepResolveRefs(doc, root);
+  const v3Paths = {};
+  for (const [pathStr, pathItem] of Object.entries(resolved.paths ?? {})) {
+    if (!pathItem)
+      continue;
+    const v3PathItem = {};
+    for (const method of ["get", "post", "put", "delete", "patch"]) {
+      const op = pathItem[method];
+      if (!op)
+        continue;
+      v3PathItem[method] = convertV2Operation(op);
+    }
+    v3Paths[pathStr] = v3PathItem;
+  }
+  const securitySchemes = convertV2SecurityDefs(resolved.securityDefinitions);
+  return {
+    openapi: "3.0.0",
+    info: resolved.info,
+    paths: v3Paths,
+    tags: resolved.tags ?? [],
+    ...resolved.externalDocs ? { externalDocs: resolved.externalDocs } : {},
+    ...Object.keys(securitySchemes).length > 0 ? { components: { securitySchemes } } : {}
+  };
+}
+function convertV2SecurityDefs(defs) {
+  if (!defs)
+    return {};
+  const result = {};
+  for (const [name, def] of Object.entries(defs)) {
+    if (def.type === "apiKey") {
+      result[name] = { type: "apiKey", name: def.name, in: def.in };
+    } else if (def.type === "basic") {
+      result[name] = { type: "http", scheme: "basic" };
+    } else if (def.type === "oauth2") {
+      const v2 = def;
+      const flow = { authorizationUrl: v2.authorizationUrl ?? "", tokenUrl: v2.tokenUrl ?? "", scopes: v2.scopes ?? {} };
+      const flows = {};
+      if (v2.flow === "implicit")
+        flows.implicit = { authorizationUrl: flow.authorizationUrl, scopes: flow.scopes };
+      else if (v2.flow === "password")
+        flows.password = { tokenUrl: flow.tokenUrl, scopes: flow.scopes };
+      else if (v2.flow === "application")
+        flows.clientCredentials = { tokenUrl: flow.tokenUrl, scopes: flow.scopes };
+      else if (v2.flow === "accessCode")
+        flows.authorizationCode = { authorizationUrl: flow.authorizationUrl, tokenUrl: flow.tokenUrl, scopes: flow.scopes };
+      result[name] = { type: "oauth2", flows };
+    }
+  }
+  return result;
+}
+function convertV2Operation(op) {
+  const params = op.parameters ?? [];
+  const v3Params = params.filter((p) => p.in !== "body").map((p) => ({
+    name: p.name,
+    in: p.in,
+    required: p.required ?? false,
+    description: p.description,
+    schema: { type: p.type ?? "string", format: p.format }
+  }));
+  const bodyParam = params.find((p) => p.in === "body");
+  let requestBody;
+  if (bodyParam?.schema) {
+    requestBody = {
+      required: bodyParam.required ?? false,
+      content: {
+        "application/json": {
+          schema: bodyParam.schema
+        }
+      }
+    };
+  }
+  const v3Responses = {};
+  for (const [status, resp] of Object.entries(op.responses ?? {})) {
+    const v2Resp = resp;
+    const v3Resp = {
+      description: v2Resp.description ?? ""
+    };
+    if (v2Resp.schema) {
+      v3Resp.content = {
+        "application/json": {
+          schema: v2Resp.schema
+        }
+      };
+    }
+    v3Responses[status] = v3Resp;
+  }
+  const result = {
+    operationId: op.operationId,
+    summary: op.summary,
+    description: op.description,
+    tags: op.tags,
+    parameters: v3Params,
+    responses: v3Responses
+  };
+  if (requestBody) {
+    result.requestBody = requestBody;
+  }
+  return result;
+}
+var init_openapi = __esm(() => {
+  init_schema();
 });
-var badgeVariantSchema = z.enum([
-  "accent",
-  "warning",
-  "danger",
-  "success",
-  "neutral",
-  "gradient"
-]);
-var badgeSchema = z.object({
-  label: z.string().min(1),
-  variant: badgeVariantSchema.default("accent")
+
+// src/lib/api-routes.ts
+import slugify from "slugify";
+function getSpecSlug(spec) {
+  return slugify(spec.name, { lower: true, strict: true });
+}
+function deriveOperationId(method, path8) {
+  const slug = path8.replace(/[/{}\-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return `${method}_${slug || "root"}`;
+}
+function getOperationId(op, method, path8) {
+  return op.operationId || deriveOperationId(method, path8);
+}
+function buildApiRoutes(specs) {
+  const routes = [];
+  for (const spec of specs) {
+    const specSlug = getSpecSlug(spec);
+    const paths = spec.document.paths ?? {};
+    for (const [pathStr, pathItem] of Object.entries(paths)) {
+      if (!pathItem)
+        continue;
+      for (const method of ["get", "post", "put", "delete", "patch"]) {
+        const op = pathItem[method];
+        if (!op)
+          continue;
+        const opId = getOperationId(op, method, pathStr);
+        routes.push({ slug: [specSlug, encodeURIComponent(opId)] });
+      }
+    }
+  }
+  return routes;
+}
+var init_api_routes = () => {};
+
+// src/lib/llms.ts
+function buildLlmsTxt(config2, pages, version) {
+  const versionLabel = getVersionLabel(config2, version);
+  const heading = versionLabel ? `# ${config2.site.title} — ${versionLabel}` : `# ${config2.site.title}`;
+  const description = config2.site.description ?? "";
+  const index = pages.map((p) => {
+    const mdUrl = p.url === "/" ? "/index.md" : `${p.url}.md`;
+    const title = p.title?.trim() || p.url;
+    return `- [${title}](${mdUrl})`;
+  }).join(`
+`);
+  const parts = [heading];
+  if (description)
+    parts.push(description);
+  parts.push(index);
+  return parts.join(`
+
+`);
+}
+function getVersionLabel(config2, version) {
+  if (version.dir === null)
+    return config2.latest?.label ?? null;
+  return config2.versions?.find((v) => v.dir === version.dir)?.label ?? null;
+}
+
+// src/server/routes/og-utils.ts
+var exports_og_utils = {};
+__export(exports_og_utils, {
+  loadLogo: () => loadLogo,
+  loadFont: () => loadFont,
+  getLogoDataUri: () => getLogoDataUri
 });
-var latestSchema = z.object({
-  label: z.string().min(1),
-  landing: z.boolean().optional()
+import fs5 from "node:fs/promises";
+import path8 from "node:path";
+function getLogoDataUri(data, filePath) {
+  const ext = path8.extname(filePath).toLowerCase();
+  const mime = MIME_MAP[ext];
+  if (!mime)
+    return null;
+  return `data:${mime};base64,${data.toString("base64")}`;
+}
+async function loadLogo(projectRoot, logoPath) {
+  try {
+    const filePath = path8.resolve(projectRoot, "public", logoPath.replace(/^\//, ""));
+    const data = await fs5.readFile(filePath);
+    return getLogoDataUri(data, filePath);
+  } catch {
+    return null;
+  }
+}
+async function loadFont(packageRoot) {
+  const fontPath = path8.resolve(packageRoot, "src/fonts/Inter-Regular.ttf");
+  const buffer = await fs5.readFile(fontPath);
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}
+var MIME_MAP;
+var init_og_utils = __esm(() => {
+  MIME_MAP = {
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg"
+  };
 });
-var versionSchema = z.object({
-  dir: dirNameSchema,
-  label: z.string().min(1),
-  badge: badgeSchema.optional(),
-  landing: z.boolean().optional(),
-  content: z.array(contentEntrySchema).min(1),
-  api: z.array(apiSchema).optional()
+
+// src/lib/snippet-generators.ts
+var exports_snippet_generators = {};
+__export(exports_snippet_generators, {
+  generateTypeScript: () => generateTypeScript,
+  generatePython: () => generatePython,
+  generateGo: () => generateGo,
+  generateCurl: () => generateCurl
 });
-var allUnique = (items, key) => uniqBy(items, key).length === items.length;
-var RESERVED_ROUTE_SEGMENTS = [
-  "api",
-  "apis",
-  "og",
-  "llms.txt",
-  "robots.txt",
-  "sitemap.xml"
-];
-var redirectSchema = z.object({
-  from: z.string(),
-  to: z.string(),
-  permanent: z.boolean().optional()
+function generateCurl({ method, url, headers, body }) {
+  const parts = [`curl -X ${method} '${url}'`];
+  for (const [key, value] of Object.entries(headers)) {
+    parts.push(`  -H '${key}: ${value}'`);
+  }
+  if (body) {
+    parts.push(`  -d '${body}'`);
+  }
+  return parts.join(" \\\n");
+}
+function generatePython({ method, url, headers, body }) {
+  const lines = ["import requests", ""];
+  const methodLower = method.toLowerCase();
+  const headerEntries = Object.entries(headers);
+  lines.push(`response = requests.${methodLower}(`);
+  lines.push(`    "${url}",`);
+  if (headerEntries.length > 0) {
+    lines.push("    headers={");
+    for (const [key, value] of headerEntries) {
+      lines.push(`        "${key}": "${value}",`);
+    }
+    lines.push("    },");
+  }
+  if (body) {
+    lines.push(`    json=${body},`);
+  }
+  lines.push(")");
+  lines.push("print(response.json())");
+  return lines.join(`
+`);
+}
+function generateGo({ method, url, headers, body }) {
+  const lines = [];
+  if (body) {
+    lines.push("payload := strings.NewReader(`" + body + "`)");
+    lines.push("");
+    lines.push(`req, _ := http.NewRequest("${method}", "${url}", payload)`);
+  } else {
+    lines.push(`req, _ := http.NewRequest("${method}", "${url}", nil)`);
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    lines.push(`req.Header.Set("${key}", "${value}")`);
+  }
+  lines.push("");
+  lines.push("resp, _ := http.DefaultClient.Do(req)");
+  lines.push("defer resp.Body.Close()");
+  return lines.join(`
+`);
+}
+function generateTypeScript({ method, url, headers, body }) {
+  const lines = [];
+  const headerEntries = Object.entries(headers);
+  lines.push(`const response = await fetch("${url}", {`);
+  lines.push(`  method: "${method}",`);
+  if (headerEntries.length > 0) {
+    lines.push("  headers: {");
+    for (const [key, value] of headerEntries) {
+      lines.push(`    "${key}": "${value}",`);
+    }
+    lines.push("  },");
+  }
+  if (body) {
+    lines.push(`  body: JSON.stringify(${body}),`);
+  }
+  lines.push("});");
+  lines.push("const data = await response.json();");
+  return lines.join(`
+`);
+}
+
+// src/cli/commands/static-generate.ts
+var exports_static_generate = {};
+__export(exports_static_generate, {
+  generateStaticSite: () => generateStaticSite
 });
-var chronicleConfigSchema = z.object({
-  site: siteSchema,
-  url: z.string().optional(),
-  content: z.array(contentEntrySchema).min(1),
-  latest: latestSchema.optional(),
-  versions: z.array(versionSchema).optional(),
-  preset: z.string().optional(),
-  logo: logoSchema.optional(),
-  theme: themeSchema.optional(),
-  navigation: navigationSchema.optional(),
-  search: searchSchema.optional(),
-  api: z.array(apiSchema).optional(),
-  redirects: z.array(redirectSchema).optional(),
-  analytics: analyticsSchema.optional(),
-  telemetry: telemetrySchema.optional()
-}).strict().refine((cfg) => allUnique(cfg.content, (c) => c.dir), {
-  message: "content[].dir must be unique",
-  path: ["content"]
-}).refine((cfg) => !cfg.versions || allUnique(cfg.versions, (v) => v.dir), {
-  message: "versions[].dir must be unique",
-  path: ["versions"]
-}).refine((cfg) => !cfg.versions || cfg.versions.every((v) => allUnique(v.content, (c) => c.dir)), {
-  message: "versions[].content[].dir must be unique within each version",
-  path: ["versions"]
-}).refine((cfg) => !cfg.versions || cfg.versions.length === 0 || !!cfg.latest, {
-  message: "latest is required when versions are declared",
-  path: ["latest"]
-}).refine((cfg) => {
-  if (!cfg.versions)
-    return true;
-  const contentDirs = new Set(cfg.content.map((c) => c.dir));
-  return !cfg.versions.some((v) => contentDirs.has(v.dir));
-}, {
-  message: "versions[].dir must not overlap with content[].dir — the URL segment would be shadowed",
-  path: ["versions"]
-}).superRefine((cfg, ctx) => {
-  const reserved = new Set(RESERVED_ROUTE_SEGMENTS);
-  const message = `dir must not be a reserved route segment: ${RESERVED_ROUTE_SEGMENTS.join(", ")}`;
-  cfg.content.forEach((c, i) => {
-    if (reserved.has(c.dir)) {
-      ctx.addIssue({ code: "custom", message, path: ["content", i, "dir"] });
+import fs6 from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import path9 from "node:path";
+import matter from "gray-matter";
+import chalk2 from "chalk";
+import satori from "satori";
+import sharp from "sharp";
+function extractHeadingsAndBody(markdown) {
+  const withoutFrontmatter = markdown.replace(/^---[\s\S]*?---/m, "");
+  const headings = [];
+  const lines = [];
+  for (const line of withoutFrontmatter.split(`
+`)) {
+    const headingMatch = line.match(/^#{1,6}\s+(.+)/);
+    if (headingMatch) {
+      headings.push(headingMatch[1]);
+    } else if (!line.startsWith("import ") && !line.startsWith("export ") && !line.startsWith("```")) {
+      const cleaned = line.replace(/<[^>]+>/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[*_~`]+/g, "").trim();
+      if (cleaned)
+        lines.push(cleaned);
     }
-  });
-  cfg.versions?.forEach((v, vi) => {
-    if (reserved.has(v.dir)) {
-      ctx.addIssue({
-        code: "custom",
-        message,
-        path: ["versions", vi, "dir"]
+  }
+  return { headings: headings.join(`
+`), body: lines.join(" ") };
+}
+function extractImages(markdown) {
+  const images = [];
+  const seen = new Set;
+  function add(src) {
+    const clean = src.split("?")[0];
+    if (clean && !seen.has(clean)) {
+      seen.add(clean);
+      images.push(clean);
+    }
+  }
+  const mdRegex = /!\[[^\]]*\]\(([^)]+)\)/g;
+  let match;
+  while ((match = mdRegex.exec(markdown)) !== null)
+    add(match[1]);
+  const htmlRegex = /<img\b[^>]*\bsrc=["']([^"']+)["']/gi;
+  while ((match = htmlRegex.exec(markdown)) !== null)
+    add(match[1]);
+  return images;
+}
+function titleFromSlug(slug) {
+  return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+async function scanContentDir(contentDir, contentMirrorRoot, prefix = []) {
+  const pages = [];
+  async function scan(dir, slugPrefix) {
+    let entries;
+    try {
+      entries = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules")
+        continue;
+      const fullPath = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath, [...slugPrefix, entry.name]);
+        continue;
+      }
+      if (!entry.name.endsWith(".mdx") && !entry.name.endsWith(".md"))
+        continue;
+      const raw = await fs6.readFile(fullPath, "utf-8");
+      const { data: fm, content: content2 } = matter(raw);
+      if (fm.draft === true)
+        continue;
+      const baseName = entry.name.replace(/\.(mdx|md)$/, "");
+      const isIndex = baseName === "index" || baseName.toLowerCase() === "readme";
+      const slugs = isIndex ? slugPrefix : [...slugPrefix, baseName];
+      const url = slugs.length === 0 ? "/" : `/${slugs.join("/")}`;
+      const originalRelative = path9.relative(contentMirrorRoot, fullPath);
+      const normalizedRelative = isIndex && baseName.toLowerCase() === "readme" ? originalRelative.replace(/readme\.(mdx?)$/i, `index.$1`) : originalRelative;
+      pages.push({
+        slugs,
+        url,
+        relativePath: normalizedRelative,
+        originalPath: originalRelative,
+        frontmatter: {
+          title: fm.title ?? titleFromSlug(slugs[slugs.length - 1] ?? "Home"),
+          description: fm.description,
+          order: fm.order,
+          icon: fm.icon,
+          lastModified: fm.lastModified,
+          draft: fm.draft
+        },
+        rawContent: content2,
+        images: extractImages(content2).map((img) => {
+          if (img.startsWith("http"))
+            return img;
+          if (img.startsWith("/"))
+            return `/_content${img}`;
+          const dirRelative = path9.dirname(normalizedRelative);
+          return `/_content/${path9.join(dirRelative, img).replace(/\\/g, "/")}`;
+        })
       });
     }
-    v.content.forEach((c, ci) => {
-      if (reserved.has(c.dir)) {
-        ctx.addIssue({
-          code: "custom",
-          message,
-          path: ["versions", vi, "content", ci, "dir"]
+  }
+  await scan(contentDir, prefix);
+  pages.sort((a, b) => {
+    const orderA = a.frontmatter.order ?? Number.MAX_SAFE_INTEGER;
+    const orderB = b.frontmatter.order ?? Number.MAX_SAFE_INTEGER;
+    if (orderA !== orderB)
+      return orderA - orderB;
+    return a.url.localeCompare(b.url);
+  });
+  return pages;
+}
+async function scanAllContent(projectRoot, config2, packageRoot) {
+  const contentMirror = path9.resolve(packageRoot, ".content");
+  const pages = [];
+  for (const root of getLatestContentRoots(config2)) {
+    const contentDir = path9.resolve(contentMirror, root.contentDir);
+    const scanned = await scanContentDir(contentDir, contentMirror, [root.contentDir]);
+    pages.push(...scanned);
+  }
+  for (const version of config2.versions ?? []) {
+    for (const root of getVersionContentRoots(config2, version.dir)) {
+      const contentDir = path9.resolve(contentMirror, version.dir, root.contentDir);
+      const scanned = await scanContentDir(contentDir, contentMirror, [version.dir, root.contentDir]);
+      pages.push(...scanned);
+    }
+  }
+  return pages;
+}
+async function scanFolderMeta(contentMirrorRoot, config2) {
+  const metaMap = new Map;
+  async function scanDir(dir, slugPrefix) {
+    let entries;
+    try {
+      entries = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const metaPath = path9.join(dir, "meta.json");
+    try {
+      const raw = await fs6.readFile(metaPath, "utf-8");
+      const meta = JSON.parse(raw);
+      const folderPath = "/" + slugPrefix.join("/");
+      metaMap.set(folderPath, meta);
+    } catch {}
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("."))
+        continue;
+      await scanDir(path9.join(dir, entry.name), [...slugPrefix, entry.name]);
+    }
+  }
+  for (const root of getLatestContentRoots(config2)) {
+    const contentDir = path9.resolve(contentMirrorRoot, root.contentDir);
+    await scanDir(contentDir, [root.contentDir]);
+  }
+  for (const version of config2.versions ?? []) {
+    for (const root of getVersionContentRoots(config2, version.dir)) {
+      const contentDir = path9.resolve(contentMirrorRoot, version.dir, root.contentDir);
+      await scanDir(contentDir, [version.dir, root.contentDir]);
+    }
+  }
+  return metaMap;
+}
+function buildPageTree(pages, config2, folderMeta) {
+  const tree = { name: "root", children: [] };
+  const folderMap = new Map;
+  for (const page of pages) {
+    const segments = page.slugs;
+    if (segments.length === 0)
+      continue;
+    let current = tree.children;
+    for (let i = 0;i < segments.length - 1; i++) {
+      const folderPath2 = "/" + segments.slice(0, i + 1).join("/");
+      let folder = folderMap.get(folderPath2);
+      if (!folder) {
+        const meta = folderMeta.get(folderPath2);
+        folder = {
+          type: "folder",
+          name: meta?.title ?? titleFromSlug(segments[i]),
+          url: folderPath2,
+          $order: meta?.order,
+          children: []
+        };
+        folderMap.set(folderPath2, folder);
+        current.push(folder);
+      }
+      current = folder.children;
+    }
+    const pageNode = {
+      type: "page",
+      name: page.frontmatter.title,
+      url: page.url,
+      icon: page.frontmatter.icon,
+      $order: page.frontmatter.order
+    };
+    const folderPath = "/" + segments.slice(0, -1).join("/");
+    const parentFolder = folderMap.get(folderPath);
+    if (parentFolder && segments.length > 1) {
+      const isIndex = page.relativePath.match(/(index|readme)\.(mdx|md)$/i);
+      if (isIndex) {
+        parentFolder.index = pageNode;
+        parentFolder.name = page.frontmatter.title;
+        continue;
+      }
+    }
+    current.push(pageNode);
+  }
+  for (const root of getLatestContentRoots(config2)) {
+    const rootFolder = folderMap.get(`/${root.contentDir}`);
+    if (rootFolder) {
+      rootFolder.name = root.contentLabel;
+    }
+  }
+  function sortChildren(children) {
+    children.sort((a, b) => {
+      const orderA = a.$order ?? Number.MAX_SAFE_INTEGER;
+      const orderB = b.$order ?? Number.MAX_SAFE_INTEGER;
+      if (orderA !== orderB)
+        return orderA - orderB;
+      return a.name.localeCompare(b.name);
+    });
+    for (const child of children) {
+      if (child.children)
+        sortChildren(child.children);
+    }
+  }
+  sortChildren(tree.children);
+  function stripOrder(node) {
+    delete node.$order;
+    if (node.children)
+      node.children.forEach(stripOrder);
+    if (node.index)
+      delete node.index.$order;
+  }
+  tree.children.forEach(stripOrder);
+  return tree;
+}
+function flattenTreeUrls(tree) {
+  const result = [];
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.type === "folder") {
+        if (node.index)
+          result.push({ url: node.index.url, title: node.index.name });
+        if (node.children)
+          walk(node.children);
+      } else if (node.type === "page") {
+        result.push({ url: node.url, title: node.name });
+      }
+    }
+  }
+  walk(tree.children);
+  return result;
+}
+function computeNavigation(tree) {
+  const navMap = new Map;
+  const ordered = flattenTreeUrls(tree);
+  for (let i = 0;i < ordered.length; i++) {
+    navMap.set(ordered[i].url, {
+      prev: i > 0 ? { url: ordered[i - 1].url, title: ordered[i - 1].title } : null,
+      next: i < ordered.length - 1 ? { url: ordered[i + 1].url, title: ordered[i + 1].title } : null
+    });
+  }
+  return navMap;
+}
+async function loadSpecs(configs, projectRoot) {
+  const results = [];
+  for (const c of configs) {
+    try {
+      results.push(await loadApiSpec(c, projectRoot));
+    } catch {
+      try {
+        const specPath = path9.resolve(projectRoot, c.spec);
+        const raw = await fs6.readFile(specPath, "utf-8");
+        const isYaml = specPath.endsWith(".yaml") || specPath.endsWith(".yml");
+        const rawDoc = isYaml ? (await import("yaml")).parse(raw) : JSON.parse(raw);
+        const doc = rawDoc.openapi?.startsWith("3.") ? resolveDocument(rawDoc) : rawDoc;
+        results.push({
+          name: c.name,
+          basePath: c.basePath,
+          server: { ...c.server, url: c.server.url },
+          auth: c.auth,
+          document: doc
         });
+      } catch {
+        console.log(chalk2.yellow(`  Warning: Skipping spec ${c.name}`));
       }
+    }
+  }
+  return results;
+}
+async function generatePageDataFiles(pages, navMap, outputDir) {
+  const dataDir = path9.join(outputDir, "data", "pages");
+  await fs6.mkdir(dataDir, { recursive: true });
+  for (const page of pages) {
+    const slugKey = page.slugs.join(",") || "index";
+    const nav = navMap.get(page.url) ?? { prev: null, next: null };
+    const data = {
+      frontmatter: page.frontmatter,
+      relativePath: page.relativePath,
+      originalPath: page.originalPath,
+      images: page.images,
+      prev: nav.prev,
+      next: nav.next
+    };
+    const filePath = path9.join(dataDir, `${slugKey}.json`);
+    await fs6.writeFile(filePath, JSON.stringify(data));
+  }
+}
+async function generateSearchIndex(pages, config2, outputDir, projectRoot) {
+  const docs = [];
+  const contentEntries = config2.content ?? [];
+  for (const page of pages) {
+    const { headings, body } = extractHeadingsAndBody(page.rawContent);
+    const dir = page.url.replace(/^\//, "").split("/")[0];
+    const entry = contentEntries.find((c) => c.dir === dir);
+    docs.push({
+      id: page.url,
+      url: page.url,
+      title: page.frontmatter.title,
+      headings,
+      body: [page.frontmatter.description ?? "", body].join(" "),
+      type: SearchResultType.Page,
+      section: entry?.label ?? dir ?? ""
     });
+  }
+  const apiConfigs = config2.api ?? [];
+  if (apiConfigs.length) {
+    try {
+      const specs = await loadSpecs(apiConfigs, projectRoot);
+      for (const spec of specs) {
+        const specSlug = getSpecSlug(spec);
+        const paths = spec.document.paths ?? {};
+        for (const [pathStr, pathItem] of Object.entries(paths)) {
+          if (!pathItem)
+            continue;
+          for (const method of ["get", "post", "put", "delete", "patch"]) {
+            const op = pathItem[method];
+            if (!op)
+              continue;
+            const opId = op.operationId ?? `${method}_${pathStr.replace(/[/{}\-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "")}`;
+            const url = `/apis/${specSlug}/${encodeURIComponent(opId)}`;
+            docs.push({
+              id: url,
+              url,
+              title: `${method.toUpperCase()} ${op.summary ?? opId}`,
+              headings: op.summary ?? opId,
+              body: [op.description ?? "", pathStr, method.toUpperCase()].join(" "),
+              type: SearchResultType.Api,
+              section: spec.name
+            });
+          }
+        }
+      }
+    } catch {
+      console.log(chalk2.yellow("  Warning: Failed to load API specs for search index"));
+    }
+  }
+  const dataDir = path9.join(outputDir, "data");
+  await fs6.mkdir(dataDir, { recursive: true });
+  await fs6.writeFile(path9.join(dataDir, "search.json"), JSON.stringify(docs));
+}
+async function generateApiSpecs(config2, outputDir, projectRoot) {
+  const specsDir = path9.join(outputDir, "data", "specs");
+  await fs6.mkdir(specsDir, { recursive: true });
+  const latestConfigs = getApiConfigsForVersion(config2, null);
+  if (latestConfigs.length) {
+    try {
+      const specs = await loadSpecs(latestConfigs, projectRoot);
+      await fs6.writeFile(path9.join(specsDir, "latest.json"), JSON.stringify(specs));
+    } catch {
+      console.log(chalk2.yellow("  Warning: Failed to load latest API specs"));
+    }
+  }
+  for (const version of config2.versions ?? []) {
+    const versionConfigs = getApiConfigsForVersion(config2, version.dir);
+    if (!versionConfigs.length)
+      continue;
+    try {
+      const specs = await loadSpecs(versionConfigs, projectRoot);
+      await fs6.writeFile(path9.join(specsDir, `${version.dir}.json`), JSON.stringify(specs));
+    } catch {
+      console.log(chalk2.yellow(`  Warning: Failed to load API specs for version ${version.dir}`));
+    }
+  }
+}
+async function generateSitemap(pages, config2, outputDir, projectRoot) {
+  if (!config2.url) {
+    await fs6.writeFile(path9.join(outputDir, "sitemap.xml"), '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"/>');
+    return;
+  }
+  const baseUrl = config2.url.replace(/\/$/, "");
+  const docPages = pages.map((page) => {
+    let lastmod = "";
+    if (page.frontmatter.lastModified) {
+      const d = new Date(page.frontmatter.lastModified);
+      if (!Number.isNaN(d.getTime()))
+        lastmod = `<lastmod>${d.toISOString()}</lastmod>`;
+    }
+    return `<url><loc>${baseUrl}/${page.slugs.join("/")}</loc>${lastmod}</url>`;
   });
+  const apiPages = [];
+  for (const v of getAllVersions(config2)) {
+    const versionDir = v.isLatest ? null : v.dir;
+    const apiConfigs = getApiConfigsForVersion(config2, versionDir);
+    if (!apiConfigs.length)
+      continue;
+    const prefix = versionDir ? `/${versionDir}` : "";
+    try {
+      const routes = buildApiRoutes(await loadSpecs(apiConfigs, projectRoot));
+      for (const route of routes) {
+        apiPages.push(`<url><loc>${baseUrl}${prefix}/apis/${route.slug.join("/")}</loc></url>`);
+      }
+    } catch {}
+  }
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<url><loc>${baseUrl}</loc></url>
+${[...docPages, ...apiPages].join(`
+`)}
+</urlset>`;
+  await fs6.writeFile(path9.join(outputDir, "sitemap.xml"), xml);
+}
+async function generateRobotsTxt(config2, outputDir) {
+  const sitemap = config2.url ? `
+Sitemap: ${config2.url}/sitemap.xml` : "";
+  const body = `User-agent: *
+Allow: /${sitemap}`;
+  await fs6.writeFile(path9.join(outputDir, "robots.txt"), body);
+}
+async function generateLlmsTxt(pages, config2, outputDir) {
+  const latestCtx = { dir: null, urlPrefix: "" };
+  const versionPrefixes = (config2.versions ?? []).map((v) => `/${v.dir}`);
+  const latestPages = pages.filter((p) => !versionPrefixes.some((pre) => p.url === pre || p.url.startsWith(`${pre}/`)));
+  const llmsPages = latestPages.map((p) => ({
+    url: p.url,
+    title: p.frontmatter.title
+  }));
+  const body = buildLlmsTxt(config2, llmsPages, latestCtx);
+  await fs6.writeFile(path9.join(outputDir, "llms.txt"), body);
+}
+async function generateOgImages(pages, config2, outputDir, packageRoot) {
+  const ogDir = path9.join(outputDir, "og");
+  await fs6.mkdir(ogDir, { recursive: true });
+  const { loadFont: loadFont2 } = await Promise.resolve().then(() => (init_og_utils(), exports_og_utils));
+  const fontData = await loadFont2(packageRoot);
+  const siteName = config2.site.title;
+  for (const page of pages) {
+    const title = page.frontmatter.title;
+    const description = page.frontmatter.description ?? "";
+    const slugKey = page.slugs.join(",") || "index";
+    try {
+      const { createElement: h } = await import("react");
+      const svg = await satori(h("div", {
+        style: {
+          height: "100%",
+          width: "100%",
+          display: "flex",
+          flexDirection: "column",
+          justifyContent: "center",
+          padding: "60px 80px",
+          backgroundColor: "#0a0a0a",
+          color: "#fafafa"
+        }
+      }, h("div", { style: { fontSize: 24, color: "#888", marginBottom: 16 } }, siteName), h("div", {
+        style: {
+          fontSize: 56,
+          fontWeight: 700,
+          lineHeight: 1.2,
+          marginBottom: 24
+        }
+      }, title), description ? h("div", { style: { fontSize: 24, color: "#999", lineHeight: 1.4 } }, description) : null), {
+        width: 1200,
+        height: 630,
+        fonts: [
+          { name: "Inter", data: fontData, weight: 400, style: "normal" }
+        ]
+      });
+      const pngBuffer = await sharp(Buffer.from(svg)).png().toBuffer();
+      await fs6.writeFile(path9.join(ogDir, `${slugKey}.png`), pngBuffer);
+    } catch {}
+  }
+}
+async function optimizeImages(pages, packageRoot, outputDir) {
+  const contentDir = path9.resolve(packageRoot, ".content");
+  const seen = new Set;
+  let optimized = 0;
+  for (const page of pages) {
+    for (const imgUrl of page.images) {
+      if (!isLocalImage(imgUrl) || seen.has(imgUrl))
+        continue;
+      seen.add(imgUrl);
+      const relativePath = imgUrl.replace(/^\/_content\//, "");
+      const srcPath = path9.resolve(contentDir, relativePath);
+      if (!srcPath.startsWith(contentDir + path9.sep) && srcPath !== contentDir)
+        continue;
+      if (isSvg(imgUrl)) {
+        const destPath2 = path9.join(outputDir, "_content", relativePath);
+        try {
+          await fs6.mkdir(path9.dirname(destPath2), { recursive: true });
+          await fs6.copyFile(srcPath, destPath2);
+          optimized++;
+        } catch {}
+        continue;
+      }
+      const webpRelative = relativePath.replace(/\.[^.]+$/, ".webp");
+      const destPath = path9.join(outputDir, "_content", webpRelative);
+      try {
+        await fs6.mkdir(path9.dirname(destPath), { recursive: true });
+        const source = await fs6.readFile(srcPath);
+        const optimizedBuf = await sharp(source).resize({ width: DEFAULT_WIDTH, withoutEnlargement: true }).webp({ quality: DEFAULT_QUALITY }).toBuffer();
+        await fs6.writeFile(destPath, optimizedBuf);
+        const origDest = path9.join(outputDir, "_content", relativePath);
+        await fs6.mkdir(path9.dirname(origDest), { recursive: true });
+        await fs6.copyFile(srcPath, origDest);
+        optimized++;
+      } catch {}
+    }
+  }
+  if (optimized > 0) {
+    console.log(chalk2.gray(`  Optimized ${optimized} images`));
+  }
+}
+async function copyPublicAssets(projectRoot, outputDir) {
+  const publicDir = path9.resolve(projectRoot, "public");
+  if (!existsSync(publicDir))
+    return;
+  async function copyTree(src, dest) {
+    const entries = await fs6.readdir(src, { withFileTypes: true });
+    await fs6.mkdir(dest, { recursive: true });
+    for (const entry of entries) {
+      const srcPath = path9.join(src, entry.name);
+      const destPath = path9.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await copyTree(srcPath, destPath);
+      } else {
+        await fs6.copyFile(srcPath, destPath);
+      }
+    }
+  }
+  await copyTree(publicDir, outputDir);
+}
+function readViteManifest(outputDir) {
+  const candidates = [
+    path9.join(outputDir, ".vite", "manifest.json"),
+    path9.join(outputDir, "assets", ".vite", "manifest.json"),
+    path9.join(outputDir, ".vite/manifest.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      try {
+        const raw = readFileSync(candidate, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function generateSpaIndex(config2, tree, outputDir) {
+  const manifest = readViteManifest(outputDir);
+  let entryJs = "";
+  const cssFiles = [];
+  const preloadFiles = [];
+  if (manifest) {
+    for (const [, entry] of Object.entries(manifest)) {
+      if (entry.isEntry) {
+        entryJs = `/${entry.file}`;
+        if (entry.css) {
+          cssFiles.push(...entry.css.map((f) => `/${f}`));
+        }
+        if (entry.imports) {
+          for (const imp of entry.imports) {
+            const impEntry = manifest[imp];
+            if (impEntry) {
+              preloadFiles.push(`/${impEntry.file}`);
+              if (impEntry.css) {
+                cssFiles.push(...impEntry.css.map((f) => `/${f}`));
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  if (!entryJs) {
+    throw new Error("Could not determine Vite client entry from manifest — static index generation aborted");
+  }
+  const latestCtx = { dir: null, urlPrefix: "" };
+  const pageData = {
+    config: config2,
+    tree,
+    version: latestCtx
+  };
+  const safeJson = JSON.stringify(pageData).replace(/</g, "\\u003c");
+  const cssLinks = [...new Set(cssFiles)].map((f) => `  <link rel="stylesheet" href="${f}">`).join(`
+`);
+  const preloadLinks = [...new Set(preloadFiles)].map((f) => `  <link rel="modulepreload" href="${f}">`).join(`
+`);
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="icon" href="/favicon.ico">
+  <link rel="icon" href="/favicon.svg" type="image/svg+xml">
+${cssLinks}
+${preloadLinks}
+  <script type="module" src="${entryJs}"></script>
+  <script>
+    window.__STATIC_MODE__ = true;
+    window.__PAGE_DATA__ = ${safeJson};
+  </script>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>`;
+  await fs6.writeFile(path9.join(outputDir, "index.html"), html);
+}
+async function generateMarkdownFiles(pages, apiSpecs, outputDir) {
+  for (const page of pages) {
+    const mdPath = page.url === "/" ? "/index.md" : `${page.url}.md`;
+    const outPath = path9.join(outputDir, mdPath);
+    await fs6.mkdir(path9.dirname(outPath), { recursive: true });
+    await fs6.writeFile(outPath, page.rawContent);
+  }
+  if (!apiSpecs.length)
+    return;
+  const { flattenSchema: flattenSchema2, generateExampleJson: generateExampleJson2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+  const { generateCurl: generateCurl2 } = await Promise.resolve().then(() => exports_snippet_generators);
+  for (const spec of apiSpecs) {
+    const specSlug = getSpecSlug(spec);
+    const paths = spec.document.paths ?? {};
+    for (const [pathStr, pathItem] of Object.entries(paths)) {
+      if (!pathItem)
+        continue;
+      for (const method of ["get", "post", "put", "delete", "patch"]) {
+        const op = pathItem[method];
+        if (!op)
+          continue;
+        const opId = op.operationId ?? `${method}_${pathStr.replace(/[/{}\-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "")}`;
+        const mdPath = `/apis/${specSlug}/${encodeURIComponent(opId)}.md`;
+        const outPath = path9.join(outputDir, mdPath);
+        await fs6.mkdir(path9.dirname(outPath), { recursive: true });
+        const md = buildApiMd(method.toUpperCase(), pathStr, op, spec.server.url, spec.auth, flattenSchema2, generateExampleJson2, generateCurl2);
+        await fs6.writeFile(outPath, md);
+      }
+    }
+  }
+}
+function buildApiMd(method, apiPath, operation, serverUrl, auth, flattenSchema2, generateExampleJson2, generateCurl2) {
+  const lines = [];
+  const params = operation.parameters ?? [];
+  lines.push(`# ${operation.summary ?? `${method} ${apiPath}`}`);
+  lines.push("");
+  if (operation.description) {
+    lines.push(operation.description);
+    lines.push("");
+  }
+  lines.push(`\`${method}\` \`${apiPath}\``);
+  lines.push("");
+  const headerParams = params.filter((p) => p.in === "header");
+  const pathParams = params.filter((p) => p.in === "path");
+  const queryParams = params.filter((p) => p.in === "query");
+  if (auth || headerParams.length > 0) {
+    lines.push("## Authorization");
+    lines.push("");
+    lines.push("| Header | Type | Required | Description |");
+    lines.push("| --- | --- | --- | --- |");
+    if (auth)
+      lines.push(`| \`${auth.header}\` | string | Yes | ${auth.placeholder ?? "API key"} |`);
+    for (const p of headerParams) {
+      const schema = p.schema ?? {};
+      lines.push(`| \`${p.name}\` | ${schema.type ?? "string"} | ${p.required ? "Yes" : "No"} | ${p.description ?? ""} |`);
+    }
+    lines.push("");
+  }
+  if (pathParams.length > 0) {
+    lines.push("## Path Parameters");
+    lines.push("");
+    lines.push("| Parameter | Type | Required | Description |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const p of pathParams) {
+      const schema = p.schema ?? {};
+      lines.push(`| \`${p.name}\` | ${schema.type ?? "string"} | ${p.required ? "Yes" : "No"} | ${p.description ?? ""} |`);
+    }
+    lines.push("");
+  }
+  if (queryParams.length > 0) {
+    lines.push("## Query Parameters");
+    lines.push("");
+    lines.push("| Parameter | Type | Required | Description |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const p of queryParams) {
+      const schema = p.schema ?? {};
+      lines.push(`| \`${p.name}\` | ${schema.type ?? "string"} | ${p.required ? "Yes" : "No"} | ${p.description ?? ""} |`);
+    }
+    lines.push("");
+  }
+  const requestBody = operation.requestBody;
+  if (requestBody?.content) {
+    const contentType = Object.keys(requestBody.content)[0];
+    const schema = contentType ? requestBody.content[contentType]?.schema : undefined;
+    if (schema) {
+      lines.push("## Request Body");
+      lines.push("");
+      lines.push(`Content-Type: \`${contentType}\``);
+      lines.push("");
+      const example = generateExampleJson2(schema);
+      lines.push("```json");
+      lines.push(JSON.stringify(example, null, 2));
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  const responses = operation.responses;
+  if (responses) {
+    lines.push("## Responses");
+    lines.push("");
+    for (const [status, resp] of Object.entries(responses)) {
+      lines.push(`### ${status}${resp.description ? ` — ${resp.description}` : ""}`);
+      lines.push("");
+      const content2 = resp.content ?? {};
+      const contentType = Object.keys(content2)[0];
+      const schema = contentType ? content2[contentType]?.schema : undefined;
+      if (schema) {
+        const example = generateExampleJson2(schema);
+        lines.push("```json");
+        lines.push(JSON.stringify(example, null, 2));
+        lines.push("```");
+        lines.push("");
+      }
+    }
+  }
+  const headers = {};
+  if (auth)
+    headers[auth.header] = auth.placeholder ?? "YOUR_API_KEY";
+  lines.push("## cURL");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(generateCurl2({ method, url: serverUrl + apiPath, headers }));
+  lines.push("```");
+  return lines.join(`
+`);
+}
+async function generateStaticSite(options) {
+  const { projectRoot, config: config2, outputDir, packageRoot } = options;
+  console.log(chalk2.cyan(`
+Generating static site...`));
+  console.log(chalk2.gray("  Scanning content..."));
+  const pages = await scanAllContent(projectRoot, config2, packageRoot);
+  console.log(chalk2.gray(`  Found ${pages.length} pages`));
+  const contentMirror = path9.resolve(packageRoot, ".content");
+  const folderMeta = await scanFolderMeta(contentMirror, config2);
+  const tree = buildPageTree(pages, config2, folderMeta);
+  const navMap = computeNavigation(tree);
+  console.log(chalk2.gray("  Generating page data files..."));
+  await generatePageDataFiles(pages, navMap, outputDir);
+  console.log(chalk2.gray("  Generating search index..."));
+  await generateSearchIndex(pages, config2, outputDir, projectRoot);
+  console.log(chalk2.gray("  Generating API specs..."));
+  await generateApiSpecs(config2, outputDir, projectRoot);
+  const latestApiConfigs = config2.api ?? [];
+  const apiSpecsForMd = latestApiConfigs.length ? await loadSpecs(latestApiConfigs, projectRoot) : [];
+  console.log(chalk2.gray("  Generating markdown files..."));
+  await generateMarkdownFiles(pages, apiSpecsForMd, outputDir);
+  console.log(chalk2.gray("  Generating sitemap.xml..."));
+  await generateSitemap(pages, config2, outputDir, projectRoot);
+  console.log(chalk2.gray("  Generating robots.txt..."));
+  await generateRobotsTxt(config2, outputDir);
+  console.log(chalk2.gray("  Generating llms.txt..."));
+  await generateLlmsTxt(pages, config2, outputDir);
+  console.log(chalk2.gray("  Generating OG images..."));
+  await generateOgImages(pages, config2, outputDir, packageRoot);
+  console.log(chalk2.gray("  Optimizing images..."));
+  await optimizeImages(pages, packageRoot, outputDir);
+  console.log(chalk2.gray("  Copying public assets..."));
+  await copyPublicAssets(projectRoot, outputDir);
+  console.log(chalk2.gray("  Generating SPA index.html..."));
+  await generateSpaIndex(config2, tree, outputDir);
+  console.log(chalk2.green(`  Static site generated: ${pages.length} pages`));
+}
+var init_static_generate = __esm(() => {
+  init_types();
+  init_config2();
+  init_openapi();
+  init_api_routes();
+  init_image_utils();
 });
+
+// src/lib/mdx-error.ts
+function cleanMessage(raw) {
+  const lines = raw.replace(ANSI_PATTERN, "").split(`
+`).map((line) => line.replace(/^\[(?:plugin|vite)[^\]]*\]\s*/, "").replace(/^\S*\.mdx?(?::[\d:-]+)*:?\s*/, "").trim()).filter((line) => line && !/^Build failed with \d+ errors?:?$/.test(line));
+  return lines[0] ?? raw.trim();
+}
+function parseMdxError(err) {
+  if (!err || typeof err !== "object")
+    return null;
+  const e = err;
+  const rawMessage = e.reason || e.message || "";
+  const missing = rawMessage.match(/Expected component `([^`]+)` to be defined/);
+  if (missing) {
+    return { message: `Unknown component <${missing[1]}> — it is not registered in Chronicle's MDX components.` };
+  }
+  const file = [e.file, e.loc?.file, e.id, ...rawMessage.match(/((?:\/|\.\.?\/)[^\s:]+\.mdx?)/) ?? []].find(isContentFile);
+  if (!file)
+    return null;
+  const place = e.place?.start ?? e.place;
+  let line = e.line ?? place?.line ?? e.loc?.line;
+  let column = e.column ?? place?.column ?? e.loc?.column;
+  if (line == null) {
+    const pos = rawMessage.match(/(\d+):(\d+)(?:-\d+:\d+)?/);
+    if (pos) {
+      line = Number(pos[1]);
+      column = Number(pos[2]);
+    }
+  }
+  return { message: cleanMessage(rawMessage), file: file.split("?")[0], line, column };
+}
+function buildCodeFrame(source, line, column, context = 2) {
+  const all = source.split(/\r?\n/);
+  const start = Math.max(1, line - context);
+  const end = Math.min(all.length, line + context);
+  const lines = [];
+  for (let n = start;n <= end; n++) {
+    lines.push({ number: n, text: all[n - 1] ?? "", target: n === line });
+  }
+  return { lines, caretColumn: column };
+}
+var ANSI_PATTERN, isContentFile = (p) => !!p && /\.mdx?$/.test(p.split("?")[0]);
+var init_mdx_error = __esm(() => {
+  ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+});
+
+// src/cli/utils/mdx-error-report.ts
+var exports_mdx_error_report = {};
+__export(exports_mdx_error_report, {
+  printMdxBuildError: () => printMdxBuildError
+});
+import fs7 from "node:fs/promises";
+import path10 from "node:path";
+import chalk3 from "chalk";
+async function printMdxBuildError(err, packageRoot) {
+  const info = parseMdxError(err);
+  if (!info)
+    return false;
+  const contentMirror = path10.resolve(packageRoot, ".content");
+  const displayPath = info.file?.startsWith(contentMirror) ? path10.relative(contentMirror, info.file) : info.file && !path10.relative(process.cwd(), info.file).startsWith("..") ? path10.relative(process.cwd(), info.file) : info.file;
+  console.error();
+  console.error(chalk3.bgRed.white(" MDX Error "), chalk3.red(info.message));
+  if (displayPath) {
+    const position = info.line ? `:${info.line}${info.column ? `:${info.column}` : ""}` : "";
+    console.error(chalk3.dim(`  ${displayPath}${position}`));
+  }
+  if (info.file && info.line) {
+    try {
+      const source = await fs7.readFile(info.file, "utf-8");
+      const frame = buildCodeFrame(source, info.line, info.column);
+      const gutter = String(frame.lines[frame.lines.length - 1]?.number ?? 0).length;
+      console.error();
+      for (const { number, text, target } of frame.lines) {
+        const ln = `${target ? ">" : " "} ${String(number).padStart(gutter)} | `;
+        console.error(target ? chalk3.red(ln) + text : chalk3.dim(ln + text));
+        if (target && frame.caretColumn) {
+          console.error(chalk3.red(`  ${" ".repeat(gutter)} | ${" ".repeat(frame.caretColumn - 1)}^`));
+        }
+      }
+    } catch {}
+  }
+  console.error();
+  return true;
+}
+var init_mdx_error_report = __esm(() => {
+  init_mdx_error();
+});
+
+// src/cli/index.ts
+import { Command as Command6 } from "commander";
+
+// src/cli/commands/build.ts
+import path11 from "node:path";
+import chalk4 from "chalk";
+import { Command } from "commander";
+
 // src/cli/utils/config.ts
+init_types();
+import fs from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { parse } from "yaml";
 function resolveConfigPath(configPath) {
   if (configPath)
     return path.resolve(configPath);
@@ -782,46 +2304,9 @@ import { fileURLToPath } from "url";
 var PACKAGE_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 // src/cli/utils/scaffold.ts
+init_config2();
 import fs2 from "node:fs/promises";
 import path3 from "node:path";
-
-// src/lib/config.ts
-import { parse as parse2 } from "yaml";
-var defaultConfig = chronicleConfigSchema.parse({
-  site: { title: "Documentation" },
-  content: [{ dir: "docs", label: "Docs" }],
-  theme: { name: "default" },
-  search: { enabled: true, placeholder: "Search..." }
-});
-function getLatestContentRoots(config2) {
-  return config2.content.map((c) => ({
-    versionDir: null,
-    versionLabel: config2.latest?.label ?? null,
-    contentDir: c.dir,
-    contentLabel: c.label,
-    contentDescription: c.description,
-    contentIcon: c.icon,
-    fsPath: `content/${c.dir}`,
-    urlPrefix: `/${c.dir}`
-  }));
-}
-function getVersionContentRoots(config2, versionDir) {
-  const version = config2.versions?.find((v) => v.dir === versionDir);
-  if (!version)
-    return [];
-  return version.content.map((c) => ({
-    versionDir: version.dir,
-    versionLabel: version.label,
-    contentDir: c.dir,
-    contentLabel: c.label,
-    contentDescription: c.description,
-    contentIcon: c.icon,
-    fsPath: `versions/${version.dir}/${c.dir}`,
-    urlPrefix: `/${version.dir}/${c.dir}`
-  }));
-}
-
-// src/cli/utils/scaffold.ts
 async function buildContentMirror(mirrorRoot, projectRoot, config2) {
   await removeMirror(mirrorRoot);
   await fs2.mkdir(mirrorRoot, { recursive: true });
@@ -881,28 +2366,54 @@ async function removeMirror(mirrorRoot) {
 }
 
 // src/cli/commands/build.ts
-var buildCommand = new Command("build").description("Build for production").option("--config <path>", "Path to chronicle.yaml").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
+var buildCommand = new Command("build").description("Build for production").option("--config <path>", "Path to chronicle.yaml").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server, static)").action(async (options) => {
   const { config: config2, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
     preset: options.preset
   });
   await linkContent(projectRoot, config2);
-  console.log(chalk2.cyan("Building for production..."));
-  const { createBuilder } = await import("vite");
-  const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
+  console.log(chalk4.cyan("Building for production..."));
+  const { createBuilder, build } = await import("vite");
+  const { createViteConfig: createViteConfig2, isStaticPreset: isStaticPreset2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
   const viteConfig = await createViteConfig2({
     packageRoot: PACKAGE_ROOT,
     projectRoot,
     configPath,
     preset
   });
-  const builder = await createBuilder({ ...viteConfig, builder: {} });
-  await builder.buildApp();
-  console.log(chalk2.green("Build complete"));
-  console.log(chalk2.cyan("Run `chronicle start` to start the server"));
+  try {
+    if (isStaticPreset2(preset)) {
+      await build(viteConfig);
+    } else {
+      const builder = await createBuilder({ ...viteConfig, builder: {} });
+      await builder.buildApp();
+    }
+    if (isStaticPreset2(preset)) {
+      const { generateStaticSite: generateStaticSite2 } = await Promise.resolve().then(() => (init_static_generate(), exports_static_generate));
+      const outputDir = path11.resolve(projectRoot, ".output/public");
+      await generateStaticSite2({
+        projectRoot,
+        config: config2,
+        outputDir,
+        packageRoot: PACKAGE_ROOT
+      });
+      console.log(chalk4.green("Static build complete"));
+      console.log(chalk4.cyan(`Output: ${outputDir}`));
+    } else {
+      console.log(chalk4.green("Build complete"));
+      console.log(chalk4.cyan("Run `chronicle start` to start the server"));
+    }
+  } catch (err) {
+    const { printMdxBuildError: printMdxBuildError2 } = await Promise.resolve().then(() => (init_mdx_error_report(), exports_mdx_error_report));
+    if (await printMdxBuildError2(err, PACKAGE_ROOT)) {
+      console.error(chalk4.red("Build failed"));
+      process.exit(1);
+    }
+    throw err;
+  }
 });
 
 // src/cli/commands/dev.ts
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 import { Command as Command2 } from "commander";
 var devCommand = new Command2("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").option("--preset <preset>", "Deploy preset (bun, node-server, etc.)").action(async (options) => {
   const { config: config2, projectRoot, configPath } = await loadCLIConfig(options.config);
@@ -911,7 +2422,7 @@ var devCommand = new Command2("dev").description("Start development server").opt
   if (process.platform === "win32" && !process.env.NITRO_DEV_RUNNER) {
     process.env.NITRO_DEV_RUNNER = "node-process";
   }
-  console.log(chalk3.cyan("Starting dev server..."));
+  console.log(chalk5.cyan("Starting dev server..."));
   const { createServer } = await import("vite");
   const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
   const viteConfig = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot, configPath, preset: options.preset });
@@ -936,9 +2447,9 @@ var devCommand = new Command2("dev").description("Start development server").opt
 });
 
 // src/cli/commands/init.ts
-import fs4 from "node:fs";
-import path7 from "node:path";
-import chalk4 from "chalk";
+import fs8 from "node:fs";
+import path12 from "node:path";
+import chalk6 from "chalk";
 import { Command as Command3 } from "commander";
 import { stringify } from "yaml";
 var defaultInitConfig = {
@@ -964,38 +2475,38 @@ var GITIGNORE_ENTRIES = ["node_modules", "dist", ".output"];
 function runInit(projectDir) {
   const events = [];
   const defaultDir = defaultInitConfig.content[0].dir;
-  const contentDir = path7.join(projectDir, "content", defaultDir);
-  if (!fs4.existsSync(contentDir)) {
-    fs4.mkdirSync(contentDir, { recursive: true });
+  const contentDir = path12.join(projectDir, "content", defaultDir);
+  if (!fs8.existsSync(contentDir)) {
+    fs8.mkdirSync(contentDir, { recursive: true });
     events.push({ type: "created", path: contentDir });
   }
-  const configPath = path7.join(projectDir, "chronicle.yaml");
-  if (!fs4.existsSync(configPath)) {
-    fs4.writeFileSync(configPath, stringify(defaultInitConfig));
+  const configPath = path12.join(projectDir, "chronicle.yaml");
+  if (!fs8.existsSync(configPath)) {
+    fs8.writeFileSync(configPath, stringify(defaultInitConfig));
     events.push({ type: "created", path: configPath });
   } else {
     events.push({ type: "skipped", path: configPath, detail: "already exists" });
   }
-  const contentFiles = fs4.readdirSync(contentDir);
+  const contentFiles = fs8.readdirSync(contentDir);
   if (contentFiles.length === 0) {
-    const indexPath = path7.join(contentDir, "index.mdx");
-    fs4.writeFileSync(indexPath, sampleMdx);
+    const indexPath = path12.join(contentDir, "index.mdx");
+    fs8.writeFileSync(indexPath, sampleMdx);
     events.push({ type: "created", path: indexPath });
   }
-  const gitignorePath = path7.join(projectDir, ".gitignore");
-  if (fs4.existsSync(gitignorePath)) {
-    const existing = fs4.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path12.join(projectDir, ".gitignore");
+  if (fs8.existsSync(gitignorePath)) {
+    const existing = fs8.readFileSync(gitignorePath, "utf-8");
     const existingLines = new Set(existing.split(/\r?\n/).map((l) => l.trim()).filter(Boolean));
     const missing = GITIGNORE_ENTRIES.filter((e) => !existingLines.has(e));
     if (missing.length > 0) {
-      fs4.appendFileSync(gitignorePath, `
+      fs8.appendFileSync(gitignorePath, `
 ${missing.join(`
 `)}
 `);
       events.push({ type: "updated", path: gitignorePath, detail: missing.join(", ") });
     }
   } else {
-    fs4.writeFileSync(gitignorePath, `${GITIGNORE_ENTRIES.join(`
+    fs8.writeFileSync(gitignorePath, `${GITIGNORE_ENTRIES.join(`
 `)}
 `);
     events.push({ type: "created", path: gitignorePath });
@@ -1004,25 +2515,25 @@ ${missing.join(`
 }
 function formatEvent(e) {
   if (e.type === "skipped") {
-    return `${chalk4.yellow("⚠")} ${e.path}${e.detail ? ` ${e.detail}` : ""}`;
+    return `${chalk6.yellow("⚠")} ${e.path}${e.detail ? ` ${e.detail}` : ""}`;
   }
   if (e.type === "updated") {
-    return `${chalk4.green("✓")} Updated ${e.path}${e.detail ? ` (+${e.detail})` : ""}`;
+    return `${chalk6.green("✓")} Updated ${e.path}${e.detail ? ` (+${e.detail})` : ""}`;
   }
-  return `${chalk4.green("✓")} Created ${e.path}`;
+  return `${chalk6.green("✓")} Created ${e.path}`;
 }
 var initCommand = new Command3("init").description("Initialize a new Chronicle project").action(() => {
   const events = runInit(process.cwd());
   for (const e of events)
     console.log(formatEvent(e));
-  console.log(chalk4.green(`
+  console.log(chalk6.green(`
 ✓ Chronicle initialized!`));
   console.log(`
-Run`, chalk4.cyan("chronicle dev"), "to start development server");
+Run`, chalk6.cyan("chronicle dev"), "to start development server");
 });
 
 // src/cli/commands/serve.ts
-import chalk5 from "chalk";
+import chalk7 from "chalk";
 import { Command as Command4 } from "commander";
 var serveCommand = new Command4("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
   const { config: config2, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
@@ -1038,9 +2549,9 @@ var serveCommand = new Command4("serve").description("Build and start production
     configPath,
     preset
   });
-  console.log(chalk5.cyan("Building for production..."));
+  console.log(chalk7.cyan("Building for production..."));
   await build(viteConfig);
-  console.log(chalk5.cyan("Starting production server..."));
+  console.log(chalk7.cyan("Starting production server..."));
   const server = await preview({
     ...viteConfig,
     preview: { port, host: options.host }
@@ -1049,13 +2560,13 @@ var serveCommand = new Command4("serve").description("Build and start production
 });
 
 // src/cli/commands/start.ts
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 import { Command as Command5 } from "commander";
 var startCommand = new Command5("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").action(async (options) => {
   const { config: config2, projectRoot, configPath } = await loadCLIConfig(options.config);
   const port = parseInt(options.port, 10);
   await linkContent(projectRoot, config2);
-  console.log(chalk6.cyan("Starting production server..."));
+  console.log(chalk8.cyan("Starting production server..."));
   const { preview } = await import("vite");
   const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
   const viteConfig = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot, configPath });