dsh-paste-code-block 0.1.2 → 0.2.5

package/src/client.js

@@ -94,8 +94,8 @@ window.__ModuleLoader__.load({
     const NS = 'paste-code-block'
     const L10N = {
       zh: {
-        'block.code': '复制代码块{n}',
-        'block.text': '复制文本块{n}',
+        'block.code': '代码块 {n}',
+        'block.text': '文本块 {n}',
         'detail.aria': '代码块详情',
         'slot.label': '粘贴代码块详情',
         'lines.one': '{count} 行',
@@ -109,10 +109,13 @@ window.__ModuleLoader__.load({
         'edit.aria': '编辑代码块内容',
         'error.stale': '代码块已失效，请重新粘贴',
         'error.remove': '无法删除该块，请重试',
+        'fold.code': '代码块',
+        'fold.text': '文本块',
+        'fold.aria': '展开或折叠该块',
       },
       en: {
-        'block.code': 'Code block #{n}',
-        'block.text': 'Text block #{n}',
+        'block.code': 'Code #{n}',
+        'block.text': 'Text #{n}',
         'detail.aria': 'Block details',
         'slot.label': 'Pasted block details',
         'lines.one': '{count} line',
@@ -126,6 +129,9 @@ window.__ModuleLoader__.load({
         'edit.aria': 'Edit block content',
         'error.stale': 'This block is no longer valid — paste it again',
         'error.remove': 'Could not remove the block — please retry',
+        'fold.code': 'Code',
+        'fold.text': 'Text',
+        'fold.aria': 'Expand or collapse this block',
       },
     }
 
@@ -138,6 +144,13 @@ window.__ModuleLoader__.load({
       }
     }
 
+    // Sent-message fold card title (embedded copy of src/i18n.js#foldTitle).
+    function foldTitle(t, type, lang, lines) {
+      const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
+      const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
+      return `${name} · ${meta}`
+    }
+
     function detectBrowserLocale() {
       try {
         const langs = [...(navigator.languages || []), navigator.language].filter(Boolean).map((l) => String(l).toLowerCase())
@@ -147,15 +160,22 @@ window.__ModuleLoader__.load({
       }
     }
 
+    // Pre-0.1.3 chip labels: no longer rendered, still recognized (see below).
+    const LEGACY_L10N = {
+      zh: { 'block.code': '复制代码块{n}', 'block.text': '复制文本块{n}' },
+      en: { 'block.code': 'Code block #{n}', 'block.text': 'Text block #{n}' },
+    }
+
     /**
-     * Recognize a rendered block label in ANY shipped locale and recover its
-     * `{ type, n }` identity — this keeps chip clicks, ✕ deletes, and the
-     * locale-switch retitling correct even for chips inserted under a
-     * different language than the one currently active. Null otherwise.
+     * Recognize a rendered block label in ANY shipped locale (or a pre-0.1.3
+     * legacy locale) and recover its `{ type, n }` identity — this keeps chip
+     * clicks, ✕ deletes, and the locale-switch retitling correct even for
+     * chips inserted under a different language than the one currently
+     * active. Null otherwise.
      */
     function parseBlockLabel(text) {
       if (!text) return null
-      for (const dict of [L10N.zh, L10N.en]) {
+      for (const dict of [L10N.zh, L10N.en, LEGACY_L10N.zh, LEGACY_L10N.en]) {
         for (const key of ['block.code', 'block.text']) {
           const pattern = new RegExp(
             '^' +
@@ -201,8 +221,8 @@ window.__ModuleLoader__.load({
     /**
      * Parse pasted text into a block, or null when it is ordinary short prose
      * that should paste plainly. `isCode` drives both the chip label
-     * (i18n key `block.code` vs `block.text`, e.g. "复制代码块N" / "Code block
-     * #N") and the fenced language on send.
+     * (i18n key `block.code` vs `block.text`, e.g. "代码块 N" / "Code #N")
+     * and the fenced language on send.
      */
     function parseBlock(raw) {
       const text = String(raw || '').replace(/^\uFEFF/, '')
@@ -262,6 +282,134 @@ window.__ModuleLoader__.load({
       return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
     }
 
+    // ----- fence segmentation (embedded copy of src/parse.js) ----------------
+    // Split a message text into ordered prose/fence segments (GFM-style ``` or
+    // ~~~ fences, opener indented <=3 spaces, closer >= opener length alone on
+    // its line). Unterminated openers stay prose. Keep in sync with parse.js.
+    function splitFencedSegments(text) {
+      const src = String(text == null ? '' : text)
+      if (!src) return []
+      const lines = src.split(/\r?\n/)
+      const segments = []
+      const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+      let proseStart = 0
+      let i = 0
+      const flushProse = (end) => {
+        if (end > proseStart) segments.push({ kind: 'prose', text: lines.slice(proseStart, end).join('\n') })
+      }
+      while (i < lines.length) {
+        const m = OPEN.exec(lines[i])
+        if (!m) { i += 1; continue }
+        const marker = m[1]
+        const ch = marker[0]
+        const info = m[2].trim()
+        if (ch === '`' && info.includes('`')) { i += 1; continue }
+        const closeRe = new RegExp('^ {0,3}' + (ch === '`' ? '`' : '~') + '{' + marker.length + ',}[ \\t]*$')
+        let j = i + 1
+        let closed = false
+        while (j < lines.length) {
+          if (closeRe.test(lines[j])) { closed = true; break }
+          j += 1
+        }
+        if (!closed) { i += 1; continue }
+        flushProse(i)
+        const bodyLines = lines.slice(i + 1, j)
+        segments.push({
+          kind: 'fence',
+          lang: info ? info.split(/\s+/)[0] : '',
+          info,
+          body: bodyLines.join('\n'),
+          raw: lines.slice(i, j + 1).join('\n'),
+        })
+        i = j + 1
+        proseStart = i
+      }
+      flushProse(lines.length)
+      return segments
+    }
+
+    // ===== Recovery mirror (draft re-seed after workspace switch / reload) ===
+    // DSH persists a session's composer draft as PLAIN TEXT
+    // (`dsh.conversation.<sid>` in localStorage) and re-seeds the editor from
+    // it — but Lexical chip nodes cannot round-trip through text (design.md
+    // §7), so switching workspaces mid-draft left every pasted block behind:
+    // the seeded draft keeps only one invisible U+200B per lost chip. The
+    // plugin therefore mirrors its block CONTENT to localStorage itself and
+    // re-attaches the chips when it recognizes that stray-ZWSP signature
+    // (BlockDock mount effect → BlockController.recover). Intentional chip
+    // deletion removes the ZWSPs along with the nodes, so it never looks
+    // like a re-seed; the mirror clears itself on send and once no blocks
+    // remain, and stale entries expire after two weeks.
+    const RECOVERY_PREFIX = 'dsh-pcb-recovery.'
+    const RECOVERY_TTL_MS = 14 * 24 * 60 * 60 * 1000
+    const RECOVERY_MAX_CHARS = 3_000_000
+    const RECOVERY_MAX_DRAFT = 200_000
+
+    function recoverySave(sid, blocks, draftText) {
+      const key = RECOVERY_PREFIX + sid
+      try {
+        if (!blocks || blocks.length === 0) { localStorage.removeItem(key); return }
+        const draft = typeof draftText === 'string' && draftText.length <= RECOVERY_MAX_DRAFT ? draftText : ''
+        const json = JSON.stringify({ at: Date.now(), draft, blocks })
+        if (json.length > RECOVERY_MAX_CHARS) { console.warn('[dsh-pcb] draft too large to mirror; chips will not survive a reload'); return }
+        localStorage.setItem(key, json)
+      } catch (e) { /* quota / private mode: best effort */ }
+    }
+
+    function recoveryLoad(sid) {
+      const key = RECOVERY_PREFIX + sid
+      try {
+        const raw = localStorage.getItem(key)
+        if (!raw) return null
+        let data = null
+        try { data = JSON.parse(raw) } catch (e) { data = null }
+        if (!data || typeof data.at !== 'number' || Date.now() - data.at > RECOVERY_TTL_MS) { localStorage.removeItem(key); return null }
+        return data
+      } catch (e) { return null }
+    }
+
+    function recoveryClear(sid) {
+      try { localStorage.removeItem(RECOVERY_PREFIX + sid) } catch (e) { /* noop */ }
+    }
+
+    /**
+     * Mirror-side carry-over donor: a store whose mirrored draft matches the
+     * re-seeded one exactly and still holds blocks (after a page reload there
+     * is no live memory to match against). Returns { sid, blocks } on a
+     * UNIQUE match, null when absent or ambiguous.
+     */
+    function recoveryScanDonor(targetSid, draft) {
+      try {
+        let hit = null
+        for (let i = 0; i < localStorage.length; i += 1) {
+          const key = localStorage.key(i)
+          if (!key || !key.startsWith(RECOVERY_PREFIX)) continue
+          const sid = key.slice(RECOVERY_PREFIX.length)
+          if (sid === targetSid) continue
+          const data = recoveryLoad(sid)
+          if (!data || data.draft !== draft || !Array.isArray(data.blocks)) continue
+          if (!data.blocks.some((b) => b && typeof b.content === 'string' && b.content !== '')) continue
+          if (hit) return null // ambiguous — refuse to guess
+          hit = { sid, blocks: data.blocks }
+        }
+        return hit
+      } catch (e) { return null }
+    }
+
+    function recoveryPruneExpired() {
+      try {
+        const doomed = []
+        for (let i = 0; i < localStorage.length; i += 1) {
+          const k = localStorage.key(i)
+          if (!k || !k.startsWith(RECOVERY_PREFIX)) continue
+          let at = 0
+          try { at = (JSON.parse(localStorage.getItem(k) || '{}').at) || 0 } catch (e) { /* fall through */ }
+          if (!at || Date.now() - at > RECOVERY_TTL_MS) doomed.push(k)
+        }
+        for (const k of doomed) localStorage.removeItem(k)
+      } catch (e) { /* noop */ }
+    }
+
     // ===== Draft controller ==================================================
     class BlockController {
       /**
@@ -282,6 +430,8 @@ window.__ModuleLoader__.load({
         this.expiry = new Map()
         this.serializing = new Set()
         this.listeners = new Map()
+        this.recoverTimer = new Map() // sid -> debounce handle for the recovery mirror
+        this.lastInput = new Map() // sid -> draft text seen by the last recover() pass
         this.counter = 0
       }
 
@@ -438,6 +588,16 @@ window.__ModuleLoader__.load({
         this.refIndex.set(block.id, { sessionId: k, block })
         this.labelIndex.set(block.label, block.id)
         this.publish(sessionId)
+        // The shell just rewrote the draft (chip + placeholder char); until
+        // the next dock pass runs, this is the session's ground truth. Keep
+        // the typing-window fingerprint and the carry-over donor match fresh
+        // so the pass right after a paste cannot mistake the new draft for a
+        // rebuild.
+        try {
+          const after = this.scope(k).shell.snapshot
+          if (after && typeof after.draft === 'string') this.lastInput.set(k, after.draft)
+        } catch (e) { /* session vanished — the next pass re-observes */ }
+        this.mirrorNow(k) // attach is a key moment — persist synchronously
         return true
       }
 
@@ -563,6 +723,7 @@ window.__ModuleLoader__.load({
         for (const [label, r] of this.labelIndex) if (r === ref) this.labelIndex.delete(label)
         this.freeLabel(sessionId, entry.type, entry.labelNumber)
         this.publish(sessionId)
+        this.mirror(k)
       }
 
       /** Update a block's content while editing it in the detail card. */
@@ -571,23 +732,31 @@ window.__ModuleLoader__.load({
         if (!record) return
         record.block.content = content
         record.block.lines = content.split(/\r?\n/)
+        this.mirror(record.sessionId)
       }
 
       clearInFlight(sessionId) {
         const k = String(sessionId)
         const expiry = this.expiry.get(k)
         if (expiry) { clearTimeout(expiry); this.expiry.delete(k) }
+        const had = this.inFlight.has(k)
         for (const b of this.inFlight.get(k) || []) {
           this.refIndex.delete(b.id)
           this.freeLabel(sessionId, b.type, b.labelNumber)
           for (const [label, r] of this.labelIndex) if (r === b.id) this.labelIndex.delete(label)
         }
         this.inFlight.delete(k)
+        if (had) this.mirrorNow(k)
       }
 
       markSerializing(ref) {
         const record = this.refIndex.get(ref)
-        if (record && !this.serializing.has(record.sessionId)) this.serializing.add(record.sessionId)
+        if (record && !this.serializing.has(record.sessionId)) {
+          this.serializing.add(record.sessionId)
+          // A send is starting: the content leaves the draft, the mirror may go.
+          // (A failed send re-mirrors via restoreFailed.)
+          recoveryClear(record.sessionId)
+        }
       }
 
       async serialize(ref) {
@@ -633,6 +802,12 @@ window.__ModuleLoader__.load({
         if (next.length > 0) this.list.set(k, next)
         else this.list.delete(k)
         this.publish(sessionId)
+        // Hand-deletion is final. Persist the pruned state synchronously so a
+        // later reload/carry-over cannot resurrect a deleted chip from a
+        // mirror the draft has already outlived — and so the recovery
+        // restore-path can never fire off invisible external residue once the
+        // list for this session is empty.
+        this.mirrorNow(k)
       }
 
       restoreFailed(sessionId) {
@@ -654,10 +829,168 @@ window.__ModuleLoader__.load({
         }
         if (survived.length) this.list.set(k, [...this.listFor(k), ...survived])
         this.publish(sessionId)
+        if (survived.length) this.mirror(k)
+      }
+
+      // ----- recovery mirror -------------------------------------------------
+      /** Debounced persistence of the session's current block payloads. */
+      mirror(sessionId) {
+        const k = String(sessionId)
+        const prev = this.recoverTimer.get(k)
+        if (prev) clearTimeout(prev)
+        this.recoverTimer.set(k, setTimeout(() => {
+          this.recoverTimer.delete(k)
+          this.mirrorNow(k)
+        }, 250))
+      }
+
+      mirrorNow(sessionId) {
+        const k = String(sessionId)
+        const t = this.recoverTimer.get(k)
+        if (t) { clearTimeout(t); this.recoverTimer.delete(k) }
+        recoverySave(k, this.listFor(k).map((b) => ({ isCode: !!b.isCode, lang: b.lang || '', content: b.content, src: b.sourceText || '' })), this.lastInput.get(k))
+      }
+
+      /**
+       * Restore the chips a text-only draft rebuild dropped. Two DSH paths
+       * strand them: (a) the persisted per-session draft re-seeds the composer
+       * after a page reload, and (b) a workspace switch on the new-session
+       * page CARRIES the draft plain-text to the target workspace's blank
+       * session (inputHub: next.setDraft(from.snapshot.draft)) — the chips,
+       * which are Lexical nodes plus controller state, never move. Both leave
+       * the same signature: stray U+200Bs (every chip contributes exactly one,
+       * and removing a chip removes its ZWSP too) with no live occurrence of
+       * ours. Deliberate deletion therefore never looks like a rebuild; and a
+       * carry-over is matched to its donor by the exact draft the donor last
+       * published — unique match only, no guessing. Blocks come from memory
+       * first (same tab), then this session's mirror, then the donor's memory
+       * or mirror. A stray U+200B that belongs to NO restorable block is
+       * ordinary invisible copy from an external app (WeChat, web pages):
+       * never restorable, cosmetic — it is left exactly where the user put
+       * it. Sweeping it used to rewrite the whole draft mid-typing and is
+       * retired in 0.2.2 (see the typing-window guard below).
+       *
+       * @param sessionId - session whose composer just (re)mounted.
+       * @param snapshot - live input state ({draft, occurrences, phase}).
+       * @returns whether the draft was rewritten by a real restore.
+       */
+      recover(sessionId, snapshot) {
+        const k = String(sessionId)
+        if (!snapshot || typeof snapshot.draft !== 'string') return false
+        const prior = this.lastInput.get(k)
+        this.lastInput.set(k, snapshot.draft)
+        if (this.serializing.has(k)) return false
+        if (snapshot.phase && snapshot.phase !== 'plain') return false
+        if ((snapshot.occurrences || []).some((o) => o.source === SOURCE)) return false
+        const draft = snapshot.draft
+        const strays = (draft.match(/\u200B/g) || []).length
+        if (strays === 0) return false
+        // Typing-window guard. Every committed keystroke re-runs this pass, so
+        // a draft that MOVED since the pass before it is live typing, not a
+        // text-only re-seed — and a real restore rewrites the whole document
+        // via setDraft: caret to the end, chips re-appended, an in-flight IME
+        // composition destroyed (0.2.2 bug: the first character typed was
+        // eaten and the view bounced once, again and again). Only a draft
+        // IDENTICAL to the last one observed for this session — or one this
+        // page view has never seen, or only ever saw the composer hydrate
+        // through while empty (fresh-boot re-seed) — can carry the rebuild
+        // signature. The empty-prior escape is sealed from the other side by
+        // reconcile pruning synchronously dropping the mirror: with nothing
+        // restorable on record, a moved-from-empty pass restores nothing.
+        if (prior && prior !== draft) return false
+        let shell
+        try {
+          shell = this.scope(k).shell
+        } catch (e) { return false } // session not ready yet — a later pass retries
+        const usable = (arr) => Array.isArray(arr)
+          ? arr.filter((b) => b && typeof b.content === 'string' && b.content !== '')
+          : []
+        let sources = usable(this.listFor(k))
+        let origin = sources.length ? 'memory' : null
+        let donor = null
+        if (!sources.length) {
+          const saved = recoveryLoad(k)
+          sources = usable(saved && saved.blocks)
+          if (sources.length) origin = 'mirror'
+        }
+        if (!sources.length) {
+          donor = this.findCarryoverSource(k, draft)
+          if (donor) {
+            sources = usable(this.listFor(donor))
+            origin = 'carry-over (live)'
+          }
+        }
+        if (!sources.length) {
+          const scanned = recoveryScanDonor(k, draft)
+          if (scanned && scanned.blocks.length) {
+            donor = scanned.sid
+            sources = usable(scanned.blocks)
+            origin = 'carry-over (mirror)'
+          }
+        }
+        if (sources.length === 0) {
+          // Nothing to restore — invisible external residue (or the residue of
+          // a deliberately deleted chip whose node already carries none of our
+          // state). NEVER rewrite the draft for it: rewriting drops the caret,
+          // destroys an in-flight IME composition and re-seeds stale text over
+          // whatever the user typed in the meantime (0.2.2).
+          return false
+        }
+        try {
+          shell.setDraft(draft.replace(/\u200B/g, ''))
+        } catch (e) {
+          console.warn('[dsh-pcb] recovery: draft rewrite failed', e)
+          return false
+        }
+        // The draft — and with it the blocks — now belongs to this session:
+        // forget the (possibly moved) bookkeeping; attach() re-derives ids,
+        // labels and numbers, and re-mirrors under this sid.
+        this.forgetSession(k)
+        if (donor) {
+          this.forgetSession(donor)
+          recoveryClear(donor)
+          this.lastInput.delete(donor)
+        }
+        let restored = 0
+        for (const b of sources) {
+          const block = { lang: b.lang || '', content: b.content, lines: b.content.split(/\r?\n/), isCode: !!b.isCode, sourceText: b.sourceText || (typeof b.src === 'string' && b.src ? b.src : undefined) }
+          if (this.attach(k, block)) restored += 1
+        }
+        console.log('[dsh-pcb] recovery: re-attached', restored, 'of', sources.length, 'block(s) via', origin, donor ? `(donor ${donor})` : '')
+        return restored > 0
+      }
+
+      /** Unmounted session that still lists blocks and last published EXACTLY this draft. */
+      findCarryoverSource(targetSid, draft) {
+        let found = null
+        for (const [x, entries] of this.list) {
+          if (x === targetSid || entries.length === 0) continue
+          if (this.serializing.has(x)) continue
+          const listeners = this.listeners.get(x)
+          if (listeners && listeners.size > 0) continue // still mounted — draft did not move
+          if (this.lastInput.get(x) !== draft) continue
+          if (found) return null // ambiguous
+          found = x
+        }
+        return found
+      }
+
+      /** Drop a session's block bookkeeping (its chips are gone or moving). */
+      forgetSession(sessionId) {
+        const k = String(sessionId)
+        for (const b of this.listFor(k)) {
+          this.freeLabel(k, b.type, b.labelNumber)
+          this.refIndex.delete(b.id)
+          for (const [label, r] of this.labelIndex) if (r === b.id) this.labelIndex.delete(label)
+        }
+        this.list.delete(k)
+        this.selected.delete(k)
       }
 
       dispose() {
         for (const t of this.expiry.values()) clearTimeout(t)
+        for (const t of this.recoverTimer.values()) clearTimeout(t)
+        this.recoverTimer.clear()
         this.expiry.clear(); this.list.clear(); this.selected.clear()
         this.used.clear(); this.refIndex.clear(); this.labelIndex.clear()
         this.inFlight.clear(); this.serializing.clear(); this.listeners.clear()
@@ -720,6 +1053,12 @@ window.__ModuleLoader__.load({
       useComposerMark(railRef, props.sessionId, input.draftRev, blocks.length > 0)
 
       React.useEffect(() => {
+        // Recognize a text-only draft re-seed (workspace switch / reload)
+        // FIRST: re-attach lost chips before reconciliation prunes them. A
+        // successful recovery mutates the draft, so this pass must NOT
+        // reconcile against its now-stale snapshot — the next draftRev pass
+        // does that with fresh occurrences.
+        if (props.controller.recover(props.sessionId, input)) return
         props.controller.reconcile(props.sessionId, input.occurrences || [], input.phase)
       }, [props.controller, props.sessionId, input.draftRev, input.phase])
 
@@ -827,6 +1166,162 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // ===== Sent-message fold =================================================
+    // A block that folded in the composer comes back *after send* as fenced
+    // text inside the user bubble (DSH renders user messages as plain
+    // pre-wrap runs), so the wall of text this plugin exists to prevent
+    // reappears in the transcript. scanFolds() (see apply) walks sent
+    // bubbles and folds every complete fenced block into a collapsed card:
+    //   [</>] python · 128 行        [⎘] ▾      (header click toggles)
+    // React owns the bubble's own children, so nothing is removed or
+    // reordered: the plainRun span being folded is hidden (display:none) and
+    // a host element we fully own is inserted directly after it. A content
+    // stamp on the run keeps the scan idempotent and self-refreshing — text
+    // or locale revision changes rebuild the host, and a fold that becomes
+    // unnecessary is undone. The copy button copies the RAW fenced text
+    // (exactly what was sent); the bubble's own copy/edit/delete bar is
+    // React-side and never sees this DOM.
+    const FOLD_HOST_CLASS = 'dsh-pcb-fold-host'
+    const FOLD_CARD_CLASS = 'dsh-pcb-fold'
+    const FOLD_RUN_ATTR = 'data-dsh-pcb-run'      // '1|<stamp>' folded · '0|<stamp>' checked, plain
+    const FOLD_STAMP_ATTR = 'data-dsh-pcb-stamp'  // on the host, matches the run's stamp
+    const FOLD_BUBBLE_SEL = [
+      '[data-chat-flow-kind="user"]',
+      '[data-chat-flow-kind="steering"]',
+      '[data-submission-echo]',
+      '[data-pending-steering]',
+    ].map((s) => `${s} [class*="bubble"]`).join(',')
+    const foldOpenKeys = new Set() // user-toggled-open cards, stable across rebuilds
+    let foldRev = 0                // bumped on locale switch so cards re-title
+
+    function hash32(str) {
+      let h = 0x811c9dc5
+      for (let i = 0; i < str.length; i += 1) {
+        h ^= str.charCodeAt(i)
+        h = Math.imul(h, 0x01000193)
+      }
+      return (h >>> 0).toString(36)
+    }
+
+    function foldStamp(text) {
+      return `${foldRev}:${text.length}:${hash32(text)}`
+    }
+
+    // Cheap pre-filter so the per-frame scan stays trivial on unfenced runs.
+    const FENCE_HINT = /(^|\n) {0,3}(```|~~~)/
+
+    function isFoldRun(el) {
+      return el.tagName === 'SPAN' && (el.getAttribute('class') || '').includes('plainRun')
+    }
+
+    /** Segments when the text holds at least one non-empty complete fence, else null. */
+    function foldPlanFor(text) {
+      if (!FENCE_HINT.test(text)) return null
+      const segments = splitFencedSegments(text)
+      let folds = 0
+      for (const seg of segments) if (seg.kind === 'fence' && seg.body.trim() !== '') folds += 1
+      return folds > 0 ? segments : null
+    }
+
+    function buildFoldCard(seg, openKey, t) {
+      const infoLang = (seg.lang || '').toLowerCase()
+      // Only an EXPLICIT ```text fence is a text block. The composer never
+      // emits a bare fence for prose (plain blocks always serialize as
+      // ```text), so a bare ``` fence is code whose language the composer
+      // could not name — fold it as a code card and re-guess the language
+      // for display. (0.2.0 bug: bare fences folded as 文本块, mismatching
+      // the 代码块 chip the message was drafted from.)
+      const isText = infoLang === 'text'
+      const lang = isText ? '' : (infoLang || detectLang(seg.body) || '')
+      const type = isText ? 'text' : 'code'
+      const lines = seg.body.split('\n').length
+      const open = foldOpenKeys.has(openKey)
+
+      const card = document.createElement('div')
+      card.className = FOLD_CARD_CLASS
+      card.setAttribute('data-pcb-type', type)
+      card.setAttribute('data-open', open ? '1' : '0')
+
+      const head = document.createElement('div')
+      head.className = 'dsh-pcb-fold-head'
+
+      const toggle = document.createElement('button')
+      toggle.type = 'button'
+      toggle.className = 'dsh-pcb-fold-toggle'
+      toggle.setAttribute('aria-expanded', open ? 'true' : 'false')
+      toggle.setAttribute('aria-label', t('fold.aria'))
+      toggle.title = t(open ? 'collapse' : 'expand')
+      const glyph = document.createElement('span')
+      glyph.className = 'dsh-pcb-fold-glyph'
+      glyph.setAttribute('aria-hidden', 'true')
+      glyph.textContent = type === 'code' ? '</>' : 'Aa'
+      const title = document.createElement('span')
+      title.className = 'dsh-pcb-fold-title'
+      title.textContent = foldTitle(t, type, lang, lines)
+      const chevron = document.createElement('span')
+      chevron.className = 'dsh-pcb-fold-chevron'
+      chevron.setAttribute('aria-hidden', 'true')
+      chevron.textContent = '▾'
+      toggle.append(glyph, title, chevron)
+
+      const copy = document.createElement('button')
+      copy.type = 'button'
+      copy.className = 'dsh-pcb-btn dsh-pcb-fold-copy'
+      copy.title = t('copy')
+      copy.setAttribute('aria-label', t('copy'))
+      copy.textContent = '⎘'
+      let copyTimer = 0
+      copy.addEventListener('click', (ev) => {
+        ev.preventDefault()
+        ev.stopPropagation()
+        try {
+          const done = navigator.clipboard?.writeText(seg.raw)
+          if (done && typeof done.then === 'function') {
+            done.then(() => {
+              copy.textContent = '✓'
+              clearTimeout(copyTimer)
+              copyTimer = setTimeout(() => { copy.textContent = '⎘' }, 1200)
+            }, () => {})
+          }
+        } catch (e) { /* noop */ }
+      })
+
+      head.append(toggle, copy)
+      const pre = document.createElement('pre')
+      pre.className = 'dsh-pcb-fold-body'
+      pre.textContent = seg.body
+      card.append(head, pre)
+
+      toggle.addEventListener('click', (ev) => {
+        ev.preventDefault()
+        ev.stopPropagation()
+        const nowOpen = card.getAttribute('data-open') !== '1'
+        card.setAttribute('data-open', nowOpen ? '1' : '0')
+        toggle.setAttribute('aria-expanded', nowOpen ? 'true' : 'false')
+        toggle.title = t(nowOpen ? 'collapse' : 'expand')
+        if (nowOpen) foldOpenKeys.add(openKey)
+        else foldOpenKeys.delete(openKey)
+      })
+      return card
+    }
+
+    function buildFoldHost(segments, keyBase, t) {
+      const host = document.createElement('div')
+      host.className = FOLD_HOST_CLASS
+      segments.forEach((seg, i) => {
+        if (seg.kind === 'fence' && seg.body.trim() !== '') {
+          host.appendChild(buildFoldCard(seg, `${keyBase}:${i}`, t))
+        } else {
+          const prose = document.createElement('span')
+          prose.className = 'dsh-pcb-fold-prose'
+          // An un-foldable fence (empty body) keeps its raw text, fences and all.
+          prose.textContent = seg.kind === 'fence' ? seg.raw : seg.text
+          host.appendChild(prose)
+        }
+      })
+      return host
+    }
+
     // ===== Styles ============================================================
     const CSS = `
       /* --- restyle DSH's inline reference chip into a boxed badge --- */
@@ -849,6 +1344,25 @@ window.__ModuleLoader__.load({
       /* the label text (the trailing ✕ element is ours — never ellipsis it) */
       [data-composer-chip="${SOURCE}"] > span > span:not(.${CHIP_X_CLASS}){font-weight:500!important;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 
+      /* --- type identity: leading glyph + tint (data-pcb-type set by scanChips) --- */
+      [data-composer-chip="${SOURCE}"][data-pcb-type="code"] > span{
+        border-color:var(--dsh-pcb-code-border,rgba(76,110,245,.38))!important;
+        background:var(--dsh-pcb-code-bg,rgba(76,110,245,.09))!important;
+        color:var(--dsw-alias-state-business-primary,#4c6ef5)!important
+      }
+      [data-composer-chip="${SOURCE}"][data-pcb-type="code"]:hover > span{
+        border-color:var(--dsw-alias-state-business-primary,#4c6ef5)!important;
+        background:var(--dsh-pcb-code-bg-hover,rgba(76,110,245,.16))!important
+      }
+      [data-composer-chip="${SOURCE}"][data-pcb-type="code"] > span::before{
+        content:'</>';flex:none;font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);
+        font-size:10px;font-weight:700;line-height:16px;opacity:.9
+      }
+      [data-composer-chip="${SOURCE}"][data-pcb-type="text"] > span::before{
+        content:'Aa';flex:none;font-size:10px;font-weight:700;line-height:16px;
+        letter-spacing:.2px;color:var(--dsw-alias-label-tertiary)
+      }
+
       /* --- per-chip ✕ delete button (element we own, appended inside the chip) --- */
       .${CHIP_X_CLASS}{
         box-sizing:border-box;flex:none;width:16px;height:16px;display:inline-grid;place-items:center;
@@ -879,9 +1393,26 @@ window.__ModuleLoader__.load({
       /* --- hide the composer's own placeholder while chips/cards are active --- */
       [data-dsh-pcb-active="1"] [data-composer-placeholder]{visibility:hidden}
 
+      /* --- sent-message fold cards (conversation bubbles) --- */
+      .dsh-pcb-fold-host{box-sizing:border-box;display:flex;flex-direction:column;gap:8px;width:100%;min-width:0}
+      .dsh-pcb-fold-prose{white-space:pre-wrap;word-break:break-word}
+      .dsh-pcb-fold{box-sizing:border-box;width:100%;min-width:0;display:flex;flex-direction:column;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-specific-input-major,var(--dsw-alias-bg-layer-1));box-shadow:var(--dsw-shadow-lv1);color:var(--dsw-alias-label-primary);overflow:hidden}
+      .dsh-pcb-fold-head{box-sizing:border-box;min-height:34px;flex:none;display:flex;align-items:center;gap:4px;padding:0 6px 0 10px}
+      .dsh-pcb-fold-toggle{flex:1;min-width:0;display:flex;align-items:center;gap:7px;padding:0;border:0;background:transparent;color:inherit;font:inherit;text-align:left;cursor:pointer}
+      .dsh-pcb-fold-glyph{flex:none;font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:11px;font-weight:700;line-height:16px;opacity:.9}
+      .dsh-pcb-fold[data-pcb-type="code"] .dsh-pcb-fold-glyph{color:var(--dsw-alias-state-business-primary,#4c6ef5)}
+      .dsh-pcb-fold[data-pcb-type="text"] .dsh-pcb-fold-glyph{color:var(--dsw-alias-label-tertiary)}
+      .dsh-pcb-fold-title{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}
+      .dsh-pcb-fold[data-pcb-type="text"] .dsh-pcb-fold-title{font-family:var(--dsw-font-family)}
+      .dsh-pcb-fold-chevron{flex:none;width:14px;text-align:center;font-size:11px;line-height:1;color:var(--dsw-alias-label-tertiary);transition:transform .14s ease}
+      .dsh-pcb-fold[data-open="1"] .dsh-pcb-fold-chevron{transform:rotate(180deg)}
+      .dsh-pcb-fold[data-open="0"] .dsh-pcb-fold-body{display:none}
+      .dsh-pcb-fold-body{box-sizing:border-box;margin:0;max-height:360px;overflow:auto;padding:8px 12px;border-top:1px solid var(--dsw-alias-border-l2);font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:12px;line-height:1.5;white-space:pre;word-break:break-all;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary);--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2)}
+
       @media (max-width:640px){
         .dsh-pcb-head{height:34px}
         .dsh-pcb-lang{max-width:55%}
+        .dsh-pcb-fold-body{max-height:240px}
       }
       @media (pointer:coarse){
         .${CHIP_X_CLASS}{width:22px;height:22px;font-size:15px}
@@ -892,7 +1423,9 @@ window.__ModuleLoader__.load({
     const inject = ['slots', 'sessions', 'conversation', 'inputTriggers', 'locale']
 
     function apply(ctx) {
-      try { console.log('[dsh-paste-code-block] client loaded') } catch (e) { /* noop */ }
+      // Bump alongside package.json on every release — the load log is the
+      // only proof of WHICH bundle generation the browser actually loaded.
+      try { console.log('[dsh-paste-code-block] client loaded v0.2.5') } catch (e) { /* noop */ }
 
       // Publish our dictionaries under the plugin namespace, then bind a
       // translator that always reflects the ACTIVE DSH language (Settings →
@@ -906,7 +1439,10 @@ window.__ModuleLoader__.load({
         : createT(detectBrowserLocale())
 
       const controller = new BlockController(ctx, t)
+      // Test seam (tests/fold-smoke.test.js drives recover() directly).
+      exports.__controllerForTests = controller
       ctx.effect(() => () => controller.dispose(), 'paste-code-block: state')
+      try { recoveryPruneExpired() } catch (e) { /* private mode: recovery simply off */ }
 
       // ----- chip DOM sync: localized labels + per-chip ✕ delete button -----
       function scanChips() {
@@ -923,6 +1459,11 @@ window.__ModuleLoader__.load({
           if (!sid) continue
           const block = controller.listFor(sid).find((b) => b.type === parsed.type && b.labelNumber === parsed.n)
           if (!block) continue
+          // Tag the chip host with its type so CSS can render the leading
+          // glyph and tint (code = blue `</>`, text = neutral `Aa`).
+          if (host.getAttribute('data-pcb-type') !== parsed.type) {
+            host.setAttribute('data-pcb-type', parsed.type)
+          }
           // Retitle the chip to the current language. Lexical caches the
           // insert-time label inside the node, so on a Settings → Language
           // switch (or a chip that remounted with the old label) the DOM is
@@ -952,10 +1493,73 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ----- sent-message fold: the scan ------------------------------------
+      function foldRun(run, plan, keyBase, stamp) {
+        run.setAttribute(FOLD_RUN_ATTR, `1|${stamp}`)
+        run.style.display = 'none'
+        const next = run.nextElementSibling
+        if (next && next.classList.contains(FOLD_HOST_CLASS)) {
+          if (next.getAttribute(FOLD_STAMP_ATTR) === stamp) return // already current
+          next.remove()
+        }
+        const host = buildFoldHost(plan, keyBase, t)
+        host.setAttribute(FOLD_STAMP_ATTR, stamp)
+        run.insertAdjacentElement('afterend', host)
+      }
+
+      /** Restore a previously folded run to DSH's own rendering. */
+      function unfoldRun(run, stamp) {
+        const next = run.nextElementSibling
+        if (next && next.classList.contains(FOLD_HOST_CLASS)) next.remove()
+        run.style.display = ''
+        run.setAttribute(FOLD_RUN_ATTR, `0|${stamp}`)
+      }
+
+      function scanFolds() {
+        if (typeof document === 'undefined') return
+        let bubbles
+        try { bubbles = document.querySelectorAll(FOLD_BUBBLE_SEL) } catch (e) { return }
+        for (const bubble of bubbles) {
+          if (!bubble.isConnected) continue
+          const holder = bubble.closest('[data-chat-flow-key]')
+          const flowKey = holder ? holder.getAttribute('data-chat-flow-key') || '' : ''
+          const kids = [...bubble.children]
+          for (let i = 0; i < kids.length; i += 1) {
+            const el = kids[i]
+            if (el.classList.contains(FOLD_HOST_CLASS)) continue
+            if (!isFoldRun(el)) continue
+            const text = el.textContent || ''
+            const stamp = foldStamp(text)
+            const marked = el.getAttribute(FOLD_RUN_ATTR) || ''
+            if (marked === `1|${stamp}` || marked === `0|${stamp}`) continue // current
+            const plan = foldPlanFor(text)
+            if (!plan) {
+              if (marked.startsWith('1|')) unfoldRun(el, stamp)
+              else el.setAttribute(FOLD_RUN_ATTR, `0|${stamp}`)
+              continue
+            }
+            // Echo/pending rows have no flow key — fall back to a content hash so
+            // two simultaneous unkeyed rows never share one open-state slot.
+            const keyBase = `${flowKey || 'h' + hash32(text)}#${i}`
+            foldRun(el, plan, keyBase, stamp)
+          }
+          // Drop orphan hosts (e.g. React remounted the run span underneath us).
+          for (const el of [...bubble.children]) {
+            if (!el.classList.contains(FOLD_HOST_CLASS)) continue
+            const prev = el.previousElementSibling
+            const mark = prev && prev.getAttribute ? prev.getAttribute(FOLD_RUN_ATTR) : null
+            const keep = !!mark && mark.startsWith('1|') &&
+              prev.style.display === 'none' &&
+              el.getAttribute(FOLD_STAMP_ATTR) === mark.slice(2)
+            if (!keep) el.remove()
+          }
+        }
+      }
+
       let scanScheduled = 0
       function scheduleScan() {
         if (scanScheduled) return
-        const run = () => { scanScheduled = 0; scanChips() }
+        const run = () => { scanScheduled = 0; scanChips(); scanFolds() }
         scanScheduled = typeof requestAnimationFrame === 'function' ? requestAnimationFrame(run) : setTimeout(run, 16)
       }
 
@@ -967,13 +1571,28 @@ window.__ModuleLoader__.load({
       }, 'paste-code-block: chip sync observer')
 
       // A locale switch (or a late dictionary registration bumps the revision
-      // too) re-derives labels: controller state first, chip DOM second.
+      // too) re-derives labels: controller state first, chip DOM second. Sent
+      // fold cards are rebuilt the same way — bumping foldRev invalidates
+      // every run stamp, so the next scan re-titles the cards in the new
+      // language while foldOpenKeys keeps who was expanded.
       ctx.effect(() => {
         const face = ctx.locale
         if (!face || typeof face.subscribe !== 'function') return undefined
-        return face.subscribe(() => { controller.retitleAll(); scheduleScan() })
+        return face.subscribe(() => { controller.retitleAll(); foldRev += 1; scheduleScan() })
       }, 'paste-code-block: locale sync')
-      scheduleScan() // late-mount safety for chips rendered before plugin boot
+      scheduleScan() // late-mount safety for chips and sent bubbles rendered before plugin boot
+
+      // On dispose (plugin removed / HMR swap) hand the transcript back to DSH.
+      ctx.effect(() => () => {
+        try {
+          for (const host of document.querySelectorAll(`.${FOLD_HOST_CLASS}`)) host.remove()
+          for (const run of document.querySelectorAll(`[${FOLD_RUN_ATTR}]`)) {
+            run.style.display = ''
+            run.removeAttribute(FOLD_RUN_ATTR)
+          }
+        } catch (e) { /* noop */ }
+        foldOpenKeys.clear()
+      }, 'paste-code-block: fold restore')
 
       ctx.effect(() => ctx.inputTriggers.registerSource({
         trigger: '@',
@@ -995,6 +1614,34 @@ window.__ModuleLoader__.load({
         return () => style.remove()
       }, 'paste-code-block: styles')
 
+      // Paste-storm guard. External automation — a Tampermonkey AutoClicker,
+      // a clipboard bridge, IME glue, or a held-down Ctrl+V — can re-dispatch
+      // the SAME clipboard text dozens of times a second. Each accepted paste
+      // mints a new block, so a storm stuffs the composer with duplicate
+      // chips. Collapse runs of an identical clipboard text that arrive faster
+      // than a human can act into a single paste (a 1200 ms sliding window,
+      // refreshed on every matching event, so a held repeat stays suppressed
+      // while it continues). 0.2.4 added a content-liveness dedup that ALSO
+      // suppressed a re-paste of the same text while its block was still
+      // attached — that made "paste the same snippet twice" impossible, which
+      // users hit immediately. 0.2.5 reverts that: identical text pasted after
+      // the burst window is a fresh intent and gets its own block. Only
+      // machine-paced repeats within the window are collapsed.
+      const STORM_WINDOW_MS = 1200
+      const pasteStorm = {
+        lastText: '',
+        lastAt: 0,
+        // True when this text is the tail of a storm; every call refreshes
+        // the window, so a held repeat stays suppressed while it continues.
+        seen(text, now) {
+          const dup = text === this.lastText && now - this.lastAt < STORM_WINDOW_MS
+          this.lastText = text
+          this.lastAt = now
+          return dup
+        },
+      }
+      exports.__pasteStormForTests = pasteStorm
+
       // Turn qualifying pastes into boxed inline chips.
       const onPaste = (ev) => {
         const clip = ev.clipboardData
@@ -1007,7 +1654,19 @@ window.__ModuleLoader__.load({
         if (!sid) return
         const block = parseBlock(text)
         if (!block) { console.log('[dsh-paste-code-block] paste NOT block', text.length); return }
-        console.log('[dsh-paste-code-block] intercept', block.isCode ? 'code' : 'text', block.lines.length, 'lang=', block.lang)
+        if (pasteStorm.seen(text, Date.now())) {
+          // Consume the event (never let the raw text fall through to the
+          // composer) but create nothing.
+          ev.preventDefault()
+          ev.stopPropagation()
+          console.log('[dsh-paste-code-block] storm paste ignored (<' + STORM_WINDOW_MS + 'ms repeat)')
+          return
+        }
+        block.sourceText = text
+        // trusted=false means a page script dispatched this paste (userscript,
+        // clipboard bridge, replay glue) rather than a real keystroke — the
+        // load-log line that names the source when a storm report comes in.
+        console.log('[dsh-paste-code-block] intercept', block.isCode ? 'code' : 'text', block.lines.length, 'lang=', block.lang, 'trusted=', ev.isTrusted)
         ev.preventDefault()
         ev.stopPropagation()
         try {