@grainulation/mill 1.0.0

package/lib/formats/slide-deck.js

@@ -0,0 +1,200 @@
+/**
+ * mill format: slide-deck
+ *
+ * Self-contained HTML with CSS scroll-snap. One slide per claim type group.
+ * Dark theme matching grainulation design tokens.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'slide-deck';
+export const extension = '.html';
+export const mimeType = 'text/html; charset=utf-8';
+export const description = 'Scroll-snap slide deck: one slide per type group with keyboard navigation';
+
+/**
+ * Convert a compilation object to a slide deck HTML page.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} HTML output
+ */
+export function convert(compilation) {
+  const meta = compilation.meta || {};
+  const claims = compilation.claims || [];
+  const conflicts = compilation.conflicts || [];
+  const certificate = compilation.certificate || {};
+
+  const title = meta.sprint || meta.question || 'Sprint Deck';
+  const compiled = certificate.compiled_at || new Date().toISOString();
+  const active = claims.filter(c => c.status === 'active').length;
+
+  // Group by type (skip reverted)
+  const byType = {};
+  for (const c of claims) {
+    if (c.status === 'reverted') continue;
+    const t = c.type || 'unknown';
+    if (!byType[t]) byType[t] = [];
+    byType[t].push(c);
+  }
+
+  const typeOrder = ['constraint', 'factual', 'recommendation', 'risk', 'estimate', 'feedback'];
+  const sortedTypes = typeOrder.filter(t => byType[t]);
+  for (const t of Object.keys(byType)) {
+    if (!sortedTypes.includes(t)) sortedTypes.push(t);
+  }
+
+  const typeColors = {
+    constraint: '#e74c3c',
+    factual: '#3498db',
+    recommendation: '#2ecc71',
+    risk: '#f39c12',
+    estimate: '#9b59b6',
+    feedback: '#1abc9c',
+    unknown: '#95a5a6',
+  };
+
+  // Title slide
+  const slides = [];
+  slides.push(`
+    <section class="slide">
+      <div class="slide-content title-slide">
+        <h1>${esc(title)}</h1>
+        ${meta.question ? `<p class="question">${esc(meta.question)}</p>` : ''}
+        <p class="meta">${esc(compiled)} | ${claims.length} claims</p>
+      </div>
+    </section>`);
+
+  // Summary slide
+  const typeStats = sortedTypes.map(t => {
+    const color = typeColors[t] || typeColors.unknown;
+    return `<div class="type-stat"><span class="dot" style="background:${color}"></span>${capitalize(t)}: ${byType[t].length}</div>`;
+  }).join('\n          ');
+
+  slides.push(`
+    <section class="slide">
+      <div class="slide-content">
+        <h2>Summary</h2>
+        <div class="summary-grid">
+          <div class="big-stat"><span class="num">${claims.length}</span><span class="label">Total</span></div>
+          <div class="big-stat"><span class="num">${active}</span><span class="label">Active</span></div>
+          ${conflicts.length ? `<div class="big-stat"><span class="num">${conflicts.length}</span><span class="label">Conflicts</span></div>` : ''}
+        </div>
+        <div class="type-stats">
+          ${typeStats}
+        </div>
+      </div>
+    </section>`);
+
+  // One slide per type group
+  for (const t of sortedTypes) {
+    const group = byType[t];
+    const color = typeColors[t] || typeColors.unknown;
+    const items = group.map(c => {
+      const body = esc(c.content || c.text || '');
+      const conf = c.confidence != null ? ` (${Math.round(c.confidence * 100)}%)` : '';
+      return `<li><strong>${esc(c.id)}</strong>${conf}: ${body}</li>`;
+    }).join('\n            ');
+
+    slides.push(`
+    <section class="slide">
+      <div class="slide-content">
+        <h2 style="border-left:4px solid ${color};padding-left:12px">${capitalize(t)}s (${group.length})</h2>
+        <ul class="claim-list">
+            ${items}
+        </ul>
+      </div>
+    </section>`);
+  }
+
+  // Conflicts slide (if any)
+  if (conflicts.length > 0) {
+    const conflictItems = conflicts.map(c => {
+      const ids = c.ids?.join(' vs ') || 'unknown';
+      const resolved = c.resolution ? ' [resolved]' : '';
+      return `<li><strong>${esc(ids)}</strong>${resolved}: ${esc(c.description || c.reason || '')}</li>`;
+    }).join('\n            ');
+
+    slides.push(`
+    <section class="slide">
+      <div class="slide-content">
+        <h2 style="border-left:4px solid #e74c3c;padding-left:12px">Conflicts (${conflicts.length})</h2>
+        <ul class="claim-list">
+            ${conflictItems}
+        </ul>
+      </div>
+    </section>`);
+  }
+
+  // Certificate slide
+  slides.push(`
+    <section class="slide">
+      <div class="slide-content title-slide">
+        <h2>Certificate</h2>
+        <p class="mono">${certificate.claim_count || claims.length} claims</p>
+        <p class="mono">sha256:${esc((certificate.sha256 || 'unknown').slice(0, 24))}</p>
+        <p class="meta">${esc(compiled)}</p>
+      </div>
+    </section>`);
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${esc(title)} — Slide Deck</title>
+<style>
+  :root { --bg:#0a0e1a; --surface:#111827; --border:#1e293b; --text:#e2e8f0; --muted:#94a3b8; }
+  * { margin:0; padding:0; box-sizing:border-box; }
+  html { scroll-snap-type:y mandatory; overflow-y:scroll; }
+  body { background:var(--bg); color:var(--text); font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif; line-height:1.6; }
+  .slide { scroll-snap-align:start; height:100vh; display:flex; align-items:center; justify-content:center; padding:2rem; }
+  .slide-content { max-width:800px; width:100%; }
+  .title-slide { text-align:center; }
+  .title-slide h1 { font-size:2.4rem; margin-bottom:0.75rem; }
+  .title-slide h2 { font-size:1.8rem; margin-bottom:1rem; }
+  .question { font-size:1.1rem; color:var(--muted); margin-bottom:1rem; }
+  .meta { font-size:0.85rem; color:var(--muted); }
+  .mono { font-family:monospace; font-size:1rem; color:var(--muted); margin-bottom:0.5rem; }
+  h2 { font-size:1.5rem; margin-bottom:1.25rem; }
+  .summary-grid { display:flex; gap:2rem; justify-content:center; margin-bottom:2rem; }
+  .big-stat { display:flex; flex-direction:column; align-items:center; }
+  .big-stat .num { font-size:2.5rem; font-weight:700; }
+  .big-stat .label { font-size:0.8rem; color:var(--muted); text-transform:uppercase; }
+  .type-stats { display:flex; flex-wrap:wrap; gap:0.75rem; justify-content:center; }
+  .type-stat { display:flex; align-items:center; gap:0.4rem; font-size:0.9rem; }
+  .dot { width:10px; height:10px; border-radius:50%; display:inline-block; }
+  .claim-list { list-style:none; max-height:70vh; overflow-y:auto; }
+  .claim-list li { padding:0.6rem 0; border-bottom:1px solid var(--border); font-size:0.9rem; }
+  .claim-list li strong { font-family:monospace; font-size:0.8rem; }
+</style>
+</head>
+<body>
+${slides.join('\n')}
+<script>
+  document.addEventListener('keydown', function(e) {
+    if (e.key === 'ArrowDown' || e.key === 'PageDown') {
+      e.preventDefault();
+      const slides = document.querySelectorAll('.slide');
+      const vh = window.innerHeight;
+      const current = Math.round(window.scrollY / vh);
+      const next = Math.min(current + 1, slides.length - 1);
+      slides[next].scrollIntoView({ behavior: 'smooth' });
+    } else if (e.key === 'ArrowUp' || e.key === 'PageUp') {
+      e.preventDefault();
+      const vh = window.innerHeight;
+      const current = Math.round(window.scrollY / vh);
+      const prev = Math.max(current - 1, 0);
+      document.querySelectorAll('.slide')[prev].scrollIntoView({ behavior: 'smooth' });
+    }
+  });
+</script>
+</body>
+</html>`;
+}
+
+function esc(str) {
+  if (str == null) return '';
+  return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/lib/formats/sql.js

@@ -0,0 +1,116 @@
+/**
+ * mill format: sql
+ *
+ * Converts compilation.json to SQL CREATE TABLE + INSERT statements.
+ * Compatible with SQLite and PostgreSQL.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'sql';
+export const extension = '.sql';
+export const mimeType = 'application/sql; charset=utf-8';
+export const description = 'SQL schema and INSERT statements for claims data';
+
+/**
+ * Convert a compilation object to SQL statements.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} SQL output
+ */
+export function convert(compilation) {
+  const claims = compilation.claims || [];
+  const meta = compilation.meta || {};
+  const certificate = compilation.certificate || {};
+
+  const lines = [];
+
+  lines.push('-- Auto-generated by mill sql format');
+  if (meta.sprint) lines.push(`-- Sprint: ${meta.sprint}`);
+  if (certificate.compiled_at) lines.push(`-- Compiled: ${certificate.compiled_at}`);
+  lines.push('');
+
+  // Claims table
+  lines.push('CREATE TABLE IF NOT EXISTS claims (');
+  lines.push('  id TEXT PRIMARY KEY,');
+  lines.push('  type TEXT,');
+  lines.push('  content TEXT,');
+  lines.push('  evidence_tier TEXT,');
+  lines.push('  status TEXT,');
+  lines.push('  confidence REAL,');
+  lines.push('  source TEXT,');
+  lines.push('  tags TEXT,');
+  lines.push('  created TEXT');
+  lines.push(');');
+  lines.push('');
+
+  // Conflicts table
+  lines.push('CREATE TABLE IF NOT EXISTS conflicts (');
+  lines.push('  id INTEGER PRIMARY KEY AUTOINCREMENT,');
+  lines.push('  claim_ids TEXT,');
+  lines.push('  description TEXT,');
+  lines.push('  resolution TEXT');
+  lines.push(');');
+  lines.push('');
+
+  // Insert claims
+  if (claims.length > 0) {
+    lines.push('-- Claims');
+    for (const claim of claims) {
+      const id = esc(claim.id || '');
+      const type = esc(claim.type || '');
+      const content = esc(claim.content || claim.text || '');
+      const evidenceTier = esc(extractTier(claim));
+      const status = esc(claim.status || '');
+      const confidence = claim.confidence != null ? String(claim.confidence) : 'NULL';
+      const source = esc(extractSource(claim));
+      const tags = esc(Array.isArray(claim.tags) ? claim.tags.join(',') : '');
+      const created = esc(claim.created || '');
+
+      lines.push(
+        `INSERT INTO claims VALUES ('${id}', '${type}', '${content}', '${evidenceTier}', '${status}', ${confidence}, '${source}', '${tags}', '${created}');`
+      );
+    }
+    lines.push('');
+  }
+
+  // Insert conflicts
+  const conflicts = compilation.conflicts || [];
+  if (conflicts.length > 0) {
+    lines.push('-- Conflicts');
+    for (const conflict of conflicts) {
+      const claimIds = esc(Array.isArray(conflict.ids) ? conflict.ids.join(',') : '');
+      const description = esc(conflict.description || conflict.reason || '');
+      const resolution = esc(conflict.resolution || '');
+
+      lines.push(
+        `INSERT INTO conflicts (claim_ids, description, resolution) VALUES ('${claimIds}', '${description}', '${resolution}');`
+      );
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function esc(value) {
+  if (value == null) return '';
+  return String(value).replace(/'/g, "''");
+}
+
+function extractTier(claim) {
+  if (typeof claim.evidence === 'string') return claim.evidence;
+  if (typeof claim.evidence === 'object' && claim.evidence !== null) {
+    return claim.evidence.tier || '';
+  }
+  return claim.evidence_tier || '';
+}
+
+function extractSource(claim) {
+  if (typeof claim.source === 'string') return claim.source;
+  if (typeof claim.source === 'object' && claim.source !== null) {
+    return claim.source.origin || claim.source.artifact || '';
+  }
+  if (typeof claim.evidence === 'object' && claim.evidence?.source) {
+    return claim.evidence.source;
+  }
+  return '';
+}

package/lib/formats/static-site.js

@@ -0,0 +1,169 @@
+/**
+ * mill format: static-site
+ *
+ * Converts compilation.json to a Hugo-compatible static site manifest.
+ * Outputs a JSON object describing the file tree (content pages, data, config).
+ * Actual file writing is left to a publisher step.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'static-site';
+export const extension = '.json';
+export const mimeType = 'application/json; charset=utf-8';
+export const description = 'Hugo-compatible static site manifest (file tree as JSON)';
+
+/**
+ * Convert a compilation object to a static site manifest.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} JSON output
+ */
+export function convert(compilation) {
+  const claims = compilation.claims || [];
+  const meta = compilation.meta || {};
+  const certificate = compilation.certificate || {};
+
+  const sprintName = meta.sprint || 'sprint';
+  const question = meta.question || '';
+  const audience = meta.audience || '';
+
+  const files = {};
+
+  // Hugo config
+  files['config.yaml'] = buildConfig(sprintName, question);
+
+  // Index page
+  files['content/_index.md'] = buildIndex(sprintName, question, audience, claims);
+
+  // Per-type section pages
+  const groups = {};
+  for (const claim of claims) {
+    const type = claim.type || 'other';
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(claim);
+  }
+
+  for (const [type, group] of Object.entries(groups)) {
+    files[`content/claims/${type}/_index.md`] = buildSectionIndex(type, group.length);
+
+    for (const claim of group) {
+      const id = claim.id || 'unknown';
+      files[`content/claims/${type}/${id}.md`] = buildClaimPage(claim);
+    }
+  }
+
+  // Data file: full claims array
+  files['data/claims.json'] = JSON.stringify(claims, null, 2);
+
+  // Data file: certificate
+  if (Object.keys(certificate).length > 0) {
+    files['data/certificate.json'] = JSON.stringify(certificate, null, 2);
+  }
+
+  // Data file: meta
+  files['data/meta.json'] = JSON.stringify(meta, null, 2);
+
+  const manifest = {
+    generator: 'mill',
+    sprint: sprintName,
+    claimCount: claims.length,
+    files,
+  };
+
+  return JSON.stringify(manifest, null, 2) + '\n';
+}
+
+function buildConfig(sprintName, question) {
+  const lines = [];
+  lines.push(`baseURL: "https://your-site.example.com/${sanitizeSlug(sprintName)}/"  # Update with your domain`);
+  lines.push(`title: "${escYaml(sprintName)}"`);
+  lines.push(`theme: "mill-default"`);
+  lines.push('languageCode: "en-us"');
+  lines.push('');
+  lines.push('params:');
+  lines.push(`  question: "${escYaml(question)}"`);
+  lines.push(`  generator: "mill"`);
+  return lines.join('\n') + '\n';
+}
+
+function buildIndex(sprintName, question, audience, claims) {
+  const lines = [];
+  lines.push('---');
+  lines.push(`title: "${escYaml(sprintName)}"`);
+  lines.push(`description: "${escYaml(question)}"`);
+  lines.push('type: "index"');
+  lines.push('---');
+  lines.push('');
+  lines.push(`# ${sprintName}`);
+  lines.push('');
+  if (question) lines.push(`**Question:** ${question}`);
+  if (audience) lines.push(`**Audience:** ${audience}`);
+  lines.push('');
+  lines.push(`**Total claims:** ${claims.length}`);
+
+  // Type summary
+  const typeCounts = {};
+  for (const c of claims) {
+    const t = c.type || 'other';
+    typeCounts[t] = (typeCounts[t] || 0) + 1;
+  }
+  lines.push('');
+  for (const [type, count] of Object.entries(typeCounts)) {
+    lines.push(`- ${type}: ${count}`);
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function buildSectionIndex(type, count) {
+  const lines = [];
+  lines.push('---');
+  lines.push(`title: "${escYaml(type)}"`);
+  lines.push(`type: "section"`);
+  lines.push('---');
+  lines.push('');
+  lines.push(`${count} ${type} claim${count !== 1 ? 's' : ''}.`);
+  return lines.join('\n') + '\n';
+}
+
+function buildClaimPage(claim) {
+  const id = claim.id || 'unknown';
+  const type = claim.type || '';
+  const content = claim.content || claim.text || '';
+  const evidence = getEvidence(claim);
+  const status = claim.status || '';
+  const tags = Array.isArray(claim.tags) ? claim.tags : [];
+  const confidence = claim.confidence != null ? claim.confidence : '';
+
+  const lines = [];
+  lines.push('---');
+  lines.push(`title: "${escYaml(id)}"`);
+  lines.push(`type: "${escYaml(type)}"`);
+  lines.push(`evidence: "${escYaml(evidence)}"`);
+  lines.push(`status: "${escYaml(status)}"`);
+  if (confidence !== '') lines.push(`confidence: ${confidence}`);
+  if (tags.length > 0) lines.push(`tags: [${tags.map(t => `"${escYaml(t)}"`).join(', ')}]`);
+  lines.push('---');
+  lines.push('');
+  lines.push(content);
+  return lines.join('\n') + '\n';
+}
+
+function getEvidence(claim) {
+  if (typeof claim.evidence === 'string') return claim.evidence;
+  if (typeof claim.evidence === 'object' && claim.evidence !== null) {
+    return claim.evidence.tier || claim.evidence_tier || '';
+  }
+  return claim.evidence_tier || '';
+}
+
+function escYaml(str) {
+  if (str == null) return '';
+  return String(str).replace(/"/g, '\\"');
+}
+
+function sanitizeSlug(str) {
+  return String(str)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}

package/lib/formats/treemap.js

@@ -0,0 +1,65 @@
+/**
+ * mill format: treemap
+ *
+ * Converts compilation.json claims to nested JSON for D3 treemap.
+ * Claims grouped by type, each with value = confidence (or 1).
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'treemap';
+export const extension = '.json';
+export const mimeType = 'application/json; charset=utf-8';
+export const description = 'Claims as nested JSON for D3 treemap visualization (grouped by type)';
+
+/**
+ * Convert a compilation object to D3 treemap JSON.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} JSON output
+ */
+export function convert(compilation) {
+  const claims = compilation.claims || [];
+  const sprintName = compilation.meta?.sprint || 'sprint';
+
+  // Group claims by type
+  const groups = {};
+  for (const claim of claims) {
+    const type = claim.type || 'other';
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(claim);
+  }
+
+  const tree = {
+    name: sprintName,
+    children: Object.entries(groups).map(([type, group]) => ({
+      name: type,
+      children: group.map(claim => {
+        const node = {
+          name: claim.id || '',
+          value: claim.confidence != null ? claim.confidence : 1,
+          evidence: getEvidence(claim),
+        };
+
+        const content = claim.content || claim.text || '';
+        if (content) node.content = content;
+
+        const status = claim.status || '';
+        if (status) node.status = status;
+
+        const tags = Array.isArray(claim.tags) ? claim.tags : [];
+        if (tags.length > 0) node.tags = tags;
+
+        return node;
+      }),
+    })),
+  };
+
+  return JSON.stringify(tree, null, 2) + '\n';
+}
+
+function getEvidence(claim) {
+  if (typeof claim.evidence === 'string') return claim.evidence;
+  if (typeof claim.evidence === 'object' && claim.evidence !== null) {
+    return claim.evidence.tier || claim.evidence_tier || '';
+  }
+  return claim.evidence_tier || '';
+}

package/lib/formats/typescript-defs.js

@@ -0,0 +1,147 @@
+/**
+ * mill format: typescript-defs
+ *
+ * Converts compilation.json to TypeScript .d.ts definitions.
+ * Derives union types from actual claim data values.
+ * Zero dependencies — node built-in only.
+ */
+
+export const name = 'typescript-defs';
+export const extension = '.d.ts';
+export const mimeType = 'text/plain; charset=utf-8';
+export const description = 'TypeScript type definitions derived from compilation data';
+
+/**
+ * Convert a compilation object to TypeScript .d.ts definitions.
+ * @param {object} compilation - The compilation.json content
+ * @returns {string} TypeScript definition output
+ */
+export function convert(compilation) {
+  const claims = compilation.claims || [];
+  const meta = compilation.meta || {};
+  const conflicts = compilation.conflicts || [];
+  const certificate = compilation.certificate || {};
+
+  const claimTypes = uniqueSorted(claims.map(c => c.type).filter(Boolean));
+  const evidenceTiers = uniqueSorted(
+    claims.map(c => {
+      if (typeof c.evidence === 'string') return c.evidence;
+      return c.evidence?.tier ?? c.evidence_tier ?? null;
+    }).filter(Boolean)
+  );
+  const statuses = uniqueSorted(claims.map(c => c.status).filter(Boolean));
+
+  const lines = [];
+
+  lines.push('// Auto-generated by mill typescript-defs format');
+  lines.push('// Derived from compilation data — do not edit manually');
+  lines.push('');
+
+  // ClaimType union
+  lines.push(`export type ClaimType = ${unionType(claimTypes)};`);
+  lines.push('');
+
+  // EvidenceTier union
+  lines.push(`export type EvidenceTier = ${unionType(evidenceTiers)};`);
+  lines.push('');
+
+  // ClaimStatus union
+  lines.push(`export type ClaimStatus = ${unionType(statuses)};`);
+  lines.push('');
+
+  // Evidence interface
+  lines.push('export interface Evidence {');
+  lines.push('  tier: EvidenceTier;');
+  lines.push('  source?: string;');
+  lines.push('}');
+  lines.push('');
+
+  // Source interface
+  lines.push('export interface ClaimSource {');
+  lines.push('  origin?: string;');
+  lines.push('  artifact?: string;');
+  lines.push('}');
+  lines.push('');
+
+  // Claim interface
+  lines.push('export interface Claim {');
+  lines.push('  id: string;');
+  lines.push('  type: ClaimType;');
+  lines.push('  content: string;');
+  lines.push('  evidence: EvidenceTier | Evidence;');
+  lines.push('  status: ClaimStatus;');
+  lines.push('  confidence?: number;');
+  lines.push('  source?: string | ClaimSource;');
+  lines.push('  tags?: string[];');
+  lines.push('  created?: string;');
+  lines.push('}');
+  lines.push('');
+
+  // Meta interface
+  lines.push('export interface Meta {');
+  lines.push('  sprint?: string;');
+  lines.push('  question?: string;');
+  lines.push('  audience?: string;');
+  for (const key of Object.keys(meta)) {
+    if (!['sprint', 'question', 'audience'].includes(key)) {
+      lines.push(`  ${sanitizeKey(key)}?: ${inferTsType(meta[key])};`);
+    }
+  }
+  lines.push('}');
+  lines.push('');
+
+  // Conflict interface
+  lines.push('export interface Conflict {');
+  lines.push('  ids?: string[];');
+  lines.push('  description?: string;');
+  lines.push('  reason?: string;');
+  lines.push('  resolution?: string;');
+  lines.push('}');
+  lines.push('');
+
+  // Certificate interface
+  lines.push('export interface Certificate {');
+  lines.push('  compiled_at?: string;');
+  lines.push('  sha256?: string;');
+  lines.push('  claim_count?: number;');
+  for (const key of Object.keys(certificate)) {
+    if (!['compiled_at', 'sha256', 'claim_count'].includes(key)) {
+      lines.push(`  ${sanitizeKey(key)}?: ${inferTsType(certificate[key])};`);
+    }
+  }
+  lines.push('}');
+  lines.push('');
+
+  // Compilation interface
+  lines.push('export interface Compilation {');
+  lines.push('  meta: Meta;');
+  lines.push('  claims: Claim[];');
+  lines.push('  conflicts: Conflict[];');
+  lines.push('  certificate: Certificate;');
+  lines.push('}');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function uniqueSorted(arr) {
+  return [...new Set(arr)].sort();
+}
+
+function unionType(values) {
+  if (values.length === 0) return 'string';
+  return values.map(v => `'${v}'`).join(' | ');
+}
+
+function sanitizeKey(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+}
+
+function inferTsType(value) {
+  if (value === null || value === undefined) return 'unknown';
+  if (typeof value === 'number') return 'number';
+  if (typeof value === 'boolean') return 'boolean';
+  if (typeof value === 'string') return 'string';
+  if (Array.isArray(value)) return 'unknown[]';
+  return 'Record<string, unknown>';
+}