@helping-ai-workflow/md2doc 3.17.0 → 3.17.2

package/lib/editor/client.js

@@ -108,6 +108,35 @@
     return { lines: r.lines, blocks, op };
   }
 
+  // v3.17.2 A3 (R65, v3.15.0 N5): do two list lines open items of the SAME
+  // list kind, i.e. would markdown read them as one list with nothing but
+  // blank lines between them? Same bullet character, or both ordered with
+  // the same delimiter (`.` / `)`); `- a` then `* b` are two lists however
+  // they are spaced.
+  const LIST_KIND_RE = /^ {0,3}(?:([-*+])|\d{1,9}([.)]))(?:[ \t]|$)/;
+  function sameListKind(lineA, lineB) {
+    const a = LIST_KIND_RE.exec(String(lineA == null ? '' : lineA));
+    const b = LIST_KIND_RE.exec(String(lineB == null ? '' : lineB));
+    if (!a || !b) return false;
+    return a[1] ? a[1] === b[1] : (!!a[2] && a[2] === b[2]);
+  }
+  // v3.17.2 A3: commitRangeRemoval()'s twin for a block that stood between
+  // two lists of the same kind: its lines and EVERY blank line on both sides
+  // go, so the two lists join TIGHT (one blank between them would make the
+  // joined list loose). One op; the shiftBlocks anchor as commitRangeRemoval().
+  function commitTightRemoval(state, startLine, endLine) {
+    const refusal = refuseInvertedRange(state, 'commitTightRemoval', startLine, endLine);
+    if (refusal) return refusal;
+    const anchor = state.blocks.filter((b) => b.endLine <= endLine).pop();
+    const span = growOverBlanks(state.lines, startLine, endLine, 'both');
+    const before = state.lines.slice(span[0] - 1, span[1]);
+    const op = { startLine: span[0], endLine: span[1], before, after: [] };
+    const r = ops.replaceLines(state.lines, span[0], span[1], []);
+    const blocks = anchor ? ops.shiftBlocks(state.blocks, anchor.id, r.delta) : state.blocks;
+    state.stack.push(op);
+    return { lines: r.lines, blocks, op };
+  }
+
   // Task 4 fix (review, Important): removing the LAST remaining item of a
   // list block (empty-Enter on a list with exactly one item) serializes to
   // '' — committing that through commitEdit() would replace the block's
@@ -874,7 +903,7 @@
   }
 
   if (typeof module === 'object' && module.exports) {
-    module.exports = { pasteIsAllListLines, LIST_LINE_RE, extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, commitInsertionAt, commitSplit, commitShortcut, growOverBlanks, commitTightInsert, planBlockMove, commitBlockMove, reorderSpanRange, spanMoveRange, spanIndentsAreAnchored, blockMoveSeamRefusal, rollbackFailedRender, transientCommitMd, headingDepthOf, withHeadingDepth, resolveDrawioLanding, shiftBlocksAfterBodyEdit, waveDiscardIsSafe, waveOfferHolds, waveRedoHolds };
+    module.exports = { pasteIsAllListLines, LIST_LINE_RE, extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, sameListKind, commitTightRemoval, commitListBlockRemoval, commitBlockInsertion, commitInsertionAt, commitSplit, commitShortcut, growOverBlanks, commitTightInsert, planBlockMove, commitBlockMove, reorderSpanRange, spanMoveRange, spanIndentsAreAnchored, blockMoveSeamRefusal, rollbackFailedRender, transientCommitMd, headingDepthOf, withHeadingDepth, resolveDrawioLanding, shiftBlocksAfterBodyEdit, waveDiscardIsSafe, waveOfferHolds, waveRedoHolds };
     return; // node: pure core only
   }
 
@@ -1355,7 +1384,7 @@
   // rather than surface.
   function burstHasUncommittedEdit() {
     return !!(currentBurst && currentBurst.editEl &&
-      burstBaselineHtml(currentBurst.editEl) !== currentBurst.original);
+      !sameBurstHtml(burstBaselineHtml(currentBurst.editEl), currentBurst.original));
   }
 
   // v3.4.0 §3: single source of truth for "does the document have anything
@@ -1389,8 +1418,18 @@
     // v3.17.0 T2 fix round 1 (R47): code typed into an open in-place edit is
     // unsaved work too — it reaches `lines` only when the edit commits. T5
     // (R56 (d)): so is the source typed into an open diagram panel.
+    // v3.17.2 B1 (v3.17.0 final review T2 L74): and so is the text typed into
+    // an open raw box. Measured before: type in the box, and the status
+    // read clean and a tab close raised no dialog — the typing was lost.
     return stack.isDirty() || burstHasUncommittedEdit() || waveUnwrittenEdit || pendingStructure !== null ||
-      codeEditHasUncommittedText() || diagramPanelHasUncommittedText();
+      codeEditHasUncommittedText() || diagramPanelHasUncommittedText() || rawEditHasUncommittedText();
+  }
+  // Guarded the same way, for the same reason (the beforeunload handler).
+  function rawEditHasUncommittedText() {
+    try {
+      const ed = activeEditor;
+      return !!ed && ed.kind === 'raw' && ed.blockEl.isConnected && ed.hasChanges();
+    } catch (e) { return false; }
   }
   // Guarded the way burstHasUncommittedEdit() is: this also runs inside the
   // beforeunload handler, where a throw would drop the navigation guard.
@@ -3268,7 +3307,7 @@
   }
   function surfaceDrawnAs(original) {
     const found = Array.prototype.filter.call(contentEl.querySelectorAll('.ed-wys-armed'),
-      (el) => !el.closest('[data-ed-transient]') && burstBaselineHtml(el) === original);
+      (el) => !el.closest('[data-ed-transient]') && sameBurstHtml(burstBaselineHtml(el), original));
     return found.length === 1 ? found[0] : null;
   }
   async function restoreAfterReconcile(carry, cap) {
@@ -4209,6 +4248,8 @@
       // 一行空白是這個編輯器自己放的，不是使用者打的，把它算成「有變更」
       // 會讓「開起來看一眼就關掉」變成一次靜默的寫檔。
       hasChanges: () => ta.value !== seed.value,
+      // v3.17.2 B1: what rawEditHasUncommittedText() asks for.
+      kind: 'raw',
       // v3.15.0 B5 fix round 2 (R80): the session by value, in the
       // discardedRawEdit shape, for reconcileScreen() to reopen it.
       snapshot: () => ({ blockId, range, startLine, endLine, source,
@@ -4251,6 +4292,7 @@
       // of repainting the same bytes, not a different edit.
       if (rangeMode) {
         if (activeEditor && activeEditor.blockEl === blockEl) activeEditor = null;
+        setDirty(); // v3.17.2 B1: the box's typing is no longer unsaved work
         await safeRerenderAll();
         return;
       }
@@ -4265,6 +4307,7 @@
       // never stomp some OTHER block's activeEditor set after this one.
       if (activeEditor && activeEditor.blockEl === blockEl) activeEditor = null;
       blockEl.innerHTML = original;
+      setDirty(); // v3.17.2 B1: the box's typing is no longer unsaved work
       // No re-wiring needed here (unlike the old per-block gutter): block
       // selection / the edit bar are handled by ONE delegated `document`
       // click listener (see wireBlockSelection() below), so this
@@ -4460,7 +4503,9 @@
       return leave().then((ok) => { if (ok) handCaretOnBelow(tail); }).catch(showUnexpectedFailure);
     }
 
-    ta.addEventListener('input', () => autoSize(ta));
+    // v3.17.2 B1: setDirty() too, as the code edit and the diagram panel do
+    // (rawEditHasUncommittedText() is the predicate's half).
+    ta.addEventListener('input', () => { autoSize(ta); setDirty(); });
     ta.addEventListener('keydown', (e) => {
       if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
         e.preventDefault();
@@ -4807,7 +4852,8 @@
     const s = {
       blockEl, host, fence, lang: fence.info, body, source,
       blockId: rec.id, startLine: rec.startLine, endLine: rec.endLine,
-      history: new codeEditLib.TextHistory({ text: body, selStart: caret, selEnd: caret }),
+      history: carriedCodeEditHistory(o, body, caret) ||
+        new codeEditLib.TextHistory({ text: body, selStart: caret, selEnd: caret }),
       originalHtml: host.innerHTML, shown: null, timer: null, composing: false,
       plainOnly: true, inflight: null, listeners: new AbortController(), editor: null,
     };
@@ -4855,6 +4901,18 @@
     return true;
   }
 
+  // v3.17.2 B4 (v3.17.0 final review M1): the Ctrl+S / language re-entry
+  // hands the closing edit's own history to the one it opens, while the block
+  // holds exactly the text that history ends on. Measured before: type, Ctrl+S,
+  // and Ctrl+Z inside the reopened edit did nothing (a fresh history had
+  // nothing to step back to).
+  function carriedCodeEditHistory(o, body, caret) {
+    const h = o.history;
+    if (!h || o.historyText !== body) return null;
+    h.push({ text: body, selStart: caret, selEnd: caret });
+    return h;
+  }
+
   function codeEditSnapshot(s) {
     const text = codeEditText(s);
     const sel = codeEditSel(s);
@@ -5013,6 +5071,17 @@
     const caret = sel ? sel[0] : codeEditText(s).length;
     const startLine = s.startLine;
     if (opts.lang !== undefined) s.lang = codeEditLib.setFenceLang(s.lang, opts.lang);
+    const history = s.history;
+    const historyText = codeEditText(s);
+    // v3.17.2 B5 (v3.17.0 final review M2): the block opened again is the one
+    // this commit leaves at `startLine` — its lines read as what was written
+    // (or, unchanged, as what was there). An untouched "/" insert is
+    // discarded on save (R19), so nothing of its own is left to open, and the
+    // block that moved up into its line is someone else's. Measured before:
+    // Ctrl+S on the untouched insert opened the code block below it, and the
+    // next keys went into that block.
+    const discarding = !!(pristineInsert && pristineInsert.blockId === s.blockId) && !s.editor.hasChanges();
+    const reopenAs = [codeEditSnapshot(s).value, s.source];
     const hold = { keys: [], clickedAway: false };
     codeEditReenterHold = hold;
     let ok;
@@ -5023,9 +5092,11 @@
     }
     const keys = (opts.carry || []).concat(hold.keys);
     let target = liveCodeEdit() === s ? s : null;
-    if (!target && ok && !hold.clickedAway && s.lastResult !== RENDER_SUPERSEDED) {
+    if (!target && ok && !hold.clickedAway && s.lastResult !== RENDER_SUPERSEDED && !discarding) {
       const el = blockElAtLine(startLine);
-      if (el && await editCodeInPlace(el, { offset: caret, keepScroll: true })) target = liveCodeEdit();
+      const rec = el ? blockRecOf(el) : null;
+      const reads = rec && rec.endLine >= rec.startLine ? lines.slice(rec.startLine - 1, rec.endLine).join('\n') : null;
+      if (el && reopenAs.indexOf(reads) !== -1 && await editCodeInPlace(el, { offset: caret, keepScroll: true, history, historyText })) target = liveCodeEdit();
     }
     if (ok && opts.save) saveAfterLastSave();
     if (!target || hold.clickedAway) {
@@ -5378,7 +5449,7 @@
   // The CODE_LANGS entry id an info string resolves to ('' for none), or null
   // for a word the table does not know.
   function codeLangIdOf(info) {
-    const word = String(info || '').trim().split(/\s+/)[0].toLowerCase();
+    const word = codeEditLib.langWord(info).toLowerCase(); // v3.17.2 A2: an attribute is no language
     if (!word) return '';
     const hit = codeEditLib.CODE_LANGS.find((l) => (l.id && l.id === word) || l.aliases.indexOf(word) !== -1);
     return hit ? hit.id : null;
@@ -9857,7 +9928,7 @@
   }
 
   function typedInBurst(burst) {
-    if (burst.transient || burstBaselineHtml(burst.editEl) === burst.original) return null;
+    if (burst.transient || sameBurstHtml(burstBaselineHtml(burst.editEl), burst.original)) return null;
     burst.history.flushTyping();
     return { blockId: burst.blockId, text: burstCommitText(burst) };
   }
@@ -12242,6 +12313,56 @@
     return clone.innerHTML;
   }
 
+  // v3.17.2 A6: "is this surface edited?" asks this, never `===` on two
+  // burstBaselineHtml() strings. An inline style is markup any page script or
+  // extension may write on an editable element, and only two of its
+  // declarations are the document's: `text-align` (a column's alignment,
+  // renderer.table and setColumnAlign()) and the editor's own `--ed-*`
+  // custom properties. MEASURED before: Playwright's screenshot (caret
+  // 'hide') writes `style="caret-color: transparent !important;"` on every
+  // editable element and leaves `style=""` behind; with the caret in a table
+  // cell the status went dirty and leaving the cell committed the table
+  // through its serializer, rewriting `|a|b|` as `| a | b |`. The baseline
+  // strings themselves are untouched: burst histories restore them as HTML.
+  // An allow-list of the declarations that count, so a style nobody has
+  // thought about reads as not an edit only when it is a style; any other
+  // foreign attribute still counts, as before.
+  const BURST_KEPT_STYLE = /^(?:text-align|--ed-[\w-]+)$/;
+  const burstFingerprints = new Map();
+  function burstEditFingerprint(html) {
+    const hit = burstFingerprints.get(html);
+    if (hit !== undefined) return hit;
+    const tpl = document.createElement('template');
+    tpl.innerHTML = html;
+    Array.prototype.forEach.call(tpl.content.querySelectorAll('[style]'), (el) => {
+      const kept = [];
+      String(el.getAttribute('style')).split(';').forEach((decl) => {
+        const at = decl.indexOf(':');
+        if (at === -1) return;
+        const prop = decl.slice(0, at).trim();
+        const lower = prop.toLowerCase();
+        if (BURST_KEPT_STYLE.test(prop.indexOf('--') === 0 ? prop : lower)) {
+          kept.push((prop.indexOf('--') === 0 ? prop : lower) + ':' + decl.slice(at + 1).trim());
+        }
+      });
+      if (kept.length) el.setAttribute('style', kept.join(';'));
+      else el.removeAttribute('style');
+    });
+    const out = tpl.innerHTML;
+    if (burstFingerprints.size >= 4) burstFingerprints.clear();
+    burstFingerprints.set(html, out);
+    return out;
+  }
+  // Both sides go through the same parse and serialize whenever either holds
+  // a style, so a string the page serialized and one re-serialized here are
+  // never compared with each other.
+  function sameBurstHtml(a, b) {
+    if (a === b) return true;
+    if (typeof a !== 'string' || typeof b !== 'string') return false;
+    if (a.indexOf('style=') === -1 && b.indexOf('style=') === -1) return false;
+    return burstEditFingerprint(a) === burstEditFingerprint(b);
+  }
+
   function startBurst(editEl) {
     // v3.15.0 B5 fix round 4 (R86 (2)): never on a screen that is not `lines`.
     if (burstsLocked()) return;
@@ -12379,7 +12500,7 @@
     // `commitResult.op === null` no-op path below, without ever reaching
     // the serializer (and therefore without ever risking a canonicalizing
     // rewrite of untouched content).
-    if (burstBaselineHtml(burst.editEl) === burst.original) {
+    if (sameBurstHtml(burstBaselineHtml(burst.editEl), burst.original)) {
       endBurstWithoutResolve();
       // §10-gap fix (review): untouched AND was pristine — an ordinary
       // "insert ＋, click away without typing" changed-my-mind. Auto-remove
@@ -12645,6 +12766,29 @@
     return true;
   }
 
+  // v3.17.2 A3 (R65, v3.15.0 N5): does the emptied paragraph stand between
+  // two tight lists of the same kind? Then its removal joins them tight, as
+  // Notion does. Measured before: `- a\n\nMid.\n\n- b` with `Mid.` emptied
+  // became `- a\n\n- b`, one LOOSE list. A loose list on either side keeps
+  // the blank line (the joined list is loose either way, and its spacing is
+  // the user's); lists of different kinds stay two lists however they are
+  // spaced, so they keep it too.
+  function emptiedParagraphJoinsLists(rec, above) {
+    const below = blocks.find((b) => b.startLine > rec.endLine) || null;
+    if (!above || !below) return false;
+    const upEl = blockElById(above.id);
+    const downEl = blockElById(below.id);
+    if (!upEl || !downEl || upEl.getAttribute('data-block-type') !== 'li' ||
+        downEl.getAttribute('data-block-type') !== 'li') return false;
+    const up = listRunOf(upEl);
+    const down = listRunOf(downEl);
+    if (!up.length || !down.length) return false;
+    if (up.concat(down).some((el) => el.getAttribute('data-list-loose') === '1')) return false;
+    const a = blockRecOf(up[0]);
+    const b = blockRecOf(down[0]);
+    return !!a && !!b && sameListKind(lines[a.startLine - 1], lines[b.startLine - 1]);
+  }
+
   // R95: the emptied paragraph's removal, one op. Same failure contract as the
   // paragraph commit below: a failed render rolls the op back and leaves the
   // burst open. When focus is still inside (Ctrl+S, a toolbar press) a
@@ -12655,7 +12799,9 @@
     if (!rec) { endBurstWithoutResolve(); return true; }
     const focusInside = burst.blockEl.contains(document.activeElement);
     const preceding = blocks.filter((b) => b.id !== rec.id && b.endLine < rec.startLine).pop() || null;
-    const result = commitRangeRemoval({ lines, blocks, stack }, rec.startLine, rec.endLine);
+    const result = emptiedParagraphJoinsLists(rec, preceding)
+      ? commitTightRemoval({ lines, blocks, stack }, rec.startLine, rec.endLine)
+      : commitRangeRemoval({ lines, blocks, stack }, rec.startLine, rec.endLine);
     if (result.op === null) { endBurstWithoutResolve(); return true; }
     const prevLines = lines;
     lines = result.lines;
@@ -13508,7 +13654,7 @@
   //    here too.
   function bystanderCarryOver(span, mutatedEl) {
     const dirtyId = (currentBurst && currentBurst.editEl &&
-      burstBaselineHtml(currentBurst.editEl) !== currentBurst.original)
+      !sameBurstHtml(burstBaselineHtml(currentBurst.editEl), currentBurst.original))
       ? String(currentBurst.blockId) : null;
     const out = {};
     let any = false;
@@ -13935,7 +14081,7 @@
     const d = discardedBurst;
     discardedBurst = null;
     if (!d) return false;
-    if (!document.body.contains(d.editEl) || burstBaselineHtml(d.editEl) !== d.reverted) {
+    if (!document.body.contains(d.editEl) || !sameBurstHtml(burstBaselineHtml(d.editEl), d.reverted)) {
       d.history.dispose();
       return false;
     }
@@ -14035,6 +14181,24 @@
     }
     const blockEl = blockElById(d.blockId);
     if (!blockEl) return false;
+    // v3.17.2 B3 (R75): a diagram panel's Esc opens the panel again, with
+    // what was typed and the preview it had, so the edit goes on where it
+    // stopped. Measured before: the raw box over the whole fence, no preview.
+    // A panel that does not open (the block no longer reads as that diagram)
+    // falls back to the raw box below.
+    if (d.diagram) {
+      const opened = await openDiagramPanel(blockEl, { kind: d.diagram.kind, seed: {
+        value: d.diagram.value, selStart: d.diagram.selStart, selEnd: d.diagram.selEnd,
+        previewHtml: d.diagram.previewHtml } });
+      const live = blockElById(d.blockId);
+      const panel = liveDiagramPanel();
+      if (opened && panel && live && panel.blockEl === live) {
+        scheduleDiagramPreview(panel);
+        setDirty();
+        return true;
+      }
+      if (!live || live.querySelector('.ed-diagram-panel')) return false;
+    }
     await openRawEditor(blockEl, d.range);
     // Re-queried rather than reusing `blockEl` above: openRawEditor()'s own
     // guard may have resolved a DIFFERENT open session first (switchAwayFrom()),
@@ -14122,7 +14286,7 @@
     // to resolve — nothing can change either condition between this check
     // and that resolution running.
     const willAutoRemove = !!(pristineInsert && pristineInsert.blockId === burst.blockId &&
-      burstBaselineHtml(burst.editEl) === burst.original);
+      sameBurstHtml(burstBaselineHtml(burst.editEl), burst.original));
     switchAwayFrom().then((ok) => { if (ok && !willAutoRemove) undo(); });
   }
 
@@ -15240,7 +15404,7 @@
   async function liBackspaceStructure(li) {
     const burst = currentBurst;
     if (burst && burst.blockType === 'li' && burst.blockEl === li &&
-        burstBaselineHtml(burst.editEl) !== burst.original) {
+        !sameBurstHtml(burstBaselineHtml(burst.editEl), burst.original)) {
       const rec = blockRecOf(li);
       if (!rec) return;
       if (!(await switchAwayFrom())) return;
@@ -16553,7 +16717,7 @@
     // auto-remove an untouched pristine table insert, so a chained undo()
     // must be skipped or it cascades one op too far.
     const willAutoRemove = !!(pristineInsert && pristineInsert.blockId === burst.blockId &&
-      burstBaselineHtml(tableEl) === burst.original);
+      sameBurstHtml(burstBaselineHtml(tableEl), burst.original));
     switchAwayFrom().then((ok) => { if (ok && !willAutoRemove) undo(); });
   }
 
@@ -21623,10 +21787,19 @@
   let saveGen = 0;
   let savesInFlight = 0;
   let lastSave = null; // v3.17.0 T9b: the newest save's round trip (saveAfterLastSave())
+  // v3.17.2 B2 (R66): every save goes out after the one before it has
+  // answered, never alongside it. Sent alongside, it carried the baseline
+  // the first reply was about to replace, the server answered 409 (sendSave()
+  // says why) and the conflict card went up over a file this page had just
+  // saved. MEASURED before: two Ctrl+S 50 ms apart with a slow reply — saves
+  // [200, 409], status failed, the conflict card up. The queued save reads
+  // `lines` and `mtimeMs` when it is sent, so it saves whatever is on screen
+  // by then, against the baseline the first reply left.
   async function save() {
     saveGen++;
     savesInFlight++;
-    const sending = sendSave();
+    const prev = lastSave;
+    const sending = (prev ? prev.then(() => {}, () => {}) : Promise.resolve()).then(() => sendSave());
     lastSave = sending;
     try { return await sending; } finally { savesInFlight--; }
   }
@@ -21730,22 +21903,15 @@
     if (ok) return save();
   }
 
-  // v3.17.0 T9b: a save asked for while an earlier one may still be on its
-  // way — a Ctrl+S held through a code edit's or diagram panel's re-entry, a
-  // second Ctrl+S while the first one's resolution is out — is sent once that
-  // one has answered. Sent alongside it, its request carried the baseline the
-  // first reply was about to replace, the server answered 409 (sendSave()'s
-  // note says why) and the conflict card went up over a file this page had
-  // just saved. A queue in the caller, not a lock in sendSave(): those callers
-  // asked for their save while the first was not even sent yet, whereas a
-  // Ctrl+S pressed on its own while a save is out still sends at once
-  // (test/editor-journey.test.js's N5-two-saves drives that path), and no
-  // save waits behind a request that never answers unless it was queued here.
+  // v3.17.0 T9b added this queue for the callers that ask for a save while an
+  // earlier one may still be on its way (a Ctrl+S held through a code edit's
+  // or diagram panel's re-entry, a second Ctrl+S while the first one's
+  // resolution is out). v3.17.2 B2 moved the queue into save() itself, so a
+  // Ctrl+S pressed on its own while a save is out waits too (EJ
+  // N5-two-saves); this is save() under the name those callers use. A save
+  // queued behind a request that never answers waits with it.
   function saveAfterLastSave() {
-    const prev = lastSave;
-    const next = (prev ? prev.then(() => {}, () => {}) : Promise.resolve()).then(() => save());
-    lastSave = next;
-    return next;
+    return save();
   }
 
   // v3.4.0 §3: the save button's own caret rescue. commitThenSave() above
@@ -26341,7 +26507,12 @@
     if (wasPristine) pristineInsert = null;
     if (!wasPristine && s.ta.value !== s.body) {
       dropDiscardedBurst();
-      discardedRawEdit = diagramPanelSnapshot(s);
+      // v3.17.2 B3 (R75): plus what the panel needs to open again on it
+      // (restoreDiscardedRawEdit()); the raw-box shape stays the fallback.
+      discardedRawEdit = Object.assign(diagramPanelSnapshot(s), { diagram: {
+        kind: s.kind, value: s.ta.value, selStart: s.ta.selectionStart, selEnd: s.ta.selectionEnd,
+        previewHtml: s.preview.innerHTML,
+      } });
     }
     endDiagramPanelVisual(s);
     if (wasPristine) return await discardPristineInsert();

package/lib/editor/code-edit.js

@@ -34,10 +34,18 @@ function firstWord(info) {
   return String(info || '').trim().split(/\s+/)[0] || '';
 }
 
-// The chip's text for a fence info string: the first word's language name,
-// aliases resolved; empty is 純文字; an unknown word is shown as written.
+// v3.17.2 A2 (R53): the info string's language word — its first word, unless
+// that word holds `=`: then it is an attribute (`title="a"`), and the fence
+// has no language. '' when there is none.
+function langWord(info) {
+  const w = firstWord(info);
+  return w.indexOf('=') === -1 ? w : '';
+}
+
+// The chip's text for a fence info string: the language word's name, aliases
+// resolved; none is 純文字; an unknown word is shown as written.
 function langLabel(info) {
-  const word = firstWord(info);
+  const word = langWord(info);
   if (!word) return '純文字';
   const w = word.toLowerCase();
   for (const l of CODE_LANGS) {
@@ -55,12 +63,16 @@ function filterLangs(query) {
     l.aliases.some((a) => a.indexOf(q) === 0));
 }
 
-// Replace the info string's first word; '' removes it. The other words are
-// kept, single-spaced.
+// Replace the info string's language word; '' removes it. What follows it
+// is kept as written (v3.17.2 A2: a quoted value's inner spaces included;
+// before, the words were re-joined single-spaced). An info string with no
+// language word (empty, or starting with an attribute) gets `lang` in front.
 function setFenceLang(info, lang) {
-  const words = String(info || '').trim().split(/\s+/).filter(Boolean);
-  const rest = words.slice(1);
-  return (lang ? [lang].concat(rest) : rest).join(' ');
+  const t = String(info || '').trim();
+  const word = langWord(t);
+  const rest = word ? t.slice(word.length).replace(/^\s+/, '') : t;
+  if (!lang) return rest;
+  return rest ? lang + ' ' + rest : lang;
 }
 
 // blockLines[0] must open a fence (up to 3 spaces, then 3+ backticks or
@@ -179,6 +191,6 @@ class TextHistory {
   }
 }
 
-return { CODE_LANGS, langLabel, filterLangs, parseFence, buildFence, setFenceLang,
+return { CODE_LANGS, langWord, langLabel, filterLangs, parseFence, buildFence, setFenceLang,
   newlineWithIndent, indentLines, TextHistory };
 });

package/lib/editor/wave-codec.js

@@ -2503,9 +2503,11 @@ function sameLane(a, b) {
  * Paint one cycle of one lane, addressed by display index.
  *
  * `ch` is a single character: a level, a value character, `|` for a gap, or `.`
- * to make the cycle continue the one in front of it. Anything else — a longer
- * string, a cycle outside the lane, a `.` or `|` at cycle 0 where there is
- * nothing to continue or to draw over — answers the doc unchanged.
+ * to make the cycle continue the one in front of it. A cycle past the lane's
+ * end grows the lane first, continuing its last level up to that cycle (see
+ * `paint`). Anything else — a longer string, a negative or fractional cycle, a
+ * `.` or `|` at cycle 0 where there is nothing to continue or to draw over —
+ * answers the doc unchanged.
  *
  * A newly painted value cell keeps the label of the value cell it replaced and
  * otherwise starts blank; a cell painted with something that is not a value
@@ -2542,12 +2544,20 @@ function paint(doc, laneIndex, from, to, ch, asRun) {
       lo = hi;
       hi = swap;
     }
-    if (!isIndex(lo, n) || !isIndex(hi, n)) return null;
+    if (lo < 0) return null;
     // A repeater at cycle 0 has nothing to repeat, and the engine answers that
     // by drawing the run and the cycle after it as x. Refusing is the honest
     // reply to a brush that cannot mean anything where it was aimed.
     if (lo === 0 && (ch === HELD_CHAR || ch === GAP_CHAR)) return null;
-    const anchored = anchorAfter(model.cells, hi);
+    // Past the lane's end: continue its last level up to `hi` first, then
+    // paint. A lane shorter than the diagram is ordinary (新增訊號 writes one
+    // cycle, hand-written lanes differ in length) and the editor's grid is as
+    // wide as the whole diagram, so `geometry.cellAt` hands out these cells on
+    // purpose; refusing them here left every click past a short lane's end
+    // silently doing nothing. How far past is bounded by the caller (the
+    // grid), not here.
+    const grown = hi < n ? model.cells : model.cells.concat(fillerCells(model.cells, n, hi + 1 - n));
+    const anchored = anchorAfter(grown, hi);
     const before = resolveCells(anchored);
     const heldLevel = lo > 0 ? before.levels[lo - 1] : '';
     const cells = anchored.slice();

package/lib/editor/wave-ui.js

@@ -1690,6 +1690,14 @@
       if (added) notify('notice', lead + where);
       return added;
     }
+    /** The lane 新增訊號 writes: `x` across the whole diagram, not one cycle
+     *  of it. A one-cycle lane draws a single x and then nothing, which read
+     *  as a broken signal (user report 2026-10-28), and every cycle after it
+     *  had to be grown by painting before it showed anything. */
+    function newSignalLane() {
+      const cycles = layoutNow().cycles;
+      return { name: '', wave: 'x' + '.'.repeat(Math.max(0, cycles - 1)) };
+    }
     function addLaneFromToolbar(name, lane) {
       addLaneAt(signalInsertAt(), name, lane);
     }
@@ -1705,7 +1713,7 @@
       const el = panels.menu('ed-wave-signal-pop', [
         { key: 'ed-wave-signal-add', label: '新增訊號',
           title: '在選取的 lane 後面加一條（沒有選取就加在最前面）—— 會落在' + where,
-          run: function () { closePopover(true); addLaneFromToolbar('add-lane', { name: '', wave: 'x' }); } },
+          run: function () { closePopover(true); addLaneFromToolbar('add-lane', newSignalLane()); } },
         { key: 'ed-wave-signal-blank', label: '新增空白列',
           title: '在選取的 lane 後面插入一個空白列（WaveJSON 的 {}，用來空出間距）—— 會落在' + where,
           run: function () { closePopover(true); addLaneFromToolbar('add-spacer', {}); } },
@@ -1950,7 +1958,7 @@
         const row = layoutNow().lanes[i];
         const actions = {
           copy: picked(function () { duplicateLaneAt(i); }),
-          addBelow: picked(function () { addLaneAt(i + 1, 'add-lane', { name: '', wave: 'x' }); }),
+          addBelow: picked(function () { addLaneAt(i + 1, 'add-lane', newSignalLane()); }),
           blankBelow: picked(function () { addLaneAt(i + 1, 'add-spacer', {}); }),
           up: picked(function () { moveLaneBy(i, -1); }),
           down: picked(function () { moveLaneBy(i, 1); }),
@@ -2473,7 +2481,7 @@
     // signal at the end — the one insert position the ⠿ menus (which add
     // BELOW a row) and 訊號 (after the selection) do not make obvious.
     panels.toolButton('ed-wave-add-lane', '＋ 新增訊號', '在最後面加一條訊號', function () {
-      addLaneAt(layoutNow().lanes.length, 'add-lane', { name: '', wave: 'x' });
+      addLaneAt(layoutNow().lanes.length, 'add-lane', newSignalLane());
     }, stage);
     // One canvas per editor session (spec §3.2); `close()` destroys it.
     engineCanvas = opts.canvas.createCanvas({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helping-ai-workflow/md2doc",
-  "version": "3.17.0",
+  "version": "3.17.2",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, Graphviz, and draw.io support",
   "keywords": [
     "markdown",