heyquilt 0.3.121 → 0.3.138

package/src/quilts/import.js

@@ -1,134 +0,0 @@
-// The server side of a git import (plans/quilt-source-control/14): the importer (import-git.js,
-// run where the repository is) uploads packs of blobs and commit records, then sends the
-// commits in order through importBatch. Each commit on a branch's first-parent chain becomes a
-// patch on its line (HEAD's branch is main) with its own square; a merge commit's side commits
-// become the commits of the merge's square. importKnown lets a second import add only new commits.
-// The snapshot of every patch is derived here, eagerly, as for any merge into a line.
-import { cleanCommit, commitId } from './records.js'
-import { QuiltError } from './service.js'
-
-const MAX_BATCH = 500
-const MAX_KNOWN = 5000
-// A git branch keeps its name as a line: git's own characters, no `..`, no trailing slash.
-const BRANCH = /^[A-Za-z0-9._-][A-Za-z0-9._/-]{0,99}$/
-
-export function importLineName (raw) {
-  const s = String(raw || '')
-  if (!BRANCH.test(s) || /\.\.|\/\/|\/$|\.lock$/.test(s) || s === 'main') throw new QuiltError(400, 'bad_request', `a git branch named ${s} cannot be a line`)
-  return s
-}
-
-export function importOps (svc) {
-  const { store, now, quiltFor, getCommit, treeGrower, seal, snapshot, fromStore } = svc.internals
-
-  /** The quilt, if an import made it: only those take imported commits. */
-  async function importQuilt (me, ref) {
-    const q = await quiltFor(me, ref, 'admin')
-    const quilt = await store.getQuilt(q.id)
-    if (!quilt.settings?.importing) throw new QuiltError(409, 'bad_request', 'this quilt was not made by an import (seam import git makes a new quilt, or adds to one it made)')
-    return q
-  }
-
-  /**
-   * lines: [{ name, tip }], new lines made first, each at a commit already imported (a git branch).
-   * items: [{ id, commit (JSON record), kind: 'patch' | 'side', line (default main), square: { id,
-   * title, base, holder }, git_sha, payload }], in an order where parents come first.
-   */
-  async function importBatch (me, ref, { items = [], lines = [] } = {}) {
-    const q = await importQuilt(me, ref)
-    if (items.length > MAX_BATCH) throw new QuiltError(400, 'bad_request', `at most ${MAX_BATCH} commits a batch`)
-    for (const l of lines) {
-      const name = importLineName(l.name)
-      if (!l.tip || !(await store.getCommit(q.id, l.tip))) throw new QuiltError(422, 'bad_request', `line ${name} starts at a commit that is not imported`)
-      try { await store.createLine({ quilt_id: q.id, name, tip: l.tip, actor: me.member_id, at: now() }) } catch (err) { throw fromStore(err) }
-    }
-    // Check everything first: ids, sealed records and blobs.
-    const prepared = []
-    for (const it of items) {
-      const c = cleanCommit({ ...it.commit, quilt_id: q.id })
-      const id = commitId(c)
-      if (id !== it.id) throw new QuiltError(422, 'bad_request', `commit ${String(it.id).slice(0, 12)} does not match its record (the server computes ${id.slice(0, 12)})`)
-      if (await store.getCommit(q.id, id)) { prepared.push({ it, c, id, done: true }); continue }
-      if (!(await store.getObject(q.id, id))) throw new QuiltError(422, 'pack_unsealed', `commit record ${id.slice(0, 12)} is not uploaded`, { ids: [id] })
-      const blobIds = [...new Set(c.changes.filter((x) => x.op === 'put').map((x) => x.blob))]
-      const have = new Set(await store.hasBlobs(q.id, blobIds))
-      const missing = blobIds.filter((b) => !have.has(b))
-      if (missing.length) throw new QuiltError(422, 'pack_unsealed', `${missing.length} blobs of commit ${id.slice(0, 12)} are not uploaded`, { ids: missing.slice(0, 50) })
-      prepared.push({ it, c, id })
-    }
-    // Snapshots of the patches, in order, sealed in one server pack before any row names them.
-    const heads = new Map() // line → { tip, root }
-    const grow = treeGrower(q.id)
-    const nodes = []
-    for (const p of prepared) {
-      if (p.done || p.it.kind !== 'patch') continue
-      const ln = p.it.line || 'main'
-      if (!heads.has(ln)) {
-        const row = await store.getLine(q.id, ln)
-        if (!row) throw new QuiltError(404, 'not_found', `no line ${ln}`)
-        heads.set(ln, { tip: row.tip, root: await snapshot(q.id, row.tip) })
-      }
-      const h = heads.get(ln)
-      if ((p.c.parents[0] || null) !== (h.tip || null)) throw new QuiltError(422, 'bad_request', `patch ${p.id.slice(0, 12)} does not follow ${ln}'s tip`)
-      const t = await grow(h.root, p.c.changes)
-      h.root = t.root
-      nodes.push(...t.objects)
-      p.root = t.root
-      h.tip = p.id
-    }
-    await seal(q.id, nodes)
-    // Stub members for the authors (14): one row per distinct stub id, before any commit names it.
-    const stubs = new Map()
-    for (const p of prepared) {
-      if (p.done) continue
-      const a = p.c.author || {}
-      if (String(a.member_id || '').startsWith('stub:') && !stubs.has(a.member_id)) {
-        const rest = a.member_id.slice(5)
-        stubs.set(a.member_id, { member_id: a.member_id, kind: a.kind === 'agent' ? 'agent' : 'person', name: a.name || null, email: rest.includes('@') ? rest : null })
-      }
-    }
-    if (stubs.size) await store.addStubs({ quilt_id: q.id, stubs: [...stubs.values()], at: now() })
-    let patches = 0; let commits = 0
-    for (const p of prepared) {
-      if (p.done) continue
-      const at = now()
-      const sq = await store.getSquare(p.it.square.id)
-      if (!sq) {
-        await store.openSquare({ square: { id: p.it.square.id, quilt_id: q.id, title: String(p.it.square.title || '').slice(0, 200), line: p.it.line || 'main', base: p.it.square.base || null, holder: p.it.square.holder || me.member_id, opened_by: me.member_id, writers: [], import: true }, at })
-      }
-      await store.stageFiles({ quilt_id: q.id, commit_id: p.id, files: p.c.changes })
-      const record = { ...p.c, id: p.id, at }
-      const payload = { ...(p.it.payload || {}), ...(p.it.git_sha ? { git_sha: p.it.git_sha } : {}) }
-      if (p.it.kind === 'patch') {
-        const ln = p.it.line || 'main'
-        const cur = await store.getLine(q.id, ln)
-        await store.merge({ commit: record, line: ln, expected_tip: cur.tip, expect_head: null, snapshot_root: p.root, actor: me.member_id, at, payload, import: true })
-        await store.fillLinePaths({ quilt_id: q.id })
-        patches++
-      } else {
-        await store.importCommit({ commit: record, actor: me.member_id, at, payload })
-      }
-      commits++
-      if (p.it.git_sha) await store.setGitSha({ quilt_id: q.id, sha: p.it.git_sha, commit_id: p.id })
-    }
-    const after = await store.getLine(q.id, 'main')
-    return { ok: true, commits, patches, tip: after.tip, patch_count: after.patch_count }
-  }
-
-  /** POST /import/known { shas }: which git commits this quilt already has → { known: { sha: commit id } }. */
-  async function importKnown (me, ref, { shas = [] } = {}) {
-    const q = await importQuilt(me, ref)
-    if (!Array.isArray(shas) || shas.length > MAX_KNOWN) throw new QuiltError(400, 'bad_request', `at most ${MAX_KNOWN} shas a request`)
-    const list = shas.map((s) => String(s).toLowerCase()).filter((s) => /^[0-9a-f]{40,64}$/.test(s))
-    return { known: list.length ? await store.gitShas(q.id, list) : {} }
-  }
-
-  /** Marks the import finished: the quilt takes ordinary merges from now on. */
-  async function importDone (me, ref) {
-    const q = await quiltFor(me, ref, 'admin')
-    const line = await store.getLine(q.id, 'main')
-    return { ok: true, tip: line.tip, patch_count: line.patch_count, tip_commit: line.tip ? (await getCommit(q.id, line.tip)).id : null }
-  }
-
-  return { importBatch, importDone, importKnown }
-}

package/src/quilts/index.js

@@ -1,72 +0,0 @@
-// Quilt source control, assembled: the server's operations over a store and an object store.
-import { createQuiltService } from './service.js'
-import { mergeOps } from './merge.js'
-import { blameOps } from './blame.js'
-import { importOps } from './import.js'
-import { squareOps } from './squares.js'
-import { eventOps } from './events.js'
-import { exportOps } from './export.js'
-import { createArchiver } from './archiver.js'
-import { windowOps } from './window.js'
-import { autoRevertOps } from './autorevert.js'
-import { QuiltError } from './service.js'
-import { lineOps } from './lines.js'
-import { tagOps } from './tags.js'
-import { claimOps } from './claims.js'
-import { reviewOps } from './reviews.js'
-import { resolutionOps } from './resolutions.js'
-import { liveOps } from './live.js'
-import { historyOps } from './history.js'
-import { signingOps } from './signing.js'
-import { tokenOps } from './tokens.js'
-import { createLimiter } from './limits.js'
-
-// Writes after which the events job runs (in the background; GET /events runs it too).
-const WRITES = ['commit', 'amend', 'mergeIntoLine', 'rebase', 'cherryPick', 'revert', 'resolve', 'handoff', 'abandon', 'reopen', 'mergeSquare', 'fold', 'split', 'newLine', 'freezeLine', 'unfreezeLine', 'createTag', 'createRelease', 'reportCheck', 'review', 'setLinePolicy', 'reportSquareCheck']
-
-export function createQuilts ({ store, objects, now = Date.now, events: eventOpts = {}, archive: archiveOpts = {}, mergeWindow: windowOpts = {}, rateLimits = {} }) {
-  const svc = createQuiltService({ store, objects, now })
-  // The merge window (07): `mergeWindow: false` turns the check off, `{ max }` sets the default.
-  const win = windowOps(svc, windowOpts || {})
-  if (windowOpts !== false) svc.internals.mergeWindow = win.checkWindow
-  const { guardReview, ...reviewApi } = reviewOps(svc)
-  svc.internals.guardReview = guardReview
-  const merges = mergeOps(svc)
-  const { mergeInternals, ...mergeApi } = merges
-  const squares = squareOps(svc, mergeInternals)
-  const ev = eventOps(svc, squares, eventOpts)
-  // The log archiver (03): after each write, in the background, writes the segments that are due.
-  const archiver = archiveOpts === false ? null : createArchiver({ store, objects, now, ...archiveOpts })
-  const { checkWindow, ...windowApi } = win
-  // Per-token rate limits (04), applied by the HTTP routes: `rateLimits: false` turns them off.
-  const rateLimiter = rateLimits === false ? null : createLimiter({ now, ...rateLimits })
-  const api = { archiver, rateLimiter, ...windowApi, ...svc, ...mergeApi, ...blameOps(svc), ...importOps(svc), ...exportOps(svc), ...lineOps(svc), ...tagOps(svc), ...claimOps(svc), ...reviewApi, ...resolutionOps(svc), ...tokenOps(svc), ...liveOps(svc), ...historyOps(svc, { mergeBase: squares.mergeBase }), ...squares, ...ev }
-  // Signed commits (signing.js): log { show_signature } checks each commit's signature.
-  const { withSignatures, ...signApi } = signingOps(svc)
-  Object.assign(api, signApi)
-  const plainLog = api.log
-  api.log = async (me, ref, opts = {}) => {
-    const { show_signature: show, ...rest } = opts
-    const r = await plainLog(me, ref, rest)
-    return show ? withSignatures(me, ref, r) : r
-  }
-  // A red check that names the patch it failed at reverts that patch by itself (07, autorevert.js).
-  const auto = autoRevertOps(svc, api)
-  const report = api.reportCheck
-  api.reportCheck = async (me, ref, line, body = {}) => {
-    const n = body.patch == null ? null : Number(body.patch)
-    if (n != null && (!Number.isInteger(n) || n < 1)) throw new QuiltError(400, 'bad_request', 'patch: the number of the patch on the line the check failed at')
-    const w = await report(me, ref, line, body)
-    if (n == null || body.status !== 'red') return w
-    return { ...w, revert: await auto.revertCulprit(me, ref, line, String(body.check).trim(), n) }
-  }
-  for (const name of WRITES) {
-    const fn = api[name]
-    api[name] = async (me, ref, ...rest) => {
-      const r = await fn(me, ref, ...rest)
-      svc.internals.quiltFor(me, ref).then((q) => { archiver?.maybe(q.id); mergeApi.sweepMerges(q.id).catch(() => {}); return ev.pumpEvents(q.id) }).catch(() => {})
-      return r
-    }
-  }
-  return api
-}

package/src/quilts/limits.js

@@ -1,67 +0,0 @@
-// Per-token rate limits (plans/quilt-source-control/04 "Rate limiting and load shedding",
-// decision 40): counted per token, so an agent's key and the person it works for are limited
-// apart; a person's token gets five times an agent's numbers (11). A limit answers at once with
-// 429 rate_limited, `limit` naming its row and `retry_after` seconds; nothing waits.
-// Counted in this API process (sliding windows of request times): with several API machines a
-// token can reach up to one allowance per machine (NOT-DONE.md).
-import crypto from 'node:crypto'
-import { QuiltError } from './service.js'
-
-const MIN = 60 * 1000
-const HOUR = 60 * MIN
-const DAY = 24 * HOUR
-
-/** 04's rows for an agent token: [name, count, window ms, which requests]. */
-export const LIMITS = [
-  ['token_rate', 600, MIN, 'rpc'],
-  ['commit_rate', 60, MIN, 'commit'],
-  ['commit_rate', 2000, DAY, 'commit'],
-  ['merge_rate', 30, HOUR, 'merge']
-]
-export const PERSON_FACTOR = 5
-
-/** Which counters a request takes: object traffic (packs, blob and object reads) takes none. */
-export function classify (method, url, body) {
-  const p = String(url).split('?')[0]
-  if (/\/(packs|objects|blobs)(\/|$)/.test(p)) return []
-  if (method === 'POST' && /\/squares\/[^/]+\/commit$/.test(p)) return ['rpc', 'commit']
-  if (method === 'POST' && /\/lines\/[^/]+\/merge$/.test(p)) return body && body.dry_run ? ['rpc'] : ['rpc', 'merge'] // a dry run is never merge-limited
-  return ['rpc']
-}
-
-/** The token's key: a hash of its Authorization header (the token itself is never kept). */
-export const tokenKey = (req, me) => {
-  const h = req && req.headers && req.headers.authorization
-  return h ? crypto.createHash('sha256').update(h).digest('hex').slice(0, 32) : `member:${me.member_id}:${me.kind}`
-}
-
-export function createLimiter ({ now = Date.now, limits = LIMITS, personFactor = PERSON_FACTOR } = {}) {
-  const seen = new Map() // token + row index → request times, oldest first
-
-  /** Counts one request of `kinds` for `key`, or throws 429 rate_limited without counting it. */
-  function take (key, kinds, person) {
-    const t = now()
-    const rows = []
-    for (let i = 0; i < limits.length; i++) {
-      const [name, count, windowMs, kind] = limits[i]
-      if (!kinds.includes(kind)) continue
-      const max = person ? count * personFactor : count
-      const id = `${key}\u0000${i}`
-      let times = seen.get(id)
-      if (!times) { times = []; seen.set(id, times) }
-      let drop = 0
-      while (drop < times.length && times[drop] <= t - windowMs) drop++
-      if (drop) times.splice(0, drop)
-      if (times.length >= max) {
-        const retry = Math.max(1, Math.ceil((times[0] + windowMs - t) / 1000))
-        throw new QuiltError(429, 'rate_limited', `rate limit ${name}: ${max} in ${windowMs >= DAY ? 'a day' : windowMs >= HOUR ? 'an hour' : 'a minute'} for this token; try again in ${retry} s`, { limit: name, retry_after: retry })
-      }
-      rows.push(times)
-    }
-    for (const times of rows) times.push(t)
-    // Forget tokens with nothing left in any window, so the map stays the size of the active ones.
-    if (seen.size > 10000) for (const [id, times] of seen) if (!times.length || times[times.length - 1] <= t - DAY) seen.delete(id)
-  }
-
-  return { take }
-}

package/src/quilts/lines.js

@@ -1,49 +0,0 @@
-// Lines (plans/quilt-source-control/06): main, and release/<name> lines made from any revision.
-// A square opens from any line and merges into any line; a frozen line refuses merges with
-// line_frozen until it is unfrozen. Anyone who can write makes a line; an admin freezes one.
-import { QuiltError } from './service.js'
-
-const RELEASE = /^release\/[A-Za-z0-9._-]{1,100}$/
-
-/** `1.0` or `release/1.0` → `release/1.0`; anything else is refused. */
-export function lineName (raw) {
-  const s = String(raw || '').trim()
-  const name = s === 'main' || s.startsWith('release/') ? s : `release/${s}`
-  if (name !== 'main' && !RELEASE.test(name)) throw new QuiltError(400, 'bad_request', 'a new line is release/<name>: letters, digits, dots, dashes and underscores')
-  return name
-}
-
-export function lineOps (svc) {
-  const { store, now, quiltFor, resolve, fromStore } = svc.internals
-
-  const view = (l) => ({ name: l.name, tip: l.tip, patch_count: l.patch_count, frozen: !!l.frozen })
-
-  /** GET /lines: every line of the quilt, main first. */
-  async function lines (me, ref) {
-    const q = await quiltFor(me, ref, 'read')
-    const all = (await store.lines(q.id)).map(view)
-    return { lines: [...all.filter((l) => l.name === 'main'), ...all.filter((l) => l.name !== 'main')] }
-  }
-
-  /** POST /lines { name, from? }: a new line at a revision (default the tip of main). */
-  async function newLine (me, ref, { name, from } = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const n = lineName(name)
-    if (n === 'main') throw new QuiltError(409, 'line_exists', 'there is already a line main')
-    const tip = await resolve(q.id, from || 'main')
-    if (!tip) throw new QuiltError(400, 'bad_request', `${from || 'main'} has no commits to start a line from`)
-    try { return view(await store.createLine({ quilt_id: q.id, name: n, tip, actor: me.member_id, at: now() })) } catch (err) { throw fromStore(err) }
-  }
-
-  async function setFrozen (me, ref, line, frozen) {
-    const q = await quiltFor(me, ref, 'admin')
-    try { return view(await store.setLineFrozen({ quilt_id: q.id, name: String(line), frozen, actor: me.member_id, at: now() })) } catch (err) { throw fromStore(err) }
-  }
-
-  return {
-    lines,
-    newLine,
-    freezeLine: (me, ref, line) => setFrozen(me, ref, line, true),
-    unfreezeLine: (me, ref, line) => setFrozen(me, ref, line, false)
-  }
-}

package/src/quilts/live.js

@@ -1,50 +0,0 @@
-// A square's live work (02, sq:<id>:live): the uncommitted changes its holder shares on the server,
-// so others (people, agents, CI) can read work in progress before it is committed. It is whole
-// files (each put or delete replaces what the square's head has), replaced at once by each PUT,
-// and never history: a commit is still how work is kept. Any host can feed it, a block folder
-// (`seam live share`), an editor or a live-editing service, through the same route.
-import { QuiltError, squareShort } from './service.js'
-import { guardClaims } from './claims.js'
-
-export function liveOps (svc) {
-  const { store, now, quiltFor, squareByRef, writable, prepareChanges, seal, snapshot, reader, fromStore } = svc.internals
-
-  // Only what still differs from the square's head: a change committed since drops out.
-  async function view (q, sq, row) {
-    const head = sq.head || sq.base
-    const root = await snapshot(q, head)
-    const changes = []
-    for (const c of row?.changes || []) {
-      const e = await reader(q).lookup(root, c.path)
-      if (c.op === 'delete' ? !e : (e && e.blob === c.blob && e.mode === c.mode)) continue
-      changes.push({ path: c.path, op: c.op, ...(c.op === 'put' ? { blob: c.blob, mode: c.mode, size: c.size, status: e ? 'modified' : 'added' } : { status: 'deleted' }) })
-    }
-    return { square: squareShort(sq.id), square_id: sq.id, head, made_on: row?.head || null, changes, by: row?.actor || null, at: row?.at || null }
-  }
-
-  /** GET /squares/:id/live: the square's shared uncommitted changes. */
-  async function live (me, ref, sqRef) {
-    const q = await quiltFor(me, ref, 'read')
-    const sq = await squareByRef(q.id, sqRef)
-    return view(q.id, sq, await store.getLive(q.id, sq.id))
-  }
-
-  /** PUT /squares/:id/live { changes: [{ path, op: 'put', content (base64) | blob, mode? } | { path, op: 'delete' }] }: replaces it; [] clears. */
-  async function setLive (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    if (sq.state !== 'open') throw new QuiltError(409, 'square_closed', `the square is ${sq.state}`)
-    if (!Array.isArray(body.changes || [])) throw new QuiltError(400, 'bad_request', 'changes is a list')
-    if ((body.changes || []).length > 5000) throw new QuiltError(400, 'bad_request', 'up to 5000 changes')
-    const prep = await prepareChanges(q.id, sq, body.changes || [])
-    await guardClaims(store, q.id, sq, prep.changes.map((x) => x.path))
-    if (prep.blobs.length) await seal(q.id, prep.blobs, { by: me.member_id })
-    const changes = prep.changes.map(({ copy_from: _, ...c }) => c)
-    try {
-      const row = await store.setLive({ quilt_id: q.id, square_id: sq.id, head: sq.head || sq.base, changes, actor: me.member_id, at: now() })
-      return view(q.id, sq, row)
-    } catch (err) { throw fromStore(err) }
-  }
-
-  return { live, setLive }
-}

package/src/quilts/merge-smart.js

@@ -1,114 +0,0 @@
-// The merge ladder seam settles a clash with (plans/quilt-source-control/07, steps 1 and 2): line
-// by line as git does, then two inserts at one place, a one-line import both sides changed,
-// whitespace-only changes, and word by word within the clashing lines. Seam's own copy, so the
-// Quilt app's merges can change without changing how a quilt merges.
-import { diff3Merge } from 'node-diff3'
-
-const lines = (s) => s.split('\n')
-
-/**
- * A text's line endings: 'crlf' (every line ends \r\n), 'lf' (none does), 'mixed', or null (one line:
- * nothing to tell).
- */
-function eolOf (s) {
-  if (typeof s !== 'string' || !s.includes('\n')) return null
-  if (!s.includes('\r\n')) return 'lf'
-  return s.replace(/\r\n/g, '').includes('\n') ? 'mixed' : 'crlf'
-}
-
-/**
- * The merges compare lines, so a side saved with Windows line endings (\r\n) against a base and other
- * side with \n differs on every line: diff3 then reads it as "ours deleted the whole file and inserted
- * it again", the delete loses to theirs' edits and the insert stays, and the file comes out as both
- * versions one after the other (task 7b480c8b07c4fa02: web/lib/docs.js, CRLF old + LF new, every
- * export twice). When the sides' line endings differ, all three are merged with \n and the result is
- * written in the line endings of the side that changed them from the base (ours when both did, or
- * when there is no base to tell), as any other edit to the file would be kept.
- */
-function eolAware (merge) {
-  return function (base, ours, theirs, ...rest) {
-    const eols = [base, ours, theirs].map(eolOf)
-    const seen = new Set(eols.filter(Boolean))
-    if (!seen.has('crlf') || seen.size < 2) return merge(base, ours, theirs, ...rest)
-    const [eb, eo, et] = eols
-    const target = (eo && eo !== eb) ? eo : (et && et !== eb) ? et : (eo || et || eb)
-    const lf = (s) => typeof s === 'string' ? s.replace(/\r\n/g, '\n') : s
-    const back = (t) => target === 'crlf' && typeof t === 'string' ? t.replace(/\n/g, '\r\n') : t
-    const r = merge(lf(base), lf(ours), lf(theirs), ...rest)
-    return typeof r === 'string' ? back(r) : { ...r, text: back(r.text) }
-  }
-}
-
-/** Two blocks inserted at one place, as one: shared leading and trailing lines once, the middles in order. */
-function addedBoth (a, b) {
-  let pre = 0
-  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
-  let post = 0
-  while (post < a.length - pre && post < b.length - pre && a[a.length - 1 - post] === b[b.length - 1 - post]) post++
-  return [...a.slice(0, pre), ...a.slice(pre, a.length - post), ...b.slice(pre, b.length - post), ...a.slice(a.length - post)]
-}
-
-const IMPORT = /^(\s*import\s*\{)([^}]*)(\}\s*from\s*(['"][^'"]+['"]).*)$/
-
-/** Both sides changed the same one-line import of the same module: the union of its names, or null. */
-function sameImport (o, a, b) {
-  if (o.length !== 1 || a.length !== 1 || b.length !== 1) return null
-  const [mo, ma, mb] = [IMPORT.exec(o[0]), IMPORT.exec(a[0]), IMPORT.exec(b[0])]
-  if (!mo || !ma || !mb || mo[4] !== ma[4] || ma[4] !== mb[4]) return null
-  const names = (m) => m[2].split(',').map((s) => s.trim()).filter(Boolean)
-  const [no, na, nb] = [names(mo), names(ma), names(mb)]
-  const gone = new Set(no.filter((n) => !na.includes(n) || !nb.includes(n)))
-  const all = [...na, ...nb.filter((n) => !na.includes(n))].filter((n) => !gone.has(n))
-  return [`${ma[1]} ${all.join(', ')} ${ma[3]}`]
-}
-
-const normWs = (l) => l.replace(/\s+/g, ' ').trim()
-const sameIgnoringWs = (a, b) => a.length === b.length && a.every((l, i) => normWs(l) === normWs(b[i]))
-const TOKEN = /\s+|\w+|[^\w\s]/g
-
-/** Two blocks of lines merged word by word against their base, or null when the same words changed on both sides. */
-function mergeWords (o, a, b) {
-  const tok = (ls) => ls.join('\n').match(TOKEN) || []
-  const regions = diff3Merge(tok(a), tok(o), tok(b), { excludeFalseConflicts: true })
-  if (regions.some((r) => !r.ok)) return null
-  return regions.map((r) => r.ok.join('')).join('').split('\n')
-}
-
-/**
- * The clash ladder's mechanical and structural steps (plan §7.3, steps 1 and 2): mergeAdditive, then
- * each region still clashing is tried again ignoring whitespace (a side that only reindented loses
- * to the side that changed something), then word by word within the clashing lines (two edits to
- * different words of one line both land); a file marked merge=union takes both sides, ours first.
- * Returns { text, conflicts, how } with `how` the step that settled it: 'lines', 'whitespace',
- * 'words' or 'union'; `conflicts` lists what no step could settle (text then holds ours there).
- */
-export const mergeSmart = eolAware(function mergeSmart (base, ours, theirs, { union = false } = {}) {
-  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
-  const out = []
-  const conflicts = []
-  let how = 'lines'
-  const rank = { lines: 0, whitespace: 1, words: 2, union: 3 }
-  const step = (h) => { if (rank[h] > rank[how]) how = h }
-  for (const r of regions) {
-    if (r.ok) { out.push(...r.ok); continue }
-    const c = r.conflict
-    const settled = ladder(c, { union })
-    if (settled) { out.push(...settled.lines); step(settled.how); continue }
-    conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
-    out.push(...c.a)
-  }
-  return { text: out.join('\n'), conflicts, how }
-})
-
-/** mergeSmart's steps for one region both sides changed ({ o, a, b }): { lines, how }, or null when none settles it. */
-function ladder (c, { union = false } = {}) {
-  if (union) return { lines: [...c.a, ...c.b], how: 'union' }
-  const both = c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)
-  if (both) return { lines: both, how: 'lines' }
-  if (sameIgnoringWs(c.a, c.b)) return { lines: c.a, how: 'whitespace' } // the same change, spaced differently
-  if (sameIgnoringWs(c.a, c.o)) return { lines: c.b, how: 'whitespace' } // ours only reindented
-  if (sameIgnoringWs(c.b, c.o)) return { lines: c.a, how: 'whitespace' } // theirs only reindented
-  const words = mergeWords(c.o, c.a, c.b)
-  if (words) return { lines: words, how: 'words' }
-  return null
-}