papergod 0.1.0

package/src/server/latex-structure.js

@@ -0,0 +1,344 @@
+import { createHash, randomUUID } from 'crypto';
+
+const SECTION_LEVELS = { section: 1, subsection: 2, subsubsection: 3 };
+
+function id(prefix) {
+  return `${prefix}_${randomUUID()}`;
+}
+
+function normalize(value) {
+  return value.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+function fingerprint(value) {
+  return createHash('sha1').update(normalize(value)).digest('hex').slice(0, 12);
+}
+
+function isEscaped(source, index) {
+  let slashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && source[cursor] === '\\'; cursor -= 1) slashes += 1;
+  return slashes % 2 === 1;
+}
+
+function isCommented(source, index) {
+  const lineStart = source.lastIndexOf('\n', index - 1) + 1;
+  for (let cursor = lineStart; cursor < index; cursor += 1) {
+    if (source[cursor] === '%' && !isEscaped(source, cursor)) return true;
+  }
+  return false;
+}
+
+function closingBrace(source, openIndex) {
+  let depth = 0;
+  for (let cursor = openIndex; cursor < source.length; cursor += 1) {
+    if (source[cursor] === '%' && !isEscaped(source, cursor)) {
+      const newline = source.indexOf('\n', cursor);
+      if (newline === -1) return -1;
+      cursor = newline;
+      continue;
+    }
+    if (source[cursor] === '{' && !isEscaped(source, cursor)) depth += 1;
+    if (source[cursor] === '}' && !isEscaped(source, cursor)) {
+      depth -= 1;
+      if (depth === 0) return cursor;
+    }
+  }
+  return -1;
+}
+
+function findCommandValue(source, command, from = 0, to = source.length) {
+  const regex = new RegExp(`\\\\${command}\\*?\\s*\\{`, 'g');
+  regex.lastIndex = from;
+  let match;
+  while ((match = regex.exec(source)) && match.index < to) {
+    if (isCommented(source, match.index)) continue;
+    const open = match.index + match[0].lastIndexOf('{');
+    const close = closingBrace(source, open);
+    if (close !== -1 && close < to) {
+      return { value: source.slice(open + 1, close), start: match.index, end: close + 1 };
+    }
+  }
+  return null;
+}
+
+function findHeadings(source, from, to) {
+  const regex = /\\(section|subsection|subsubsection)\*?\s*\{/g;
+  regex.lastIndex = from;
+  const headings = [];
+  let match;
+  while ((match = regex.exec(source)) && match.index < to) {
+    if (isCommented(source, match.index)) continue;
+    const open = match.index + match[0].lastIndexOf('{');
+    const close = closingBrace(source, open);
+    if (close === -1 || close >= to) continue;
+    headings.push({
+      command: match[1], level: SECTION_LEVELS[match[1]], title: source.slice(open + 1, close).trim(),
+      start: match.index, headingEnd: close + 1,
+    });
+    regex.lastIndex = close + 1;
+  }
+  return headings;
+}
+
+function trimRange(source, start, end) {
+  while (start < end && /\s/.test(source[start])) start += 1;
+  while (end > start && /\s/.test(source[end - 1])) end -= 1;
+  return { start, end };
+}
+
+function plainText(raw) {
+  return raw
+    .replace(/(?<!\\)%.*$/gm, ' ')
+    .replace(/\\(?:cite|ref|label|footnote|emph|textbf|textit)\*?(?:\[[^\]]*\])?\{([^{}]*)\}/g, '$1')
+    .replace(/\\[a-zA-Z@]+\*?(?:\[[^\]]*\])?/g, ' ')
+    .replace(/[{}]/g, ' ')
+    .replace(/\$+[^$]*\$+/g, ' equation ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+// Common Latin/English abbreviations whose trailing period is not a sentence
+// boundary. Keys include multi-character sequences such as "e.g" where the
+// intermediate period is part of the token.
+export const SENTENCE_ABBREVIATIONS = new Set([
+  'e.g', 'i.e', 'etc', 'cf', 'vs', 'viz', 'ca', 'approx', 'resp', 'ibid', 'loc', 'cit', 'op',
+  'fig', 'figs', 'sec', 'secs', 'eq', 'eqn', 'eqns', 'ref', 'refs', 'no', 'nos', 'vol', 'vols',
+  'pp', 'p', 'ch', 'chap', 'app', 'appx', 'dr', 'mr', 'mrs', 'ms', 'prof', 'st', 'rev', 'gen',
+  'gov', 'dept', 'univ', 'inc', 'ltd', 'ed', 'eds', 'al', 'jr', 'sr', 'ph', 'th',
+]);
+
+export function isAbbreviationAt(source, dotIndex) {
+  if (typeof source !== 'string' || !Number.isInteger(dotIndex)) return false;
+  let start = dotIndex - 1;
+  while (start >= 0 && /[A-Za-z.]/.test(source[start])) start -= 1;
+  const token = source.slice(start + 1, dotIndex);
+  if (!token) return false;
+  if (/^[A-Z]$/.test(token)) {
+    // A single capital before the period is an initial (A. M. Turing) only when
+    // it is followed by another initial; a sentence-final "do X." is a boundary.
+    return /^\s*(?:['\u2019\u201D"\u201C»›)\]}]*\s*)*[A-Z]\s*\./.test(source.slice(dotIndex + 1));
+  }
+  return SENTENCE_ABBREVIATIONS.has(token.toLowerCase());
+}
+
+// Closing quotes/brackets that may legally follow a sentence-final period.
+const CLOSING_PUNCTUATION = '"' + "'" + ')\]}' + '\u2019\u201D\u201C\u2018»›';
+
+// Given the index of a sentence-final character (.?!), return the index just
+// past any trailing closing quotes/brackets, or -1 when the character is glued
+// to a following word/command (i.e. not a boundary).
+export function sentenceEndIndex(source, punctIndex, end = source.length) {
+  let cursor = punctIndex + 1;
+  while (cursor < end && CLOSING_PUNCTUATION.includes(source[cursor])) cursor += 1;
+  const follower = source[cursor];
+  if (cursor < end && follower !== undefined && !/\s/.test(follower)) {
+    const visibleCommand = source.slice(cursor, end).match(/^\\(?:emph|textbf|textit|textrm|texttt|underline|mbox)\b/);
+    if (!visibleCommand) return -1; // glued to a word or a non-prose command
+  }
+  return cursor;
+}
+
+function sentenceRanges(source, start, end) {
+  const ranges = [];
+  let sentenceStart = start;
+  const suppressedBraces = [];
+  for (let cursor = start; cursor < end; cursor += 1) {
+    const character = source[cursor];
+    if (character === '{' && !isEscaped(source, cursor)) {
+      const command = source.slice(Math.max(start, cursor - 120), cursor)
+        .match(/\\([a-zA-Z@]+)\*?(?:\[[^\]]*\])*\s*$/)?.[1]?.toLowerCase() || '';
+      const suppressed = Boolean(suppressedBraces.at(-1))
+        || /^(?:cite\w*|ref|eqref|pageref|autoref|label|footnote|url)$/.test(command);
+      suppressedBraces.push(suppressed);
+      continue;
+    }
+    if (character === '}' && !isEscaped(source, cursor)) {
+      suppressedBraces.pop();
+      continue;
+    }
+    if (!'.?!'.includes(character) || isEscaped(source, cursor) || suppressedBraces.at(-1)) continue;
+    const previous = source[cursor - 1];
+    const boundary = sentenceEndIndex(source, cursor, end);
+    if (boundary === -1) continue; // glued to command, citation, etc.
+    // Next non-space character after the punctuation (and any closing quotes).
+    let look = boundary;
+    while (look < end && /\s/.test(source[look])) look += 1;
+    const nextNonSpace = source[look];
+    if (/\d/.test(previous || '') && /\d/.test(nextNonSpace || '')) continue; // decimal number
+    if (character === '.' && isAbbreviationAt(source, cursor)) continue; // e.g. i.e. cf. A. M.
+    if (look < end && /[a-z]/.test(nextNonSpace || '')) continue; // embedded quote: "think?" is ...
+    const range = trimRange(source, sentenceStart, boundary);
+    if (range.end > range.start) ranges.push(range);
+    sentenceStart = boundary;
+    cursor = boundary - 1;
+  }
+  const tail = trimRange(source, sentenceStart, end);
+  if (tail.end > tail.start) ranges.push(tail);
+  return ranges;
+}
+
+function inferIntent(value, index, count) {
+  const text = plainText(value).toLowerCase();
+  if (/\?$/.test(text)) return 'Pose a research question.';
+  if (/\b(we propose|we present|this paper contributes|our contribution)\b/.test(text)) return 'State the paper contribution.';
+  if (/\b(results?|findings?)\b.*\b(show|demonstrate|indicate|suggest)\b/.test(text)) return 'Report an empirical finding.';
+  if (/\b(however|nevertheless|in contrast|although)\b/.test(text)) return 'Introduce a contrast or limitation.';
+  if (/\b(therefore|thus|consequently|because)\b/.test(text)) return 'Explain reasoning or a consequence.';
+  if (index === 0) return 'Establish the paragraph topic.';
+  if (index === count - 1 && count > 1) return 'Conclude the point or transition onward.';
+  return 'Develop or support the paragraph argument.';
+}
+
+function isProseChunk(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return false;
+  if (/^\\(?:begin|end)\{(?:equation|align|figure|table|tikzpicture|thebibliography)\}/.test(trimmed)) return false;
+  if (/^(?:\\(?:maketitle|bibliography|bibliographystyle|label)\b[^\n]*\s*)+$/.test(trimmed)) return false;
+  return plainText(trimmed).length > 0;
+}
+
+function paragraphRanges(source, start, end) {
+  const ranges = [];
+  const separator = /\n[ \t]*\n+/g;
+  separator.lastIndex = start;
+  let cursor = start;
+  let match;
+  while ((match = separator.exec(source)) && match.index < end) {
+    const range = trimRange(source, cursor, match.index);
+    if (range.end > range.start && isProseChunk(source.slice(range.start, range.end))) ranges.push(range);
+    cursor = match.index + match[0].length;
+  }
+  const range = trimRange(source, cursor, end);
+  if (range.end > range.start && isProseChunk(source.slice(range.start, range.end))) ranges.push(range);
+  return ranges;
+}
+
+function previousMatcher(items, keyOf) {
+  const map = new Map();
+  for (const item of items || []) {
+    const key = keyOf(item);
+    if (!map.has(key)) map.set(key, []);
+    map.get(key).push(item);
+  }
+  return { map, items: items || [], used: new Set() };
+}
+
+function takePrevious(matcher, key, index) {
+  const matches = matcher.map.get(key) || [];
+  let exact = matches.shift();
+  while (exact && matcher.used.has(exact.id)) exact = matches.shift();
+  if (exact) {
+    matcher.used.add(exact.id);
+    return exact;
+  }
+  const positional = matcher.items[index];
+  if (positional && !matcher.used.has(positional.id)) {
+    matcher.used.add(positional.id);
+    return positional;
+  }
+  const unused = matcher.items.find((item) => !matcher.used.has(item.id));
+  if (unused) matcher.used.add(unused.id);
+  return unused || null;
+}
+
+function buildParagraphs(source, section, previousSection) {
+  const previousParagraphs = previousSection?.children || [];
+  const paragraphMatcher = previousMatcher(previousParagraphs, (item) => fingerprint(item.text || ''));
+  return paragraphRanges(source, section.contentStart, section.contentEnd).map((range, paragraphIndex) => {
+    const raw = source.slice(range.start, range.end);
+    const previous = takePrevious(paragraphMatcher, fingerprint(raw), paragraphIndex);
+    const paragraphId = previous?.id || id('paragraph');
+    const sentenceSourceRanges = sentenceRanges(source, range.start, range.end);
+    const previousSentences = previous?.children || [];
+    const sentenceMatcher = previousMatcher(previousSentences, (item) => fingerprint(item.text || ''));
+    const children = sentenceSourceRanges.map((sentenceRange, sentenceIndex) => {
+      const sentenceRaw = source.slice(sentenceRange.start, sentenceRange.end);
+      const old = takePrevious(sentenceMatcher, fingerprint(sentenceRaw), sentenceIndex);
+      return {
+        id: old?.id || id('sentence'), type: 'sentence', parentId: paragraphId, order: sentenceIndex,
+        text: sentenceRaw, prompt: old?.prompt || '', summary: old?.summary || '',
+        intent: old?.intent || inferIntent(sentenceRaw, sentenceIndex, sentenceSourceRanges.length),
+        sourceRange: { ...sentenceRange, contentStart: sentenceRange.start, contentEnd: sentenceRange.end },
+      };
+    });
+    const readable = plainText(raw);
+    return {
+      id: paragraphId, type: 'paragraph', parentId: section.id, order: paragraphIndex,
+      text: raw, prompt: previous?.prompt || '',
+      summary: previous?.summary || plainText(children[0]?.text || readable).slice(0, 180),
+      sourceRange: { ...range, contentStart: range.start, contentEnd: range.end }, children,
+    };
+  });
+}
+
+export function parseLatexDocument(source, previousDocument = {}) {
+  if (typeof source !== 'string') throw new TypeError('LaTeX source must be a string');
+  const beginDocument = source.search(/\\begin\s*\{document\}/);
+  const endDocument = source.search(/\\end\s*\{document\}/);
+  const bodyStart = beginDocument === -1 ? 0 : beginDocument + source.slice(beginDocument).match(/^\\begin\s*\{document\}/)[0].length;
+  const bodyEnd = endDocument === -1 ? source.length : endDocument;
+  const title = findCommandValue(source, 'title', 0, bodyStart)?.value.trim() || previousDocument.title || '';
+  const headings = findHeadings(source, bodyStart, bodyEnd);
+  const descriptors = [];
+
+  const abstractStartMatch = /\\begin\s*\{abstract\}/g;
+  abstractStartMatch.lastIndex = bodyStart;
+  const abstractMatch = abstractStartMatch.exec(source);
+  if (abstractMatch && abstractMatch.index < bodyEnd) {
+    const closeRegex = /\\end\s*\{abstract\}/g;
+    closeRegex.lastIndex = abstractMatch.index + abstractMatch[0].length;
+    const close = closeRegex.exec(source);
+    if (close && close.index < bodyEnd) {
+      descriptors.push({
+        command: 'abstract', level: 1, title: 'Abstract', start: abstractMatch.index,
+        headingEnd: abstractMatch.index + abstractMatch[0].length,
+        contentStart: abstractMatch.index + abstractMatch[0].length, contentEnd: close.index,
+        end: close.index + close[0].length,
+      });
+    }
+  }
+
+  headings.forEach((heading, index) => {
+    const next = headings[index + 1];
+    descriptors.push({
+      ...heading, contentStart: heading.headingEnd, contentEnd: next?.start || bodyEnd,
+      end: next?.start || bodyEnd,
+    });
+  });
+  descriptors.sort((a, b) => a.start - b.start);
+
+  const previousSections = previousDocument.sections || [];
+  const sectionMatcher = previousMatcher(previousSections, (item) => `${item.level || 1}:${normalize(item.title || item.text || '')}`);
+  const sections = descriptors.map((descriptor, sectionIndex) => {
+    const key = `${descriptor.level}:${normalize(descriptor.title)}`;
+    const previous = takePrevious(sectionMatcher, key, sectionIndex);
+    const section = {
+      id: previous?.id || id('section'), type: 'section', parentId: previousDocument.id || '', order: sectionIndex,
+      level: descriptor.level, command: descriptor.command, title: descriptor.title, text: descriptor.title,
+      prompt: previous?.prompt || '', summary: previous?.summary || '',
+      sourceRange: {
+        start: descriptor.start, end: descriptor.end,
+        contentStart: descriptor.contentStart, contentEnd: descriptor.contentEnd,
+      },
+      children: [],
+    };
+    section.children = buildParagraphs(source, { ...descriptor, id: section.id }, previous);
+    if (!section.summary) section.summary = section.children[0]?.summary || '';
+    return section;
+  });
+
+  return { title, sections, sourceLength: source.length };
+}
+
+export function findStructureNode(document, nodeId) {
+  if (document.id === nodeId) return document;
+  const visit = (nodes) => {
+    for (const node of nodes || []) {
+      if (node.id === nodeId) return node;
+      const found = visit(node.children);
+      if (found) return found;
+    }
+    return null;
+  };
+  return visit(document.sections);
+}

package/src/server/latex.js

@@ -0,0 +1,67 @@
+import { execFile } from 'child_process';
+import { resolve as pathResolve, dirname, basename } from 'path';
+
+const ENGINE_ORDER = ['tectonic', 'pdflatex', 'xelatex', 'lualatex'];
+const COMPILE_TIMEOUT_MS = 30000;
+const FIND_COMMAND = process.platform === 'win32' ? 'where' : 'which';
+
+export async function detectEngines() {
+  const available = [];
+  for (const engine of ENGINE_ORDER) {
+    try {
+      await new Promise((res, rej) => {
+        execFile(FIND_COMMAND, [engine], { timeout: 5000, shell: false }, (err) => {
+          if (err) rej(err);
+          else res();
+        });
+      });
+      available.push(engine);
+    } catch {}
+  }
+  return available;
+}
+
+export async function compile(texPath, workspaceRoot) {
+  const engines = await detectEngines();
+  if (engines.length === 0) {
+    return { ok: false, error: 'No LaTeX engine found. Install pdflatex, xelatex, lualatex, or tectonic.', engine: null };
+  }
+
+  const engine = engines[0];
+  const fileDir = dirname(texPath);
+  const fileBase = basename(texPath, '.tex');
+
+  let args;
+  if (engine === 'tectonic') {
+    args = [texPath, '--outdir', fileDir];
+  } else {
+    args = ['-no-shell-escape', '-interaction=nonstopmode', '-halt-on-error', '-output-directory', fileDir, fileBase];
+  }
+
+  return new Promise((done) => {
+    execFile(engine, args, {
+      cwd: fileDir,
+      timeout: COMPILE_TIMEOUT_MS,
+      shell: false,
+      env: {
+        ...process.env,
+        openin_any: 'p',
+        openout_any: 'p',
+        shell_escape: 'f',
+      },
+      maxBuffer: 10 * 1024 * 1024,
+      killSignal: 'SIGKILL',
+    }, (err, stdout, stderr) => {
+      if (err) {
+        if (err.killed) {
+          return done({ ok: false, error: 'Compilation timed out (30s)', engine });
+        }
+        const combined = (stderr || '') + (stdout || '');
+        const errorMatch = combined.match(/^!.*$/m);
+        return done({ ok: false, error: errorMatch?.[0] || stderr || err.message, engine, log: combined });
+      }
+      const pdfPath = pathResolve(fileDir, fileBase + '.pdf');
+      done({ ok: true, pdf: pdfPath, engine, output: stdout });
+    });
+  });
+}

package/src/server/library-engine.js

@@ -0,0 +1,193 @@
+const DEFAULT_LIMITS = { corpora: 3, patterns: 3, vocabulary: 12 };
+const STOP_WORDS = new Set([
+  'about', 'after', 'again', 'against', 'among', 'because', 'before', 'being', 'between', 'could',
+  'during', 'first', 'from', 'have', 'into', 'more', 'other', 'paper', 'results', 'should', 'their',
+  'there', 'these', 'they', 'this', 'through', 'using', 'were', 'which', 'with', 'would',
+]);
+
+function words(value) {
+  return [...new Set(String(value || '').toLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) || [])];
+}
+
+function textFor(type, item) {
+  if (type === 'corpus') return [item.name, item.description, item.content, item.source, ...(item.tags || [])].join(' ');
+  if (type === 'pattern') return [item.name, item.description, item.template, item.source, ...(item.tags || []), ...(item.sectionTypes || [])].join(' ');
+  return [item.term, item.preferred, item.definition, item.source, ...(item.tags || []), ...(item.alternatives || []), ...(item.examples || [])].join(' ');
+}
+
+function scoreItem(type, item, queryTokens, tags) {
+  const haystack = textFor(type, item).toLowerCase();
+  let score = 0;
+  queryTokens.forEach((token) => {
+    if (haystack.includes(token)) score += haystack.includes(` ${token} `) ? 4 : 2;
+  });
+  tags.forEach((tag) => {
+    if ((item.tags || []).some((candidate) => candidate.toLowerCase() === tag)) score += 6;
+  });
+  return score;
+}
+
+function ranked(type, items, { query = '', tags = [], limit = 10, sectionType = '' } = {}) {
+  const queryTokens = words(query);
+  const normalizedTags = tags.map((tag) => String(tag).toLowerCase());
+  return items
+    .filter((item) => type !== 'pattern' || !sectionType || item.sectionTypes.length === 0
+      || item.sectionTypes.some((candidate) => candidate.toLowerCase() === sectionType.toLowerCase()))
+    .map((item, index) => ({ item, index, score: scoreItem(type, item, queryTokens, normalizedTags) }))
+    .filter((entry) => queryTokens.length === 0 && normalizedTags.length === 0 || entry.score > 0)
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .slice(0, Math.max(0, Math.min(Number(limit) || 10, 100)))
+    .map(({ item, score }) => ({ ...item, relevance: score }));
+}
+
+export function mergedVocabulary(libraries) {
+  const merged = new Map();
+  for (const item of libraries.vocabulary.global) merged.set(item.term.trim().toLowerCase(), { ...item, scope: 'global' });
+  for (const item of libraries.vocabulary.session) merged.set(item.term.trim().toLowerCase(), { ...item, scope: 'session' });
+  return [...merged.values()];
+}
+
+export function searchLibraries(libraries, options = {}) {
+  return {
+    corpora: ranked('corpus', libraries.corpora, { ...options, limit: options.limits?.corpora ?? options.limit ?? 10 }),
+    sentencePatterns: ranked('pattern', libraries.sentencePatterns, { ...options, limit: options.limits?.patterns ?? options.limit ?? 10 }),
+    vocabulary: ranked('vocabulary', mergedVocabulary(libraries), { ...options, limit: options.limits?.vocabulary ?? options.limit ?? 20 }),
+  };
+}
+
+function allResources(libraries) {
+  return [
+    ...libraries.corpora.map((item) => ({ type: 'corpus', item })),
+    ...libraries.sentencePatterns.map((item) => ({ type: 'pattern', item })),
+    ...libraries.vocabulary.global.map((item) => ({ type: 'vocabulary', scope: 'global', item })),
+    ...libraries.vocabulary.session.map((item) => ({ type: 'vocabulary', scope: 'session', item })),
+  ];
+}
+
+function descriptor(type, item, scope) {
+  return { id: item.id, type, scope: scope || null, name: item.name || item.term };
+}
+
+export function buildLibraryContext(libraries, { query = '', tags = [], sectionType = '', resourceIds = [] } = {}) {
+  const explicit = new Set(Array.isArray(resourceIds) ? resourceIds : []);
+  let selected;
+  if (explicit.size > 0) {
+    selected = allResources(libraries).filter(({ item }) => explicit.has(item.id));
+  } else {
+    const found = searchLibraries(libraries, { query, tags, sectionType, limits: DEFAULT_LIMITS });
+    selected = [
+      ...found.corpora.map((item) => ({ type: 'corpus', item })),
+      ...found.sentencePatterns.map((item) => ({ type: 'pattern', item })),
+      ...found.vocabulary.map((item) => ({ type: 'vocabulary', scope: item.scope, item })),
+    ];
+  }
+
+  const blocks = selected.map(({ type, scope, item }) => {
+    if (type === 'corpus') {
+      return `[CORPUS ${item.id}] ${item.name}\nSource: ${item.source || 'user library'}\n${item.content}`;
+    }
+    if (type === 'pattern') {
+      const slots = item.slots.map((slot) => `${slot.name}${slot.required ? '*' : ''}: ${slot.description}`).join('; ');
+      return `[SENTENCE_PATTERN ${item.id}] ${item.name}\nTemplate: ${item.template}\nSlots: ${slots || 'none'}`;
+    }
+    return `[VOCABULARY ${item.id} scope=${scope}] ${item.term}${item.preferred ? ` -> prefer: ${item.preferred}` : ''}`
+      + `${item.definition ? `\nMeaning: ${item.definition}` : ''}`;
+  });
+  const resources = selected.map(({ type, scope, item }) => descriptor(type, item, scope));
+  return {
+    prompt: blocks.length ? `Writing library resources:\n${blocks.join('\n\n')}\n\nUse only resources that improve the text. Report the IDs you actually use in usedResourceIds.` : '',
+    resources,
+    resourceIds: resources.map((item) => item.id),
+    mode: explicit.size > 0 ? 'selected' : 'automatic',
+  };
+}
+
+export function renderSentencePattern(pattern, values = {}) {
+  if (!pattern || typeof pattern.template !== 'string') throw new Error('Pattern is required');
+  const missing = (pattern.slots || [])
+    .filter((slot) => slot.required && (typeof values[slot.name] !== 'string' || !values[slot.name].trim()))
+    .map((slot) => slot.name);
+  if (missing.length) {
+    const error = new Error(`Missing required pattern slots: ${missing.join(', ')}`);
+    error.code = 'MISSING_PATTERN_SLOTS';
+    error.status = 400;
+    error.details = missing;
+    throw error;
+  }
+  const rendered = pattern.template.replace(/\{([a-zA-Z][\w-]*)\}/g, (match, name) => {
+    const value = values[name];
+    return typeof value === 'string' && value.trim() ? value.trim() : match;
+  });
+  return { rendered, patternId: pattern.id, values };
+}
+
+function cleanLatex(content) {
+  return content
+    .replace(/(?<!\\)%.*$/gm, ' ')
+    .replace(/\\(?:begin|end)\{[^}]+\}/g, ' ')
+    .replace(/\\[a-zA-Z@]+\*?(?:\[[^\]]*\])?(?:\{([^{}]*)\})?/g, '$1')
+    .replace(/[{}$]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function extractLibraryCandidates(content, source = 'current document') {
+  const clean = cleanLatex(content);
+  const sentences = clean.match(/[^.!?]+[.!?]+/g) || [];
+  const patterns = sentences
+    .map((sentence) => sentence.trim())
+    .filter((sentence) => sentence.length >= 35 && sentence.length <= 300)
+    .slice(0, 12)
+    .map((template, index) => ({
+      kind: 'sentence-patterns',
+      value: {
+        name: `Extracted expression ${index + 1}`, template, description: 'Candidate extracted from the current paper.',
+        tags: ['extracted'], sectionTypes: [], slots: [], source,
+      },
+    }));
+
+  const frequencies = new Map();
+  for (const word of clean.toLowerCase().match(/[a-z][a-z-]{6,}/g) || []) {
+    if (!STOP_WORDS.has(word)) frequencies.set(word, (frequencies.get(word) || 0) + 1);
+  }
+  const vocabulary = [...frequencies.entries()]
+    .filter(([, count]) => count >= 2)
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .slice(0, 12)
+    .map(([term, count]) => ({
+      kind: 'vocabulary', scope: 'session',
+      value: {
+        term, preferred: term, definition: `Appears ${count} times in the current paper.`, source,
+        alternatives: [], examples: [], tags: ['extracted'],
+      },
+    }));
+  return { patterns, vocabulary };
+}
+
+export function composeMockParagraph(libraries, context, instruction = '') {
+  const selected = new Set(context.resourceIds || []);
+  const corpora = libraries.corpora.filter((item) => selected.has(item.id));
+  const patterns = libraries.sentencePatterns.filter((item) => selected.has(item.id));
+  const vocabulary = mergedVocabulary(libraries).filter((item) => selected.has(item.id));
+  const pieces = [];
+  const usedResourceIds = [];
+  if (corpora[0]) {
+    pieces.push(corpora[0].content.trim());
+    usedResourceIds.push(corpora[0].id);
+  }
+  if (patterns[0]) {
+    const rendered = patterns[0].template.replace(/\{([a-zA-Z][\w-]*)\}/g, (_match, name) => `[${name}]`);
+    pieces.push(rendered);
+    usedResourceIds.push(patterns[0].id);
+  }
+  if (vocabulary.length) {
+    const terms = vocabulary.slice(0, 4).map((item) => item.preferred || item.term);
+    pieces.push(`Use the preferred terminology ${terms.join(', ')} while developing this argument.`);
+    usedResourceIds.push(...vocabulary.slice(0, 4).map((item) => item.id));
+  }
+  if (!pieces.length) {
+    const topic = instruction.trim().replace(/[.!?]+$/, '');
+    pieces.push(topic ? `This paragraph develops the following point: ${topic}.` : 'Develop the central claim with evidence and appropriate qualifications.');
+  }
+  return { draft: pieces.join(' '), usedResourceIds: [...new Set(usedResourceIds)] };
+}