dsh-paste-code-block 0.2.5 → 0.2.7

package/tests/fold.test.js

@@ -0,0 +1,147 @@
+// Regression tests for the "pasted block is rendered wrong in the sent message" bug.
+//
+// Two real shapes are under test (see fixtures.js, captured from the user's own
+// session logs):
+//   P  the prose the user originally pasted
+//   W  what 0.2.5 serialised it to - a clean ```text fence plus a typed tail
+//   B  what 0.2.5 produced when W was pasted back in: a BARE fence wrapped
+//      around an already-fenced text, which is what broke the transcript.
+//
+// Run: node --test      (from the package root)
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  parseBlock,
+  serializeBlock,
+  splitFencedSegments,
+  wholeFence,
+  fenceMarkerFor,
+  fenceRanges,
+  planFoldRuns,
+} from '../src/parse.js'
+import { W, B, B2, P } from './fixtures.js'
+
+const lf = (s) => s.replace(/\r\n/g, '\n')
+const unwrap = (s) => s.replace(/^\n/, '').replace(/\n$/, '')
+
+// DSH renders a sent user message as ONE plain-text run per @mention chip: the
+// chip keeps only the label (the part after the last "/"), so the run before it
+// stops at the "@".  Mirrors what the transcript really contains.
+function dshRuns(message) {
+  const out = []
+  const re = /@([A-Za-z0-9._-]+\/[A-Za-z0-9._/-]+)/g
+  let last = 0
+  let m
+  while ((m = re.exec(message)) !== null) {
+    out.push(message.slice(last, m.index))
+    out.push(m[1].split('/').pop())
+    last = m.index + m[0].length
+  }
+  out.push(message.slice(last))
+  return out
+}
+
+test('a plain prose paste becomes a TEXT block with one clean fence', () => {
+  const block = parseBlock(P)
+  assert.equal(block.isCode, false)
+  assert.equal(unwrap(serializeBlock(block)), '```text\n' + P + '\n```')
+  // ... which is exactly the prefix of the message the user actually sent.
+  assert.ok(W.startsWith('```text\n' + P))
+})
+
+test('0.2.5 broke when the previous message was pasted back (real captured data)', () => {
+  // B is W wrapped in one extra BARE fence - the reported breakage.
+  assert.ok(B.startsWith('```\n```text'))
+  assert.equal(lf(B), lf('```\n' + W + '\n```'))
+})
+
+test('re-pasting the previous message now stays a TEXT block (the user bug)', () => {
+  const block = parseBlock(W)
+  assert.equal(block.isCode, false, 'W was mis-typed as CODE by 0.2.5')
+  const sent = serializeBlock(block)
+  // The wrapper marker grows so the inner ``` fence can never close it.
+  assert.ok(sent.startsWith('\n````text\n'), 'wrapper marker must grow past the body fences')
+  assert.equal(unwrap(sent), '````text\n' + W + '\n````')
+  assert.notEqual(unwrap(sent), B, 'must not reproduce the 0.2.5 output')
+})
+
+test('the whole-bubble plan sees the fence that straddles DSH mention chips', () => {
+  const runs = dshRuns(B2)
+  assert.deepEqual(runs.map((r) => r.length), [16, 37, 71, 37, 281])
+  const plan = planFoldRuns(B2, runs)
+  assert.equal(plan.mode, 'bubble')
+  assert.equal(plan.fences.length, 1)
+  // Same answer when the message still carries CRLF from the Windows clipboard.
+  assert.equal(planFoldRuns(B, dshRuns(B)).mode, 'bubble')
+})
+
+test('per-run scanning is what produced the bogus one-line card', () => {
+  for (const [msg, tailBody] of [[B, '解决这个'], [B2, '测试，不需要执行']]) {
+    const runs = dshRuns(msg)
+    const tail = runs[runs.length - 1]
+    const fences = splitFencedSegments(tail).filter((s) => s.kind === 'fence')
+    assert.equal(fences.length, 1)
+    assert.equal(fences[0].body.trim(), tailBody)
+  }
+})
+
+test('a fence that sits inside a single run keeps the per-run path', () => {
+  const msg = '看这个 @a/b\n```js\nconst a = 1\n```\n谢谢'
+  const runs = dshRuns(msg)
+  const plan = planFoldRuns(msg, runs)
+  assert.equal(plan.mode, 'single')
+  assert.deepEqual(plan.runs, [2])
+})
+
+test('prose alone plans no fold', () => {
+  assert.equal(planFoldRuns(P, [P]), null)
+  assert.equal(planFoldRuns('hello\nworld\n', ['hello\nworld\n']), null)
+})
+
+test('fenceRanges agrees with splitFencedSegments', () => {
+  const samples = [W, B, B2, '````text\na\n```\nb\n```\n````', '前言\n```\nx\n```\n后记']
+  for (const s of samples) {
+    const segs = splitFencedSegments(s).filter((x) => x.kind === 'fence')
+    const ranges = fenceRanges(s)
+    assert.equal(ranges.length, segs.length, `range count for ${JSON.stringify(s.slice(0, 12))}`)
+    // splitFencedSegments rebuilds raw/body from line arrays, so it normalises
+    // CRLF to LF; the offsets themselves must still line up exactly.
+    segs.forEach((seg, i) => assert.equal(lf(s.slice(ranges[i].start, ranges[i].end)), seg.raw))
+  }
+})
+
+test('a clean fenced paste takes its type from the info string', () => {
+  assert.equal(parseBlock('```text\nhello\n```').isCode, false)
+  assert.equal(parseBlock('```text\nhello\n```').lang, '')
+  const js = parseBlock('```js\nconst a = 1\n```')
+  assert.equal(js.isCode, true)
+  assert.equal(js.lang, 'js')
+  assert.equal(unwrap(serializeBlock(js)), '```js\nconst a = 1\n```')
+  // Bare fence with no info string stays code.
+  assert.equal(parseBlock('```\nhello\n```').isCode, true)
+})
+
+test('wholeFence only matches a fence that is the whole paste', () => {
+  assert.equal(wholeFence('```text\nx\n```').lang, 'text')
+  assert.equal(wholeFence('```text\nx\n```\n尾注'), null)
+  assert.ok(wholeFence('\n```text\nx\n```\n'), 'blank lines around the fence are tolerated')
+  assert.equal(wholeFence('前言\n```text\nx\n```'), null)
+  assert.equal(wholeFence('no fence here'), null)
+})
+
+test('the wrapper marker always outgrows the body', () => {
+  assert.equal(fenceMarkerFor('no fences'), '```')
+  assert.equal(fenceMarkerFor('a\n```\nb\n```'), '````')
+  assert.equal(fenceMarkerFor('`````'), '``````')
+  const nested = unwrap(serializeBlock(parseBlock(W)))
+  assert.equal(fenceMarkerFor(nested), '`````')
+})
+
+test('re-pasting the fixed output is stable', () => {
+  const once = unwrap(serializeBlock(parseBlock(W)))
+  const twice = unwrap(serializeBlock(parseBlock(once)))
+  // Stable modulo the CRLF -> LF normalisation splitFencedSegments performs.
+  assert.equal(lf(twice), lf(once))
+  assert.equal(planFoldRuns(once, [once]).mode, 'single')
+})

package/tests/i18n.test.js

@@ -0,0 +1,112 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  NS, zh, en, dictionaries, createT, blockLabel, parseBlockLabel, detectBrowserLocale, foldTitle,
+} from '../src/i18n.js'
+
+test('namespace is the plugin source name', () => {
+  assert.equal(NS, 'paste-code-block')
+})
+
+test('zh and en dictionaries carry identical key sets', () => {
+  const zhKeys = Object.keys(zh).sort()
+  const enKeys = Object.keys(en).sort()
+  assert.deepEqual(zhKeys, enKeys)
+  assert.ok(zhKeys.length >= 10, 'dictionaries should be reasonably complete')
+})
+
+test('block labels render in both locales with the number interpolated', () => {
+  assert.equal(blockLabel(createT('zh'), 'code', 2), '代码块 2')
+  assert.equal(blockLabel(createT('zh'), 'text', 7), '文本块 7')
+  assert.equal(blockLabel(createT('en'), 'code', 2), 'Code #2')
+  assert.equal(blockLabel(createT('en'), 'text', 7), 'Text #7')
+})
+
+test('chip names stay action-free (no “复制” wording on reference chips)', () => {
+  // The chip is a reference badge, not a copy button; the old 0.1.2 names
+  // read like an imperative and were dropped in 0.1.3.
+  assert.ok(!zh['block.code'].includes('复制'))
+  assert.ok(!zh['block.text'].includes('复制'))
+})
+
+test('parseBlockLabel round-trips every locale and both block types', () => {
+  for (const locale of ['zh', 'en']) {
+    const t = createT(locale)
+    for (const type of ['code', 'text']) {
+      for (const n of [1, 2, 9, 10, 123]) {
+        const label = blockLabel(t, type, n)
+        assert.deepEqual(parseBlockLabel(label), { type, n }, `${locale} ${type} #${n}`)
+      }
+    }
+  }
+})
+
+test('a label in one language still parses while the other is active', () => {
+  // Chips keep the insert-time label until the client retitles them; identity
+  // recovery must be locale-independent either way.
+  assert.deepEqual(parseBlockLabel('代码块 3'), { type: 'code', n: 3 })
+  assert.deepEqual(parseBlockLabel('Text #4'), { type: 'text', n: 4 })
+})
+
+test('legacy pre-0.1.3 labels still resolve to their block identity', () => {
+  // Chips inserted by an older bundle keep working until the next retitle.
+  assert.deepEqual(parseBlockLabel('复制代码块3'), { type: 'code', n: 3 })
+  assert.deepEqual(parseBlockLabel('复制文本块12'), { type: 'text', n: 12 })
+  assert.deepEqual(parseBlockLabel('Code block #4'), { type: 'code', n: 4 })
+  assert.deepEqual(parseBlockLabel('Text block #1'), { type: 'text', n: 1 })
+})
+
+test('parseBlockLabel rejects anything that is not a block label', () => {
+  assert.equal(parseBlockLabel(''), null)
+  assert.equal(parseBlockLabel(null), null)
+  assert.equal(parseBlockLabel('Code block x'), null)
+  assert.equal(parseBlockLabel('Code block #x'), null)
+  assert.equal(parseBlockLabel('复制代码块'), null)
+  assert.equal(parseBlockLabel('复制文本块abc'), null)
+  assert.equal(parseBlockLabel('Hello world'), null)
+  assert.equal(parseBlockLabel('Pasted Code Block 1'), null)
+})
+
+test('createT interpolates params, falls back to en, then to the raw key', () => {
+  const t = createT('zh')
+  assert.equal(t('lines.other', { count: 5 }), '5 行')
+  assert.equal(createT('en')('lines.one', { count: 1 }), '1 line')
+  assert.equal(createT('en')('lines.other', { count: 2 }), '2 lines')
+  // missing param keeps the placeholder
+  assert.equal(t('lines.other'), '{count} 行')
+  // unknown key with an en counterpart falls through to en
+  assert.equal(t('detail.aria'), '代码块详情')
+  assert.equal(createT('fr')('detail.aria'), 'Block details') // unknown locale -> en
+  // unknown key everywhere -> the key itself
+  assert.equal(t('no.such.key'), 'no.such.key')
+})
+
+test('dictionaries map exposes both locales', () => {
+  assert.deepEqual(Object.keys(dictionaries).sort(), ['en', 'zh'])
+})
+
+// ===== foldTitle (sent-message fold cards) ==================================
+test('fold title localizes the type name and line count', () => {
+  assert.equal(foldTitle(createT('zh'), 'text', '', 128), '文本块 · 128 行')
+  assert.equal(foldTitle(createT('en'), 'text', '', 128), 'Text · 128 lines')
+  assert.equal(foldTitle(createT('en'), 'text', '', 1), 'Text · 1 line')
+})
+
+test('a code card shows the fence language instead of the type name', () => {
+  assert.equal(foldTitle(createT('zh'), 'code', 'python', 42), 'python · 42 行')
+  assert.equal(foldTitle(createT('en'), 'code', 'python', 42), 'python · 42 lines')
+  // Untagged code falls back to the localized type name.
+  assert.equal(foldTitle(createT('zh'), 'code', '', 3), '代码块 · 3 行')
+  assert.equal(foldTitle(createT('en'), 'code', '', 3), 'Code · 3 lines')
+})
+
+test('fold dictionary keys exist in both locales', () => {
+  for (const key of ['fold.code', 'fold.text', 'fold.aria']) {
+    assert.ok(zh[key], `zh missing ${key}`)
+    assert.ok(en[key], `en missing ${key}`)
+  }
+})
+
+test('detectBrowserLocale never throws outside a browser', () => {
+  assert.ok(['zh', 'en'].includes(detectBrowserLocale()))
+})

package/tests/lexical-chip-probe.mjs

@@ -0,0 +1,109 @@
+// Reproduction probe for the chip-removal node-map shape (NOT part of the test
+// glob: it needs optional deps, so CI never runs it).
+//
+//   npm i --no-save lexical@0.49.0 @lexical/headless@0.49.0
+//   node tests/lexical-chip-probe.mjs
+//
+// Expected output:
+//   _nodeMap value shape: valueIsNode true, hasNodeProp false
+//   OLD code (value.node):    removed = 0  | refs after = r1,r2,r3   <- v0.1.2 silent no-op
+//   NEW code (value is node): removed = 1  | refs after = r1,r3
+import { createHeadlessEditor } from '@lexical/headless'
+import { $createParagraphNode, $createTextNode, $getRoot, DecoratorNode } from 'lexical'
+
+const SOURCE = 'paste-code-block'
+
+class ReferenceChipNode extends DecoratorNode {
+  static getType() { return 'reference-chip' }
+  static clone(node) { return new ReferenceChipNode(node.__source, node.__ref, node.__label, node.__key) }
+  constructor(source = SOURCE, ref = '', label = '', key) {
+    super(key)
+    this.__source = source
+    this.__ref = ref
+    this.__label = label
+  }
+  createDOM() { return document.createElement('span') }
+  updateDOM() { return false }
+  isInline() { return true }
+  isKeyboardSelectable() { return false }
+  getSource() { return this.__source }
+  getReference() { return this.__ref }
+  getLabel() { return this.__label }
+}
+
+function freshEditor() {
+  const editor = createHeadlessEditor({
+    namespace: 'probe',
+    nodes: [ReferenceChipNode],
+    onError: (err) => { throw err },
+  })
+  editor.update(() => {
+    const p = $createParagraphNode()
+    p.append($createTextNode('alpha '))
+    p.append(new ReferenceChipNode(SOURCE, 'r1', 'block 1'))
+    p.append(new ReferenceChipNode(SOURCE, 'r2', 'block 2'))
+    p.append(new ReferenceChipNode(SOURCE, 'r3', 'block 3'))
+    p.append($createTextNode(' omega'))
+    const root = $getRoot()
+    root.clear()
+    root.append(p)
+  }, { discrete: true })
+  return editor
+}
+
+function refsOf(editor) {
+  let refs = []
+  editor.getEditorState().read(() => {
+    refs = $getRoot().getChildren()[0].getChildren()
+      .filter((n) => typeof n.getSource === 'function')
+      .map((n) => n.getReference())
+  })
+  return refs
+}
+
+function shapeOf(editor) {
+  const found = []
+  editor.getEditorState().read(() => {
+    const map = editor.getEditorState()._nodeMap
+    for (const [key, value] of map) {
+      if (typeof value.getSource === 'function') {
+        found.push({ valueIsNode: true, hasNodeProp: 'node' in value, key: value.getKey() === key })
+      } else if (value && value.node) {
+        found.push({ valueIsNode: false, hasNodeProp: true, key: value.node.getKey() === key })
+      }
+    }
+  })
+  return found
+}
+
+function removeWith(editor, pick) {
+  let hits = 0
+  editor.update(() => {
+    const map = editor.getEditorState()._nodeMap
+    const targets = []
+    for (const value of map.values()) {
+      const node = pick(value)
+      if (!node || typeof node.getSource !== 'function' || typeof node.getReference !== 'function') continue
+      if (node.getSource() === SOURCE && node.getReference() === 'r2') targets.push(node)
+    }
+    for (const node of targets) node.remove()
+    hits = targets.length
+  }, { discrete: true })
+  return hits
+}
+
+const probe = freshEditor()
+console.log('1) _nodeMap value shape:', JSON.stringify(shapeOf(probe)))
+
+const oldWay = freshEditor()
+console.log('2) OLD code (value.node):   removed =', removeWith(oldWay, (v) => v && v.node), '| refs after =', refsOf(oldWay).join(','))
+
+const newWay = freshEditor()
+console.log('3) NEW code (value is node): removed =', removeWith(newWay, (v) => (v && typeof v.getSource === 'function' ? v : v && v.node)), '| refs after =', refsOf(newWay).join(','))
+
+const textAfter = (editor) => {
+  let text = ''
+  editor.getEditorState().read(() => { text = $getRoot().getTextContent() })
+  return text
+}
+console.log('4) draft text after NEW removal:', JSON.stringify(textAfter(newWay)))

package/tests/parse.test.js

@@ -0,0 +1,183 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { parseBlock, detectLang, serializeBlock, splitFencedSegments } from '../src/parse.js'
+
+test('ordinary short prose is not treated as a block', () => {
+  assert.equal(parseBlock('hello world'), null)
+  assert.equal(parseBlock('a'), null)
+})
+
+test('multi-line text becomes a block', () => {
+  const b = parseBlock('line one\nline two\nline three')
+  assert.ok(b)
+  assert.equal(b.isCode, false)
+  assert.equal(b.lines.length, 3)
+})
+
+test('a short line below the length threshold is null', () => {
+  // 95 chars, no newline, no fences, no indent -> not a block
+  const s = 'a'.repeat(95)
+  assert.equal(parseBlock(s), null)
+})
+
+test('a long single line is treated as a block', () => {
+  // >= 96 chars, no newline -> still a block (length rule)
+  const s = 'a'.repeat(96)
+  assert.ok(parseBlock(s))
+})
+
+test('fenced code block is parsed with its language tag', () => {
+  const raw = '```js\nconst x = 1;\n```'
+  const b = parseBlock(raw)
+  assert.ok(b)
+  assert.equal(b.isCode, true)
+  assert.equal(b.lang, 'js')
+  assert.equal(b.content, 'const x = 1;')
+})
+
+test('fenced block with no language tags as empty lang but still code', () => {
+  const b = parseBlock('```\nplain\n```')
+  assert.ok(b)
+  assert.equal(b.isCode, true)
+  assert.equal(b.lang, '')
+})
+
+test('indented, brace-dense code is detected as code', () => {
+  const raw = '  function main() {\n    console.log("hi")\n    return 0;\n  }'
+  const b = parseBlock(raw)
+  assert.ok(b)
+  assert.equal(b.isCode, true)
+  assert.equal(b.lang, 'javascript')
+})
+
+test('python shebang is detected', () => {
+  const raw = '#!/usr/bin/env python3\nprint("hi")'
+  const b = parseBlock(raw)
+  assert.ok(b)
+  assert.equal(b.isCode, true)
+  assert.equal(b.lang, 'python')
+})
+
+test('markdown prose with several signals is text, not code', () => {
+  const md = '# Title\n\nSome **bold** text with a [link](https://x.test).\n\n- item\n- item2'
+  const b = parseBlock(md)
+  assert.ok(b)
+  assert.equal(b.isCode, false)
+})
+
+test('empty input returns null', () => {
+  assert.equal(parseBlock(''), null)
+  assert.equal(parseBlock(null), null)
+  assert.equal(parseBlock(undefined), null)
+})
+
+test('detectLang: common languages', () => {
+  assert.equal(detectLang('const a = 1;'), 'javascript')
+  assert.equal(detectLang('def foo():'), 'python')
+  assert.equal(detectLang('SELECT * FROM t'), 'sql')
+  assert.equal(detectLang('{"a":1}'), 'json')
+  assert.equal(detectLang('<root></root>'), 'xml')
+  assert.equal(detectLang(''), '')
+})
+
+test('serializeBlock wraps plain text in a text fence', () => {
+  const b = parseBlock('line one\nline two')
+  assert.ok(b)
+  assert.equal(serializeBlock(b), '\n```text\nline one\nline two\n```\n')
+})
+
+test('serializeBlock preserves the detected language for code', () => {
+  const b = parseBlock('function main() {\n  console.log(1)\n}')
+  assert.ok(b)
+  assert.equal(b.isCode, true)
+  assert.equal(b.lang, 'javascript')
+  assert.ok(serializeBlock(b).startsWith('\n```javascript\n'))
+})
+
+// ===== splitFencedSegments (sent-message fold segmentation) ================
+test('empty text yields no segments', () => {
+  assert.deepEqual(splitFencedSegments(''), [])
+  assert.deepEqual(splitFencedSegments(null), [])
+})
+
+test('prose-only text is one prose segment', () => {
+  const segs = splitFencedSegments('hello\nworld')
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'prose')
+  assert.equal(segs[0].text, 'hello\nworld')
+})
+
+test('a single fenced block is extracted with lang, body and raw', () => {
+  const text = '```python\ndef f():\n    pass\n```'
+  const segs = splitFencedSegments(text)
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'fence')
+  assert.equal(segs[0].lang, 'python')
+  assert.equal(segs[0].body, 'def f():\n    pass')
+  assert.equal(segs[0].raw, text)
+})
+
+test('prose around fences is kept verbatim and in order', () => {
+  const text = '看一下\n```js\nconst x = 1;\n```\n最后一个问题'
+  const segs = splitFencedSegments(text)
+  assert.deepEqual(segs.map((s) => s.kind), ['prose', 'fence', 'prose'])
+  assert.equal(segs[0].text, '看一下')
+  assert.equal(segs[1].lang, 'js')
+  assert.equal(segs[2].text, '最后一个问题')
+})
+
+test('two serialized plugin blocks split apart with blank prose', () => {
+  // serializeBlock emits `\n```text\n…\n```\n` per block — back to back.
+  const text = '\n```text\nfirst block\n```\n\n```python\nprint(1)\n```\n'
+  const segs = splitFencedSegments(text)
+  const fences = segs.filter((s) => s.kind === 'fence')
+  assert.equal(fences.length, 2)
+  assert.equal(fences[0].body, 'first block')
+  assert.equal(fences[1].body, 'print(1)')
+})
+
+test('tilde fences and info strings with extra words', () => {
+  const segs = splitFencedSegments('~~~yaml title: a\nkey: value\n~~~')
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'fence')
+  assert.equal(segs[0].lang, 'yaml')
+  assert.equal(segs[0].body, 'key: value')
+})
+
+test('a longer fence wraps inner shorter fences', () => {
+  const text = '````markdown\n```js\nx\n```\n````'
+  const segs = splitFencedSegments(text)
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'fence')
+  assert.equal(segs[0].lang, 'markdown')
+  assert.equal(segs[0].body, '```js\nx\n```')
+})
+
+test('unterminated fences stay prose', () => {
+  const segs = splitFencedSegments('before\n```json\n{"a": 1}')
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'prose')
+  assert.equal(segs[0].text, 'before\n```json\n{"a": 1}')
+})
+
+test('fence indented up to 3 spaces opens; 4+ stays prose (indented code)', () => {
+  const ok = splitFencedSegments('  ```\nx\n  ```')
+  assert.equal(ok.length, 1)
+  assert.equal(ok[0].kind, 'fence')
+  const deep = splitFencedSegments('    ```\n    x\n    ```')
+  assert.equal(deep.length, 1)
+  assert.equal(deep[0].kind, 'prose')
+})
+
+test('backticks inside a ``` info string mean prose, not a fence', () => {
+  const segs = splitFencedSegments('```weird `tick`\nbody\n```')
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'prose')
+})
+
+test('empty-body fence is still reported as a fence segment', () => {
+  const segs = splitFencedSegments('```\n```')
+  assert.equal(segs.length, 1)
+  assert.equal(segs[0].kind, 'fence')
+  assert.equal(segs[0].body, '')
+})

package/tests/projection.test.js

@@ -0,0 +1,64 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { detectOffsetOf, separatorSpaceSpan } from '../src/projection.js'
+
+/** Occurrence factory: our chips project as one zero-width char. */
+function occ(offset, { length = 1, source = 'paste-code-block', ref = 'r1' } = {}) {
+  return { offset, length, source, ref }
+}
+
+test('detect offset equals the clipboard offset when no chip precedes', () => {
+  const c = occ(4)
+  assert.equal(detectOffsetOf([c], c), 4)
+})
+
+test('a preceding foreign chip (longer clipboard text) shifts detect offsets', () => {
+  const fileChip = occ(0, { length: 5, source: 'dsh-file-upload', ref: 'f1' })
+  const block = occ(5, { ref: 'r1' })
+  assert.equal(detectOffsetOf([fileChip, block], block), 1)
+})
+
+test('trailing occurrences never shift an earlier one', () => {
+  const block = occ(0, { ref: 'r1' })
+  const later = occ(9, { length: 5, source: 'dsh-file-upload', ref: 'f2' })
+  assert.equal(detectOffsetOf([block, later], block), 0)
+})
+
+test('separator space right after our chip is located in detect coordinates', () => {
+  const block = occ(0)
+  const projection = { draft: '\u200B ', occurrences: [block] }
+  assert.deepEqual(separatorSpaceSpan(projection, block), { start: 1, end: 2 })
+})
+
+test('separator span accounts for chips that precede ours', () => {
+  const fileChip = occ(0, { length: 5, source: 'dsh-file-upload', ref: 'f1' })
+  const block = occ(5)
+  // clipboard: [file(0..5)][chip(5)][' '(6)] -> detect: [file=1][chip][space]
+  const projection = { draft: '/file\u200B ', occurrences: [fileChip, block] }
+  assert.deepEqual(separatorSpaceSpan(projection, block), { start: 2, end: 3 })
+})
+
+test('a pre-existing space before the chip is not what gets removed', () => {
+  const block = occ(4)
+  // "abc " was typed by the user; the chip was appended, then the shell's space.
+  const projection = { draft: 'abc \u200B ', occurrences: [block] }
+  const span = separatorSpaceSpan(projection, block)
+  assert.deepEqual(span, { start: 5, end: 6 })
+  // the character under the span is the appended one, not the user's space
+  assert.equal(projection.draft.charAt(4), '\u200B')
+  assert.equal(projection.draft.charAt(3), ' ')
+  assert.equal(projection.draft.charAt(span.start), ' ')
+})
+
+test('no span when the character after our chip is not a space', () => {
+  const block = occ(0)
+  assert.equal(separatorSpaceSpan({ draft: '\u200B', occurrences: [block] }, block), null)
+  assert.equal(separatorSpaceSpan({ draft: '\u200Btext', occurrences: [block] }, block), null)
+})
+
+test('missing projection or occurrence yields no span', () => {
+  const block = occ(0)
+  assert.equal(separatorSpaceSpan(null, block), null)
+  assert.equal(separatorSpaceSpan({ draft: '\u200B ', occurrences: [] }, null), null)
+})