create-pmos 0.150.0 → 0.152.0

package/workspace/public/pm/c3-md.js

@@ -0,0 +1,395 @@
+/* pm/c3-md.js — markdown for the console3 document sheet (initiative c3-doc-sheet-rich): read it as rich text, edit it as rich
+ * text, and show a change as a rendered diff.
+ *
+ *   parseMd(md)            → blocks   the subset PMOS documents use: headings, paragraphs, quotes, bulleted, numbered and
+ *                                     checklist lists, tables, dividers and fenced code; inline bold, italic, code and links
+ *   toMd(blocks)           → md       the canonical markdown of blocks; toMd(parseMd(toMd(b))) === toMd(b)
+ *   canonMd(md)            → md       toMd(parseMd(md)): two texts that read the same compare equal
+ *   diffMd(before, after)  → md       `after`, with the words removed and added since `before` wrapped in markers that
+ *                                     toDom draws as <del> and <ins>; a line or sentence rewritten in most of its words is
+ *                                     shown whole, removed then added
+ *   toDom(blocks, doc?)    → Node[]   the blocks as elements (no innerHTML: every text is a text node); links are http(s),
+ *                                     mailto or relative only
+ *   fromDom(root)          → blocks   what the rich-text editor holds, read back as blocks
+ *
+ * parseMd, toMd, canonMd and diffMd are pure (Node-testable: c3-md.test.js); toDom and fromDom need a document.
+ */
+
+export const INS = '\uE000';
+export const INS_END = '\uE001';
+export const DEL = '\uE002';
+export const DEL_END = '\uE003';
+const MARK = /[\uE000-\uE003]/g;
+
+/* ── inline ── */
+
+/** Inline markdown → [{ t:'text', s } | { t:'b'|'i', c:[…] } | { t:'code', s } | { t:'a', href, c:[…] }]. */
+export function parseInline(src) {
+  const s = String(src == null ? '' : src);
+  const out = [];
+  let buf = '';
+  const flush = () => { if (buf) { out.push({ t: 'text', s: buf }); buf = ''; } };
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === '\\' && i + 1 < s.length && /[\\`*_[\]()#|>-]/.test(s[i + 1])) { buf += s[i + 1]; i += 2; continue; }
+    if (c === '`') {
+      const j = s.indexOf('`', i + 1);
+      if (j > i) { flush(); out.push({ t: 'code', s: s.slice(i + 1, j) }); i = j + 1; continue; }
+    }
+    if (c === '[') {
+      const m = /^\[((?:[^\]\\]|\\.)+)\]\(([^)\s]+)\)/.exec(s.slice(i));
+      if (m) { flush(); out.push({ t: 'a', href: m[2], c: parseInline(m[1]) }); i += m[0].length; continue; }
+    }
+    if ((c === '*' || c === '_') && s[i + 1] === c) {
+      const j = s.indexOf(c + c, i + 2);
+      if (j > i + 2) { flush(); out.push({ t: 'b', c: parseInline(s.slice(i + 2, j)) }); i = j + 2; continue; }
+    }
+    if ((c === '*' || c === '_') && s[i + 1] !== c && s[i + 1] !== ' ' && (c === '*' || !/\w/.test(s[i - 1] || ''))) {
+      let j = i + 1;
+      while (j < s.length && !(s[j] === c && s[j + 1] !== c && s[j - 1] !== ' ' && s[j - 1] !== c)) j++;
+      if (j < s.length && j > i + 1 && (c === '*' || !/\w/.test(s[j + 1] || ''))) { flush(); out.push({ t: 'i', c: parseInline(s.slice(i + 1, j)) }); i = j + 1; continue; }
+    }
+    buf += c; i++;
+  }
+  flush();
+  return out;
+}
+
+// Text is escaped only where markdown would read it as syntax: a backslash before punctuation, `, *, [ and ], and an _ that
+// is not inside a word (snake_case stays as written).
+const escText = (s) => String(s).replace(/\\(?=[\\`*_[\]()#|>-])/g, '\\\\').replace(/[`*[\]]/g, '\\$&').replace(/(^|\W)_|_(?=\W|$)/g, (m) => m.replace('_', '\\_'));
+/** Inline nodes → markdown. `raw`: text as it is, unescaped (for a plain-text label). */
+export function inlineMd(nodes, raw) {
+  return (nodes || []).map((n) => {
+    if (n.t === 'text') return raw ? n.s : escText(n.s);
+    if (n.t === 'code') return raw ? n.s : '`' + n.s + '`';
+    const inner = inlineMd(n.c, raw);
+    if (raw || !inner.trim()) return inner;
+    const lead = inner.match(/^\s*/)[0]; const tail = inner.match(/\s*$/)[0]; const core = inner.trim();
+    if (n.t === 'b') return lead + '**' + core + '**' + tail;
+    if (n.t === 'i') return lead + '*' + core + '*' + tail;
+    if (n.t === 'a') return lead + '[' + core + '](' + n.href + ')' + tail;
+    return inner;
+  }).join('');
+}
+// a paragraph or list item whose text would start a heading, quote, list or rule is escaped at its start
+const lineSafe = (s) => s.replace(/^(#{1,6}\s|>|[-+]\s|\d+[.)]\s|-{3,}\s*$)/, '\\$1');
+
+/* ── blocks ── */
+
+const LIST = /^(\s*)([-*+]|\d+[.)])\s+/;
+const TASK = /^\[( |x|X)\]\s+/;
+const cells = (r) => {
+  const t = r.trim().replace(/^\|/, '').replace(/\|\s*$/, '');
+  const out = []; let cur = ''; for (let i = 0; i < t.length; i++) { if (t[i] === '\\' && t[i + 1] === '|') { cur += '|'; i++; } else if (t[i] === '|') { out.push(cur.trim()); cur = ''; } else cur += t[i]; }
+  out.push(cur.trim()); return out;
+};
+const isRule = (l) => /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(l);
+const startsBlock = (l) => /^(#{1,6}\s|>|```|~~~|\s*(-{3,}|\*{3,}|_{3,})\s*$)/.test(l) || LIST.test(l) || /^\s*\|/.test(l);
+
+/** Markdown → blocks: { t:'h', level, c } · { t:'p', c } · { t:'quote', blocks } · { t:'list', ordered, items:[{ task, c }] } ·
+ *  { t:'table', head:[c], rows:[[c]] } · { t:'hr' } · { t:'code', lang, s }. Marker characters (diffMd) pass through as text. */
+export function parseMd(md) {
+  const L = String(md == null ? '' : md).replace(/\r\n?/g, '\n').split('\n');
+  const out = []; let i = 0;
+  const bare = (l) => l.replace(MARK, '');
+  while (i < L.length) {
+    const l = L[i]; const b = bare(l); let m;
+    if (!b.trim()) { i++; continue; }
+    if ((m = /^(```|~~~)\s*([\w-]*)/.exec(b))) {
+      const fence = m[1]; const body = []; i++;
+      while (i < L.length && !bare(L[i]).startsWith(fence)) body.push(L[i++]);
+      i++; out.push({ t: 'code', lang: m[2] || '', s: body.join('\n') }); continue;
+    }
+    if ((m = /^(#{1,6})\s+(.*?)\s*#*\s*$/.exec(l))) { out.push({ t: 'h', level: m[1].length, c: parseInline(m[2]) }); i++; continue; }
+    if (/^\s*(-{3,}|\*{3,}|_{3,})\s*$/.test(b)) { out.push({ t: 'hr' }); i++; continue; }
+    if (/^\s*>/.test(b)) {
+      const body = [];
+      while (i < L.length && /^\s*>/.test(bare(L[i]))) body.push(L[i++].replace(/^(\s*[\uE000-\uE003]*)\s*>\s?/, '$1'));
+      out.push({ t: 'quote', blocks: parseMd(body.join('\n')) }); continue;
+    }
+    if (/^\s*\|/.test(b) && i + 1 < L.length && isRule(bare(L[i + 1]))) {
+      const head = cells(l); i += 2; const rows = [];
+      while (i < L.length && /^\s*\|/.test(bare(L[i]))) rows.push(cells(L[i++]));
+      out.push({ t: 'table', head: head.map(parseInline), rows: rows.map((r) => head.map((_, k) => parseInline(r[k] || ''))) }); continue;
+    }
+    if (LIST.test(b)) {
+      const ordered = /^\s*\d/.test(b); const items = [];
+      while (i < L.length && LIST.test(bare(L[i])) && /^\s*\d/.test(bare(L[i])) === ordered) {
+        const lead = (/^[\uE000-\uE003]*/.exec(L[i]) || [''])[0];
+        let t = lead + L[i].slice(lead.length).replace(LIST, ''); i++;
+        while (i < L.length && /^\s{2,}\S/.test(L[i]) && !LIST.test(bare(L[i]))) t += ' ' + L[i++].trim();
+        const tk = TASK.exec(t.replace(MARK, ''));
+        if (tk) { const k = t.indexOf('['); t = t.slice(0, k) + t.slice(k).replace(TASK, ''); }
+        items.push({ task: tk ? tk[1] !== ' ' : null, c: parseInline(t) });
+      }
+      out.push({ t: 'list', ordered, items }); continue;
+    }
+    const body = [];
+    while (i < L.length && bare(L[i]).trim() && (!body.length || !startsBlock(bare(L[i])))) body.push(L[i++].trim());
+    out.push({ t: 'p', c: parseInline(body.join(' ')) });
+  }
+  return out;
+}
+
+/** Blocks → markdown, one blank line between blocks. */
+export function toMd(blocks) {
+  return (blocks || []).map((b) => {
+    if (b.t === 'h') return '#'.repeat(b.level || 2) + ' ' + inlineMd(b.c).trim();
+    if (b.t === 'p') return lineSafe(inlineMd(b.c).trim());
+    if (b.t === 'hr') return '---';
+    if (b.t === 'code') return '```' + (b.lang || '') + '\n' + b.s + '\n```';
+    if (b.t === 'quote') return toMd(b.blocks).split('\n').map((x) => (x ? '> ' + x : '>')).join('\n');
+    if (b.t === 'list') return b.items.map((it, k) => (b.ordered ? (k + 1) + '. ' : '- ') + (it.task == null ? '' : it.task ? '[x] ' : '[ ] ') + inlineMd(it.c).trim()).join('\n');
+    if (b.t === 'table') {
+      const cell = (c) => inlineMd(c).trim().replace(/\|/g, '\\|');
+      const w = Math.max(b.head.length, ...b.rows.map((r) => r.length));
+      const line = (r) => '| ' + Array.from({ length: w }, (_, k) => (r[k] ? cell(r[k]) : '')).join(' | ') + ' |';
+      return [line(b.head), '|' + Array.from({ length: w }, () => '---').join('|') + '|', ...b.rows.map(line)].join('\n');
+    }
+    return '';
+  }).filter((x) => x !== '').join('\n\n');
+}
+
+export const canonMd = (md) => toMd(parseMd(md));
+
+/* ── the rendered diff ── */
+
+function lcs(a, b) {
+  const n = a.length, m = b.length;
+  if (n * m > 400000) return [...a.map((x) => ['-', x]), ...b.map((x) => ['+', x])];
+  const T = Array.from({ length: n + 1 }, () => new Int32Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) T[i][j] = a[i] === b[j] ? T[i + 1][j + 1] + 1 : Math.max(T[i + 1][j], T[i][j + 1]);
+  const ops = []; let i = 0, j = 0;
+  while (i < n && j < m) { if (a[i] === b[j]) { ops.push(['=', a[i]]); i++; j++; } else if (T[i + 1][j] >= T[i][j + 1]) ops.push(['-', a[i++]]); else ops.push(['+', b[j++]]); }
+  while (i < n) ops.push(['-', a[i++]]); while (j < m) ops.push(['+', b[j++]]);
+  return ops;
+}
+/** Runs of ops: [{ eq:true, items } | { eq:false, del:[…], add:[…] }]. */
+function runs(ops) {
+  const out = [];
+  for (const [op, x] of ops) {
+    const last = out[out.length - 1];
+    if (op === '=') { if (last && last.eq) last.items.push(x); else out.push({ eq: true, items: [x] }); }
+    else { if (!last || last.eq) out.push({ eq: false, del: [], add: [] }); out[out.length - 1][op === '-' ? 'del' : 'add'].push(x); }
+  }
+  return out;
+}
+const wrap = (s, a, z) => (s && s.trim() ? a + s + z : s);
+function words(a, b) {
+  const tok = (x) => x.match(/\s+|[^\s]+/g) || [];
+  const A = tok(a), B = tok(b); const ops = lcs(A, B);
+  const real = (x) => /\S/.test(x);
+  const same = ops.filter(([o, x]) => o === '=' && real(x)).length;
+  const tot = Math.max(A.filter(real).length, B.filter(real).length);
+  if (tot > 4 && same / tot < 0.6) return wrap(a, DEL, DEL_END) + ' ' + wrap(b, INS, INS_END);
+  return runs(ops).map((r) => (r.eq ? r.items.join('') : wrap(r.del.join(''), DEL, DEL_END) + (r.del.length && r.add.length ? ' ' : '') + wrap(r.add.join(''), INS, INS_END))).join('');
+}
+function sentences(a, b) {
+  const cut = (x) => x.split(/(?<=[.;!?])\s+/);
+  const A = cut(a), B = cut(b);
+  if (A.length < 2 && B.length < 2) return words(a, b);
+  return runs(lcs(A, B)).map((r) => {
+    if (r.eq) return r.items.join(' ');
+    const n = Math.min(r.del.length, r.add.length); const parts = [];
+    for (let k = 0; k < n; k++) parts.push(words(r.del[k], r.add[k]));
+    r.del.slice(n).forEach((x) => parts.push(wrap(x, DEL, DEL_END)));
+    r.add.slice(n).forEach((x) => parts.push(wrap(x, INS, INS_END)));
+    return parts.join(' ');
+  }).join(' ');
+}
+const PREFIX = /^(\s*(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?|\s*>\s?|#{1,6}\s+)/;
+function wrapLine(l, a, z) {
+  if (!l.trim() || isRule(l)) return l;
+  if (/^\s*\|/.test(l)) return '| ' + cells(l).map((c) => wrap(c, a, z)).join(' | ') + ' |';
+  if (/^(```|~~~)/.test(l) || /^\s*(-{3,}|\*{3,})\s*$/.test(l)) return l;
+  const p = (PREFIX.exec(l) || [''])[0];
+  return p + wrap(l.slice(p.length), a, z);
+}
+function lineDiff(a, b) {
+  const pa = (PREFIX.exec(a) || [''])[0], pb = (PREFIX.exec(b) || [''])[0];
+  if (/^\s*\|/.test(a) && /^\s*\|/.test(b) && !isRule(a) && !isRule(b)) {
+    const ca = cells(a), cb = cells(b);
+    return '| ' + cb.map((c, k) => (ca[k] === c ? c : sentences(ca[k] || '', c))).join(' | ') + ' |';
+  }
+  if (pa === pb) return pb + sentences(a.slice(pa.length), b.slice(pb.length));
+  return null;
+}
+
+/** `after` with the change since `before` marked. `before` null: the whole of `after` is new. */
+export function diffMd(before, after) {
+  const B = String(after == null ? '' : after).split('\n');
+  if (before == null) return B.map((l) => wrapLine(l, INS, INS_END)).join('\n');
+  const A = String(before).split('\n');
+  const out = [];
+  for (const r of runs(lcs(A, B))) {
+    if (r.eq) { out.push(...r.items); continue; }
+    const n = Math.min(r.del.length, r.add.length);
+    const removed = []; const added = [];
+    for (let k = 0; k < n; k++) {
+      const d = lineDiff(r.del[k], r.add[k]);
+      if (d == null) { removed.push(wrapLine(r.del[k], DEL, DEL_END)); added.push(wrapLine(r.add[k], INS, INS_END)); } else added.push(d);
+    }
+    r.del.slice(n).forEach((l) => removed.push(wrapLine(l, DEL, DEL_END)));
+    r.add.slice(n).forEach((l) => added.push(wrapLine(l, INS, INS_END)));
+    // a removed table row or list item stays in its table or list: put it with the rows after it
+    out.push(...removed.filter((l) => l.trim()), ...added);
+  }
+  return out.join('\n');
+}
+
+/** Words added and removed between two texts: [added, removed]. */
+export function wordCounts(before, after) {
+  const A = String(before || '').match(/\S+/g) || [], B = String(after || '').match(/\S+/g) || [];
+  let add = 0, del = 0;
+  for (const [o] of lcs(A, B)) { if (o === '+') add++; else if (o === '-') del++; }
+  return [add, del];
+}
+
+/* ── DOM ── */
+
+/** A safe href: http(s), mailto, a fragment or a relative path; anything else (javascript:, data:) is dropped. */
+export function safeHref(h) {
+  const s = String(h || '').trim();
+  if (/^(https?:|mailto:)/i.test(s)) return s;
+  if (/^[a-z][\w+.-]*:/i.test(s)) return null;
+  return s;
+}
+
+/** Text with diff markers → nodes: the marked runs inside <ins> and <del>. `st` carries an open marker across inline nodes. */
+function textNodes(doc, s, st) {
+  const out = []; let buf = '';
+  const push = () => {
+    if (!buf) return;
+    const t = doc.createTextNode(buf); buf = '';
+    if (st.mode) { const w = doc.createElement(st.mode); w.appendChild(t); out.push(w); } else out.push(t);
+  };
+  for (const ch of String(s)) {
+    if (ch === INS || ch === DEL) { push(); st.mode = ch === INS ? 'ins' : 'del'; }
+    else if (ch === INS_END || ch === DEL_END) { push(); st.mode = null; }
+    else buf += ch;
+  }
+  push();
+  return out;
+}
+function inlineDom(doc, nodes, st) {
+  const out = [];
+  for (const n of nodes || []) {
+    if (n.t === 'text') { out.push(...textNodes(doc, n.s, st)); continue; }
+    if (n.t === 'code') { const c = doc.createElement('code'); c.append(...textNodes(doc, n.s, st)); out.push(c); continue; }
+    const tag = n.t === 'b' ? 'strong' : n.t === 'i' ? 'em' : 'a';
+    const e = doc.createElement(tag);
+    if (n.t === 'a') {
+      const h = safeHref(n.href);
+      if (h != null) { e.setAttribute('href', h); if (/^https?:/i.test(h)) { e.setAttribute('target', '_blank'); e.setAttribute('rel', 'noopener'); } }
+    }
+    e.append(...inlineDom(doc, n.c, st));
+    out.push(e);
+  }
+  return out;
+}
+
+/** Blocks → elements. `opts.editable` draws checklist boxes that can be ticked (the editor). */
+export function toDom(blocks, doc, opts = {}) {
+  const d = doc || document;
+  const mk = (tag, cls) => { const e = d.createElement(tag); if (cls) e.className = cls; return e; };
+  return (blocks || []).map((b) => {
+    const st = { mode: null };
+    if (b.t === 'h') { const e = mk('h' + Math.min(6, Math.max(1, b.level || 2))); e.append(...inlineDom(d, b.c, st)); return e; }
+    if (b.t === 'p') { const e = mk('p'); e.append(...inlineDom(d, b.c, st)); return e; }
+    if (b.t === 'hr') return mk('hr');
+    if (b.t === 'code') { const p = mk('pre'); if (b.lang) p.setAttribute('data-lang', b.lang); const c = mk('code'); c.append(...textNodes(d, b.s, st)); p.appendChild(c); return p; }
+    if (b.t === 'quote') { const q = mk('blockquote'); q.append(...toDom(b.blocks, d, opts)); return q; }
+    if (b.t === 'list') {
+      const l = mk(b.ordered ? 'ol' : 'ul', b.items.some((it) => it.task != null) ? 'tasks' : '');
+      for (const it of b.items) {
+        const li = mk('li');
+        if (it.task != null) {
+          li.className = 'task' + (it.task ? ' done' : '');
+          const box = mk('input'); box.type = 'checkbox'; box.checked = !!it.task; box.setAttribute('aria-label', 'Done');
+          if (opts.editable) box.setAttribute('contenteditable', 'false'); else box.disabled = true;
+          const sp = mk('span'); sp.append(...inlineDom(d, it.c, st));
+          li.append(box, sp);
+        } else li.append(...inlineDom(d, it.c, st));
+        l.appendChild(li);
+      }
+      return l;
+    }
+    if (b.t === 'table') {
+      const w = mk('div', 'tw'); const t = mk('table'); const th = mk('thead'); const tr = mk('tr');
+      for (const c of b.head) { const x = mk('th'); x.append(...inlineDom(d, c, st)); tr.appendChild(x); }
+      th.appendChild(tr); const tb = mk('tbody');
+      for (const r of b.rows) { const row = mk('tr'); for (const c of r) { const x = mk('td'); x.append(...inlineDom(d, c, st)); row.appendChild(x); } tb.appendChild(row); }
+      t.append(th, tb); w.appendChild(t); return w;
+    }
+    return d.createTextNode('');
+  });
+}
+
+/* reading the editor back */
+function inlineOf(n) {
+  const out = [];
+  const text = (s) => { if (!s) return; const last = out[out.length - 1]; if (last && last.t === 'text') last.s += s; else out.push({ t: 'text', s }); };
+  for (const c of Array.from(n.childNodes || [])) {
+    if (c.nodeType === 3) { text(c.textContent.replace(/\u00a0/g, ' ').replace(/\u200b/g, '').replace(/\s+/g, ' ')); continue; }
+    if (c.nodeType !== 1) continue;
+    const t = c.tagName;
+    if (t === 'BR') { text(' '); continue; }
+    if (t === 'INPUT' || t === 'UL' || t === 'OL') continue;
+    if (t === 'CODE') { out.push({ t: 'code', s: c.textContent.replace(/\u200b/g, '') }); continue; }
+    if (t === 'STRONG' || t === 'B') { out.push({ t: 'b', c: inlineOf(c) }); continue; }
+    if (t === 'EM' || t === 'I') { out.push({ t: 'i', c: inlineOf(c) }); continue; }
+    if (t === 'A') { out.push({ t: 'a', href: c.getAttribute('href') || '', c: inlineOf(c) }); continue; }
+    if (t === 'SPAN' && /font-weight:\s*(bold|[6-9]00)/.test(c.getAttribute('style') || '')) { out.push({ t: 'b', c: inlineOf(c) }); continue; }
+    if (t === 'SPAN' && /font-style:\s*italic/.test(c.getAttribute('style') || '')) { out.push({ t: 'i', c: inlineOf(c) }); continue; }
+    for (const x of inlineOf(c)) { if (x.t === 'text') text(x.s); else out.push(x); }
+  }
+  return out;
+}
+const trimInline = (c) => {
+  const a = c.slice();
+  while (a.length && a[0].t === 'text' && !a[0].s.trim()) a.shift();
+  while (a.length && a[a.length - 1].t === 'text' && !a[a.length - 1].s.trim()) a.pop();
+  if (a.length && a[0].t === 'text') a[0] = { ...a[0], s: a[0].s.replace(/^\s+/, '') };
+  if (a.length && a[a.length - 1].t === 'text') a[a.length - 1] = { ...a[a.length - 1], s: a[a.length - 1].s.replace(/\s+$/, '') };
+  return a;
+};
+const BLOCK = /^(P|DIV|H[1-6]|BLOCKQUOTE|UL|OL|TABLE|PRE|HR|SECTION)$/;
+/** The editor's children → blocks. Loose text and inline nodes between blocks become a paragraph. */
+export function fromDom(root) {
+  const out = []; let loose = null;
+  const endLoose = () => { if (loose) { const c = trimInline(inlineOf(loose)); if (c.length) out.push({ t: 'p', c }); loose = null; } };
+  for (const n of Array.from(root.childNodes || [])) {
+    if (n.nodeType === 1 && BLOCK.test(n.tagName)) { endLoose(); out.push(...blockOf(n)); continue; }
+    if (n.nodeType === 3 && !n.textContent.trim() && !loose) continue;
+    if (!loose) loose = (root.ownerDocument || document).createElement('p');
+    loose.appendChild(n.cloneNode(true));
+  }
+  endLoose();
+  return out;
+}
+function blockOf(n) {
+  const t = n.tagName;
+  if (/^H[1-6]$/.test(t)) return [{ t: 'h', level: +t[1], c: trimInline(inlineOf(n)) }];
+  if (t === 'HR') return [{ t: 'hr' }];
+  if (t === 'PRE') return [{ t: 'code', lang: n.getAttribute('data-lang') || '', s: n.textContent.replace(/\n$/, '') }];
+  if (t === 'BLOCKQUOTE') { const b = fromDom(n); return b.length ? [{ t: 'quote', blocks: b }] : []; }
+  if (t === 'UL' || t === 'OL') {
+    const items = Array.from(n.children).filter((li) => li.tagName === 'LI').map((li) => {
+      const box = li.querySelector(':scope > input[type=checkbox]');
+      return { task: box ? !!box.checked : null, c: trimInline(inlineOf(li)) };
+    });
+    const nested = Array.from(n.querySelectorAll(':scope > li > ul, :scope > li > ol')).flatMap(blockOf);
+    return [{ t: 'list', ordered: t === 'OL', items }, ...nested];
+  }
+  if (t === 'TABLE' || (t === 'DIV' && n.querySelector(':scope > table'))) {
+    const tb = t === 'TABLE' ? n : n.querySelector(':scope > table');
+    const rows = Array.from(tb.querySelectorAll('tr')).map((r) => Array.from(r.children).map((c) => trimInline(inlineOf(c))));
+    if (!rows.length) return [];
+    return [{ t: 'table', head: rows[0], rows: rows.slice(1) }];
+  }
+  if ((t === 'DIV' || t === 'SECTION') && Array.from(n.children).some((c) => BLOCK.test(c.tagName))) return fromDom(n);
+  const c = trimInline(inlineOf(n));
+  return c.length ? [{ t: 'p', c }] : [];
+}

package/workspace/public/pm/c3-notes.js

@@ -282,20 +282,26 @@ function after(s, n, mode) {
   const p = partsOf(n);
   const names = n.meeting && n.meeting.context ? peopleOf(n.meeting.context) : [];
   const cf = conflictsOf(n);
-  const td = (text) => el('td', null, text);
   const kids = [
     el('div', { class: 'c3cv-head' }, el('h3', null, c3ic('notes'), 'Notes'), recordButton(s, n, mode)),
     el('div', { class: 'chips2' }, el('b', null, n.title || 'Untitled note'), el('span', { class: 'dim mono cal3-sm' }, [dayOf(startOf(n)), mins(lenOf(n))].filter(Boolean).join(' · ')), ...names.map(avatar)),
     ...(() => { const rp = mode ? null : replayOf(s, n); return rp ? [el('div', { class: 'cal3-replay', 'data-cal3-notes': 'replay' }, el('h4', null, 'Replay'), rp, el('p', { class: 'dim cal3-sm' }, 'Kept on this machine.'))] : []; })(),
     ...cf.map((c) => el('div', { class: 'fold w', 'data-cal3-notes': 'conflict' }, c3ic('alert', 'sm'), '“' + c.text + '” differs from ', el('span', { class: 'mono' }, c.doc + (c.line ? ':' + c.line : '')))),
-    p.overview ? editable(p.from === 'final', 'p', p.overview, 'Overview', (t) => saveFinal(s, n, 'overview', 0, t), { class: 'cal3-ov', 'data-cal3-notes': 'overview' })
-      : el('p', { class: 'dim cal3-ov', 'data-cal3-notes': 'no-overview' }, mode ? 'The overview is written when you stop recording.' : 'No overview yet.'),
+    p.overview || !mode ? editable(true, 'p', p.overview, 'Summary', (t) => saveFinal(s, n, 'overview', 0, t), { class: 'cal3-ov', 'data-cal3-notes': p.overview ? 'overview' : 'no-overview' }, p.from === 'final' ? null : 'Write a summary of the meeting')
+      : el('p', { class: 'dim cal3-ov', 'data-cal3-notes': 'no-overview' }, 'The overview is written when you stop recording.'),
   ];
-  if (p.decisions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'decisions' }, el('thead', null, el('tr', null, el('th', null, 'Decision'), el('th', null, 'Why'))),
-    el('tbody', null, p.decisions.map((d) => el('tr', { 'data-cal3-notes': 'decision' }, el('td', null, editable(p.from === 'final', 'span', d.text, 'Decision', (t) => saveFinal(s, n, d.sec, d.i, t))), el('td', { class: 'dim' }, d.why || d.by || ''))))));
+  // each part of a decision or a next step is corrected in place: in the final notes (/api/notes/final-edit), or in the bullet
+  // it was caught from (/api/notes/bullet). A bullet has no why, so a caught decision's why is not shown.
+  const fin = p.from === 'final';
+  const cell = (x, field, label, ph, cls) => {
+    const on = fin || (x.bullet !== undefined && field !== 'why');
+    return el('td', cls ? { class: cls } : null, editable(on, 'span', x[field] || '', label, (t) => saveItem(s, n, x, field, t), { 'data-cal3-notes-field': field }, ph));
+  };
+  if (p.decisions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'decisions' }, el('thead', null, el('tr', null, el('th', null, 'Decision'), fin ? el('th', null, 'Why') : null)),
+    el('tbody', null, p.decisions.map((d) => el('tr', { 'data-cal3-notes': 'decision' }, cell(d, 'text', 'Decision'), fin ? cell(d, 'why', 'Why', 'Add why', 'dim') : null)))));
   if (p.actions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'actions' }, el('thead', null, el('tr', null, el('th', null, 'Next step'), el('th', null, 'Owner'), el('th', null, 'Due'), el('th'))),
-    el('tbody', null, p.actions.map((a) => el('tr', { 'data-cal3-notes': 'action' }, el('td', null, editable(p.from === 'final', 'span', a.text, 'Next step', (t) => saveFinal(s, n, a.sec, a.i, t))),
-      td(a.owner || el('span', { class: 'dim' }, 'No owner')), td(a.due || el('span', { class: 'dim' }, '—')),
+    el('tbody', null, p.actions.map((a) => el('tr', { 'data-cal3-notes': 'action' }, cell(a, 'text', 'Next step'),
+      cell(a, 'owner', 'Owner', 'No owner'), cell(a, 'due', 'Due', 'No date'),
       el('td', { class: 'cal3-tdr' }, btn('chip2 lk', { 'data-cal3-notes': 'make-task', title: n.initiative ? 'Add this step to ' + iniName(n.initiative) + ' as a plan item' : 'Link the note to an initiative first' },
         [c3ic('plus', 'sm'), 'Make task'], (e) => makeTask(n, a, { btn: e.currentTarget }))))))));
   if (p.questions.length) kids.push(el('div', { class: 'cal3-ctx', 'data-cal3-notes': 'questions' }, el('h4', null, 'Open questions'),
@@ -313,10 +319,11 @@ function after(s, n, mode) {
   return el('section', { class: 'card cal3-ncard', 'data-cv': 'notes' }, kids);
 }
 
-/** A text the PM corrects in place once the notes are final: a click puts the cursor in it, leaving it saves, Esc puts it back. */
-function editable(on, tag, text, label, save, attrs) {
-  if (!on) return el(tag, attrs || null, text);
-  const node = el(tag, { ...(attrs || {}), contenteditable: 'true', spellcheck: 'true', role: 'textbox', 'aria-label': 'Edit ' + label, 'data-cal3-notes-edit': '' }, text);
+/** A text the PM corrects in place: a click puts the cursor in it, leaving it saves, Esc puts it back. With a placeholder
+ * (`ph`), the text may be empty: the placeholder shows, and emptying the text clears it; without one, an empty text is refused. */
+function editable(on, tag, text, label, save, attrs, ph) {
+  if (!on) return el(tag, attrs || null, text || (ph ? el('span', { class: 'dim' }, ph) : ''));
+  const node = el(tag, { ...(attrs || {}), class: [attrs && attrs.class, ph ? 'cal3-ed' : null].filter(Boolean).join(' ') || null, contenteditable: 'true', spellcheck: 'true', role: 'textbox', 'aria-label': 'Edit ' + label, 'data-cal3-notes-edit': '', 'data-ph': ph || null }, text);
   let last = text;
   node.addEventListener('keydown', (e) => {
     if (e.key === 'Enter' && tag !== 'p') { e.preventDefault(); node.blur(); }
@@ -324,15 +331,27 @@ function editable(on, tag, text, label, save, attrs) {
   });
   node.addEventListener('blur', async () => {
     const v = node.textContent.replace(/\s+/g, ' ').trim();
-    if (!v || v === last) { node.textContent = last; return; }
-    if (await save(v)) last = v; else node.textContent = last;
+    if ((!v && !ph) || v === last) { node.textContent = last; return; }
+    if (await save(v)) { last = v; node.textContent = v; } else node.textContent = last;
   });
   return node;
 }
-async function saveFinal(s, n, sec, i, text) {
-  const r = await pmPost('/api/notes/final-edit', { id: n.id, sec, i, text });
+/* one part of a decision or a next step: in the final notes, or in the bullet it was caught from */
+async function saveItem(s, n, x, field, text) {
+  if (x.sec) return saveFinal(s, n, x.sec, x.i, text, field === 'text' ? undefined : field);
+  const r = await pmPost('/api/notes/bullet', { id: n.id, bullet: x.bullet, [field]: text });
   if (!r || !r.ok) { toast('Not saved' + ((r && r.error) ? ': ' + r.error : '')); return false; }
-  n.final_notes = r.final_notes;
+  const b = (n.bullets || []).find((y) => y && y.id === x.bullet);
+  if (b) Object.assign(b, r.bullet);
+  x[field] = text;
+  toast('Saved');
+  return true;
+}
+async function saveFinal(s, n, sec, i, text, field) {
+  const r = await pmPost('/api/notes/final-edit', field ? { id: n.id, sec, i, text, field } : { id: n.id, sec, i, text });
+  if (!r || !r.ok) { toast('Not saved' + ((r && r.error) ? ': ' + r.error : '')); return false; }
+  if (r.final_notes) n.final_notes = r.final_notes;
+  if ('overview_pm' in r) { if (r.overview_pm) n.overview_pm = r.overview_pm; else delete n.overview_pm; }
   toast('Saved');
   return true;
 }