@helping-ai-workflow/md2doc 3.17.2 → 3.17.4

package/lib/editor/code-edit.js

@@ -123,8 +123,8 @@ function newlineWithIndent(text, pos) {
 }
 
 // D3 Tab / Shift+Tab over a selection (R42). Touched lines are those that
-// intersect [selStart, selEnd]; when the selection is not collapsed and its
-// end sits at column 0 of a line, that line is not touched. Indent adds two
+// intersect [selStart, selEnd]; when the selection is not collapsed, a line it
+// only touches at an edge (it starts at the line's end, or ends at column 0) is not touched. Indent adds two
 // spaces; dedent removes up to two leading spaces. A position on a touched
 // line keeps its column relative to the line's text (indent: a column-0
 // position moves with the text, unlike VS Code; dedent: clamps at the line
@@ -136,9 +136,10 @@ function indentLines(text, selStart, selEnd, dedent) {
   for (const l of lines) { starts.push(off); off += l.length + 1; }
   const touched = lines.map((l, i) => {
     const s = starts[i], e = s + l.length;
-    if (!(s <= selEnd && e >= selStart)) return false;
-    if (selEnd > selStart && s === selEnd) return false;
-    return true;
+    // v3.17.3 C3: a selection that starts exactly at a line's end, or ends at
+    // its start, does not touch that line; a collapsed caret touches its own.
+    if (selEnd === selStart) return s <= selStart && e >= selStart;
+    return s < selEnd && e > selStart;
   });
   const delta = lines.map((l, i) => {
     if (!touched[i]) return 0;

package/lib/editor/convert-md.js

@@ -154,6 +154,13 @@ function listAttrsFor(target) {
   return null;
 }
 
+// A run of hash characters at the very end of a heading's text, set off by a
+// space (or the whole text), reads as the ATX closing sequence and is dropped
+// on the next parse; its first character is written escaped to keep it text.
+function escapeClosingHashes(md) {
+  return md.replace(/(^|[ \t])(#+)([ \t]*)$/, '$1\\$2$3');
+}
+
 function emitAs(content, target, opts) {
   const o = opts || {};
   const prefix = o.indentPrefix || '';
@@ -170,7 +177,7 @@ function emitAs(content, target, opts) {
     const text = body.length > 1 ? body.map((l) => l.trim()).join(' ') : body.join(' ');
     // An EMPTY heading emits no trailing space, or converting '##' to a
     // heading of the same level would rewrite the line to '## '.
-    return [text === '' ? prefix + hashes : prefix + hashes + ' ' + text];
+    return [text === '' ? prefix + hashes : prefix + hashes + ' ' + escapeClosingHashes(text)];
   }
 
   if (target === 'quote') return body.map((l) => prefix + '> ' + l);
@@ -203,5 +210,5 @@ function emitAs(content, target, opts) {
   return body.slice();
 }
 
-return { CONVERT_TARGETS, stripMarker, emitAs, targetIsList, listAttrsFor };
+return { CONVERT_TARGETS, stripMarker, emitAs, targetIsList, listAttrsFor, escapeClosingHashes };
 });

package/lib/editor/dot-preview.js

@@ -0,0 +1,65 @@
+'use strict';
+// A kept-alive worker thread for the Graphviz preview. Created on the first
+// preview, reused for every later one. An engine error comes back as an
+// ordinary Error (the server answers 422 with its first line); a worker that
+// dies takes its in-flight requests down with an Error flagged `crashed`
+// (the server answers 500), and the next request starts a fresh worker.
+const path = require('path');
+const { Worker } = require('worker_threads');
+
+function createDotPreview() {
+  let worker = null;
+  let seq = 0;
+  const pending = new Map();
+
+  // Only the requests that belong to `w` die with it: a worker that was
+  // closed or replaced reports its exit late, after a new one took over.
+  function failAll(err, w) {
+    for (const [id, p] of pending) {
+      if (w !== undefined && p.worker !== w) continue;
+      p.reject(err);
+      pending.delete(id);
+    }
+  }
+  function start() {
+    const w = new Worker(path.join(__dirname, 'dot-worker.js'));
+    // An idle worker must not keep the process (or a test) alive.
+    w.unref();
+    w.on('message', (m) => {
+      const p = pending.get(m.id);
+      if (!p) return;
+      pending.delete(m.id);
+      if (m.error !== undefined) p.reject(new Error(m.error));
+      else p.resolve(m.svg);
+    });
+    const dead = (err) => {
+      if (worker === w) worker = null;
+      const e = new Error(String((err && err.message) || 'graphviz worker exited'));
+      e.crashed = true;
+      failAll(e, w);
+    };
+    w.on('error', dead);
+    w.on('exit', () => dead(null));
+    return w;
+  }
+  return {
+    render(source) {
+      if (worker === null) worker = start();
+      const id = ++seq;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject, worker });
+        // A request in flight keeps the loop alive until it answers.
+        worker.ref();
+        worker.postMessage({ id, source });
+      }).finally(() => { if (pending.size === 0 && worker !== null) worker.unref(); });
+    },
+    close() {
+      const w = worker;
+      worker = null;
+      if (w !== null) w.terminate();
+      failAll(Object.assign(new Error('graphviz worker closed'), { crashed: true }));
+    },
+  };
+}
+
+module.exports = { createDotPreview };

package/lib/editor/dot-worker.js

@@ -0,0 +1,14 @@
+'use strict';
+// Worker-thread entry for the stateless /api/preview: lays a dot source out
+// with the same renderDotSvg the bake uses, so a large graph does not block
+// the editor server's event loop (and with it /api/ping and every save).
+const { parentPort } = require('worker_threads');
+const { renderDotSvg } = require('../md2doc.js');
+
+parentPort.on('message', async (m) => {
+  try {
+    parentPort.postMessage({ id: m.id, svg: await renderDotSvg(m.source) });
+  } catch (e) {
+    parentPort.postMessage({ id: m.id, error: String((e && e.message) || e) });
+  }
+});

package/lib/editor/inline-md.js

@@ -517,13 +517,48 @@
     return { s, altStart, altEnd, destStart, destEnd, angle, title };
   }
 
+  // v3.17.3 A3: marked keeps a backslash before anything but [ and ] in an
+  // image's alt (measured, marked 14: `a\`b` renders alt a\`b, `x\\y` renders
+  // x\\y), and an unbalanced backtick in the brackets turns the whole image
+  // into a code span. So only [ and ] are backslash-escaped; the backtick,
+  // the ampersand and the backslash are written as the character references
+  // the browser reads back as the same character. The reader side below
+  // undoes those, plus the backslash escapes older files hold.
+  // Final review M2 (R25 / R7), widened by v3.17.4 E1 (R10): every character
+  // reference the reader decodes — marked passes them into the alt attribute
+  // untouched and the browser decodes them — so the field shows what the
+  // reader shows. A decimal or hex number needs no table. A name goes through
+  // the installed decoder (the client installs one that asks the page itself,
+  // so every name the browser knows decodes); with none installed, the six
+  // names amp, lt, gt, quot, apos and nbsp. A name the decoder does not know
+  // stays as written in the field, and is written so that it renders as that
+  // text. An edited alt is written as the decoded character itself.
+  const ALT_ESCAPE = { '[': '\\[', ']': '\\]', '&': '&', '`': '`', '\\': '\' };
+  const ALT_NAMED_CHAR = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: '\u00a0' };
+  const defaultNamedReference = (name) => ALT_NAMED_CHAR[name];
+  let namedReference = defaultNamedReference;
+  function setNamedReferenceDecoder(fn) { namedReference = typeof fn === 'function' ? fn : defaultNamedReference; }
+  const ALT_UNESCAPE = /\\([!-\/:-@\[-`{-~])|&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|([A-Za-z][A-Za-z0-9]*));/g;
+  // A number the HTML parser would not give as itself (zero, a surrogate,
+  // past U+10FFFF) is U+FFFD there, so it is here too.
+  function altCodePoint(n) {
+    return n === 0 || n > 0x10ffff || (n >= 0xd800 && n <= 0xdfff) ? '\ufffd' : String.fromCodePoint(n);
+  }
+  function altUnescape(m, c, dec, hex, name) {
+    if (c !== undefined) return c;
+    if (dec !== undefined) return altCodePoint(parseInt(dec, 10));
+    if (hex !== undefined) return altCodePoint(parseInt(hex, 16));
+    const r = namedReference(name);
+    return typeof r === 'string' ? r : m;
+  }
+
   function parseImageParagraph(text) {
     const f = scanImage(text);
     if (!f) return null;
     const rawAlt = f.s.slice(f.altStart, f.altEnd);
     const rawDest = f.s.slice(f.destStart, f.destEnd);
     return {
-      alt: rawAlt.replace(/\\([!-\/:-@\[-`{-~])/g, '$1'),
+      alt: rawAlt.replace(ALT_UNESCAPE, altUnescape),
       dest: f.angle ? rawDest.slice(1, -1) : rawDest,
       title: f.title,
       angle: f.angle,
@@ -531,20 +566,20 @@
   }
 
   // Alt and/or destination replaced, everything else kept. `alt` is plain text
-  // (the three characters that would end or bend the brackets gain a
-  // backslash); `dest` is written as given, so the caller makes it
+  // (the characters that would end or bend the brackets are escaped, see
+  // ALT_ESCAPE); `dest` is written as given, so the caller makes it
   // markdown-ready — an angle-bracketed original loses its brackets.
   function rewriteImage(text, patch) {
     const f = scanImage(text);
     if (!f) return String(text == null ? '' : text);
     const p = patch || {};
     let out = f.s.slice(0, f.altStart);
-    out += typeof p.alt === 'string' ? p.alt.replace(/[\\\[\]]/g, '\\$&') : f.s.slice(f.altStart, f.altEnd);
+    out += typeof p.alt === 'string' ? p.alt.replace(/[\\\[\]&`]/g, (c) => ALT_ESCAPE[c]) : f.s.slice(f.altStart, f.altEnd);
     out += f.s.slice(f.altEnd, f.destStart);
     out += typeof p.dest === 'string' ? p.dest : f.s.slice(f.destStart, f.destEnd);
     out += f.s.slice(f.destEnd);
     return out;
   }
 
-  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder };
 });

package/lib/editor/list-md.js

@@ -304,18 +304,9 @@
   // per block is what let the per-li degrade path address a different item's
   // line. See the continuation-column note in the emission below.
   //
-  // RUN (spec §3.8): a run breaks at a shallower li, at a same-depth li whose
-  // data-list-type differs, or at a non-li block. Deeper items never break
-  // the run they are nested under. Every run's ordinal restarts at 1 — hence
-  // `counters`, indexed by depth, with everything deeper than the current
-  // depth cleared whenever the walk comes back up.
-  //
-  // Rule (b) compares against the last block seen AT THAT DEPTH (`types`),
-  // NOT against the immediately previous block: with a deeper item sitting
-  // between two same-depth blocks, comparing against `prev` makes the
-  // list-type change invisible and the ordinal never restarts. The md then
-  // re-lexes as <ol start="3">, §3.8 discards `start`, and the next commit
-  // renumbers to '1.' — the document oscillates between two states forever.
+  // RUN (spec §3.8): the rules and their bookkeeping are planRuns()'s, below
+  // (v3.17.3 moved them there so a run's marker style is known before its
+  // first item is written).
   //
   // Same DOM-API constraint as the rest of this module, plus
   // `classList.contains` (state classes are token-matched, never compared as
@@ -363,16 +354,115 @@
   // `prefix` is what §3.4's colDelta measures the OLD side against, so it comes
   // back as literal text rather than a count — a caller that finds a TAB in it
   // knows the column arithmetic is not exact and can decline.
-  const SRC_MARKER_RE = /^([ \t]*)(?:[-*+]|\d{1,9}[.)])([ \t]+)(?:\[[ xX]\][ \t]+)?/;
+  const SRC_MARKER_RE = /^([ \t]*)([-*+]|\d{1,9}[.)])([ \t]+)(?:\[[ xX]\][ \t]+)?/;
+  // `style` is the LAST marker's bullet character or ordinal delimiter ('-',
+  // '*', '+', '.', ')') — the item's own, on a same-line nest — or null.
   function splitSourceMarkers(line) {
     const text = typeof line === 'string' ? line : '';
     let at = 0;
+    let style = null;
     for (;;) {
       const m = SRC_MARKER_RE.exec(text.slice(at));
       if (!m) break;
       at += m[0].length;
+      style = m[2].charAt(m[2].length - 1);
     }
-    return { prefix: text.slice(0, at), content: text.slice(at) };
+    return { prefix: text.slice(0, at), content: text.slice(at), style: style };
+  }
+
+  // ── v3.17.3 A9 (R5): a run is written with ITS OWN marker ───────────────
+  // A bullet list may use '-', '*' or '+', an ordered one '.' or ')', and
+  // CommonMark starts a NEW list at a change of either. Writing the canonical
+  // '- ' / 'n. ' for every item turned `* a\n* b` into `- a\n- bX` on an edit
+  // to b — a in the same commit — which rewrote lines nobody touched (README
+  // promises only touched lines change).
+  //
+  // So every run (the RUN rule below: one list at one depth, as marked sees
+  // it — `- a` and `* c` side by side are two lists, data-list-start keeps
+  // them apart) is written with one style, chosen by its items' SOURCE
+  // markers in three tiers, the first tier with any vote deciding (within a
+  // tier the majority, ties going to the earliest):
+  //   1. the run's own CARRIED items (opts.carryOver: bytes replayed, so the
+  //      marker on their first line is the list's own);
+  //   2. its re-serialised items, by what opts.sourceMarker(blockEl) answers
+  //      (client.js reads it off the file — the edited item, say);
+  //   3. items opts.foreign(blockEl) names — moved in from another list by
+  //      the gesture (client.js's moveSpanAcrossLists()). Their old marker is
+  //      another list's, so it counts only for a run made of nothing else (a
+  //      list moved whole keeps its style); otherwise a moved item takes the
+  //      run's. Without the tiers a `* moved` dropped into `- alpha` won the
+  //      1:1 tie and rewrote the untouched item (review I1, measured).
+  // An item with no source at all (one Enter just made) votes for nothing and
+  // takes the run's style; a run where no item has one is written
+  // canonically. A style the run's type cannot carry (a '*' source on an item
+  // converted to ordered) is not a vote.
+  const UL_STYLES = '-*+';
+  const OL_STYLES = '.)';
+  function styleFits(style, listType) {
+    return typeof style === 'string' && style.length === 1 &&
+      (listType === 'ol' ? OL_STYLES : UL_STYLES).indexOf(style) !== -1;
+  }
+
+  // The run bookkeeping, done once ahead of the emission so a run's style is
+  // known before its first item is written (that item may be the one being
+  // re-serialised, with no source of its own). Returns, per block, null (not
+  // a li) or { run, ordinal }. `firstOrdinal` is the number the FIRST run
+  // starts at (default 1; client.js's convert passes the number a joined list
+  // continues from, v3.17.3 A7) — every later run restarts at 1.
+  //
+  // RUN (spec §3.8): a run breaks at a shallower li, at a same-depth li whose
+  // data-list-type differs, or at a non-li block. Deeper items never break
+  // the run they are nested under. Every run's ordinal restarts at 1 — hence
+  // `counters`, indexed by depth, with everything deeper than the current
+  // depth cleared whenever the walk comes back up.
+  //
+  // Rule (b) compares against the last block seen AT THAT DEPTH (`types`),
+  // NOT against the immediately previous block: with a deeper item sitting
+  // between two same-depth blocks, comparing against `prev` makes the
+  // list-type change invisible and the ordinal never restarts. The md then
+  // re-lexes as <ol start="3">, §3.8 discards `start`, and the next commit
+  // renumbers to '1.' — the document oscillates between two states forever.
+  //
+  // Rule (d) is the fourth reset, and rules (a)-(c) cannot derive it:
+  // '  1. x' followed by '  1) y' is TWO nested list tokens (a delimiter
+  // change starts a new list) at the SAME depth with the SAME type, so
+  // without this the second list is renumbered as a continuation of the
+  // first ('2. y') and a commit rewrites a list the user never touched.
+  // lib/md2doc.js stamps the attribute; only the renderer still knows
+  // where marked's token boundaries were.
+  function planRuns(els, firstOrdinal) {
+    const plan = [];
+    const counters = [];
+    const types = [];
+    const runAt = [];
+    let nextRun = 0;
+    let prev = null;
+    let first = true;
+    els.forEach((blockEl) => {
+      if (blockEl.getAttribute('data-block-type') !== 'li') { plan.push(null); return; }
+      const indent = Number(blockEl.getAttribute('data-indent')) || 0;
+      const listType = blockEl.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul';
+      const isListStart = blockEl.getAttribute('data-list-start') === '1';
+      // Going DEEPER opens a brand-new run at that depth (even when the type
+      // matches); a list-type change against the last block AT THIS DEPTH
+      // closes that run and opens another; coming back UP leaves this depth's
+      // run open (deeper items did not break it) but clears every deeper
+      // depth so the next descent restarts at 1.
+      if (isListStart || !prev || indent > prev.indent || types[indent] !== listType) {
+        counters[indent] = first ? firstOrdinal - 1 : 0;
+        runAt[indent] = nextRun++;
+      }
+      first = false;
+      for (let k = counters.length - 1; k > indent; k--) {
+        counters[k] = 0;
+        types[k] = undefined;
+      }
+      types[indent] = listType;
+      counters[indent] = (counters[indent] || 0) + 1;
+      plan.push({ run: runAt[indent], ordinal: counters[indent] });
+      prev = { indent: indent };
+    });
+    return plan;
   }
 
   function spaces(n) {
@@ -460,6 +550,36 @@
     // `blank: true`, so
     // `lineMeta.length === md.split('\n').length` still holds.
     const blankBefore = (opts && typeof opts.blankBefore === 'function') ? opts.blankBefore : null;
+    const sourceMarker = (opts && typeof opts.sourceMarker === 'function') ? opts.sourceMarker : null;
+    const foreign = (opts && typeof opts.foreign === 'function') ? opts.foreign : null;
+    const firstOrdinal = (opts && Number(opts.firstOrdinal) >= 1) ? Math.floor(Number(opts.firstOrdinal)) : 1;
+    const els = toArray(blockEls);
+    const plan = planRuns(els, firstOrdinal);
+    // v3.17.3 A9: each run's style, by the tiered vote described at UL_STYLES.
+    // votes[run][tier] = [{ style, n }] in first-seen order.
+    const votes = {};
+    els.forEach((blockEl, i) => {
+      if (!plan[i]) return;
+      const id = blockEl.getAttribute('data-block-id');
+      const carried = carryOver && id !== null && carryOver[id];
+      const style = carried && carried.length ? splitSourceMarkers(carried[0]).style
+        : (sourceMarker ? sourceMarker(blockEl) : null);
+      const listType = blockEl.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul';
+      if (!styleFits(style, listType)) return;
+      const tier = foreign && foreign(blockEl) ? 2 : (carried && carried.length ? 0 : 1);
+      const byTier = votes[plan[i].run] || (votes[plan[i].run] = [[], [], []]);
+      const v = byTier[tier];
+      const hit = v.find((x) => x.style === style);
+      if (hit) hit.n++;
+      else v.push({ style: style, n: 1 });
+    });
+    const runStyle = {};
+    Object.keys(votes).forEach((r) => {
+      const v = votes[r].find((t) => t.length > 0);
+      let best = null;
+      v.forEach((x) => { if (!best || x.n > best.n) best = x; });
+      runStyle[r] = best.style;
+    });
     let prevItemEl = null;
     const unsupported = [];
     const unsupportedByLi = [];
@@ -467,13 +587,8 @@
     const lineMeta = [];
     const lines = [];
     // widths[k] = the marker width (as a literal run of spaces) of the
-    // innermost item seen at depth k; counters[k] = the running ordinal of
-    // the run currently open at depth k.
+    // innermost item seen at depth k. The ordinals are planRuns()'s.
     const widths = [];
-    const counters = [];
-    // types[k] = the list type of the last block seen at depth k, so rule (b)
-    // survives a deeper item sitting between two same-depth blocks.
-    const types = [];
     let prev = null; // { indent, listType }
 
     // ── Round 6: a CONTENT-FREE TASK item cannot be given a line of its own ──
@@ -522,7 +637,7 @@
       return line.slice(k);
     }
 
-    toArray(blockEls).forEach((blockEl) => {
+    els.forEach((blockEl, blockIdx) => {
       const blockId = blockEl.getAttribute('data-block-id');
 
       // §3.8 rule (c): a non-li block terminates a run. It has no marker and
@@ -546,40 +661,21 @@
       if (pending && indent <= pending.indent) flushPending();
       const listType = blockEl.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul';
       const isTask = blockEl.getAttribute('data-task') === '1';
-      // §3.8 rule (d): this block is the first item of its own list TOKEN.
-      const isListStart = blockEl.getAttribute('data-list-start') === '1';
-
-      // Run bookkeeping. Going DEEPER opens a brand-new run at that depth
-      // (even when the type matches); a list-type change against the last
-      // block AT THIS DEPTH closes that run and opens another; coming back
-      // UP leaves this depth's run open (deeper items did not break it) but
-      // clears every deeper depth so the next descent restarts at 1.
-      //
-      // Rule (d) is the fourth reset, and rules (a)-(c) cannot derive it:
-      // '  1. x' followed by '  1) y' is TWO nested list tokens (a delimiter
-      // change starts a new list) at the SAME depth with the SAME type, so
-      // without this the second list is renumbered as a continuation of the
-      // first ('2. y') and a commit rewrites a list the user never touched.
-      // lib/md2doc.js stamps the attribute; only the renderer still knows
-      // where marked's token boundaries were.
-      if (isListStart || !prev || indent > prev.indent || types[indent] !== listType) {
-        counters[indent] = 0;
-      }
-      for (let k = counters.length - 1; k > indent; k--) {
-        counters[k] = 0;
-        types[k] = undefined;
-      }
-      types[indent] = listType;
+      // §3.8's run bookkeeping (rules (a)-(d)) is planRuns()'s, above.
+      const slot = plan[blockIdx];
 
       const indentPrefix = widths.slice(0, indent).join('');
-      counters[indent] = (counters[indent] || 0) + 1;
 
       const checkEl = firstChildWithClass(blockEl, 'ed-li-check');
       const isChecked = checkEl ? checkEl.getAttribute('data-checked') === '1' : false;
       // Two-part marker: the bullet (ordered ordinal or '- ') and an
       // optional checkbox, kept independent so an ordered task list gets
       // BOTH ('1. [ ] todo') — RULING F-N, same as serializeList above.
-      const bullet = listType === 'ol' ? (counters[indent] + '. ') : '- ';
+      // v3.17.3 A9: in the run's own style ('* ', '1) '); every style is one
+      // character, so the bullet's width — which `widths` and the child
+      // indent are computed from — is the canonical one's.
+      const style = runStyle[slot.run];
+      const bullet = listType === 'ol' ? (slot.ordinal + (style || '.') + ' ') : ((style || '-') + ' ');
       const marker = isTask ? bullet + (isChecked ? '[x] ' : '[ ] ') : bullet;
 
       const textEl = firstChildWithClass(blockEl, 'ed-li-text');

package/lib/editor/server.js

@@ -4,7 +4,8 @@ const path = require('path');
 const http = require('http');
 const crypto = require('crypto');
 const drawioLib = require('../drawio.js');
-const { renderMarkdown, buildKatexStyleTag, diagramEnginePaths, renderDotSvg } = require('../md2doc.js');
+const { renderMarkdown, buildKatexStyleTag, diagramEnginePaths } = require('../md2doc.js');
+const { createDotPreview } = require('./dot-preview.js');
 
 const LINEOPS_SRC = fs.readFileSync(path.join(__dirname, 'lineops.js'), 'utf8');
 const INLINE_MD_SRC = fs.readFileSync(path.join(__dirname, 'inline-md.js'), 'utf8');
@@ -353,6 +354,8 @@ async function createEditorServer({
   // has ever been registered" — see registerAliveConnection() and
   // DEFAULT_NEVER_OPENED_GRACE_MS's own comment on why that boundary moved
   // off GET /edit/:id.
+  // v3.17.3 A4: real paths of the files POST /api/asset wrote in this process.
+  const writtenAssets = new Set();
   const aliveConnections = new Set();
   let shutdownGraceTimer = null;
   // Guards against the (already-benign, but worth making impossible on
@@ -677,6 +680,8 @@ async function createEditorServer({
     });
   }
 
+  // Graphviz preview runs in a worker thread, created on the first request.
+  const dotPreview = createDotPreview();
   const server = http.createServer(async (req, res) => {
     try {
       const url = new URL(req.url, 'http://127.0.0.1');
@@ -707,7 +712,10 @@ async function createEditorServer({
       // is running could fire a cross-site "simple" POST at every candidate
       // localhost port and write to disk.
       const STATE_CHANGING_POST_PATHS = new Set(['/api/render', '/api/save', '/api/ping', '/api/asset', '/api/preview']);
-      if (req.method === 'POST' && STATE_CHANGING_POST_PATHS.has(url.pathname)) {
+      // v3.17.3 A4: DELETE /api/asset is state-changing too; it gets the same
+      // content-type gate (the client sends it with the fetch).
+      if ((req.method === 'POST' && STATE_CHANGING_POST_PATHS.has(url.pathname)) ||
+          (req.method === 'DELETE' && url.pathname === '/api/asset')) {
         const contentType = String(req.headers['content-type'] || '');
         if (!/^application\/json\b/i.test(contentType)) {
           return send(res, 415, { error: 'content-type must be application/json' });
@@ -847,8 +855,11 @@ async function createEditorServer({
         if (body.lang !== 'dot') return send(res, 400, { error: 'lang must be dot' });
         if (typeof body.source !== 'string') return send(res, 400, { error: 'source must be a string' });
         try {
-          return send(res, 200, { svg: await renderDotSvg(body.source) });
+          return send(res, 200, { svg: await dotPreview.render(body.source) });
         } catch (e) {
+          // A dead worker is the server's fault, not the source's: 500, and
+          // the next request starts a new one.
+          if (e && e.crashed === true) return send(res, 500, { error: 'graphviz worker failed' });
           const first = String((e && e.message) || e).split('\n')[0];
           return send(res, 422, { error: first });
         }
@@ -1005,9 +1016,45 @@ async function createEditorServer({
           }
           throw e;
         }
+        writtenAssets.add(path.join(realAssets, name));
         return send(res, 200, { name, path: assetLib.relPath(name) });
       }
 
+      // v3.17.3 A4: takes back an upload the page made and then could not use
+      // (a replace refused while its file was still on the way). Only a file
+      // this server instance wrote through POST /api/asset can go: the path is
+      // looked up in `writtenAssets`, never trusted. Anything else, a file that
+      // exists included, is 404 and untouched. `fileId` (optional) names the
+      // document the path is relative to; without it every open document's
+      // directory is tried.
+      if (req.method === 'DELETE' && url.pathname === '/api/asset') {
+        const rel = url.searchParams.get('path');
+        const fidRaw = url.searchParams.get('fileId');
+        const fid = fidRaw === null ? null : Number(fidRaw);
+        if (typeof rel !== 'string' || rel === '' || rel.indexOf('\0') !== -1 ||
+            (fid !== null && (!Number.isInteger(fid) || fid < 0 || fid >= absFiles.length))) {
+          return send(res, 404, { error: 'not an uploaded asset' });
+        }
+        const candidates = fid === null ? absFiles : [absFiles[fid]];
+        for (const file of candidates) {
+          let target;
+          try {
+            const dir = fs.realpathSync(path.dirname(file));
+            const abs = path.resolve(dir, rel);
+            target = path.join(fs.realpathSync(path.dirname(abs)), path.basename(abs));
+          } catch (e) { continue; }
+          if (!writtenAssets.has(target)) continue;
+          try { fs.unlinkSync(target); } catch (e) {
+            if (e && e.code === 'ENOENT') { writtenAssets.delete(target); continue; }
+            throw e;
+          }
+          writtenAssets.delete(target);
+          res.writeHead(204);
+          return res.end();
+        }
+        return send(res, 404, { error: 'not an uploaded asset' });
+      }
+
       // v3.6.0: the liveness stream. A GET (EventSource cannot send any other
       // method), held open for as long as the tab exists. fileId/clientId are
       // read here purely so a future diagnostic has them to hand — see
@@ -1128,6 +1175,8 @@ async function createEditorServer({
   }, neverOpenedGraceMs);
   if (neverOpenedTimer.unref) neverOpenedTimer.unref();
 
+  server.on('close', () => dotPreview.close());
+
   return {
     server,
     port,

package/lib/editor/wave-ui.js

@@ -1020,6 +1020,15 @@
           // moves (the ⠿ menu's 上移 / 下移 say Alt+↑ / Alt+↓); from the
           // canvas, the selected one, as before. A group's ⠿ (or its menu)
           // moves the group, like that menu's 上移 / 下移.
+          // v3.17.3 (C14, R14): 週期與相位…'s fields are text the keyboard is
+          // typing into. Alt+↑/↓ there writes what is typed to the signal
+          // whose panel this is (closePopover flushes to its own index) and
+          // moves no lane; before, the selected lane moved under the open
+          // panel and the value landed on whoever then sat at its index.
+          if (popover !== null && popover.kind === 'period' && popover.el.contains(ev.target)) {
+            closePopover(true);
+            return;
+          }
           const named = keyboardLane(ev.target);
           const group = named === null ? keyboardGroup(ev.target) : null;
           if (named !== null) {