@agentproto/corpus 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/report/index.mjs

@@ -0,0 +1,633 @@
+import { resolveKnowledge } from '../chunk-3P23OX5X.mjs';
+import matter from 'gray-matter';
+import { z } from 'zod';
+
+/**
+ * @agentproto/corpus v0.1.0-alpha
+ * Composition of AIP-10/12/18/9/15/41 — autonomous knowledge-improvement kit.
+ */
+var flat = (v) => Array.isArray(v) ? v.join(" ") : v == null ? "" : String(v);
+var asTags = (v) => Array.isArray(v) ? v : v ? [String(v)] : [];
+var firstSentence = (body) => {
+  const txt = body.replace(/^#.*$/gm, "").replace(/\s+/g, " ").trim();
+  return (txt.split(/(?<=[.!?])\s/)[0] || txt).slice(0, 260);
+};
+async function walkMd(dataset, dir) {
+  let rels;
+  try {
+    rels = await dataset.walk(dir);
+  } catch {
+    return [];
+  }
+  return rels.filter((r) => r.endsWith(".md")).map((r) => `${dir}/${r}`);
+}
+async function buildPacks(opts) {
+  const { dataset, config } = opts;
+  const viewsDir = opts.viewsDir ?? "views";
+  const facetOrder = [...new Set(config.chapters.flatMap((c) => c.facets ?? []))];
+  const sources = [];
+  for (const path of await walkMd(dataset, "sources")) {
+    let raw;
+    try {
+      raw = await dataset.readFile(path);
+    } catch {
+      continue;
+    }
+    let fm = {};
+    try {
+      fm = matter(raw).data;
+    } catch {
+      fm = {};
+    }
+    const id = flat(fm.id).trim();
+    if (!id) continue;
+    const corpusMeta = fm.metadata?.corpus ?? {};
+    const url = String(
+      corpusMeta.originalUrl ?? corpusMeta.importerSourceUrl ?? ""
+    ).replace(/\s+/g, "").trim();
+    sources.push({
+      id,
+      title: flat(fm.title).replace(/\s+/g, " ").trim(),
+      url,
+      tags: asTags(fm.tags)
+    });
+  }
+  const facetOf = (s) => facetOrder.find((f) => s.tags.includes(f)) ?? "other";
+  sources.sort((a, b) => {
+    const fa = facetOrder.indexOf(facetOf(a));
+    const fb = facetOrder.indexOf(facetOf(b));
+    if (fa !== fb) return (fa < 0 ? 99 : fa) - (fb < 0 ? 99 : fb);
+    return a.title.localeCompare(b.title);
+  });
+  const idToN = /* @__PURE__ */ new Map();
+  sources.forEach((s, i) => {
+    s.n = i + 1;
+    idToN.set(s.id, i + 1);
+  });
+  const entries = [];
+  for (const path of await walkMd(dataset, "entries")) {
+    let raw;
+    try {
+      raw = await dataset.readFile(path);
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = matter(raw);
+    } catch {
+      continue;
+    }
+    const fm = parsed.data;
+    const title = flat(fm.title).replace(/\s+/g, " ").trim();
+    if (!title) continue;
+    const segs = path.replace(/^entries\//, "").split("/");
+    const kind = typeof fm.kind === "string" && fm.kind ? fm.kind : segs.slice(-2)[0] ?? "unknown";
+    const srcs = asTags(fm.sources).map((s) => flat(s).replace(/\s+/g, "").trim());
+    const ns = [
+      ...new Set(srcs.map((id) => idToN.get(id)).filter((n) => !!n))
+    ].sort((a, b) => a - b);
+    entries.push({
+      kind,
+      title,
+      conf: fm.confidence ?? "",
+      tags: asTags(fm.tags),
+      ns,
+      gist: firstSentence(parsed.content)
+    });
+  }
+  const files = [];
+  files.push({
+    path: `${viewsDir}/_bibliography.json`,
+    content: JSON.stringify({ sources }, null, 2)
+  });
+  files.push({
+    path: `${viewsDir}/_bibliography.md`,
+    content: "# Bibliography (global citation index)\n\n" + sources.map((s) => `${s.n}. ${s.title || s.id} \u2014 ${s.url}`).join("\n") + "\n"
+  });
+  const chapters = [];
+  for (const ch of config.chapters) {
+    const facets = ch.facets ?? [];
+    const kw = (ch.kw ?? []).map((s) => s.toLowerCase());
+    const seen = /* @__PURE__ */ new Set();
+    const scored = [];
+    for (const e of entries) {
+      if (!facets.some((f) => e.tags.includes(f))) continue;
+      const hay = `${e.title} ${e.tags.join(" ")} ${e.gist}`.toLowerCase();
+      const hits = kw.filter((k) => hay.includes(k)).length;
+      if (kw.length && hits === 0) continue;
+      const key = e.title.toLowerCase().slice(0, 50);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      scored.push({ e, hits });
+    }
+    scored.sort(
+      (a, b) => b.hits - a.hits || String(b.e.conf).localeCompare(String(a.e.conf))
+    );
+    const picks = scored.slice(0, ch.cap ?? 28).map((x) => x.e);
+    const srcFiles = [...new Set(facets.map((f) => `sources.${f}.md`))];
+    const lines = picks.map(
+      (e) => `- **[${e.kind}]** ${e.title}${e.conf ? ` _(conf ${e.conf})_` : ""} ${e.ns.length ? `[${e.ns.join(",")}]` : "[uncited]"}
+  ${e.gist}`
+    );
+    files.push({
+      path: `${viewsDir}/${ch.id}.md`,
+      content: `# Pack \u2014 ${ch.title}
+
+**Facets:** ${facets.join(", ")} \xB7 **${picks.length} distilled claims** (each tagged with its global source number [n]).
+
+**Also read for full context + exact quotes/URLs:** ${srcFiles.join(", ")} (in the corpus root), and ${viewsDir}/_bibliography.md.
+
+## Distilled claims for this chapter
+
+${lines.join("\n")}
+`
+    });
+    chapters.push({ id: ch.id, title: ch.title, entryCount: picks.length });
+  }
+  return { files, bibliography: sources.length, chapters };
+}
+
+// src/report/cites.ts
+function citesOf(s) {
+  return [...s.matchAll(/\[(\d{1,3}(?:,\s*\d{1,3})*)\]/g)].flatMap(
+    (m) => m[1].split(",").map((n) => parseInt(n.trim(), 10))
+  );
+}
+function outOfRangeCites(s, bibMax) {
+  return [...new Set(citesOf(s).filter((n) => n < 1 || n > bibMax))];
+}
+
+// src/report/assemble.ts
+var PREAMBLE = /^\s*(?:I have|I'll|Here is|Here's|Writing|Let me|Okay|Done)/i;
+var CROSSREF = /\[(\d{1,3})\s*(?:→|->|—>|to see|see)\s*(?:see\s*)?(\d{1,3})\]/g;
+function cleanDraft(draft) {
+  if (!draft) return "";
+  let s = draft.replace(/\r/g, "");
+  const i = s.indexOf("## ");
+  if (i > 0) s = s.slice(i);
+  s = s.replace(CROSSREF, "[$2]");
+  return s.replace(/\n{3,}/g, "\n\n").trim();
+}
+function assembleChapters(opts) {
+  const chaptersDir = opts.chaptersDir ?? "chapters";
+  const files = [];
+  let preamblesStripped = 0;
+  const outOfRange = [];
+  for (const c of opts.chapters) {
+    const body = cleanDraft(c.draft);
+    if (PREAMBLE.test(c.draft || "")) preamblesStripped++;
+    if (body) files.push({ path: `${chaptersDir}/${c.ch}.md`, content: body + "\n" });
+    const oor = outOfRangeCites(body, opts.bibMax);
+    if (oor.length) outOfRange.push({ ch: c.ch, cites: oor });
+  }
+  return {
+    files,
+    stats: {
+      chapters: opts.chapters.length,
+      preamblesStripped,
+      withOutOfRangeCites: outOfRange.length,
+      outOfRange
+    }
+  };
+}
+var reportSectionKindSchema = z.enum([
+  "front",
+  "part",
+  "chapter",
+  "annexes",
+  "sources"
+]);
+var reportSectionSchema = z.object({
+  /** Stable id — chapter id, or `_front`/`_annexes`/`_sources` for the glue. */
+  id: z.string(),
+  /** Human label (heading text, leading `#`s stripped). May be "". */
+  title: z.string(),
+  /** The section's raw markdown, exactly as it appears in REPORT.md. */
+  markdown: z.string(),
+  kind: reportSectionKindSchema
+});
+var bibEntrySchema = z.object({
+  n: z.number(),
+  id: z.string(),
+  title: z.string(),
+  url: z.string()
+});
+var reportContentSchema = z.object({
+  title: z.string(),
+  sections: z.array(reportSectionSchema),
+  bibliography: z.object({
+    mode: z.literal("numbered"),
+    entries: z.array(bibEntrySchema)
+  }).optional(),
+  /** Document metadata (brand · subtitle · tag · custodian) — presentation-free. */
+  meta: z.record(z.string(), z.string()).optional()
+});
+var stripHeading = (s) => s.replace(/^#+\s*/, "").trim();
+async function collectReportSections(opts) {
+  const { config, report } = opts;
+  const chaptersDir = opts.chaptersDir ?? "chapters";
+  const viewsDir = opts.viewsDir ?? "views";
+  const rd = async (p) => (await report.readFile(p)).trim();
+  const rdOpt = async (p) => {
+    try {
+      return await rd(p);
+    } catch {
+      return null;
+    }
+  };
+  const titleOf = (id) => config.chapters.find((c) => c.id === id)?.title ?? id;
+  const sections = [];
+  const front = await rdOpt(config.frontFile ?? `${chaptersDir}/_front.md`);
+  if (front) sections.push({ id: "_front", title: "", markdown: front, kind: "front" });
+  if (config.parts && config.parts.length) {
+    for (const part of config.parts) {
+      sections.push({
+        id: stripHeading(part.heading).toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+        title: stripHeading(part.heading),
+        markdown: part.heading,
+        kind: "part"
+      });
+      for (const id of part.chapters ?? []) {
+        sections.push({
+          id,
+          title: titleOf(id),
+          markdown: await rd(`${chaptersDir}/${id}.md`),
+          kind: "chapter"
+        });
+      }
+    }
+  } else {
+    for (const c of config.chapters) {
+      sections.push({
+        id: c.id,
+        title: c.title,
+        markdown: await rd(`${chaptersDir}/${c.id}.md`),
+        kind: "chapter"
+      });
+    }
+  }
+  if (config.annexesFile) {
+    const annexes = await rdOpt(config.annexesFile);
+    if (annexes)
+      sections.push({ id: "_annexes", title: "Annexes", markdown: annexes, kind: "annexes" });
+  }
+  const bib = (await rd(`${viewsDir}/_bibliography.md`)).replace(/^# Bibliography.*$/m, "").trim();
+  sections.push({
+    id: "_sources",
+    title: "Sources",
+    markdown: "## Sources\n\n" + bib,
+    kind: "sources"
+  });
+  return sections;
+}
+function reportContentToMarkdown(sections) {
+  return sections.map((s) => s.markdown).join("\n\n") + "\n";
+}
+async function buildReportContent(opts) {
+  const { config, report } = opts;
+  const viewsDir = opts.viewsDir ?? "views";
+  const sections = await collectReportSections(opts);
+  let title = config.title?.trim() ?? "";
+  if (!title) {
+    const front = sections.find((s) => s.kind === "front");
+    title = front?.markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "Report";
+  }
+  let bibliography;
+  try {
+    const raw = await report.readFile(`${viewsDir}/_bibliography.json`);
+    const parsed = JSON.parse(raw);
+    const src = Array.isArray(parsed.sources) ? parsed.sources : [];
+    const entries = src.map((s) => {
+      const o = s ?? {};
+      return {
+        n: typeof o.n === "number" ? o.n : 0,
+        id: typeof o.id === "string" ? o.id : "",
+        title: typeof o.title === "string" ? o.title : "",
+        url: typeof o.url === "string" ? o.url : ""
+      };
+    });
+    if (entries.length) bibliography = { mode: "numbered", entries };
+  } catch {
+  }
+  const meta = {};
+  const cover = config.cover;
+  if (cover) {
+    for (const k of ["brand", "subtitle", "tag", "meta"]) {
+      const v = cover[k];
+      if (typeof v === "string" && v.trim()) meta[k] = v.trim();
+    }
+  }
+  if (config.profile) meta.profile = config.profile;
+  return {
+    title,
+    sections,
+    ...bibliography ? { bibliography } : {},
+    ...Object.keys(meta).length ? { meta } : {}
+  };
+}
+
+// src/report/stitch.ts
+async function stitchReport(opts) {
+  const sections = await collectReportSections(opts);
+  const content = reportContentToMarkdown(sections);
+  const wordCount = sections.map((s) => s.markdown).join(" ").split(/\s+/).length;
+  return { content, wordCount };
+}
+
+// src/report/apply-edits.ts
+function occ(hay, n) {
+  let c = 0;
+  let i = 0;
+  while ((i = hay.indexOf(n, i)) !== -1) {
+    c++;
+    i += n.length;
+  }
+  return c;
+}
+async function applyEdits(opts) {
+  const chaptersDir = opts.chaptersDir ?? "chapters";
+  const files = [];
+  let md = "# Fix-apply report (edit-based)\n\nEach edit lands only if `find` matches exactly once and `replace` adds no out-of-range [n].\n\n";
+  let applied = 0;
+  let skipped = 0;
+  let filesChanged = 0;
+  for (const r of opts.results) {
+    const path = `${chaptersDir}/${r.id}.md`;
+    let text = await opts.report.readFile(path);
+    const edits = r.edits ?? [];
+    let n = 0;
+    md += `## ${r.id} \u2014 ${edits.length} proposed edit(s)
+`;
+    for (const e of edits) {
+      const find = e.find ?? "";
+      const replace = e.replace ?? "";
+      const oor = outOfRangeCites(replace, opts.bibMax);
+      const count = find ? occ(text, find) : 0;
+      let status;
+      if (!find) status = "SKIP (empty find)";
+      else if (count === 0) status = "SKIP (find not matched verbatim)";
+      else if (count > 1) status = `SKIP (find matches ${count}\xD7 \u2014 ambiguous)`;
+      else if (oor.length)
+        status = `SKIP (replace adds out-of-range cite ${oor.join(",")})`;
+      else {
+        text = text.replace(find, replace);
+        n++;
+        status = "\u2705 applied";
+      }
+      md += `- ${status} \u2014 _${e.reason || ""}_
+`;
+      if (status.startsWith("\u2705")) {
+        md += `    find:    ${JSON.stringify(find.slice(0, 200))}
+    replace: ${JSON.stringify(replace.slice(0, 200))}
+`;
+      }
+    }
+    const post = [];
+    if (!text.startsWith("## ")) post.push("no longer starts at '##'");
+    const oorAll = outOfRangeCites(text, opts.bibMax);
+    if (oorAll.length) post.push(`out-of-range cites present: ${oorAll.join(",")}`);
+    if (post.length)
+      md += `- \u26A0\uFE0F POST-CHECK FAILED (${post.join("; ")}) \u2192 NOT written
+`;
+    else if (n > 0) {
+      files.push({ path, content: text });
+      filesChanged++;
+    }
+    applied += n;
+    skipped += edits.length - n;
+    md += `- result: ${n}/${edits.length} applied${post.length ? " (reverted)" : ""}
+
+`;
+  }
+  return { files, report: md, stats: { filesChanged, applied, skipped } };
+}
+
+// src/report/model.ts
+async function runModel(model, input) {
+  const { result } = await model.complete(input);
+  return typeof result === "string" ? result : JSON.stringify(result);
+}
+
+// src/report/analyze.ts
+function buildFacetAnalysisPrompt(input) {
+  return {
+    system: "You are a research analyst. Your output is a structured markdown analysis document that will be used as input to a long-form research bible chapter. Write in clear, dense prose with H2 headers. No filler, no meta-commentary.",
+    prompt: `Synthesize these knowledge entries about the facet "${input.facet}" into a structured markdown analysis document for a research bible.
+
+Include:
+- ## Key Themes: recurring patterns across entries
+- ## Major Findings: the most credible, high-confidence claims
+- ## Notable Examples: concrete worked instances worth citing
+- ## Gaps & Contradictions: what is unknown, disputed, or missing
+
+ENTRIES:
+
+${input.entriesText}`
+  };
+}
+async function analyzeDataset(opts) {
+  const files = [];
+  const skipped = [];
+  for (const facet of opts.facets) {
+    const entries = await resolveKnowledge({
+      fs: opts.dataset,
+      query: { tags: [facet] }
+    });
+    if (entries.length === 0) {
+      skipped.push(facet);
+      continue;
+    }
+    const entriesText = entries.map(
+      (e) => `### ${e.title} (${e.kind}, confidence ${e.confidence ?? "?"})
+
+${e.body}`
+    ).join("\n\n---\n\n");
+    const content = await runModel(
+      opts.model,
+      buildFacetAnalysisPrompt({ facet, entriesText })
+    );
+    files.push({
+      path: `sources.${facet}.md`,
+      content: `# Analysis: ${facet}
+
+${content}`
+    });
+  }
+  return { files, analyzed: files.length, skipped };
+}
+
+// src/report/write.ts
+function buildChapterWritePrompt(ctx) {
+  const words = ctx.chapter.words ?? "800-1500";
+  return {
+    system: `You are an expert research writer. Write in clear, dense, well-structured prose. Every non-obvious claim must be cited inline as [n] from the Bibliography. Use Markdown H2 and H3 subheaders within the chapter. No meta-commentary or filler. Aim for ${words} words.`,
+    prompt: `Write the chapter "${ctx.chapter.title}" for the research document "${ctx.title}".
+
+## Distilled claims for this chapter (with citation numbers):
+
+${ctx.packContent}
+
+` + (ctx.analysisContext ? `## Per-facet analysis (for deeper context):
+
+${ctx.analysisContext}
+
+` : "") + `## Bibliography (for citation verification):
+
+${ctx.bibliography ?? ""}
+
+Write the chapter now. Start with the "## ${ctx.chapter.title}" heading, then the content.`
+  };
+}
+async function writeChapter(ctx, model) {
+  const draft = await runModel(model, buildChapterWritePrompt(ctx));
+  return { ch: ctx.chapter.id, draft };
+}
+function buildReviewPrompt(ctx) {
+  return {
+    system: "You are a meticulous fact + citation reviewer for a long-form research report. Propose ONLY targeted, exact-match edits \u2014 never a rewrite. Each edit's `find` MUST be a verbatim substring of the chapter that occurs EXACTLY ONCE, and `replace` must keep every citation [n] within the valid range. Fix wrong/missing citations, unsupported or overstated claims, and factual errors against the analysis + bibliography. Output ONLY a JSON object \u2014 no prose, no fences.",
+    prompt: `Review the chapter "${ctx.chapter.title}". Valid citations are [1]..[${ctx.bibMax}].
+
+## Chapter (current text):
+
+${ctx.chapterText}
+
+` + (ctx.analysisContext ? `## Per-facet analysis (ground truth):
+
+${ctx.analysisContext}
+
+` : "") + `## Bibliography:
+
+${ctx.bibliography ?? ""}
+
+Return JSON: { "edits": [ { "find": "<verbatim once-occurring span>", "replace": "<corrected span>", "reason": "<short why>" } ] }. Return { "edits": [] } if the chapter is clean.`
+  };
+}
+var reviewSchema = z.object({
+  edits: z.array(
+    z.object({
+      find: z.string().optional(),
+      replace: z.string().optional(),
+      reason: z.string().optional()
+    })
+  ).default([])
+});
+function extractJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = fenced ? fenced[1] : text;
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start === -1 || end === -1) return { edits: [] };
+  try {
+    return JSON.parse(body.slice(start, end + 1));
+  } catch {
+    return { edits: [] };
+  }
+}
+async function reviewChapter(ctx, model) {
+  const text = await runModel(model, buildReviewPrompt(ctx));
+  const parsed = reviewSchema.safeParse(extractJson(text));
+  const edits = parsed.success ? parsed.data.edits : [];
+  return { id: ctx.chapter.id, edits };
+}
+var reportCoverFactSchema = z.object({ k: z.string(), v: z.string() }).passthrough();
+var reportCoverPageSchema = z.object({
+  kicker: z.string().optional(),
+  title: z.string().optional(),
+  meta: z.string().optional(),
+  tag: z.string().optional(),
+  align: z.string().optional(),
+  facts: z.array(reportCoverFactSchema).optional()
+}).passthrough();
+var reportCoverSchema = z.object({
+  brand: z.string().optional(),
+  subtitle: z.string().optional(),
+  tag: z.string().optional(),
+  meta: z.string().optional(),
+  brandLetterSpacing: z.string().optional(),
+  brandFontSize: z.string().optional()
+}).passthrough();
+var reportPartSchema = z.object({
+  heading: z.string(),
+  chapters: z.array(z.string()).default([])
+}).passthrough();
+var reportChapterSchema = z.object({
+  /** = view filename + chapter source filename. */
+  id: z.string(),
+  /** Exact "## " heading the writer must use. */
+  title: z.string(),
+  /** Target length hint for the writer (e.g. "700–900"). */
+  words: z.string().optional(),
+  /** Analysis files (sources.<facet>.md) the writer/reviewer reads. */
+  src: z.array(z.string()).optional(),
+  /** The writer brief — what this chapter must cover. */
+  cover: z.string().optional(),
+  /** build-packs: which distilled-entry tags route into this view. */
+  facets: z.array(z.string()).default([]),
+  /** build-packs: keyword needles that rank (and gate) entries. */
+  kw: z.array(z.string()).optional(),
+  /** build-packs: max distilled claims in the view (default 28). */
+  cap: z.number().optional()
+}).passthrough();
+var reportConfigSchema = z.object({
+  /** Dataset path (repo-relative). Legacy `bible.config.json` key. */
+  workspace: z.string().optional(),
+  /** Pointer to the dataset this report consumes (the portable form). */
+  dataset: z.string().optional(),
+  /** Multiple datasets feeding one report (1 report → M datasets). */
+  corpora: z.array(z.string()).optional(),
+  /** Render/prompt profile preset (bible | brief | memo | deck). */
+  profile: z.string().optional(),
+  /** Highest valid citation [n]; out-of-range = error (used downstream). */
+  bibMax: z.number().optional(),
+  title: z.string().optional(),
+  cover: reportCoverSchema.optional(),
+  frontCovers: z.array(reportCoverPageSchema).optional(),
+  backCovers: z.array(reportCoverPageSchema).optional(),
+  runningHeader: z.string().optional(),
+  runningFooter: z.string().optional(),
+  frontFile: z.string().optional(),
+  annexesFile: z.string().optional(),
+  parts: z.array(reportPartSchema).optional(),
+  rulesText: z.string().optional(),
+  factsText: z.string().optional(),
+  briefText: z.string().optional(),
+  chapters: z.array(reportChapterSchema)
+}).passthrough();
+
+// src/report/plan.ts
+var planSchema = z.object({
+  title: z.string().optional(),
+  chapters: z.array(reportChapterSchema).min(1)
+});
+function extractJson2(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = fenced ? fenced[1] : text;
+  const start = body.indexOf("{");
+  const end = body.lastIndexOf("}");
+  if (start === -1 || end === -1) throw new Error("plan: no JSON object in completion");
+  return JSON.parse(body.slice(start, end + 1));
+}
+async function planOutline(opts) {
+  const profile = opts.profile ?? "bible";
+  const target = opts.targetChapters ?? 8;
+  const text = await runModel(opts.model, {
+    system: "You are a research editor planning a long-form, citation-backed report. Output ONLY a JSON object \u2014 no prose, no fences.",
+    prompt: `Plan a "${profile}" report from this brief and the available dataset facets.
+
+BRIEF:
+${opts.brief}
+
+DATASET FACETS (chapters route against these tags):
+${opts.facets.join(", ")}
+
+Return JSON: { "title": string, "chapters": [ { "id": kebab-id, "title": "N. Heading", "facets": [subset of the facets above], "kw": [keyword needles], "cap": number, "words": "min-max", "cover": "1-2 sentence writer brief" } ] }.
+Aim for about ${target} chapters. Every chapter MUST list at least one facet from the list.`
+  });
+  const parsed = planSchema.parse(extractJson2(text));
+  return { ...parsed.title ? { title: parsed.title } : {}, chapters: parsed.chapters };
+}
+
+export { analyzeDataset, applyEdits, assembleChapters, bibEntrySchema, buildChapterWritePrompt, buildFacetAnalysisPrompt, buildPacks, buildReportContent, buildReviewPrompt, citesOf, cleanDraft, collectReportSections, outOfRangeCites, planOutline, reportChapterSchema, reportConfigSchema, reportContentSchema, reportContentToMarkdown, reportCoverFactSchema, reportCoverPageSchema, reportCoverSchema, reportPartSchema, reportSectionKindSchema, reportSectionSchema, reviewChapter, runModel, stitchReport, writeChapter };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map