hivecode-mcp 0.12.2 → 0.13.0

package/lang-toml.js

@@ -1,136 +1,136 @@
-// TOML language provider for ICR — section/key structural splitter.
-// Cargo.toml / pyproject.toml are constantly edited concurrently (two people add
-// dependencies). This provider merges by STRUCTURE: every `[section]` (and
-// `[[array-of-tables]]`) is a unit keyed by its name; keys in the top-level
-// preamble are units of their own; splitUnit descends into a section so two
-// edits to DIFFERENT keys of the same table merge cleanly.
-//
-// Honest heuristic: tracks #-comments and single/double/triple-quoted strings;
-// parses() = balanced delimiters + well-formed section headers.
-
-function scannerAt(src) {
-  const n = src.length
-  return function at(i) {
-    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
-    for (const q of ['"""', "'''"]) if (src.startsWith(q, i)) { let j = i + 3; while (j < n && !src.startsWith(q, j)) { if (src[j] === '\\') j++; j++ } return Math.min(n, j + 3) }
-    if (src[i] === '"' || src[i] === "'") {
-      const q = src[i]; let j = i + 1
-      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
-      return j
-    }
-    return -1
-  }
-}
-
-function lines(src) {
-  const out = []
-  let i = 0
-  while (i < src.length) {
-    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
-    const body = src.slice(i, e).replace(/\r?\n$/, '')
-    const trimmed = body.trim()
-    out.push({ start: i, end: e, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
-    i = e
-  }
-  return out
-}
-
-const SECTION = /^\s*(\[\[?)([^\]]+)\]\]?\s*(#.*)?$/
-const KEYLINE = /^\s*([A-Za-z0-9_."'-]+)\s*=/
-
-// Bracket delta for one line, string/comment aware (multi-line arrays continue a key).
-function bracketDelta(src, at, s, e) {
-  let d = 0, k = s
-  while (k < e) {
-    const j = at(k); if (j > k) { k = Math.min(e, j); continue }
-    const c = src[k]
-    if (c === '[' || c === '{') d++
-    else if (c === ']' || c === '}') d--
-    k++
-  }
-  return d
-}
-
-// Top-level units: a [section] header owns everything until the next header;
-// preamble `key = value` lines are individual units (multi-line values included).
-function blocks(src) {
-  const at = scannerAt(src)
-  const L = lines(src)
-  const units = []
-  let i = 0
-  while (i < L.length) {
-    while (i < L.length && L[i].text.trim() === '') i++
-    if (i >= L.length) break
-    const start = L[i].start
-    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++ // leading comments attach
-    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
-    if (SECTION.test(L[i].text)) {
-      i++ // header
-      while (i < L.length && !SECTION.test(L[i].text)) i++
-      let last = i - 1
-      while (last >= 0 && L[last].text.trim() === '') last--
-      units.push({ start, end: L[last].end })
-    } else {
-      // one key (or stray statement); consume continuation lines while brackets open
-      let depth = bracketDelta(src, at, L[i].start, L[i].end)
-      let e = L[i].end; i++
-      while (i < L.length && depth > 0) { depth += bracketDelta(src, at, L[i].start, L[i].end); e = L[i].end; i++ }
-      units.push({ start, end: e })
-    }
-  }
-  return units
-}
-
-function keyOf(text) {
-  const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
-  let m = head.match(SECTION); if (m) return (m[1] === '[[' ? 'tables:' : 'table:') + m[2].trim()
-  m = head.match(KEYLINE); if (m) return 'key:' + m[1].replace(/["']/g, '')
-  return 'stmt:' + head.trim().replace(/\s+/g, ' ')
-}
-
-function keyed(raw, src) {
-  const seen = new Map(), out = []
-  for (const u of raw) {
-    const text = src.slice(u.start, u.end)
-    let k = keyOf(text)
-    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
-    if (c > 1) k += '#' + c
-    out.push({ key: k, text, start: u.start, end: u.end })
-  }
-  return out
-}
-
-function balanced(src) {
-  const at = scannerAt(src)
-  const stack = []
-  const pair = { ']': '[', '}': '{' }
-  let i = 0
-  while (i < src.length) {
-    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
-    const c = src[i]
-    if (c === '[' || c === '{') stack.push(c)
-    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
-    i++
-  }
-  return stack.length === 0
-}
-
-export const toml = {
-  id: 'toml',
-  exts: ['.toml'],
-  parses: (src) => balanced(String(src == null ? '' : src)),
-  parsesUnit: (src) => balanced(String(src)),
-  units: (src) => keyed(blocks(String(src)), String(src)),
-  declaredNames: () => new Set(),
-  // Descend into a section: each `key = value` inside merges independently.
-  splitUnit: (text) => {
-    const src = String(text)
-    const L = lines(src)
-    let h = 0; while (h < L.length && L[h].blank) h++
-    if (h >= L.length || !SECTION.test(L[h].text)) return null
-    const sig = src.slice(0, L[h].end)
-    const body = src.slice(L[h].end)
-    const inner = keyed(blocks(body), body)
-    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
-  },
-}
+// TOML language provider for ICR — section/key structural splitter.
+// Cargo.toml / pyproject.toml are constantly edited concurrently (two people add
+// dependencies). This provider merges by STRUCTURE: every `[section]` (and
+// `[[array-of-tables]]`) is a unit keyed by its name; keys in the top-level
+// preamble are units of their own; splitUnit descends into a section so two
+// edits to DIFFERENT keys of the same table merge cleanly.
+//
+// Honest heuristic: tracks #-comments and single/double/triple-quoted strings;
+// parses() = balanced delimiters + well-formed section headers.
+
+function scannerAt(src) {
+  const n = src.length
+  return function at(i) {
+    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
+    for (const q of ['"""', "'''"]) if (src.startsWith(q, i)) { let j = i + 3; while (j < n && !src.startsWith(q, j)) { if (src[j] === '\\') j++; j++ } return Math.min(n, j + 3) }
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i]; let j = i + 1
+      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
+      return j
+    }
+    return -1
+  }
+}
+
+function lines(src) {
+  const out = []
+  let i = 0
+  while (i < src.length) {
+    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
+    const body = src.slice(i, e).replace(/\r?\n$/, '')
+    const trimmed = body.trim()
+    out.push({ start: i, end: e, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
+    i = e
+  }
+  return out
+}
+
+const SECTION = /^\s*(\[\[?)([^\]]+)\]\]?\s*(#.*)?$/
+const KEYLINE = /^\s*([A-Za-z0-9_."'-]+)\s*=/
+
+// Bracket delta for one line, string/comment aware (multi-line arrays continue a key).
+function bracketDelta(src, at, s, e) {
+  let d = 0, k = s
+  while (k < e) {
+    const j = at(k); if (j > k) { k = Math.min(e, j); continue }
+    const c = src[k]
+    if (c === '[' || c === '{') d++
+    else if (c === ']' || c === '}') d--
+    k++
+  }
+  return d
+}
+
+// Top-level units: a [section] header owns everything until the next header;
+// preamble `key = value` lines are individual units (multi-line values included).
+function blocks(src) {
+  const at = scannerAt(src)
+  const L = lines(src)
+  const units = []
+  let i = 0
+  while (i < L.length) {
+    while (i < L.length && L[i].text.trim() === '') i++
+    if (i >= L.length) break
+    const start = L[i].start
+    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++ // leading comments attach
+    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
+    if (SECTION.test(L[i].text)) {
+      i++ // header
+      while (i < L.length && !SECTION.test(L[i].text)) i++
+      let last = i - 1
+      while (last >= 0 && L[last].text.trim() === '') last--
+      units.push({ start, end: L[last].end })
+    } else {
+      // one key (or stray statement); consume continuation lines while brackets open
+      let depth = bracketDelta(src, at, L[i].start, L[i].end)
+      let e = L[i].end; i++
+      while (i < L.length && depth > 0) { depth += bracketDelta(src, at, L[i].start, L[i].end); e = L[i].end; i++ }
+      units.push({ start, end: e })
+    }
+  }
+  return units
+}
+
+function keyOf(text) {
+  const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
+  let m = head.match(SECTION); if (m) return (m[1] === '[[' ? 'tables:' : 'table:') + m[2].trim()
+  m = head.match(KEYLINE); if (m) return 'key:' + m[1].replace(/["']/g, '')
+  return 'stmt:' + head.trim().replace(/\s+/g, ' ')
+}
+
+function keyed(raw, src) {
+  const seen = new Map(), out = []
+  for (const u of raw) {
+    const text = src.slice(u.start, u.end)
+    let k = keyOf(text)
+    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
+    if (c > 1) k += '#' + c
+    out.push({ key: k, text, start: u.start, end: u.end })
+  }
+  return out
+}
+
+function balanced(src) {
+  const at = scannerAt(src)
+  const stack = []
+  const pair = { ']': '[', '}': '{' }
+  let i = 0
+  while (i < src.length) {
+    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
+    const c = src[i]
+    if (c === '[' || c === '{') stack.push(c)
+    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
+    i++
+  }
+  return stack.length === 0
+}
+
+export const toml = {
+  id: 'toml',
+  exts: ['.toml'],
+  parses: (src) => balanced(String(src == null ? '' : src)),
+  parsesUnit: (src) => balanced(String(src)),
+  units: (src) => keyed(blocks(String(src)), String(src)),
+  declaredNames: () => new Set(),
+  // Descend into a section: each `key = value` inside merges independently.
+  splitUnit: (text) => {
+    const src = String(text)
+    const L = lines(src)
+    let h = 0; while (h < L.length && L[h].blank) h++
+    if (h >= L.length || !SECTION.test(L[h].text)) return null
+    const sig = src.slice(0, L[h].end)
+    const body = src.slice(L[h].end)
+    const inner = keyed(blocks(body), body)
+    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
+  },
+}

package/lang-yaml.js

@@ -1,183 +1,183 @@
-// YAML language provider for ICR — indent-mapping structural splitter.
-// YAML configs (CI pipelines, k8s manifests, docker-compose) are merged constantly
-// and line merges garble them. This provider merges by STRUCTURE: every top-level
-// `key:` block is a unit keyed by its key name, and splitUnit descends into nested
-// mapping levels — so two people editing DIFFERENT jobs/services/sections merge
-// cleanly, and the SAME key edited two ways is a named conflict.
-//
-// Honest heuristic (no parser dependency): tracks #-comments, quoted strings, and
-// flow brackets; parses() checks bracket balance + indentation coherence (a dedent
-// must land on an indent level that exists — the failure mode of a bad splice).
-// Block scalars (|, >) are tolerated: their content is deeper-indented free text.
-
-function scannerAt(src) {
-  const n = src.length
-  return function at(i) {
-    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
-    if (src[i] === '"' || src[i] === "'") {
-      const q = src[i]; let j = i + 1
-      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
-      return j
-    }
-    return -1
-  }
-}
-
-// Line records with indent; comment-only and blank lines are marked.
-function lines(src) {
-  const out = []
-  let i = 0
-  while (i < src.length) {
-    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
-    const raw = src.slice(i, e)
-    const body = raw.replace(/\r?\n$/, '')
-    let indent = 0; while (indent < body.length && body[indent] === ' ') indent++
-    const trimmed = body.trim()
-    out.push({ start: i, end: e, indent, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
-    i = e
-  }
-  return out
-}
-
-// KEY SHAPES. A YAML key may be QUOTED, and a quoted key legally contains ':' and '#';
-// a plain key may contain '#' too ('#' only opens a comment at line start or after a
-// space). The original class excluded both characters from the key body, so any such key
-// failed KEY and fell through to `'stmt:' + <whole head line>` — a unit key that contains
-// the VALUE. Two sides editing that ONE key then produced two DIFFERENT unit keys, so the
-// engine saw unrelated add/deletes, unioned them, and emitted the key TWICE while
-// reporting the merge 'auto' and clean. Duplicate mapping keys are invalid YAML and every
-// loader keeps the last, so one side's edit was silently discarded — no-silent-loss
-// failing exactly as it did for type-first method signatures in lang-brace.js.
-// Measured before the fix (both top level and nested): "a:b", 'a:b', foo#bar, "a#b" all
-// auto-merged into a duplicated key; plain keys conflicted correctly.
-const QKEY = /^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*')\s*:(\s|$)/  // "quoted key": / 'quoted key':
-const KEY = /^([^:#\s][^:]*?):(\s|$)/     // `key:` or `key: value` (body may contain '#')
-const DASH = /^-(\s|$)/                    // list item
-
-// Cut a trailing ` #comment` that is not inside quotes, so it never lands in a key.
-function stripComment(line) {
-  const at = scannerAt(line)
-  let i = 0
-  while (i < line.length) {
-    if (line[i] === '#' && i > 0 && /\s/.test(line[i - 1])) return line.slice(0, i)
-    const j = at(i)
-    if (j > i && line[i] !== '#') { i = j; continue }
-    i++
-  }
-  return line
-}
-
-// `"a"` and `a` name the SAME key in YAML, so they must key the same — otherwise the
-// pair is the very ambiguity this function exists to remove.
-const unquote = (k) => (/^"(?:[^"\\]|\\.)*"$/.test(k) || /^'(?:[^']|'')*'$/.test(k)) ? k.slice(1, -1) : k
-
-function keyOf(text) {
-  const t = stripComment(text.trim()).trim()
-  let m = t.match(QKEY)
-  if (m) return 'key:' + unquote(m[1])
-  m = t.match(KEY)
-  if (m) return 'key:' + unquote(m[1].trim())
-  if (t === '---' || t === '...') return 'doc:' + t
-  return 'stmt:' + t.replace(/\s+/g, ' ')
-}
-
-// Units whose heads sit at exactly `baseIndent`: a `key:`/`- ` head owns all
-// following blank or deeper-indented lines (its block).
-function blocks(src, baseIndent = 0) {
-  const L = lines(src)
-  const units = []
-  let i = 0
-  while (i < L.length) {
-    while (i < L.length && L[i].text.trim() === '') i++ // pure blanks are gap text
-    if (i >= L.length) break
-    const start = L[i].start
-    // leading comment lines attach to the unit that follows
-    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++
-    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
-    if (L[i].indent !== baseIndent) { units.push({ start, end: L[i].end }); i++; continue }
-    i++ // the head line
-    while (i < L.length && (L[i].blank || L[i].indent > baseIndent)) i++
-    let last = i - 1
-    while (last >= 0 && L[last].text.trim() === '') last-- // trailing blanks are gap text
-    units.push({ start, end: L[last].end })
-  }
-  return units
-}
-
-function keyed(raw, src) {
-  const seen = new Map(), out = []
-  for (const u of raw) {
-    const text = src.slice(u.start, u.end)
-    // key by the HEAD line (skipping attached leading comments)
-    const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
-    const baseKey = keyOf(head)
-    let k = baseKey
-    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
-    if (c > 1) k += '#' + c
-    out.push({ key: k, baseKey, text, start: u.start, end: u.end })
-  }
-  return out
-}
-
-// Bracket balance (flow style) + unterminated-string detection.
-function balanced(src) {
-  const at = scannerAt(src)
-  const stack = []
-  const pair = { ')': '(', ']': '[', '}': '{' }
-  let i = 0
-  while (i < src.length) {
-    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
-    const c = src[i]
-    if (c === '(' || c === '[' || c === '{') stack.push(c)
-    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
-    i++
-  }
-  return stack.length === 0
-}
-
-// Indentation coherence: an indent INCREASE opens a new level (always legal in YAML —
-// nested mapping, list, or block-scalar content); a DECREASE must land on a level
-// that is already on the stack. This is exactly what a bad merge splice violates.
-function indentsOk(src) {
-  const L = lines(src)
-  let stack = null
-  for (const l of L) {
-    if (l.blank) continue
-    if (stack == null) { stack = [l.indent]; continue }
-    const top = stack[stack.length - 1]
-    if (l.indent > top) { stack.push(l.indent); continue }
-    if (l.indent < top) {
-      while (stack.length > 1 && stack[stack.length - 1] > l.indent) stack.pop()
-      if (stack[stack.length - 1] !== l.indent) return false
-    }
-  }
-  return true
-}
-
-export const yaml = {
-  id: 'yaml',
-  exts: ['.yml', '.yaml'],
-  parses: (src) => { const s = String(src == null ? '' : src); return balanced(s) && indentsOk(s) },
-  parsesUnit: (src) => { const s = String(src); return balanced(s) && indentsOk(s) },
-  units: (src) => keyed(blocks(String(src), 0), String(src)),
-  declaredNames: () => new Set(), // keys are structure, not code declarations
-  // Descend one mapping level: `jobs:` -> each job merges independently.
-  splitUnit: (text) => {
-    const src = String(text)
-    const L = lines(src)
-    let h = 0; while (h < L.length && L[h].blank) h++
-    if (h >= L.length) return null
-    const head = L[h]
-    if (!KEY.test(head.text.trim())) return null
-    if (head.text.trim().match(/:\s*[|>][+-]?\s*(#.*)?$/)) return null // block scalar: free text, do not descend
-    if (!/:\s*(#.*)?$/.test(head.text)) return null                    // inline value (`key: v`): nothing beneath
-    let b = h + 1; while (b < L.length && L[b].blank) b++
-    if (b >= L.length || L[b].indent <= head.indent) return null       // empty block
-    const bodyIndent = L[b].indent
-    const sig = src.slice(0, L[h].end)
-    const body = src.slice(L[h].end)
-    const inner = keyed(blocks(body, bodyIndent), body)
-    if (inner.some((u) => u.key.startsWith('stmt:-') || DASH.test(u.text.trim()))) return null // list items: order matters, stay whole
-    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
-  },
-}
+// YAML language provider for ICR — indent-mapping structural splitter.
+// YAML configs (CI pipelines, k8s manifests, docker-compose) are merged constantly
+// and line merges garble them. This provider merges by STRUCTURE: every top-level
+// `key:` block is a unit keyed by its key name, and splitUnit descends into nested
+// mapping levels — so two people editing DIFFERENT jobs/services/sections merge
+// cleanly, and the SAME key edited two ways is a named conflict.
+//
+// Honest heuristic (no parser dependency): tracks #-comments, quoted strings, and
+// flow brackets; parses() checks bracket balance + indentation coherence (a dedent
+// must land on an indent level that exists — the failure mode of a bad splice).
+// Block scalars (|, >) are tolerated: their content is deeper-indented free text.
+
+function scannerAt(src) {
+  const n = src.length
+  return function at(i) {
+    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i]; let j = i + 1
+      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
+      return j
+    }
+    return -1
+  }
+}
+
+// Line records with indent; comment-only and blank lines are marked.
+function lines(src) {
+  const out = []
+  let i = 0
+  while (i < src.length) {
+    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
+    const raw = src.slice(i, e)
+    const body = raw.replace(/\r?\n$/, '')
+    let indent = 0; while (indent < body.length && body[indent] === ' ') indent++
+    const trimmed = body.trim()
+    out.push({ start: i, end: e, indent, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
+    i = e
+  }
+  return out
+}
+
+// KEY SHAPES. A YAML key may be QUOTED, and a quoted key legally contains ':' and '#';
+// a plain key may contain '#' too ('#' only opens a comment at line start or after a
+// space). The original class excluded both characters from the key body, so any such key
+// failed KEY and fell through to `'stmt:' + <whole head line>` — a unit key that contains
+// the VALUE. Two sides editing that ONE key then produced two DIFFERENT unit keys, so the
+// engine saw unrelated add/deletes, unioned them, and emitted the key TWICE while
+// reporting the merge 'auto' and clean. Duplicate mapping keys are invalid YAML and every
+// loader keeps the last, so one side's edit was silently discarded — no-silent-loss
+// failing exactly as it did for type-first method signatures in lang-brace.js.
+// Measured before the fix (both top level and nested): "a:b", 'a:b', foo#bar, "a#b" all
+// auto-merged into a duplicated key; plain keys conflicted correctly.
+const QKEY = /^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*')\s*:(\s|$)/  // "quoted key": / 'quoted key':
+const KEY = /^([^:#\s][^:]*?):(\s|$)/     // `key:` or `key: value` (body may contain '#')
+const DASH = /^-(\s|$)/                    // list item
+
+// Cut a trailing ` #comment` that is not inside quotes, so it never lands in a key.
+function stripComment(line) {
+  const at = scannerAt(line)
+  let i = 0
+  while (i < line.length) {
+    if (line[i] === '#' && i > 0 && /\s/.test(line[i - 1])) return line.slice(0, i)
+    const j = at(i)
+    if (j > i && line[i] !== '#') { i = j; continue }
+    i++
+  }
+  return line
+}
+
+// `"a"` and `a` name the SAME key in YAML, so they must key the same — otherwise the
+// pair is the very ambiguity this function exists to remove.
+const unquote = (k) => (/^"(?:[^"\\]|\\.)*"$/.test(k) || /^'(?:[^']|'')*'$/.test(k)) ? k.slice(1, -1) : k
+
+function keyOf(text) {
+  const t = stripComment(text.trim()).trim()
+  let m = t.match(QKEY)
+  if (m) return 'key:' + unquote(m[1])
+  m = t.match(KEY)
+  if (m) return 'key:' + unquote(m[1].trim())
+  if (t === '---' || t === '...') return 'doc:' + t
+  return 'stmt:' + t.replace(/\s+/g, ' ')
+}
+
+// Units whose heads sit at exactly `baseIndent`: a `key:`/`- ` head owns all
+// following blank or deeper-indented lines (its block).
+function blocks(src, baseIndent = 0) {
+  const L = lines(src)
+  const units = []
+  let i = 0
+  while (i < L.length) {
+    while (i < L.length && L[i].text.trim() === '') i++ // pure blanks are gap text
+    if (i >= L.length) break
+    const start = L[i].start
+    // leading comment lines attach to the unit that follows
+    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++
+    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
+    if (L[i].indent !== baseIndent) { units.push({ start, end: L[i].end }); i++; continue }
+    i++ // the head line
+    while (i < L.length && (L[i].blank || L[i].indent > baseIndent)) i++
+    let last = i - 1
+    while (last >= 0 && L[last].text.trim() === '') last-- // trailing blanks are gap text
+    units.push({ start, end: L[last].end })
+  }
+  return units
+}
+
+function keyed(raw, src) {
+  const seen = new Map(), out = []
+  for (const u of raw) {
+    const text = src.slice(u.start, u.end)
+    // key by the HEAD line (skipping attached leading comments)
+    const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
+    const baseKey = keyOf(head)
+    let k = baseKey
+    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
+    if (c > 1) k += '#' + c
+    out.push({ key: k, baseKey, text, start: u.start, end: u.end })
+  }
+  return out
+}
+
+// Bracket balance (flow style) + unterminated-string detection.
+function balanced(src) {
+  const at = scannerAt(src)
+  const stack = []
+  const pair = { ')': '(', ']': '[', '}': '{' }
+  let i = 0
+  while (i < src.length) {
+    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
+    const c = src[i]
+    if (c === '(' || c === '[' || c === '{') stack.push(c)
+    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
+    i++
+  }
+  return stack.length === 0
+}
+
+// Indentation coherence: an indent INCREASE opens a new level (always legal in YAML —
+// nested mapping, list, or block-scalar content); a DECREASE must land on a level
+// that is already on the stack. This is exactly what a bad merge splice violates.
+function indentsOk(src) {
+  const L = lines(src)
+  let stack = null
+  for (const l of L) {
+    if (l.blank) continue
+    if (stack == null) { stack = [l.indent]; continue }
+    const top = stack[stack.length - 1]
+    if (l.indent > top) { stack.push(l.indent); continue }
+    if (l.indent < top) {
+      while (stack.length > 1 && stack[stack.length - 1] > l.indent) stack.pop()
+      if (stack[stack.length - 1] !== l.indent) return false
+    }
+  }
+  return true
+}
+
+export const yaml = {
+  id: 'yaml',
+  exts: ['.yml', '.yaml'],
+  parses: (src) => { const s = String(src == null ? '' : src); return balanced(s) && indentsOk(s) },
+  parsesUnit: (src) => { const s = String(src); return balanced(s) && indentsOk(s) },
+  units: (src) => keyed(blocks(String(src), 0), String(src)),
+  declaredNames: () => new Set(), // keys are structure, not code declarations
+  // Descend one mapping level: `jobs:` -> each job merges independently.
+  splitUnit: (text) => {
+    const src = String(text)
+    const L = lines(src)
+    let h = 0; while (h < L.length && L[h].blank) h++
+    if (h >= L.length) return null
+    const head = L[h]
+    if (!KEY.test(head.text.trim())) return null
+    if (head.text.trim().match(/:\s*[|>][+-]?\s*(#.*)?$/)) return null // block scalar: free text, do not descend
+    if (!/:\s*(#.*)?$/.test(head.text)) return null                    // inline value (`key: v`): nothing beneath
+    let b = h + 1; while (b < L.length && L[b].blank) b++
+    if (b >= L.length || L[b].indent <= head.indent) return null       // empty block
+    const bodyIndent = L[b].indent
+    const sig = src.slice(0, L[h].end)
+    const body = src.slice(L[h].end)
+    const inner = keyed(blocks(body, bodyIndent), body)
+    if (inner.some((u) => u.key.startsWith('stmt:-') || DASH.test(u.text.trim()))) return null // list items: order matters, stay whole
+    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
+  },
+}