heyquilt 0.3.122 → 0.3.140

package/src/quilts/keys.js

@@ -1,186 +0,0 @@
-// Seam's own keys for its own accounts (accounts.js):
-//  - a computer linked through Seam's device flow (`seam login`): it shows a code, the person
-//    approves it on seam.heyquilt.com/device, and the computer gets a key (ssk_…) that lasts
-//    30 days and is renewed with the computer's own Ed25519 key, no browser (`resume`);
-//  - agents an account makes (`seam agent new <name>`), each with its own key (sak_…), which the
-//    owner refreshes (a new key, the old one revoked) or revokes with the agent.
-// Only a key's sha256 is kept. An agent is the member agent:<id>, on behalf of its owner.
-import crypto from 'node:crypto'
-import { QuiltError } from './errors.js'
-import { uuidv7 } from './ids.js'
-
-export const DEVICE_KEY_PREFIX = 'ssk_'
-export const AGENT_KEY_PREFIX = 'sak_'
-export const DEVICE_LINK_CONTEXT = 'seam-device-link-v1'
-export const DEVICE_RESUME_CONTEXT = 'seam-device-resume-v1'
-export const DEVICE_KEY_DAYS = 30
-export const LINK_SECONDS = 600
-export const MAX_AGENTS = 100
-const KEY = /^s[sa]k_[A-Za-z0-9_-]{43}$/
-const USER_CODE_ABC = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
-
-export const isSeamKey = (s) => KEY.test(String(s || ''))
-const sha = (s) => crypto.createHash('sha256').update(String(s)).digest('hex')
-const newSecret = (prefix) => prefix + crypto.randomBytes(32).toString('base64url')
-const userCode = () => { const b = crypto.randomBytes(8); let s = ''; for (let i = 0; i < 8; i++) s += USER_CODE_ABC[b[i] % USER_CODE_ABC.length]; return `${s.slice(0, 4)}-${s.slice(4)}` }
-
-function publicKeyOf (publicKey) {
-  try {
-    const k = crypto.createPublicKey({ key: Buffer.from(String(publicKey), 'base64url'), format: 'der', type: 'spki' })
-    if (k.asymmetricKeyType !== 'ed25519') throw new Error('not ed25519')
-    return k
-  } catch { throw new QuiltError(400, 'bad_request', 'publicKey: this computer\'s Ed25519 public key (SPKI DER, base64url)') }
-}
-const signedBy = (publicKey, text, signature) => {
-  try { return crypto.verify(null, Buffer.from(text), publicKeyOf(publicKey), Buffer.from(String(signature || ''), 'base64url')) } catch { return false }
-}
-
-export function keyOps (svc, { siteUrl = 'https://seam.heyquilt.com' } = {}) {
-  const { store, now, fromStore } = svc.internals
-  const site = String(siteUrl).replace(/\/+$/, '')
-  const profile = (a) => ({ id: a.id, name: a.name, email: a.email })
-  const agentView = (a) => ({ id: a.id, name: a.name, member_id: `agent:${a.id}`, created_at: a.created_at, ...(a.revoked_at ? { revoked_at: a.revoked_at } : {}) })
-  const accountOf = (me) => {
-    if (!me.account || me.kind !== 'person') throw new QuiltError(403, 'needs_account', 'sign in with your Seam account for this')
-    return me.account
-  }
-  const wrap = async (fn) => { try { return await fn() } catch (err) { throw fromStore(err) } }
-
-  async function deviceKeyFor (account, publicKey, name) {
-    const secret = newSecret(DEVICE_KEY_PREFIX)
-    const at = now()
-    await wrap(() => store.addKey({ id: uuidv7(at), hash: sha(secret), account_id: account.id, kind: 'device', public_key: publicKey, name, created_at: at, expires_at: at + DEVICE_KEY_DAYS * 86400_000, replace: true }))
-    return { token: secret, expiresIn: DEVICE_KEY_DAYS * 86400, profile: profile(account) }
-  }
-
-  /** POST /v1/device/start { publicKey, deviceName, platform? }: a code to approve on the site. */
-  async function deviceStart ({ publicKey, deviceName, platform } = {}) {
-    publicKeyOf(publicKey)
-    const name = String(deviceName || 'a computer').trim().slice(0, 200) || 'a computer'
-    const code = crypto.randomBytes(32).toString('base64url')
-    const at = now()
-    let link
-    for (let i = 0; !link; i++) {
-      try { link = await store.addDeviceLink({ id: uuidv7(at), code_hash: sha(code), user_code: userCode(), public_key: String(publicKey), name, platform: platform ? String(platform).slice(0, 40) : null, created_at: at, expires_at: at + LINK_SECONDS * 1000 }) } catch (err) { if (err.code !== 'exists' || i > 3) throw fromStore(err) }
-    }
-    return { deviceCode: code, userCode: link.user_code, verificationUrl: `${site}/device?code=${link.user_code}`, expiresIn: LINK_SECONDS, interval: 3 }
-  }
-
-  async function liveLink (userCodeIn) {
-    const l = await store.deviceLink({ user_code: String(userCodeIn || '').trim().toUpperCase() })
-    if (!l || l.expires_at < now()) throw new QuiltError(404, 'not_found', 'no such sign-in code, or it expired: run seam login again')
-    return l
-  }
-
-  /** GET /v1/device/:code: what the approval page shows (the signed-in person's own account only). */
-  async function deviceLinkInfo (me, code) {
-    accountOf(me)
-    const l = await liveLink(code)
-    return { user_code: l.user_code, name: l.name, platform: l.platform, state: l.state, expires_at: l.expires_at }
-  }
-
-  /** POST /v1/device/approve { user_code, approve? }: the signed-in person approves (or declines) a computer. */
-  async function deviceApprove (me, { user_code: code, approve = true } = {}) {
-    const account = accountOf(me)
-    const l = await liveLink(code)
-    if (l.state !== 'pending') throw new QuiltError(409, 'moved', 'this code was already used')
-    const out = await wrap(() => store.setDeviceLink({ id: l.id, from: 'pending', state: approve === false ? 'declined' : 'approved', account_id: account }))
-    return { user_code: out.user_code, name: out.name, state: out.state }
-  }
-
-  /** POST /v1/device/poll { deviceCode, signature }: pending, or the computer's key once approved. */
-  async function devicePoll ({ deviceCode, signature } = {}) {
-    const l = await store.deviceLink({ code_hash: sha(deviceCode) })
-    if (!l || !signedBy(l.public_key, `${DEVICE_LINK_CONTEXT}\0${deviceCode}`, signature)) throw new QuiltError(404, 'not_found', 'no such sign-in link')
-    if (l.state === 'taken' || l.expires_at < now()) throw new QuiltError(410, 'expired', 'this sign-in link expired: run seam login again')
-    if (l.state === 'declined') throw new QuiltError(403, 'declined', 'sign-in was declined in the browser')
-    if (l.state === 'pending') return { status: 'pending' }
-    await wrap(() => store.setDeviceLink({ id: l.id, from: 'approved', state: 'taken' }))
-    const account = await store.getAccount(l.account_id)
-    return { status: 'approved', ...(await deviceKeyFor(account, l.public_key, l.name)) }
-  }
-
-  /** POST /v1/device/resume { publicKey, at, signature }: a linked computer signs back in with its key. */
-  async function deviceResume ({ publicKey, at, signature } = {}) {
-    publicKeyOf(publicKey)
-    if (!Number.isFinite(Number(at)) || Math.abs(now() - Number(at)) > 5 * 60_000) throw new QuiltError(400, 'bad_request', 'at: the time now, in ms (check this computer\'s clock)')
-    const k = await store.deviceKey(String(publicKey))
-    if (!k || !signedBy(publicKey, `${DEVICE_RESUME_CONTEXT}\0${at}`, signature)) throw new QuiltError(401, 'not_linked', 'this computer is not signed in: run seam login')
-    const account = await store.getAccount(k.account_id)
-    return deviceKeyFor(account, k.public_key, k.name)
-  }
-
-  /** POST /v1/me/signout: ends the key the caller signed in with. */
-  async function signout (me) {
-    if (me.key) await wrap(() => store.revokeKey({ id: me.key, at: now() }))
-    return { ok: true }
-  }
-
-  /** The caller a Seam key stands for, or null when it is unknown, revoked or expired. */
-  async function keyCaller (secret) {
-    if (!isSeamKey(secret)) return null
-    const k = await store.keyByHash(sha(secret))
-    if (!k || k.revoked_at || (k.expires_at && k.expires_at <= now())) return null
-    const account = await store.getAccount(k.account_id)
-    if (!account) return null
-    if (k.kind === 'device') return { member_id: account.member_id, kind: 'person', name: account.name, account: account.id, key: k.id }
-    const a = await store.getAgent(k.agent_id)
-    if (!a || a.revoked_at) return null
-    return { member_id: `agent:${a.id}`, kind: 'agent', name: a.name, tool: 'seam', on_behalf_of: account.member_id, key: k.id }
-  }
-
-  async function agentKeyFor (account, agent) {
-    const secret = newSecret(AGENT_KEY_PREFIX)
-    const at = now()
-    await wrap(() => store.addKey({ id: uuidv7(at), hash: sha(secret), account_id: account, kind: 'agent', agent_id: agent.id, name: agent.name, created_at: at, expires_at: null, replace: true }))
-    return { ...agentView(agent), key: secret }
-  }
-
-  async function ownAgent (account, which) {
-    const w = String(which || '')
-    const all = await store.agentsOf(account)
-    const a = all.find((x) => x.id === w) || (() => {
-      const named = all.filter((x) => x.name === w && !x.revoked_at)
-      if (named.length > 1) throw new QuiltError(400, 'bad_request', `${named.length} agents are named ${w}; use its id`)
-      return named[0]
-    })()
-    if (!a) throw new QuiltError(404, 'not_found', `no agent ${w}`)
-    return a
-  }
-
-  /** POST /v1/agents { name, claim? }: a new agent and its key (shown in this answer only); `claim` re-links an old agent (agent:<id>) listed for this account's email, keeping its member id and its patches. */
-  async function createAgent (me, { name, claim } = {}) {
-    const account = accountOf(me)
-    if (claim != null && !/^agent:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(String(claim))) throw new QuiltError(400, 'bad_request', 'claim: the old agent\'s member id, agent:<id>')
-    let n = String(name || '').trim()
-    if (!n && claim) n = (await store.agentClaims((await store.getAccount(account)).email)).claims.find((c) => c.member_id === claim)?.name || 'agent'
-    if (!n || n.length > 100) throw new QuiltError(400, 'bad_request', 'name: the agent\'s name, up to 100 characters')
-    const at = now()
-    const a = await wrap(() => store.createAgent({ id: uuidv7(at), account_id: account, name: n, created_at: at, max: MAX_AGENTS, ...(claim ? { claim: String(claim).toLowerCase() } : {}) }))
-    return agentKeyFor(account, a)
-  }
-
-  /** GET /v1/agents: the account's agents, revoked ones too, and `relink`: old agents it may re-link. */
-  async function agents (me) {
-    const account = accountOf(me)
-    const a = await store.getAccount(account)
-    return { agents: (await store.agentsOf(account)).map(agentView), relink: (await store.agentClaims(a.email)).claims }
-  }
-
-  /** POST /v1/agents/:id/key: a new key for the agent; its old key stops working. */
-  async function refreshAgentKey (me, which) {
-    const account = accountOf(me)
-    const a = await ownAgent(account, which)
-    if (a.revoked_at) throw new QuiltError(409, 'revoked', `${a.name} was revoked; make a new agent`)
-    return agentKeyFor(account, a)
-  }
-
-  /** DELETE /v1/agents/:id: revokes the agent and its key. Its patches stay its own. */
-  async function revokeAgent (me, which) {
-    const account = accountOf(me)
-    const a = await ownAgent(account, which)
-    return agentView(await wrap(() => store.revokeAgent({ id: a.id, account_id: account, at: now() })))
-  }
-
-  return { deviceStart, deviceLinkInfo, deviceApprove, devicePoll, deviceResume, signout, keyCaller, createAgent, agents, refreshAgentKey, revokeAgent }
-}

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
-}