ez-reads 1.0.0

package/src/distiller.mjs

@@ -0,0 +1,356 @@
+import Groq from 'groq-sdk';
+
+const MODEL = 'qwen/qwen3-32b';
+const MAX_SECTION_CHARS = 3000;
+const MAX_TOKENS = 4096;
+const DELAY_MS = 25_000; // 25s between calls to stay under 6k TPM
+
+const DEEP_DIVE = `You are an expert science communicator writing an in-depth technical explainer of a research paper. Your audience is technically curious readers with a general STEM background.
+
+Rules:
+- Write with genuine depth — explain the "why" behind methods and design choices, not just the "what."
+- Cover intuition, trade-offs, and how ideas connect to the broader field.
+- Use precise analogies to clarify complex ideas, but never sacrifice accuracy for simplicity.
+- When you introduce a technical term, define it inline on first use.
+- Be thorough but concise — every sentence should add understanding.`;
+
+// ---------- per-chunk prompts ----------
+// Chunks map to natural paper sections: abstract, intro, methods, results, discussion
+
+const CHUNK_ABSTRACT = {
+  name: 'abstract & overview',
+  system: `${DEEP_DIVE}
+
+Given a paper's title, authors, and abstract, return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "title": "string — the exact paper title",
+  "authors": ["string — author names"],
+  "tldr": "string — a precise one-sentence summary capturing the core contribution and its significance",
+  "analogy": "string — a vivid 2-3 sentence analogy that accurately captures the paper's central idea using a real-world parallel. Make it illuminating, not dumbed-down.",
+  "abstract_simplified": "string — a thorough 4-6 sentence summary covering: (1) what problem the paper addresses, (2) why it matters, (3) the core approach, (4) the key findings, and (5) what this means for the field",
+  "color_theme": {
+    "primary": "string — hex color suited to the paper's field (blue for CS/AI, green for biology, purple for physics, teal for math, red for medicine, etc.)",
+    "accent": "string — a complementary hex accent color"
+  }
+}`,
+  buildInput: (d) => {
+    let parts = [];
+    if (d.title) parts.push(`TITLE: ${d.title}`);
+    if (d.authors?.length) parts.push(`AUTHORS: ${d.authors.join(', ')}`);
+    if (d.abstract) parts.push(`ABSTRACT:\n${d.abstract}`);
+    return parts.join('\n\n').slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const CHUNK_INTRO = {
+  name: 'key contributions',
+  system: `${DEEP_DIVE}
+
+Given the introduction and overview sections of a research paper, identify and explain the key contributions in depth. Return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "key_contributions": [
+    {
+      "emoji": "string — one relevant emoji",
+      "title": "string — concise label for this contribution",
+      "description": "string — 3-5 sentences explaining: what this contribution is, why it is novel compared to prior work, and how it advances the state of the art. Include specific details."
+    }
+  ]
+}
+Guidelines: 3-5 contributions. Each description should demonstrate real understanding of the novelty, not just restate the claim.`,
+  buildInput: (d) => {
+    const secs = findSections(d.sections, [
+      'introduction', 'intro', 'contribution', 'overview', 'background', 'motivation', 'related',
+    ]);
+    let text = secs.map((s) => `## ${s.heading}\n${s.text}`).join('\n\n');
+    if (!text) text = d.abstract || '';
+    return text.slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const CHUNK_METHODS = {
+  name: 'methodology deep-dive',
+  system: `${DEEP_DIVE}
+
+Given the methodology sections of a research paper, produce a detailed, structured breakdown of the approach. Return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "methodology": {
+    "summary": "string — 3-4 sentences explaining the overall approach: what method was chosen, why it was chosen over alternatives, and what makes it distinctive",
+    "steps": [
+      {
+        "emoji": "string — one relevant emoji for this step",
+        "label": "string — clear step name",
+        "detail": "string — 3-5 sentences covering: what happens in this step, the intuition behind it, why this particular design choice was made, and how it connects to the next step. Mention specific techniques by name and explain them."
+      }
+    ]
+  }
+}
+Guidelines: 4-7 steps. Focus on conveying the reasoning and intuition behind each choice, not just a mechanical description. Explain trade-offs where relevant.`,
+  buildInput: (d) => {
+    const secs = findSections(d.sections, [
+      'method', 'approach', 'model', 'architecture', 'framework', 'design',
+      'system', 'technique', 'training', 'implementation', 'algorithm', 'pipeline',
+    ]);
+    let text = secs.map((s) => `## ${s.heading}\n${s.text}`).join('\n\n');
+    if (!text) text = collectAllText(d).slice(0, MAX_SECTION_CHARS);
+    return text.slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const CHUNK_RESULTS = {
+  name: 'results & analysis',
+  system: `${DEEP_DIVE}
+
+Given the results and experiments sections of a research paper, extract key findings with analytical depth AND notable quantitative metrics. Return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "results": [
+    {
+      "emoji": "string — one relevant emoji",
+      "finding": "string — the key result stated clearly and precisely",
+      "detail": "string — 3-5 sentences providing: the experimental context, how this result compares to baselines or prior work, what it means practically, and any important nuances or caveats"
+    }
+  ],
+  "stats": [
+    {
+      "value": "string — the specific number or metric (e.g. '94.2%', '3.5x', '1.2B')",
+      "label": "string — what this number measures",
+      "context": "string — 1-2 sentences putting this number in perspective: compare to the previous state of the art, explain the magnitude of improvement, or convey what it means in practical terms"
+    }
+  ]
+}
+Guidelines: 3-5 results with genuine depth — highlight both strengths and surprising or nuanced findings. 2-4 stats with meaningful comparisons. Avoid cherry-picking only the best numbers; include context about where the approach shines and where it doesn't.`,
+  buildInput: (d) => {
+    const secs = findSections(d.sections, [
+      'result', 'experiment', 'evaluation', 'finding', 'performance',
+      'benchmark', 'ablation', 'comparison', 'analysis', 'empirical',
+    ]);
+    let text = secs.map((s) => `## ${s.heading}\n${s.text}`).join('\n\n');
+    if (!text) text = collectAllText(d).slice(0, MAX_SECTION_CHARS);
+    return text.slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const CHUNK_DISCUSSION = {
+  name: 'significance & context',
+  system: `${DEEP_DIVE}
+
+Given the discussion, conclusion, and related sections of a research paper, extract the significance, limitations, and key technical terms. Return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "significance": "string — 4-6 sentences on broader impact: how this work changes the field, what new possibilities it opens, potential real-world applications, and how it connects to the bigger picture of the discipline",
+  "limitations": [
+    "string — each limitation as 1-2 sentences: state the limitation clearly AND explain why it matters or how it could be addressed in future work"
+  ],
+  "glossary": [
+    {
+      "term": "string — the technical term or concept",
+      "definition": "string — a thorough 2-3 sentence definition: what it means, why it's important in this context, and (where helpful) how it relates to more familiar concepts"
+    }
+  ]
+}
+Guidelines: 3-5 substantive limitations (not just surface-level caveats — explain the impact of each). 5-10 glossary terms covering the most important technical concepts from the paper, with definitions that genuinely teach the reader.`,
+  buildInput: (d) => {
+    const secs = findSections(d.sections, [
+      'discussion', 'conclusion', 'limitation', 'future', 'related',
+      'significance', 'impact', 'broader', 'abstract', 'summary',
+    ]);
+    let text = secs.map((s) => `## ${s.heading}\n${s.text}`).join('\n\n');
+    if (!text) text = (d.abstract || '') + '\n\n' + collectAllText(d);
+    return text.slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const CHUNK_FIGURES = {
+  name: 'figure selection',
+  system: `${DEEP_DIVE}
+
+Given a list of figure captions from a research paper, select the 3-5 most important figures — prioritize architecture diagrams, key result charts, and data visualizations that are essential to understanding the work. Return ONLY valid JSON (no markdown fences, no commentary):
+{
+  "figures": [
+    {
+      "id": "string — the figure id exactly as provided",
+      "caption": "string — the original caption",
+      "explanation": "string — 2-3 sentences explaining what this figure shows and why it is important for understanding the paper",
+      "category": "string — one of: Architecture, Results, Data, Method, Comparison, Overview"
+    }
+  ]
+}
+Guidelines: Select 3-5 figures maximum. Prefer figures that convey the most information visually — architecture diagrams, performance charts, ablation plots, and key data visualizations. Skip trivial or redundant figures.`,
+  buildInput: (d) => {
+    if (!d.figures?.length) return '';
+    return d.figures.map((f) => `[${f.id}] ${f.caption}`).join('\n\n').slice(0, MAX_SECTION_CHARS);
+  },
+};
+
+const ALL_CHUNKS = [CHUNK_ABSTRACT, CHUNK_INTRO, CHUNK_METHODS, CHUNK_RESULTS, CHUNK_DISCUSSION];
+
+// ---------- main export ----------
+
+export async function distillPaper(paperData, onProgress) {
+  const apiKey = process.env.GROQ_API_KEY;
+  if (!apiKey) {
+    throw new Error('GROQ_API_KEY environment variable is required.');
+  }
+
+  const client = new Groq({ apiKey });
+  const merged = {};
+
+  // Build the chunk list — add figures chunk if the paper has figures
+  const chunks = [...ALL_CHUNKS];
+  if (paperData.figures?.length > 0) {
+    chunks.push(CHUNK_FIGURES);
+  }
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+
+    if (onProgress) onProgress(chunk.name, i + 1, chunks.length);
+
+    const input = chunk.buildInput(paperData);
+    const result = await callGroq(client, chunk.system, input);
+    Object.assign(merged, result);
+
+    // Delay between calls to respect TPM limit (skip after last call)
+    if (i < chunks.length - 1) {
+      await sleep(DELAY_MS);
+    }
+  }
+
+  // If figures were selected by the LLM, merge back the original URLs from paperData
+  if (merged.figures && paperData.figures?.length > 0) {
+    const figureMap = new Map(paperData.figures.map((f) => [f.id, f]));
+    merged.figures = merged.figures
+      .filter((f) => figureMap.has(f.id))
+      .map((f) => ({ ...f, url: figureMap.get(f.id).url }));
+  }
+
+  return merged;
+}
+
+// ---------- helpers ----------
+
+async function callGroq(client, system, userContent) {
+  const response = await client.chat.completions.create({
+    model: MODEL,
+    max_tokens: MAX_TOKENS,
+    temperature: 0.4,
+    messages: [
+      { role: 'system', content: system },
+      { role: 'user', content: userContent },
+    ],
+  });
+
+  const text = response.choices[0]?.message?.content || '';
+  const cleaned = cleanModelOutput(text);
+
+  // Try parsing the cleaned output directly
+  try {
+    return JSON.parse(cleaned);
+  } catch (_) {
+    // If JSON is truncated (hit token limit), try to repair it
+    try {
+      const repaired = repairTruncatedJson(cleaned);
+      return JSON.parse(repaired);
+    } catch (_) {
+      // Fall through to LLM retry
+    }
+  }
+
+  // Retry once — ask the model to fix its JSON
+  await sleep(DELAY_MS);
+  const retry = await client.chat.completions.create({
+    model: MODEL,
+    max_tokens: MAX_TOKENS,
+    temperature: 0,
+    messages: [
+      {
+        role: 'user',
+        content: `The following was supposed to be valid JSON but failed to parse. Fix it and return ONLY valid JSON, nothing else:\n\n${cleaned}`,
+      },
+    ],
+  });
+  const retryText = cleanModelOutput(retry.choices[0]?.message?.content || '');
+
+  try {
+    return JSON.parse(retryText);
+  } catch (_) {
+    const repaired = repairTruncatedJson(retryText);
+    return JSON.parse(repaired);
+  }
+}
+
+function cleanModelOutput(text) {
+  // Strip Qwen3 <think>...</think> reasoning blocks
+  let out = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+  // Strip markdown fences
+  out = out.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  return out;
+}
+
+/**
+ * Attempt to repair truncated JSON by closing open strings, arrays, and objects.
+ * Handles the common case where the LLM response was cut off mid-output.
+ */
+function repairTruncatedJson(text) {
+  let s = text.trim();
+
+  // If it looks like it was cut off inside a string, close the string
+  // Count unescaped quotes to determine if we're inside a string
+  let inString = false;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '\\') { i++; continue; } // skip escaped char
+    if (s[i] === '"') inString = !inString;
+  }
+  if (inString) {
+    // Truncate back to the last clean sentence/word boundary if possible
+    const lastGoodBreak = s.lastIndexOf('. ');
+    const lastSpace = s.lastIndexOf(' ');
+    const cutPoint = lastGoodBreak > s.length * 0.5 ? lastGoodBreak + 1 : lastSpace;
+    if (cutPoint > s.length * 0.5) {
+      s = s.slice(0, cutPoint) + '"';
+    } else {
+      s += '"';
+    }
+  }
+
+  // Remove any trailing comma after closing the string
+  s = s.replace(/,\s*$/, '');
+
+  // Count open brackets/braces and close them
+  let openBraces = 0;
+  let openBrackets = 0;
+  inString = false;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '\\') { i++; continue; }
+    if (s[i] === '"') { inString = !inString; continue; }
+    if (inString) continue;
+    if (s[i] === '{') openBraces++;
+    if (s[i] === '}') openBraces--;
+    if (s[i] === '[') openBrackets++;
+    if (s[i] === ']') openBrackets--;
+  }
+
+  // Close any open arrays then objects
+  for (let i = 0; i < openBrackets; i++) s += ']';
+  for (let i = 0; i < openBraces; i++) s += '}';
+
+  return s;
+}
+
+function findSections(sections, keywords) {
+  if (!sections?.length) return [];
+  return sections.filter((s) =>
+    keywords.some((kw) => s.heading.toLowerCase().includes(kw))
+  );
+}
+
+function collectAllText(data) {
+  let parts = [];
+  if (data.abstract) parts.push(data.abstract);
+  if (data.sections?.length) {
+    for (const s of data.sections) parts.push(s.text);
+  }
+  return parts.join('\n\n');
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/fetcher.mjs

@@ -0,0 +1,327 @@
+import * as cheerio from 'cheerio';
+
+/**
+ * Detect input type and fetch paper content.
+ * Returns { title, authors, abstract, sections: [{ heading, text }], url }
+ */
+export async function fetchPaper(input) {
+  input = input.trim();
+
+  if (isArxiv(input)) {
+    return fetchArxiv(input);
+  }
+
+  if (isDoi(input)) {
+    return fetchDoi(input);
+  }
+
+  throw new Error(
+    'Unsupported input. Please provide an ArXiv URL (e.g. https://arxiv.org/abs/2401.00001) or a DOI (e.g. 10.1234/example).'
+  );
+}
+
+function isArxiv(input) {
+  return /arxiv\.org\/(abs|html|pdf)\//.test(input);
+}
+
+function isDoi(input) {
+  return /^10\.\d{4,}\//.test(input) || /doi\.org\/10\.\d{4,}\//.test(input);
+}
+
+// ---------- ArXiv ----------
+
+function arxivIdFrom(url) {
+  const match = url.match(/arxiv\.org\/(?:abs|html|pdf)\/([^\s?#]+)/);
+  return match ? match[1].replace(/\.pdf$/, '') : null;
+}
+
+async function fetchArxiv(input) {
+  const id = arxivIdFrom(input);
+  if (!id) throw new Error('Could not parse ArXiv ID from URL.');
+
+  const htmlUrl = `https://arxiv.org/html/${id}`;
+  const absUrl = `https://arxiv.org/abs/${id}`;
+
+  let result;
+
+  // Try HTML version first (richer content)
+  try {
+    const res = await fetch(htmlUrl, { headers: { 'User-Agent': 'ez-reads/1.0' } });
+    if (res.ok) {
+      const html = await res.text();
+      const parsed = parseArxivHtml(html, htmlUrl);
+      if (parsed.sections.length > 0) {
+        result = { ...parsed, url: absUrl };
+      }
+    }
+  } catch (_) {
+    // fall through to abstract page
+  }
+
+  if (!result) {
+    // Fallback: abstract page
+    const res = await fetch(absUrl, { headers: { 'User-Agent': 'ez-reads/1.0' } });
+    if (!res.ok) throw new Error(`Failed to fetch ArXiv page: ${res.status}`);
+    const html = await res.text();
+    result = { ...parseArxivAbstract(html), url: absUrl };
+  }
+
+  // If no publishedDate was extracted from the page, try the ArXiv API for the exact date
+  if (!result.publishedDate) {
+    result.publishedDate = await fetchArxivApiDate(id);
+  }
+
+  // Last resort: derive an approximate date from the ArXiv ID (YYMM.NNNNN)
+  if (!result.publishedDate && id) {
+    const idMatch = id.match(/^(\d{4})\./);
+    if (idMatch) {
+      const yymm = idMatch[1];
+      const yy = parseInt(yymm.slice(0, 2));
+      const mm = yymm.slice(2, 4);
+      const year = yy >= 90 ? 1900 + yy : 2000 + yy;
+      result.publishedDate = `${year}-${mm}-01`;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Fetch the exact publication date from the ArXiv Atom API.
+ * Returns an ISO date string (YYYY-MM-DD) or null.
+ */
+async function fetchArxivApiDate(arxivId) {
+  try {
+    const res = await fetch(
+      `https://export.arxiv.org/api/query?id_list=${arxivId}&max_results=1`,
+      { headers: { 'User-Agent': 'ez-reads/1.0' } }
+    );
+    if (!res.ok) return null;
+    const xml = await res.text();
+    // Extract <published> element from Atom feed (e.g. <published>2017-06-12T17:57:34Z</published>)
+    const match = xml.match(/<published>(\d{4}-\d{2}-\d{2})T/);
+    return match ? match[1] : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function parseArxivHtml(html, baseUrl) {
+  const $ = cheerio.load(html);
+
+  const title = $('.ltx_title').first().text().replace(/^\s*Title:\s*/i, '').trim() ||
+                $('h1').first().text().trim();
+
+  const authors = [];
+  $('.ltx_personname').each((_, el) => {
+    const name = $(el).text().trim();
+    if (name) authors.push(name);
+  });
+
+  const abstract = $('.ltx_abstract .ltx_p').map((_, el) => $(el).text().trim()).get().join(' ') ||
+                   $('.ltx_abstract').text().replace(/^\s*Abstract[:\s]*/i, '').trim();
+
+  // Extract publication date from the HTML version
+  const publishedDate = extractArxivDate($);
+
+  const sections = [];
+  $('section.ltx_section, section.ltx_subsection').each((_, sec) => {
+    const heading = $(sec).find('.ltx_title').first().text().trim()
+      .replace(/^\d+[\.\s]*/, '');
+
+    const paragraphs = [];
+    $(sec).find('.ltx_para .ltx_p, .ltx_p').each((_, p) => {
+      // skip paragraphs that belong to nested subsections
+      if ($(p).closest('section.ltx_subsection').length > 0 &&
+          $(p).closest('section.ltx_section')[0] === sec &&
+          $(p).closest('section.ltx_subsection')[0] !== sec) {
+        return;
+      }
+      const text = $(p).text().trim();
+      if (text) paragraphs.push(text);
+    });
+
+    if (heading && paragraphs.length > 0) {
+      sections.push({ heading, text: paragraphs.join('\n\n') });
+    }
+  });
+
+  // Extract figures (images with captions)
+  const figures = [];
+  $('figure.ltx_figure, figure.ltx_table').each((_, fig) => {
+    const $fig = $(fig);
+    const id = $fig.attr('id') || `figure-${figures.length + 1}`;
+
+    // Find the image source
+    const imgEl = $fig.find('img').first();
+    let url = imgEl.attr('src') || '';
+    if (url && !url.startsWith('http')) {
+      // Resolve relative URLs against the arxiv HTML page URL
+      url = new URL(url, baseUrl + '/').href;
+    }
+
+    // Extract caption text
+    const caption = $fig.find('figcaption, .ltx_caption').text().trim();
+
+    if (url && caption) {
+      figures.push({ url, caption, id });
+    }
+  });
+
+  return { title, authors, abstract, sections, publishedDate, figures };
+}
+
+function parseArxivAbstract(html) {
+  const $ = cheerio.load(html);
+
+  const title = $('h1.title').text().replace(/^Title:\s*/i, '').trim();
+
+  const authors = [];
+  $('div.authors a').each((_, el) => {
+    authors.push($(el).text().trim());
+  });
+
+  const abstract = $('blockquote.abstract').text().replace(/^Abstract:\s*/i, '').trim();
+
+  // Extract publication / submission date
+  const publishedDate = extractArxivDate($);
+
+  return {
+    title,
+    authors,
+    abstract,
+    sections: [{ heading: 'Abstract', text: abstract }],
+    publishedDate,
+    figures: [],
+  };
+}
+
+/**
+ * Try to extract a publication date from an ArXiv page.
+ * Looks at <meta> tags, the dateline div, and submission history.
+ * Returns an ISO date string (YYYY-MM-DD) or null.
+ */
+function extractArxivDate($) {
+  // 1. <meta name="citation_date" content="2017/06/12">
+  const citationDate = $('meta[name="citation_date"]').attr('content')
+    || $('meta[name="citation_publication_date"]').attr('content')
+    || $('meta[name="citation_online_date"]').attr('content');
+  if (citationDate) {
+    const d = new Date(citationDate.replace(/\//g, '-'));
+    if (!isNaN(d)) return d.toISOString().slice(0, 10);
+  }
+
+  // 2. <meta name="dc.date" ...> or <meta property="article:published_time">
+  const dcDate = $('meta[name="dc.date"]').attr('content')
+    || $('meta[property="article:published_time"]').attr('content');
+  if (dcDate) {
+    const d = new Date(dcDate);
+    if (!isNaN(d)) return d.toISOString().slice(0, 10);
+  }
+
+  // 3. Dateline text like "Submitted on 12 Jun 2017" on the abstract page
+  const dateline = $('div.dateline').text() || '';
+  const subMatch = dateline.match(/(\d{1,2}\s+\w+\s+\d{4})/);
+  if (subMatch) {
+    const d = new Date(subMatch[1]);
+    if (!isNaN(d)) return d.toISOString().slice(0, 10);
+  }
+
+  // 4. Submission history text
+  const historyText = $('div.submission-history').text() || '';
+  const histMatch = historyText.match(/\[v1\]\s*\w+,\s*(\d{1,2}\s+\w+\s+\d{4})/);
+  if (histMatch) {
+    const d = new Date(histMatch[1]);
+    if (!isNaN(d)) return d.toISOString().slice(0, 10);
+  }
+
+  return null;
+}
+
+// ---------- DOI ----------
+
+function extractDoi(input) {
+  const match = input.match(/(10\.\d{4,}\/[^\s]+)/);
+  return match ? match[1] : input;
+}
+
+async function fetchDoi(input) {
+  const doi = extractDoi(input);
+  const doiUrl = `https://doi.org/${doi}`;
+
+  // Get structured metadata via content negotiation
+  let metadata = {};
+  try {
+    const metaRes = await fetch(doiUrl, {
+      headers: {
+        Accept: 'application/vnd.citeprocjson',
+        'User-Agent': 'ez-reads/1.0',
+      },
+      redirect: 'follow',
+    });
+    if (metaRes.ok) {
+      metadata = await metaRes.json();
+    }
+  } catch (_) {
+    // proceed without structured metadata
+  }
+
+  const title = metadata.title || '';
+  const authors = (metadata.author || []).map(
+    (a) => [a.given, a.family].filter(Boolean).join(' ')
+  );
+  const abstract = metadata.abstract || '';
+
+  // Extract publication date from citeproc metadata
+  let publishedDate = null;
+  const issued = metadata.issued || metadata.published || metadata.created;
+  if (issued && issued['date-parts'] && issued['date-parts'][0]) {
+    const parts = issued['date-parts'][0]; // [year, month?, day?]
+    if (parts[0]) {
+      const y = String(parts[0]);
+      const m = String(parts[1] || 1).padStart(2, '0');
+      const d = String(parts[2] || 1).padStart(2, '0');
+      publishedDate = `${y}-${m}-${d}`;
+    }
+  }
+
+  // Try to scrape the landing page for body text
+  let sections = [];
+  try {
+    const pageRes = await fetch(doiUrl, {
+      headers: { 'User-Agent': 'ez-reads/1.0' },
+      redirect: 'follow',
+    });
+    if (pageRes.ok) {
+      const html = await pageRes.text();
+      const $ = cheerio.load(html);
+
+      // Remove nav, header, footer, scripts
+      $('nav, header, footer, script, style, .references, #references').remove();
+
+      $('h2, h3').each((_, heading) => {
+        const headText = $(heading).text().trim();
+        const paragraphs = [];
+        let next = $(heading).next();
+        while (next.length && !next.is('h2, h3')) {
+          if (next.is('p, div.paragraph')) {
+            const t = next.text().trim();
+            if (t) paragraphs.push(t);
+          }
+          next = next.next();
+        }
+        if (headText && paragraphs.length) {
+          sections.push({ heading: headText, text: paragraphs.join('\n\n') });
+        }
+      });
+    }
+  } catch (_) {
+    // proceed without body text
+  }
+
+  if (sections.length === 0 && abstract) {
+    sections = [{ heading: 'Abstract', text: abstract }];
+  }
+
+  return { title, authors, abstract, sections, url: doiUrl, publishedDate, figures: [] };
+}