Outline: per-chunk outlines, richer points, print and share

- One outline for the whole study plus one per chunk (picker at the top);
  chunk outlines can start from the chunk's verses, each carrying its words
- Points can have a type (illustration, application, quote, question,
  transition), minutes (with a running total), a longer note, verse text
  fetched from a passage, and cross-references / word studies attached from
  the chunk
- Share (system share sheet, or copy), Print / PDF, Copy as text, Word and
  Markdown downloads for any one outline
- All of it included in the Markdown, HTML/PDF and Word study exports,
  with each chunk's outline under that chunk

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

src/utils/bibleUtils.jsx

@@ -1,4 +1,4 @@
-import { labelFor as outlineLabel } from './outlineLabels.js';
+import { labelFor as outlineLabel, kindLabel as outlineKindLabel } from './outlineLabels.js';
 
 // ---------------------------------------------------------------------------
 // Study constants
@@ -193,6 +193,10 @@ export function buildExportHtml(project) {
     .outline > ul { margin-left: 0; }
     .outline li { margin: 0.3rem 0; line-height: 1.5; }
     .outline .lbl { display: inline-block; min-width: 2rem; font-weight: 700; }
+    .outline .kind { font-size: 0.75em; text-transform: uppercase; letter-spacing: 0.05em; color: #92400e; border: 1px solid #fcd34d; border-radius: 9999px; padding: 0 0.4em; margin-right: 0.3em; }
+    .outline .o-note { margin: 0.2rem 0 0 2rem; color: #334155; font-size: 0.95em; }
+    .outline .o-quote { margin: 0.3rem 0 0.3rem 2rem; padding-left: 0.75rem; border-left: 3px solid #cbd5e1; font-style: italic; }
+    .outline .o-attach { margin-left: 2rem; font-size: 0.85em; color: #64748b; }
     .outline .ref { color: #64748b; font-size: 0.9em; }
     .definition-block { margin-top: 1rem; padding: 1rem; border: 1px solid #e2e8f0; border-radius: 0.75rem; background: #f8fafc; }
     @media print {
@@ -206,7 +210,7 @@ export function buildExportHtml(project) {
 
   // The outline, if one was written: nested lists, labelled I. / A. / 1. like on the page
   const outlineHtml = (project.outline ?? []).length > 0
-    ? `<section class="outline"><h2 class="chapter-heading">Outline</h2>${outlineListHtml(project.outline, 0)}</section>`
+    ? `<section class="outline"><h2 class="chapter-heading">Outline</h2>${outlineTimeHtml(project.outline)}${outlineListHtml(project.outline, 0)}</section>`
     : '';
 
   const chunksHtml = chapters.map((ch, chapterIndex) => {
@@ -268,6 +272,7 @@ export function buildExportHtml(project) {
         <section class="chunk">
           <div class="scripture-ref">${escHtml(scripture)}</div>
           ${versesText}
+          ${(chunk.outline ?? []).length > 0 ? `<div class="outline"><strong>OUTLINE:</strong>${outlineListHtml(chunk.outline, 0)}</div>` : ''}
           <div class="oia">
             <div class="oia-section"><strong>OBSERVATION:</strong><p>${observation}</p></div>
             <div class="oia-section"><strong>INTERPRETATION:</strong><p>${interpretation}</p></div>
@@ -304,8 +309,65 @@ export function buildExportHtml(project) {
 }
 
 // <ul> of outline points, each with its label (I., A., 1. …) and passage
+function outlineTimeHtml(tree) {
+  const total = flattenMinutes(tree);
+  return total > 0 ? `<p class="ref">About ${total} minute${total === 1 ? '' : 's'}</p>` : '';
+}
+
+function flattenMinutes(nodes) {
+  return (nodes ?? []).reduce((sum, n) => sum + (Number.isFinite(n.minutes) ? n.minutes : 0) + flattenMinutes(n.children), 0);
+}
+
 function outlineListHtml(nodes, depth) {
-  return `<ul>${nodes.map((n, i) => `<li><span class="lbl">${escHtml(outlineLabel(depth, i))}</span>${escHtml((n.text ?? '').trim() || '(untitled)')}${n.ref ? ` <span class="ref">(${escHtml(n.ref)})</span>` : ''}${n.children?.length ? outlineListHtml(n.children, depth + 1) : ''}</li>`).join('')}</ul>`;
+  const one = (n, i) => {
+    const kind = n.kind ? `<span class="kind">${escHtml(outlineKindLabel(n.kind))}</span> ` : '';
+    const mins = Number.isFinite(n.minutes) && n.minutes > 0 ? ` <span class="ref">· ${n.minutes} min</span>` : '';
+    const note = (n.note ?? '').trim() ? `<div class="o-note">${escHtml(n.note.trim()).replace(/\n/g, '<br />')}</div>` : '';
+    const quote = n.scripture?.text ? `<blockquote class="o-quote">“${escHtml(n.scripture.text)}” — ${escHtml(n.scripture.ref)}</blockquote>` : '';
+    const attached = (n.attachments ?? []).length > 0
+      ? `<div class="o-attach">${n.attachments.map((a) => `${a.type === 'word' ? 'Word' : 'See'}: ${escHtml(a.label)}${a.detail ? ` — ${escHtml(a.detail)}` : ''}`).join(' · ')}</div>` : '';
+    return `<li><span class="lbl">${escHtml(outlineLabel(depth, i))}</span>${kind}${escHtml((n.text ?? '').trim() || '(untitled)')}${n.ref ? ` <span class="ref">(${escHtml(n.ref)})</span>` : ''}${mins}${note}${quote}${attached}${n.children?.length ? outlineListHtml(n.children, depth + 1) : ''}</li>`;
+  };
+  return `<ul>${nodes.map(one).join('')}</ul>`;
+}
+
+// A page of just one outline (for printing or saving as PDF): the title, the passage, the points.
+export function buildOutlineHtml({ title, subtitle = '', tree }) {
+  const total = flattenMinutes(tree);
+  const style = `
+    body { font-family: Georgia, serif; color: #0f172a; margin: 0; padding: 40px; }
+    .page { max-width: 760px; margin: auto; }
+    h1 { margin: 0 0 0.25rem; font-size: 1.7rem; }
+    .sub { color: #64748b; margin: 0 0 1.5rem; }
+    .outline ul { list-style: none; margin: 0.25rem 0 0.25rem 1.6rem; padding: 0; }
+    .outline > ul { margin-left: 0; }
+    .outline li { margin: 0.45rem 0; line-height: 1.5; }
+    .outline > ul > li { margin-top: 0.9rem; font-weight: 600; }
+    .outline > ul > li li { font-weight: 400; }
+    .lbl { display: inline-block; min-width: 2.1rem; font-weight: 700; }
+    .ref { color: #64748b; font-size: 0.9em; font-weight: 400; }
+    .kind { font-size: 0.72em; text-transform: uppercase; letter-spacing: 0.05em; color: #92400e; border: 1px solid #fcd34d; border-radius: 9999px; padding: 0 0.4em; margin-right: 0.3em; font-weight: 400; }
+    .o-note { margin: 0.2rem 0 0 2.1rem; color: #334155; font-size: 0.95em; font-weight: 400; }
+    .o-quote { margin: 0.3rem 0 0.3rem 2.1rem; padding-left: 0.75rem; border-left: 3px solid #cbd5e1; font-style: italic; font-weight: 400; }
+    .o-attach { margin-left: 2.1rem; font-size: 0.85em; color: #64748b; font-weight: 400; }
+    @media print { body { padding: 0; } li { break-inside: avoid; } }
+  `;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${escHtml(title)} — Outline</title>
+  <style>${style}</style>
+</head>
+<body>
+  <div class="page">
+    <h1>${escHtml(title)}</h1>
+    <p class="sub">${escHtml([subtitle, total > 0 ? `About ${total} minute${total === 1 ? '' : 's'}` : ''].filter(Boolean).join(' · '))}</p>
+    <div class="outline">${outlineListHtml(tree, 0)}</div>
+  </div>
+</body>
+</html>`;
 }
 
 export function wordTableHtml(rows) {

src/utils/docxExport.js

@@ -14,7 +14,8 @@ import {
   WidthType,
 } from 'docx';
 import { formatChunkReference, getChunkVerseEntries, htmlToPlainText } from './bibleUtils.jsx';
-import { flatten } from './outline.js';
+import { detailLines, flatten, timeSummary } from './outline.js';
+import { kindLabel } from './outlineLabels.js';
 
 export function createParagraphsFromText(text) {
   return text
@@ -73,6 +74,37 @@ export function sectionLabel(text) {
   });
 }
 
+// The paragraphs of an outline: each point indented by level, with its note, verse and attachments under it.
+export const outlineParagraphs = (tree) => flatten(tree).flatMap(({ node, depth, label }) => [
+  new Paragraph({
+    indent: { left: 420 * depth, hanging: 420 },
+    spacing: { after: 60 },
+    children: [
+      new TextRun({ text: `${label}\t`, bold: true, color: DOCX_ACCENT }),
+      ...(node.kind ? [new TextRun({ text: `${kindLabel(node.kind)}: `, italics: true, color: '92400E' })] : []),
+      new TextRun({ text: (node.text ?? '').trim() || '(untitled)' }),
+      ...(node.ref ? [new TextRun({ text: `  (${node.ref})`, italics: true, color: '7A7060' })] : []),
+      ...(Number.isFinite(node.minutes) && node.minutes > 0 ? [new TextRun({ text: `  · ${node.minutes} min`, color: '7A7060' })] : []),
+    ],
+  }),
+  ...detailLines(node).map((line) => new Paragraph({
+    indent: { left: 420 * depth + 420 },
+    spacing: { after: 40 },
+    children: [new TextRun({ text: line, italics: true, color: '4B5563', size: 20 })],
+  })),
+]);
+
+// Just one outline, as its own Word document.
+export async function buildOutlineDocxBlob({ title, subtitle = '', tree }) {
+  const children = [
+    new Paragraph({ text: title, heading: HeadingLevel.TITLE }),
+    new Paragraph({ children: [new TextRun({ text: [subtitle, timeSummary(tree)].filter(Boolean).join(' · '), italics: true, color: '7A7060' })], spacing: { after: 300 } }),
+    ...outlineParagraphs(tree),
+  ];
+  const doc = new Document({ styles: DOCX_STYLES, sections: [{ children }] });
+  return Packer.toBlob(doc);
+}
+
 export async function buildStudyDocxBlob(project, chapterSummary) {
   const children = [
     new Paragraph({ text: project.title, heading: HeadingLevel.TITLE }),
@@ -93,17 +125,8 @@ export async function buildStudyDocxBlob(project, chapterSummary) {
   // The outline comes first, indented by level like the page
   if ((project.outline ?? []).length > 0) {
     children.push(new Paragraph({ text: 'Outline', heading: HeadingLevel.HEADING_1, spacing: { before: 240, after: 160 } }));
-    flatten(project.outline).forEach(({ node, depth, label }) => {
-      children.push(new Paragraph({
-        indent: { left: 420 * depth, hanging: 420 },
-        spacing: { after: 80 },
-        children: [
-          new TextRun({ text: `${label}\t`, bold: true, color: DOCX_ACCENT }),
-          new TextRun({ text: (node.text ?? '').trim() || '(untitled)' }),
-          ...(node.ref ? [new TextRun({ text: `  (${node.ref})`, italics: true, color: '7A7060' })] : []),
-        ],
-      }));
-    });
+    if (timeSummary(project.outline)) children.push(new Paragraph({ children: [new TextRun({ text: timeSummary(project.outline), italics: true, color: '7A7060' })], spacing: { after: 120 } }));
+    children.push(...outlineParagraphs(project.outline));
   }
 
   project.chapters.forEach((ch, chapterIndex) => {
@@ -154,6 +177,11 @@ export async function buildStudyDocxBlob(project, chapterSummary) {
       }));
       children.push(new Paragraph({ text: '', spacing: { after: 120 } }));
 
+      if ((chunk.outline ?? []).length > 0) {
+        children.push(sectionLabel('Outline'));
+        children.push(...outlineParagraphs(chunk.outline));
+      }
+
       if (chunk.generalNotes?.trim()) {
         children.push(sectionLabel('Background / General Notes'));
         children.push(...createParagraphsFromText(chunk.generalNotes));

src/utils/exportBuilders.js

@@ -4,7 +4,7 @@ import {
   getChunkVerseEntries,
   htmlToPlainText,
 } from './bibleUtils.jsx';
-import { outlineToMarkdown } from './outline.js';
+import { outlineToMarkdown, timeSummary } from './outline.js';
 
 // ---------------------------------------------------------------------------
 // Export / prompt builders (exported for testing)
@@ -43,13 +43,15 @@ export function buildMarkdownExport(project) {
             return `- ${summary}${definition}`;
           }).join('\n')}\n\n`;
 
-      return `### ${scripture}\n\n${versesText}\n\n${generalNotes ? `**Background / Notes**\n\n${generalNotes}\n\n` : ''}**Observation**\n\n${observation}\n\n**Interpretation**\n\n${interpretation}\n\n**Application**\n\n${application}\n\n${crossRefsLine}${greekSection}`;
+      const chunkOutline = (chunk.outline ?? []).length > 0 ? `**Outline**\n\n${outlineToMarkdown(chunk.outline)}\n\n` : '';
+
+      return `### ${scripture}\n\n${versesText}\n\n${chunkOutline}${generalNotes ? `**Background / Notes**\n\n${generalNotes}\n\n` : ''}**Observation**\n\n${observation}\n\n**Interpretation**\n\n${interpretation}\n\n**Application**\n\n${application}\n\n${crossRefsLine}${greekSection}`;
     }).join('---\n\n');
 
     return `## ${ch.book} ${ch.chapter}\n\n${chunkSections}`;
   }).join('\n');
 
-  const outline = (project.outline ?? []).length > 0 ? `## Outline\n\n${outlineToMarkdown(project.outline)}\n\n` : '';
+  const outline = (project.outline ?? []).length > 0 ? `## Outline\n\n${timeSummary(project.outline) ? `*${timeSummary(project.outline)}*\n\n` : ''}${outlineToMarkdown(project.outline)}\n\n` : '';
   return `# ${project.title}\n\n*${project.translation}*\n\n${outline}${chapterSections}`;
 }
 

src/utils/outline.js

@@ -1,14 +1,18 @@
 // A study's true outline: main points, sub-points under them, and so on (I. / A. / 1. / a.). It is a tree
 // of nodes { id, text, ref, chunkId, children } kept on the project as `project.outline`. Every function
 // returns a new tree and leaves the one it was given alone.
-import { formatChunkReference, makeId } from './bibleUtils.jsx';
-import { labelFor, toRoman } from './outlineLabels.js';
+import { formatChunkReference, getChunkVerseEntries, makeId } from './bibleUtils.jsx';
+import { KINDS, kindLabel, labelFor, toRoman } from './outlineLabels.js';
 
-export { labelFor, toRoman };
+export { KINDS, kindLabel, labelFor, toRoman };
 
 export const MAX_DEPTH = 5; // levels below the main points
 
-export const newNode = (text = '', extra = {}) => ({ id: makeId(), text, ref: '', chunkId: null, children: [], ...extra });
+// A point: its words, an optional passage and chunk link, plus a longer note, a kind, minutes,
+// the text of a verse, and things attached from the chunks (cross-references, word studies).
+export const newNode = (text = '', extra = {}) => ({
+  id: makeId(), text, ref: '', chunkId: null, note: '', kind: '', minutes: null, scripture: null, attachments: [], children: [], ...extra,
+});
 
 // ---- finding ---------------------------------------------------------------
 
@@ -136,14 +140,44 @@ export function flatten(tree, depth = 0, parentId = null) {
 
 export const countNodes = (tree) => flatten(tree).length;
 
-const pointText = (n) => `${n.text.trim() || '(untitled)'}${n.ref.trim() ? ` (${n.ref.trim()})` : ''}`;
+const minutesText = (m) => (Number.isFinite(m) && m > 0 ? `${m} min` : '');
+
+// Total minutes written on the points (blank ones count as nothing)
+export const totalMinutes = (tree) => flatten(tree).reduce((sum, { node }) => sum + (Number.isFinite(node.minutes) ? node.minutes : 0), 0);
+
+// The headline of a point: "[Illustration] The words (passage) · 5 min"
+const pointText = (n) => {
+  const kind = n.kind ? `[${kindLabel(n.kind)}] ` : '';
+  const mins = minutesText(n.minutes);
+  return `${kind}${(n.text ?? '').trim() || '(untitled)'}${(n.ref ?? '').trim() ? ` (${n.ref.trim()})` : ''}${mins ? ` · ${mins}` : ''}`;
+};
+
+// The lines under a point's headline: its note, verse text and attachments.
+export function detailLines(node) {
+  const lines = [];
+  for (const l of (node.note ?? '').split('\n')) if (l.trim()) lines.push(l.trim());
+  if (node.scripture?.text) lines.push(`“${node.scripture.text}” — ${node.scripture.ref}`);
+  for (const a of node.attachments ?? []) lines.push(`${a.type === 'word' ? 'Word' : 'See'}: ${a.label}${a.detail ? ` — ${a.detail}` : ''}`);
+  return lines;
+}
+
+export const timeSummary = (tree) => {
+  const total = totalMinutes(tree);
+  return total > 0 ? `About ${total} minute${total === 1 ? '' : 's'}` : '';
+};
 
 export function outlineToText(tree) {
-  return flatten(tree).map(({ node, depth, label }) => `${'    '.repeat(depth)}${label} ${pointText(node)}`).join('\n');
+  return flatten(tree).flatMap(({ node, depth, label }) => [
+    `${'    '.repeat(depth)}${label} ${pointText(node)}`,
+    ...detailLines(node).map((l) => `${'    '.repeat(depth)}     ${l}`),
+  ]).join('\n');
 }
 
 export function outlineToMarkdown(tree) {
-  return flatten(tree).map(({ node, depth, label }) => `${'    '.repeat(depth)}- **${label}** ${pointText(node)}`).join('\n');
+  return flatten(tree).flatMap(({ node, depth, label }) => [
+    `${'    '.repeat(depth)}- **${label}** ${pointText(node)}`,
+    ...detailLines(node).map((l) => `${'    '.repeat(depth)}    *${l}*`),
+  ]).join('\n');
 }
 
 // ---- starting one ------------------------------------------------------------
@@ -162,3 +196,41 @@ export function seedFromChunks(project, tree = []) {
   });
   return [...tree, ...added];
 }
+
+// ---- one outline per chunk ---------------------------------------------------
+// A study has one outline for the whole message (project.outline) and each chunk can have its own
+// (chunk.outline). `scope` is STUDY or a chunk's id.
+export const STUDY = 'study';
+
+export function chunkOf(project, chunkId) {
+  for (const chapter of project?.chapters ?? []) for (const chunk of chapter.chunks ?? []) if (chunk.id === chunkId) return chunk;
+  return null;
+}
+
+export const outlineFor = (project, scope) => (scope === STUDY ? project?.outline ?? [] : chunkOf(project, scope)?.outline ?? []);
+
+// A copy of the project with that scope's outline replaced.
+export function withOutline(project, scope, tree) {
+  if (scope === STUDY) return { ...project, outline: tree };
+  return {
+    ...project,
+    chapters: project.chapters.map((ch) => ({ ...ch, chunks: ch.chunks.map((c) => (c.id === scope ? { ...c, outline: tree } : c)) })),
+  };
+}
+
+// One point per verse of the chunk, each carrying that verse's words, for verses not already in `tree`.
+export function seedFromVerses(project, chunkId, tree = []) {
+  const have = new Set(flatten(tree).map((f) => f.node.scripture?.ref).filter(Boolean));
+  const added = [];
+  (project?.chapters ?? []).forEach((chapter, chapterIndex) => {
+    for (const chunk of chapter.chunks ?? []) {
+      if (chunk.id !== chunkId) continue;
+      for (const v of getChunkVerseEntries(project, chapterIndex, chunk)) {
+        const ref = `${chapter.book} ${v.chapter}:${v.number}`;
+        if (have.has(ref)) continue;
+        added.push(newNode('', { ref, scripture: { ref, text: v.text, translation: project.translation ?? 'BSB' } }));
+      }
+    }
+  });
+  return [...tree, ...added];
+}

src/utils/outline.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import {
   addAfter, addChild, addRoot, countNodes, flatten, getNode, indent, labelFor, moveNode, newNode, outdent,
-  insertAt, locate, outlineToMarkdown, outlineToText, removeNode, seedFromChunks, toRoman, updateNode, MAX_DEPTH,
+  STUDY, chunkOf, detailLines, insertAt, outlineFor, seedFromVerses, withOutline, locate, timeSummary, totalMinutes, outlineToMarkdown, outlineToText, removeNode, seedFromChunks, toRoman, updateNode, MAX_DEPTH,
 } from './outline.js';
 
 const n = (id, text = id, children = []) => ({ id, text, ref: '', chunkId: null, children });
@@ -120,3 +120,60 @@ describe('putting a deleted point back', () => {
     expect(ids(insertAt([n('b')], 'missing', 0, n('x')))).toEqual(['x', 'b']);
   });
 });
+
+describe('richer points', () => {
+  const rich = [{
+    ...n('a', 'Creation'), ref: 'Gen 1', kind: 'illustration', minutes: 5, note: 'Tell the story.\n\nKeep it short.',
+    scripture: { ref: 'Genesis 1:1', text: 'In the beginning', translation: 'BSB' },
+    attachments: [{ id: 'x', type: 'xref', label: 'John 1:1' }, { id: 'w', type: 'word', label: 'bara (H1254)', detail: 'to create' }],
+    children: [{ ...n('b', 'Light'), minutes: 3 }],
+  }];
+  test('text and markdown show the kind, minutes, note, verse and attachments', () => {
+    expect(outlineToText(rich)).toBe([
+      'I. [Illustration] Creation (Gen 1) · 5 min',
+      '     Tell the story.',
+      '     Keep it short.',
+      '     “In the beginning” — Genesis 1:1',
+      '     See: John 1:1',
+      '     Word: bara (H1254) — to create',
+      '    A. Light · 3 min',
+    ].join('\n'));
+    expect(outlineToMarkdown(rich)).toContain('- **I.** [Illustration] Creation (Gen 1) · 5 min\n    *Tell the story.*');
+  });
+  test('totals the minutes, and says nothing when there are none', () => {
+    expect(totalMinutes(rich)).toBe(8);
+    expect(timeSummary(rich)).toBe('About 8 minutes');
+    expect(timeSummary([n('z')])).toBe('');
+  });
+  test('new points start plain, and older ones without the new fields still work', () => {
+    expect(newNode('x')).toMatchObject({ note: '', kind: '', minutes: null, scripture: null, attachments: [] });
+    expect(detailLines(n('old'))).toEqual([]);
+  });
+});
+
+describe('an outline for each chunk', () => {
+  const project = {
+    translation: 'BSB', outline: [n('whole')],
+    chapters: [{ book: 'Titus', bookAbbrev: 'TIT', chapter: '1', verses: [{ number: 1, text: 'One.' }, { number: 2, text: 'Two.' }, { number: 3, text: 'Three.' }], chunks: [
+      { id: 'c1', startVerse: 1, endVerse: 2, observation: '', outline: [n('mine')] },
+      { id: 'c2', startVerse: 3, endVerse: 3, observation: '' },
+    ] }],
+  };
+  test('reads and replaces the outline of the whole study or of one chunk', () => {
+    expect(ids(outlineFor(project, STUDY))).toEqual(['whole']);
+    expect(ids(outlineFor(project, 'c1'))).toEqual(['mine']);
+    expect(outlineFor(project, 'c2')).toEqual([]);
+    const next = withOutline(project, 'c2', [n('new')]);
+    expect(ids(outlineFor(next, 'c2'))).toEqual(['new']);
+    expect(ids(outlineFor(next, 'c1'))).toEqual(['mine']);
+    expect(ids(outlineFor(next, STUDY))).toEqual(['whole']);
+    expect(outlineFor(project, 'c2')).toEqual([]); // the original is untouched
+    expect(ids(outlineFor(withOutline(project, STUDY, []), STUDY))).toEqual([]);
+  });
+  test('seeding from verses adds a point per verse with its words, and never twice', () => {
+    const t = seedFromVerses(project, 'c1', []);
+    expect(t.map((x) => [x.ref, x.scripture.text])).toEqual([['Titus 1:1', 'One.'], ['Titus 1:2', 'Two.']]);
+    expect(seedFromVerses(project, 'c1', t)).toHaveLength(2);
+    expect(seedFromVerses(project, 'c2', [])).toHaveLength(1);
+  });
+});

src/utils/outlineExport.js

@@ -0,0 +1,60 @@
+// Taking one outline out of the app: print or save as PDF, share it, or download it.
+import { buildOutlineHtml } from './bibleUtils.jsx';
+import { outlineToText } from './outline.js';
+
+const slug = (s) => String(s).replace(/[^\w]+/g, '-').replace(/^-|-$/g, '') || 'outline';
+
+function downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  URL.revokeObjectURL(url);
+}
+
+// What gets shared as text: a heading, then the outline.
+export const outlineShareText = ({ title, subtitle = '', tree }) => `${title}${subtitle ? `\n${subtitle}` : ''}\n\n${outlineToText(tree)}`;
+
+// Opens a print-ready page of just this outline. Returns false when the browser blocked the window.
+export function printOutline({ title, subtitle, tree }) {
+  const win = window.open('', '_blank');
+  if (!win) return false;
+  win.document.write(buildOutlineHtml({ title, subtitle, tree }));
+  win.document.close();
+  win.onload = () => { win.focus(); win.print(); };
+  return true;
+}
+
+// Uses the phone/tablet/computer share sheet when there is one (Messages, Mail, AirDrop…), otherwise
+// copies the text. -> 'shared' | 'copied' | 'cancelled' | 'failed'
+export async function shareOutline(outline) {
+  const text = outlineShareText(outline);
+  if (navigator.share) {
+    try {
+      await navigator.share({ title: `${outline.title} — Outline`, text });
+      return 'shared';
+    } catch (err) {
+      if (err?.name === 'AbortError') return 'cancelled';
+      // fall through to copying
+    }
+  }
+  try {
+    await navigator.clipboard.writeText(text);
+    return 'copied';
+  } catch {
+    return 'failed';
+  }
+}
+
+export function downloadOutlineMarkdown({ title, subtitle, tree }) {
+  const text = `# ${title}\n\n${subtitle ? `*${subtitle}*\n\n` : ''}${tree.length ? outlineToText(tree) : ''}\n`;
+  downloadBlob(new Blob([text], { type: 'text/markdown;charset=utf-8' }), `${slug(title)}-outline.md`);
+}
+
+export async function downloadOutlineDocx(outline) {
+  const { buildOutlineDocxBlob } = await import('./docxExport.js'); // the Word library only loads when used
+  downloadBlob(await buildOutlineDocxBlob(outline), `${slug(outline.title)}-outline.docx`);
+}

src/utils/outlineExport.test.js

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { outlineShareText, printOutline, shareOutline } from './outlineExport.js';
+import { buildOutlineHtml } from './bibleUtils.jsx';
+
+const outline = {
+  title: 'Titus 1 — Elders', subtitle: 'Titus 1:5–9',
+  tree: [{ id: 'a', text: 'Appoint elders', ref: 'Titus 1:5', kind: 'application', minutes: 4, note: 'Why it matters', children: [{ id: 'b', text: 'Blameless', ref: '', children: [] }] }],
+};
+beforeEach(() => { vi.stubGlobal('navigator', { ...navigator, share: undefined, clipboard: { writeText: vi.fn(() => Promise.resolve()) } }); });
+afterEach(() => { vi.unstubAllGlobals(); vi.restoreAllMocks(); });
+
+test('the share text has the title, passage and the outline', () => {
+  const text = outlineShareText(outline);
+  expect(text.startsWith('Titus 1 — Elders\nTitus 1:5–9\n\nI. [Application] Appoint elders (Titus 1:5) · 4 min')).toBe(true);
+  expect(text).toContain('A. Blameless');
+});
+
+test('uses the system share sheet when there is one', async () => {
+  const share = vi.fn(() => Promise.resolve());
+  vi.stubGlobal('navigator', { share, clipboard: { writeText: vi.fn() } });
+  expect(await shareOutline(outline)).toBe('shared');
+  expect(share).toHaveBeenCalledWith(expect.objectContaining({ title: 'Titus 1 — Elders — Outline' }));
+});
+
+test('closing the share sheet is not an error, and a broken one falls back to copying', async () => {
+  vi.stubGlobal('navigator', { share: vi.fn(() => Promise.reject(Object.assign(new Error('x'), { name: 'AbortError' }))), clipboard: { writeText: vi.fn() } });
+  expect(await shareOutline(outline)).toBe('cancelled');
+  const writeText = vi.fn(() => Promise.resolve());
+  vi.stubGlobal('navigator', { share: vi.fn(() => Promise.reject(new Error('nope'))), clipboard: { writeText } });
+  expect(await shareOutline(outline)).toBe('copied');
+  expect(writeText).toHaveBeenCalled();
+});
+
+test('without a share sheet it copies, and says so when even that fails', async () => {
+  expect(await shareOutline(outline)).toBe('copied');
+  vi.stubGlobal('navigator', { clipboard: { writeText: vi.fn(() => Promise.reject(new Error('denied'))) } });
+  expect(await shareOutline(outline)).toBe('failed');
+});
+
+test('print writes a page of just the outline, and reports a blocked window', () => {
+  const doc = { write: vi.fn(), close: vi.fn() };
+  vi.spyOn(window, 'open').mockReturnValue({ document: doc, focus: vi.fn(), print: vi.fn() });
+  expect(printOutline(outline)).toBe(true);
+  const html = doc.write.mock.calls[0][0];
+  expect(html).toContain('Appoint elders');
+  expect(html).toContain('About 4 minutes');
+  window.open.mockReturnValue(null);
+  expect(printOutline(outline)).toBe(false);
+});
+
+test('the printable page escapes text and shows notes', () => {
+  const html = buildOutlineHtml({ title: 'A <b>', tree: [{ id: 'x', text: '<i>hi</i>', ref: '', note: 'line', children: [] }] });
+  expect(html).toContain('A &lt;b&gt;');
+  expect(html).toContain('&lt;i&gt;hi&lt;/i&gt;');
+  expect(html).toContain('class="o-note"');
+});

src/utils/outlineLabels.js

@@ -26,3 +26,9 @@ export function labelFor(depth, index) {
     default: return `(${letter(n, false)})`;
   }
 }
+
+export const KINDS = [
+  ['', 'Point'], ['illustration', 'Illustration'], ['application', 'Application'],
+  ['quote', 'Quote'], ['question', 'Question'], ['transition', 'Transition'],
+];
+export const kindLabel = (kind) => KINDS.find(([id]) => id === kind)?.[1] ?? '';

src/utils/passageText.js

@@ -0,0 +1,49 @@
+// "Titus 1:5–9" -> the words of those verses, for putting scripture inside an outline point.
+import { matchBooks } from './passageRef.js';
+import { CHAPTER_COUNTS, bookOptions } from './bibleUtils.jsx';
+import { fetchChapter } from './bibleText.js';
+
+export const MAX_VERSES = 40; // a whole chapter's worth is plenty to paste into a point
+
+// -> { book, bookName, chapter, start, end } (start/end null = the whole chapter) or null. Accepts
+// "Titus 1:5-9", "titus 1:5", "John 3" and a dash or en dash.
+export function parsePassageRange(text) {
+  const m = String(text ?? '').trim().replace(/\./g, ' ').match(/^((?:[1-3]\s*)?[a-z][a-z ]*?)\s*(\d{1,3})(?:\s*[:v ]\s*(\d{1,3})(?:\s*[-–—]\s*(\d{1,3}))?)?$/i);
+  if (!m) return null;
+  const [, name, chapterText, startText, endText] = m;
+  const book = matchBooks(name)[0];
+  const chapter = Number(chapterText);
+  if (!book || chapter < 1 || chapter > (CHAPTER_COUNTS[book.abbrev] ?? 1)) return null;
+  const start = startText ? Number(startText) : null;
+  const end = endText ? Number(endText) : start;
+  if (start != null && end < start) return null;
+  return { book: book.abbrev, bookName: bookOptions.find((b) => b.abbrev === book.abbrev)?.name ?? book.name, chapter, start, end };
+}
+
+export const formatRange = (r) => `${r.bookName} ${r.chapter}${r.start == null ? '' : r.end === r.start ? `:${r.start}` : `:${r.start}–${r.end}`}`;
+
+// -> { ref, text, translation }. Throws Error(message) when the passage can't be read or found.
+export async function fetchPassageText(text, translation = 'BSB') {
+  const range = parsePassageRange(text);
+  if (!range) throw new Error('Type a passage like “Titus 1:5–9”.');
+  const { verses } = await fetchChapter(translation, range.book, range.chapter);
+  const picked = range.start == null ? verses : verses.filter((v) => v.number >= range.start && v.number <= range.end);
+  if (picked.length === 0) throw new Error('Those verses weren’t found in that chapter.');
+  if (picked.length > MAX_VERSES) throw new Error(`That's ${picked.length} verses — pick ${MAX_VERSES} or fewer.`);
+  return { ref: formatRange(range), text: picked.map((v) => v.text).join(' '), translation };
+}
+
+// What a chunk offers to attach to a point: its cross-references and the words studied in it.
+// -> [{ key, type: 'xref' | 'word', label, detail? }]
+export function attachableFromChunk(chunk) {
+  if (!chunk) return [];
+  const refs = (chunk.crossReferences ?? []).map((r) => ({ key: `x:${r}`, type: 'xref', label: r }));
+  const words = (chunk.greekWords ?? [])
+    .filter((w) => w.lexeme || w.strongNumber || w.query)
+    .map((w) => ({
+      key: `w:${w.strongNumber || w.lexeme || w.query}`, type: 'word',
+      label: [w.lexeme, w.strongNumber && `(${w.strongNumber})`].filter(Boolean).join(' ') || w.query,
+      detail: w.shortDefinition && !/^(No definition|Lookup failed)/.test(w.shortDefinition) ? w.shortDefinition : undefined,
+    }));
+  return [...refs, ...words];
+}

src/utils/passageText.test.js

@@ -0,0 +1,45 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { attachableFromChunk, fetchPassageText, parsePassageRange } from './passageText.js';
+
+const chapter = { chapter: { content: [1, 2, 3, 4, 5].map((n) => ({ type: 'verse', number: n, content: [`Verse ${n} text.`] })) } };
+beforeEach(() => vi.stubGlobal('fetch', vi.fn(() => Promise.resolve({ ok: true, json: () => Promise.resolve(chapter) }))));
+afterEach(() => vi.unstubAllGlobals());
+
+test('reads a verse, a range, or a whole chapter', () => {
+  expect(parsePassageRange('Titus 1:5')).toMatchObject({ book: 'TIT', chapter: 1, start: 5, end: 5 });
+  expect(parsePassageRange('titus 1:5-9')).toMatchObject({ start: 5, end: 9 });
+  expect(parsePassageRange('1 Cor 13:4–7')).toMatchObject({ book: '1CO', chapter: 13, start: 4, end: 7 });
+  expect(parsePassageRange('John 3')).toMatchObject({ chapter: 3, start: null });
+});
+
+test('rejects things that are not passages, or backwards ranges', () => {
+  expect(parsePassageRange('hello')).toBeNull();
+  expect(parsePassageRange('Titus 9:1')).toBeNull();
+  expect(parsePassageRange('Titus 1:9-5')).toBeNull();
+});
+
+test('fetches just the verses asked for, and names the passage', async () => {
+  const got = await fetchPassageText('Titus 1:2-3');
+  expect(got).toEqual({ ref: 'Titus 1:2–3', text: 'Verse 2 text. Verse 3 text.', translation: 'BSB' });
+});
+
+test('says so when the verses are not there, or the passage is not understood', async () => {
+  await expect(fetchPassageText('Titus 1:50')).rejects.toThrow(/weren’t found/);
+  await expect(fetchPassageText('nonsense')).rejects.toThrow(/Type a passage/);
+});
+
+test('offers a chunk\'s cross-references and studied words to attach', () => {
+  const chunk = {
+    crossReferences: ['John 1:1'],
+    greekWords: [
+      { strongNumber: 'G1401', lexeme: 'δοῦλος', shortDefinition: 'a slave' },
+      { query: 'xyz', shortDefinition: 'No definition found.' },
+    ],
+  };
+  expect(attachableFromChunk(chunk)).toEqual([
+    { key: 'x:John 1:1', type: 'xref', label: 'John 1:1' },
+    { key: 'w:G1401', type: 'word', label: 'δοῦλος (G1401)', detail: 'a slave' },
+    { key: 'w:xyz', type: 'word', label: 'xyz', detail: undefined },
+  ]);
+  expect(attachableFromChunk(null)).toEqual([]);
+});