fromsrc 0.0.0 → 0.0.2

package/dist/source.js

@@ -0,0 +1,188 @@
+import matter from 'gray-matter';
+import { z } from './schema';
+
+function createRemoteSource(config) {
+  const base = trimslash(config.baseUrl);
+  const ttl = config.ttl ?? 1e3 * 60 * 5;
+  const indexUrl = config.index || `${base}/llms.txt`;
+  const docsUrl = config.docsEndpoint || `${base}/api/docs?limit=1000`;
+  const rawUrl = trimslash(config.rawEndpoint || `${base}/api/raw`);
+  const searchIndexUrl = config.searchIndexEndpoint || `${base}/api/search-index`;
+  const listcache = createcache(ttl);
+  const filecache = createcache(ttl);
+  const searchcache = createcache(ttl);
+  return {
+    async list() {
+      const cached = listcache.get("list");
+      if (cached) return cached;
+      const docs = await loaddocs(docsUrl);
+      if (docs.length > 0) {
+        listcache.set("list", docs);
+        return docs;
+      }
+      const llms = await loadllms(indexUrl, base);
+      listcache.set("list", llms);
+      return llms;
+    },
+    async get(slug) {
+      const path = slug.length === 0 ? "index" : slug.join("/");
+      const cached = filecache.get(path);
+      if (cached) return cached;
+      const normalized = slug.length === 0 ? "index" : slug.map((part) => encodeURIComponent(part)).join("/");
+      const res = await fetch(`${rawUrl}/${normalized}`);
+      if (!res.ok) return null;
+      const source = await res.text();
+      const parsed = parsefrontmatter(source);
+      const docs = await this.list();
+      const item = docs.find((doc) => doc.slug === path || path === "index" && doc.slug === "");
+      const data = { ...parsed.data };
+      if (item?.title) data.title = item.title;
+      if (item?.description) data.description = item.description;
+      const value = { content: parsed.content, data };
+      filecache.set(path, value);
+      return value;
+    },
+    async search() {
+      const cached = searchcache.get("search");
+      if (cached) return cached;
+      const docs = await loadsearch(searchIndexUrl);
+      searchcache.set("search", docs);
+      return docs;
+    }
+  };
+}
+function createcache(ttl) {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const value = store.get(key);
+      if (!value) return null;
+      if (Date.now() - value.at > ttl) {
+        store.delete(key);
+        return null;
+      }
+      return value.data;
+    },
+    set(key, data) {
+      store.set(key, { data, at: Date.now() });
+    }
+  };
+}
+const docsSchema = z.object({
+  data: z.array(
+    z.object({
+      slug: z.string(),
+      title: z.string(),
+      description: z.string().optional()
+    })
+  )
+});
+const indexSchema = z.object({
+  documents: z.array(
+    z.object({
+      path: z.string(),
+      title: z.string(),
+      description: z.string().optional(),
+      headings: z.array(z.string()),
+      content: z.string()
+    })
+  )
+});
+async function loaddocs(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return [];
+    const data = docsSchema.parse(await res.json());
+    return data.data;
+  } catch {
+    return [];
+  }
+}
+async function loadsearch(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return [];
+    const data = indexSchema.parse(await res.json());
+    return data.documents.map((doc) => ({
+      slug: normalizepath(doc.path),
+      title: doc.title,
+      description: doc.description,
+      content: doc.content,
+      headings: headings(doc.headings)
+    }));
+  } catch {
+    return [];
+  }
+}
+async function loadllms(url, base) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return [];
+    const text = await res.text();
+    return parseLlmsIndex(text, base);
+  } catch {
+    return [];
+  }
+}
+function parseLlmsIndex(text, baseUrl) {
+  const docs = [];
+  for (const line of text.split("\n")) {
+    const match = line.match(/^- \[(.+?)\]\((.+?)\)(?:: (.+))?$/);
+    if (!match) continue;
+    const title = match[1];
+    const url = match[2];
+    if (!title || !url) continue;
+    const description = match[3]?.trim();
+    const slug = slugfrom(url, baseUrl);
+    if (!slug && url !== `${baseUrl}/docs`) continue;
+    docs.push({ slug, title, description });
+  }
+  return docs;
+}
+function slugfrom(value, base) {
+  const parsed = parseurl(value, base);
+  if (!parsed) return "";
+  const path = parsed.pathname.replace(/^\/docs\/?/, "").replace(/\/$/, "").trim();
+  return normalizepath(path);
+}
+function parseurl(value, base) {
+  try {
+    return new URL(value, base);
+  } catch {
+    return null;
+  }
+}
+function normalizepath(value) {
+  return value.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function trimslash(value) {
+  return value.replace(/\/+$/, "");
+}
+function headingid(text) {
+  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function parsefrontmatter(source) {
+  try {
+    const parsed = matter(source);
+    const data = typeof parsed.data === "object" && parsed.data !== null ? { ...parsed.data } : {};
+    return { content: parsed.content, data };
+  } catch {
+    return { content: source, data: {} };
+  }
+}
+function headings(values) {
+  if (values.length === 0) return void 0;
+  const seen = /* @__PURE__ */ new Map();
+  const list = [];
+  for (const text of values) {
+    const base = headingid(text);
+    if (!base) continue;
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    const id = count === 0 ? base : `${base}-${count}`;
+    list.push({ id, text, level: 2 });
+  }
+  return list.length > 0 ? list : void 0;
+}
+
+export { createRemoteSource };

package/dist/stats.d.ts

@@ -0,0 +1,25 @@
+type DocsStats = {
+    totalPages: number;
+    totalWords: number;
+    avgWords: number;
+    totalHeadings: number;
+    totalLinks: number;
+    totalCodeBlocks: number;
+    totalImages: number;
+    languages: Record<string, number>;
+    lastUpdated: string;
+};
+type PageStats = {
+    path: string;
+    words: number;
+    headings: number;
+    links: number;
+    codeBlocks: number;
+    images: number;
+};
+declare function analyzePage(content: string, path: string): PageStats;
+declare function analyzeDocs(dir: string): Promise<DocsStats>;
+declare function formatStats(stats: DocsStats): string;
+declare function compareStats(before: DocsStats, after: DocsStats): string;
+
+export { type DocsStats, type PageStats, analyzeDocs, analyzePage, compareStats, formatStats };

package/dist/stats.js

@@ -0,0 +1,81 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { relative, join, extname } from 'node:path';
+
+function analyzePage(content, path) {
+  const words = content.split(/\s+/).filter(Boolean).length;
+  const headings = (content.match(/^#{1,6}\s/gm) || []).length;
+  const links = (content.match(/\[([^\]]*)\]\(([^)]*)\)/g) || []).length;
+  const images = (content.match(/!\[([^\]]*)\]\(([^)]*)\)/g) || []).length;
+  const codeBlocks = Math.floor((content.match(/^```/gm) || []).length / 2);
+  return { path, words, headings, links, codeBlocks, images };
+}
+function extractLanguages(content) {
+  const langs = {};
+  for (const m of content.match(/^```(\w+)/gm) || []) {
+    const l = m.slice(3);
+    langs[l] = (langs[l] || 0) + 1;
+  }
+  return langs;
+}
+async function collectFiles(dir) {
+  const files = [];
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await collectFiles(full));
+    else if ([".md", ".mdx"].includes(extname(entry.name))) files.push(full);
+  }
+  return files;
+}
+async function analyzeDocs(dir) {
+  const files = await collectFiles(dir);
+  const pages = [];
+  const languages = {};
+  let latest = "";
+  for (const file of files) {
+    const content = await readFile(file, "utf-8");
+    const modified = (await stat(file)).mtime.toISOString();
+    if (modified > latest) latest = modified;
+    pages.push(analyzePage(content, relative(dir, file)));
+    for (const [lang, count] of Object.entries(extractLanguages(content)))
+      languages[lang] = (languages[lang] || 0) + count;
+  }
+  const totalWords = pages.reduce((s, p) => s + p.words, 0);
+  const sum = (fn) => pages.reduce((s, p) => s + fn(p), 0);
+  return {
+    totalPages: pages.length,
+    totalWords,
+    avgWords: pages.length ? Math.round(totalWords / pages.length) : 0,
+    totalHeadings: sum((p) => p.headings),
+    totalLinks: sum((p) => p.links),
+    totalCodeBlocks: sum((p) => p.codeBlocks),
+    totalImages: sum((p) => p.images),
+    languages,
+    lastUpdated: latest || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatStats(stats) {
+  const langs = Object.entries(stats.languages).sort((a, b) => b[1] - a[1]).map(([l, c]) => `${l}: ${c}`).join(", ");
+  return [
+    `pages: ${stats.totalPages}`,
+    `words: ${stats.totalWords} (avg ${stats.avgWords}/page)`,
+    `headings: ${stats.totalHeadings}`,
+    `links: ${stats.totalLinks}`,
+    `code blocks: ${stats.totalCodeBlocks}`,
+    `images: ${stats.totalImages}`,
+    langs ? `languages: ${langs}` : null,
+    `updated: ${stats.lastUpdated}`
+  ].filter(Boolean).join("\n");
+}
+function compareStats(before, after) {
+  const d = (l, a, b) => b - a === 0 ? null : `${l}: ${b - a > 0 ? "+" : ""}${b - a}`;
+  return [
+    d("pages", before.totalPages, after.totalPages),
+    d("words", before.totalWords, after.totalWords),
+    d("headings", before.totalHeadings, after.totalHeadings),
+    d("links", before.totalLinks, after.totalLinks),
+    d("code blocks", before.totalCodeBlocks, after.totalCodeBlocks),
+    d("images", before.totalImages, after.totalImages)
+  ].filter(Boolean).join("\n");
+}
+
+export { analyzeDocs, analyzePage, compareStats, formatStats };

package/dist/tanstack.d.ts

@@ -0,0 +1,3 @@
+export { tanstackAdapter } from './adaptertanstack.js';
+export { AdapterContext, AdapterProvider, FrameworkAdapter, createadapter, useAdapter } from './adapter.js';
+import 'react';

package/dist/tanstack.js

@@ -0,0 +1,3 @@
+"use client";
+export { tanstackAdapter } from './adaptertanstack';
+export { AdapterContext, AdapterProvider, createadapter, useAdapter } from './adapter';

package/dist/testing.d.ts

@@ -0,0 +1,35 @@
+type TestCase = {
+    name: string;
+    fn: () => Promise<void> | void;
+};
+type TestResult = {
+    name: string;
+    passed: boolean;
+    error?: string;
+    duration: number;
+};
+type TestSuite = {
+    name: string;
+    results: TestResult[];
+    passed: number;
+    failed: number;
+    duration: number;
+};
+declare function createTestSuite(name: string): {
+    test: (caseName: string, fn: () => Promise<void> | void) => void;
+    run: () => Promise<TestSuite>;
+};
+declare function assertFrontmatter(content: string, fields: string[]): void;
+declare function assertHeadings(content: string, options?: {
+    minCount?: number;
+    maxDepth?: number;
+    sequential?: boolean;
+}): void;
+declare function assertLinks(content: string): void;
+declare function assertLength(content: string, options: {
+    minWords?: number;
+    maxWords?: number;
+}): void;
+declare function formatTestSuite(suite: TestSuite): string;
+
+export { type TestCase, type TestResult, type TestSuite, assertFrontmatter, assertHeadings, assertLength, assertLinks, createTestSuite, formatTestSuite };

package/dist/testing.js

@@ -0,0 +1,134 @@
+function headingid(value) {
+  return value.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+}
+function collectheadingids(content) {
+  return [...content.matchAll(/^#{1,6}\s+(.+)$/gm)].map((match) => {
+    const value = match[1];
+    if (!value) return "";
+    return headingid(value);
+  }).filter(Boolean);
+}
+function createTestSuite(name) {
+  const cases = [];
+  function test(caseName, fn) {
+    cases.push({ name: caseName, fn });
+  }
+  async function run() {
+    const results = [];
+    const start = performance.now();
+    for (const c of cases) {
+      const t = performance.now();
+      try {
+        await c.fn();
+        results.push({ name: c.name, passed: true, duration: performance.now() - t });
+      } catch (e) {
+        results.push({
+          name: c.name,
+          passed: false,
+          error: e instanceof Error ? e.message : String(e),
+          duration: performance.now() - t
+        });
+      }
+    }
+    return {
+      name,
+      results,
+      passed: results.filter((r) => r.passed).length,
+      failed: results.filter((r) => !r.passed).length,
+      duration: performance.now() - start
+    };
+  }
+  return { test, run };
+}
+function assertFrontmatter(content, fields) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) throw new Error("missing frontmatter");
+  const body = match[1];
+  if (!body) throw new Error("invalid frontmatter");
+  const lines = body.split("\n");
+  const values = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const index = line.indexOf(":");
+    if (index < 1) continue;
+    const key = line.slice(0, index).trim();
+    if (!key) continue;
+    if (values.has(key)) throw new Error(`duplicate field: ${key}`);
+    const value = line.slice(index + 1).trim();
+    values.set(key, value);
+  }
+  for (const field of fields) {
+    if (!values.has(field)) throw new Error(`missing field: ${field}`);
+    const value = values.get(field) ?? "";
+    if (!value) throw new Error(`empty field: ${field}`);
+  }
+}
+function assertHeadings(content, options) {
+  const ids = collectheadingids(content);
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) throw new Error(`duplicate heading id: ${id}`);
+    seen.add(id);
+  }
+  const headings = [...content.matchAll(/^(#{1,6})\s+/gm)].map((m) => m[1]?.length ?? 0).filter((level) => level > 0);
+  if (options?.minCount && headings.length < options.minCount) {
+    throw new Error(`expected at least ${options.minCount} headings, found ${headings.length}`);
+  }
+  if (options?.maxDepth) {
+    for (const level of headings) {
+      if (level > options.maxDepth) {
+        throw new Error(`heading h${level} exceeds max depth ${options.maxDepth}`);
+      }
+    }
+  }
+  if (options?.sequential) {
+    for (let i = 1; i < headings.length; i++) {
+      const current = headings[i];
+      const previous = headings[i - 1];
+      if (!current || !previous) continue;
+      if (current > previous + 1) {
+        throw new Error(`heading h${headings[i]} skips level after h${headings[i - 1]}`);
+      }
+    }
+  }
+}
+function assertLinks(content) {
+  const placeholders = /* @__PURE__ */ new Set(["#", "todo", "http://", "https://", "about:blank", "javascript:void(0)"]);
+  const headingids = new Set(collectheadingids(content));
+  const links = [...content.matchAll(/\[([^\]]*)\]\(([^)]*)\)/g)];
+  for (const [, text = "", url = ""] of links) {
+    if (!text.trim()) throw new Error("empty link text");
+    const value = url.trim();
+    const lowered = value.toLowerCase();
+    if (!value || placeholders.has(lowered)) {
+      throw new Error(`placeholder link: ${url}`);
+    }
+    if (value.startsWith("#")) {
+      const target = value.slice(1).toLowerCase();
+      if (!target || !headingids.has(target)) {
+        throw new Error(`missing anchor target: ${url}`);
+      }
+    }
+  }
+}
+function assertLength(content, options) {
+  const words = content.replace(/^---\n[\s\S]*?\n---\n?/, "").split(/\s+/).filter(Boolean).length;
+  if (options.minWords && words < options.minWords) {
+    throw new Error(`expected at least ${options.minWords} words, found ${words}`);
+  }
+  if (options.maxWords && words > options.maxWords) {
+    throw new Error(`expected at most ${options.maxWords} words, found ${words}`);
+  }
+}
+function formatTestSuite(suite) {
+  const lines = [
+    `${suite.name}: ${suite.passed}/${suite.results.length} passed (${Math.round(suite.duration)}ms)`
+  ];
+  for (const r of suite.results) {
+    const status = r.passed ? "pass" : "FAIL";
+    lines.push(`  ${status} ${r.name} (${Math.round(r.duration)}ms)`);
+    if (r.error) lines.push(`       ${r.error}`);
+  }
+  return lines.join("\n");
+}
+
+export { assertFrontmatter, assertHeadings, assertLength, assertLinks, createTestSuite, formatTestSuite };

package/dist/themeutil.d.ts

@@ -0,0 +1,31 @@
+type ThemeColors = {
+    bg: string;
+    surface: string;
+    fg: string;
+    muted: string;
+    dim: string;
+    accent: string;
+    line: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+};
+type ThemeConfig = {
+    light: ThemeColors;
+    dark: ThemeColors;
+    radius?: string;
+    font?: string;
+    mono?: string;
+};
+type ThemePreset = {
+    name: string;
+    config: ThemeConfig;
+};
+declare function generateCss(config: ThemeConfig): string;
+declare const presets: Record<string, ThemePreset>;
+declare function mergeTheme(base: ThemeConfig, overrides: Partial<ThemeConfig>): ThemeConfig;
+declare function contrastRatio(hex1: string, hex2: string): number;
+declare function cssVariables(colors: ThemeColors): Record<string, string>;
+
+export { type ThemeColors, type ThemeConfig, type ThemePreset, contrastRatio, cssVariables, generateCss, mergeTheme, presets };

package/dist/themeutil.js

@@ -0,0 +1,92 @@
+const colorKeys = [
+  "bg",
+  "surface",
+  "fg",
+  "muted",
+  "dim",
+  "accent",
+  "line",
+  "success",
+  "warning",
+  "error",
+  "info"
+];
+function colors(bg, surface, fg, muted, dim, accent, line, success, warning, error, info) {
+  return { bg, surface, fg, muted, dim, accent, line, success, warning, error, info };
+}
+function generateCss(config) {
+  const lines = [":root {"];
+  for (const key of colorKeys) lines.push(`	--${key}: ${config.light[key]};`);
+  if (config.radius) lines.push(`	--radius: ${config.radius};`);
+  if (config.font) lines.push(`	--font: ${config.font};`);
+  if (config.mono) lines.push(`	--mono: ${config.mono};`);
+  lines.push("}", "", ".dark {");
+  for (const key of colorKeys) lines.push(`	--${key}: ${config.dark[key]};`);
+  lines.push("}");
+  return lines.join("\n");
+}
+const presets = {
+  default: {
+    name: "default",
+    config: {
+      light: colors("#ffffff", "#f8f9fa", "#1a1a1a", "#6b7280", "#9ca3af", "#2563eb", "#e5e7eb", "#16a34a", "#ca8a04", "#dc2626", "#2563eb"),
+      dark: colors("#0a0a0a", "#141414", "#f5f5f5", "#a1a1aa", "#71717a", "#3b82f6", "#27272a", "#22c55e", "#eab308", "#ef4444", "#3b82f6")
+    }
+  },
+  ocean: {
+    name: "ocean",
+    config: {
+      light: colors("#f0f7ff", "#e0efff", "#0c1929", "#4a6a8a", "#7a9aba", "#0066cc", "#c4daf0", "#0d7a3e", "#b8860b", "#c41e3a", "#0066cc"),
+      dark: colors("#0a1628", "#112240", "#e6f0ff", "#8baac8", "#5a7a98", "#4d9fff", "#1e3a5f", "#2ecc71", "#f1c40f", "#e74c3c", "#4d9fff")
+    }
+  },
+  forest: {
+    name: "forest",
+    config: {
+      light: colors("#f5faf5", "#e8f5e8", "#1a2e1a", "#4a6b4a", "#7a9b7a", "#2d8a4e", "#c8e0c8", "#1a7a35", "#a68b00", "#c0392b", "#2d8a4e"),
+      dark: colors("#0a160a", "#142014", "#e8f5e8", "#8ab88a", "#5a8a5a", "#4caf50", "#1e3a1e", "#27ae60", "#f39c12", "#e74c3c", "#4caf50")
+    }
+  },
+  rose: {
+    name: "rose",
+    config: {
+      light: colors("#fff5f7", "#ffe4ea", "#2a1015", "#8a4a5a", "#ba7a8a", "#e11d48", "#f0c8d0", "#16a34a", "#ca8a04", "#dc2626", "#e11d48"),
+      dark: colors("#160a0e", "#201418", "#fce4ec", "#c88a9a", "#8a5a6a", "#fb7185", "#3a1e28", "#22c55e", "#eab308", "#ef4444", "#fb7185")
+    }
+  }
+};
+function mergeTheme(base, overrides) {
+  return {
+    light: { ...base.light, ...overrides.light },
+    dark: { ...base.dark, ...overrides.dark },
+    radius: overrides.radius ?? base.radius,
+    font: overrides.font ?? base.font,
+    mono: overrides.mono ?? base.mono
+  };
+}
+function luminance(hex) {
+  const rgb = [1, 3, 5].map((i) => {
+    const c = Number.parseInt(hex.slice(i, i + 2), 16) / 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  });
+  const red = rgb[0] ?? 0;
+  const green = rgb[1] ?? 0;
+  const blue = rgb[2] ?? 0;
+  return 0.2126 * red + 0.7152 * green + 0.0722 * blue;
+}
+function contrastRatio(hex1, hex2) {
+  const l1 = luminance(hex1);
+  const l2 = luminance(hex2);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function cssVariables(colors2) {
+  const vars = {};
+  for (const key of colorKeys) {
+    vars[`--${key}`] = colors2[key];
+  }
+  return vars;
+}
+
+export { contrastRatio, cssVariables, generateCss, mergeTheme, presets };

package/dist/typegen.d.ts

@@ -0,0 +1,10 @@
+interface TypegenConfig {
+    dir: string;
+    output: string;
+    schemaName?: string;
+}
+declare function inferType(value: unknown): string;
+declare function generateTypes(config: TypegenConfig): Promise<string>;
+declare function writeTypes(config: TypegenConfig): Promise<void>;
+
+export { type TypegenConfig, generateTypes, inferType, writeTypes };

package/dist/typegen.js

@@ -0,0 +1,74 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+
+function inferType(value) {
+  if (value === null || value === void 0) return "unknown";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "unknown[]";
+    const types = [...new Set(value.map(inferType))];
+    return types.length === 1 ? `${types[0]}[]` : `(${types.join(" | ")})[]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "Record<string, unknown>";
+    const fields = entries.map(([k, v]) => `${k}: ${inferType(v)}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  return "unknown";
+}
+async function scanFiles(dir) {
+  const paths = [];
+  async function walk(current) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) await walk(full);
+      else if (entry.name.endsWith(".mdx")) paths.push(full);
+    }
+  }
+  await walk(dir);
+  return paths;
+}
+async function generateTypes(config) {
+  const name = config.schemaName ?? "DocFrontmatter";
+  const files = await scanFiles(config.dir);
+  const fieldTypes = /* @__PURE__ */ new Map();
+  const fieldCounts = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const file of files) {
+    const source = await readFile(file, "utf-8");
+    const { data } = matter(source);
+    if (!data || typeof data !== "object") continue;
+    total++;
+    for (const [key, value] of Object.entries(data)) {
+      const type = inferType(value);
+      let field = fieldTypes.get(key);
+      if (!field) {
+        field = /* @__PURE__ */ new Set();
+        fieldTypes.set(key, field);
+      }
+      field.add(type);
+      fieldCounts.set(key, (fieldCounts.get(key) ?? 0) + 1);
+    }
+  }
+  const lines = [`export interface ${name} {`];
+  const sorted = [...fieldTypes.entries()].sort(([a], [b]) => a.localeCompare(b));
+  for (const [key, types] of sorted) {
+    const optional = (fieldCounts.get(key) ?? 0) < total;
+    const union = [...types].join(" | ");
+    const suffix = optional ? "?" : "";
+    lines.push(`	${key}${suffix}: ${union}`);
+  }
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+async function writeTypes(config) {
+  const content = await generateTypes(config);
+  await writeFile(config.output, content, "utf-8");
+}
+
+export { generateTypes, inferType, writeTypes };