@heyquilt/seam 0.0.0-stage → 0.1.0

package/lib/quilts/tools.js

@@ -0,0 +1,201 @@
+// Quilt source control's MCP tools (plans/quilt-source-control/12), served by `seam mcp` (seam/),
+// not by the Quilt app's MCP: one description and one schema per tool, answered by the same
+// server routes the CLI uses, so Claude Code, Cursor, Codex and every other tool get the same
+// behaviour and the same sentences.
+//
+// Locally, in a folder made by `seam checkout`, the quilt and square come from the folder and
+// seam_commit seals the folder's changes; anywhere else (and always for hosted agents) name the
+// quilt and square, and seam_commit takes the files' new contents.
+import { z } from 'zod'
+import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents } from './describe.js'
+import { status as blockStatus, commitFolder, syncTo } from './block.js'
+
+export const SEAM_TOOLS = ['seam_quilts', 'seam_open_square', 'seam_squares', 'seam_log', 'seam_show', 'seam_diff', 'seam_blame', 'seam_cat', 'seam_ls', 'seam_commit', 'seam_merge', 'seam_rebase', 'seam_revert', 'seam_cherry_pick', 'seam_resolve', 'seam_square_status', 'seam_square_handoff', 'seam_abandon', 'seam_reopen', 'seam_fold', 'seam_split', 'seam_events', 'seam_events_webhook']
+
+/** What every agent is told about source control, in each MCP's instructions. */
+export const SEAM_GUIDE = 'Quilt source control (quilts): a quilt is a repository on the Quilt server; you work in a square (your own branch and working copy), commit save points in it, and merge it into main, where it becomes a patch. ' +
+  'Open a square with seam_open_square, commit with seam_commit, merge with seam_merge (into: "main"). A merge never stops half way: a real conflict is refused, kept in your square as conflict markers, and you settle it (edit the file and commit it without the markers, or seam_resolve) and merge again. ' +
+  'Read history with seam_log, seam_show, seam_diff, seam_blame and seam_cat; revisions are main, main~3, patch:12, sq:<id>, a commit id or git:<sha>. ' +
+  'In a folder checked out from a square (it holds .seam/block.json), edit the files with your own tools and check them with seam_square_status.'
+
+const QUILT = z.string().max(100).optional().describe('The quilt (its slug or id); in a folder made by seam checkout, that folder\'s quilt')
+const SQUARE = z.string().max(100).optional().describe('The square (sq:<id>); in a block folder, that folder\'s square')
+const REV = z.string().max(200).optional()
+const PATHS = z.array(z.string().max(1000)).max(200).optional().describe('Only these paths (files or directories)')
+
+export const SEAM_DESCRIPTIONS = {
+  seam_quilts: 'Lists the quilts (repositories) you can reach, or makes a new one (new: its slug).',
+  seam_open_square: 'Opens a square: your own unit of work, branched from the tip of main (or line). Returns its id (sq:…). Agents open squares, never lines.',
+  seam_squares: 'The open squares of a quilt, with holder, head, how far behind main each is and its conflicted paths. all: true for merged and abandoned ones too.',
+  seam_square_status: 'One square as the server sees it (head, behind_by, conflicted paths), the patches merged under it that changed its files, and which files would conflict if merged now; in a block folder also the files changed since the last commit.',
+  seam_square_handoff: 'Hands your square to another member (to), with a note on what is done and what is left. You stop being able to commit to it.',
+  seam_abandon: 'Abandons a square whose work is not wanted. Its commits stay readable and seam_reopen brings it back.',
+  seam_reopen: 'Reopens an abandoned square; you become its holder.',
+  seam_events: 'What happened to your work since you last looked: patch.merged (a patch changed files your open square changed, and whether your merge would now conflict), conflict.added (a conflict was kept in your square), square.handoff. Pass after (the cursor from the last answer) to get only new ones.',
+  seam_events_webhook: 'Has the quilt server POST your events to a URL (signed with HMAC-SHA256 over <timestamp>.<body>, retried 3 times), so you are woken instead of polling: url, events (default all), secret (made for you if left out). url: "off" removes it.',
+  seam_fold: 'Folds a square (square) into another square you hold (into): its work becomes one commit there and the square closes. Overlapping changes become conflict markers in the target.',
+  seam_split: 'Splits your square by paths: groups: [[paths], ...], each group moves to a new square (same base) as one commit; the largest group, and paths no group names, stay in this square.',
+  seam_log: 'History, newest first: rev (default main, or your square), paths to limit it, limit (default 20). Each patch on main is one line\'s merge.',
+  seam_show: 'One commit or patch: who, when, why, which square, and its diff. rev: patch:12, main~1, sq:…, a commit id, git:<sha>. format: unified (default), stat or names.',
+  seam_diff: 'The difference between two revisions (from, to); with only to, against its parent (for a square: against where it branched). format: unified, stat or names.',
+  seam_blame: 'Each line of a file at a revision, with the commit and patch that last changed it and who made it. Computed by the server.',
+  seam_cat: 'A file\'s content at any revision (path, rev). To change a file, read it from your own square (rev sq:<id>), not from main: main moves while you work, and a commit built from a different version of main than your square started from can undo work that merged in between. A conflicted file comes back with its conflict markers: format diff (default: one side in full after +++++++, each other side as a diff from its base after %%%%%%%), snapshot (every side in full) or git (<<<<<<< ======= >>>>>>>, two sides only).',
+  seam_ls: 'The files at a revision, under paths (directories).',
+  seam_commit: 'Seals your square\'s changes as a commit (a save point). In a block folder: the folder\'s changed files (paths: only these). Elsewhere: files: [{ path, content }] (text; base64: true for bytes) and delete: [paths]. message says why. Committing a conflicted file without its markers settles the conflict.',
+  seam_merge: 'Merges your square into a line (into: "main") or, with from, merges another square or revision into your square (a two-parent commit; conflicts stay in your square as markers). Into a line: the server rebases it onto the tip as one commit and moves main, retrying lost races itself. The result is a patch. A real conflict is refused: the square is rebased with the conflict kept in it (your folder gets the markers); settle it and merge again. dry_run: true says what would happen.',
+  seam_rebase: 'Moves your square onto the tip of its line (or onto a revision). Conflicts become conflict markers in the square, never a stop.',
+  seam_revert: 'Undoes a patch (or commit): a new square from the tip whose one commit inverts it. Merge that square with seam_merge.',
+  seam_cherry_pick: 'Applies one commit\'s change (from) to your square as a new commit.',
+  seam_resolve: 'Settles conflicted files in your square by choosing a side: entries [{ path, choose: ours | theirs | base | suggestion | delete }]; suggestion takes the word-level merge a conflict offers (its suggestion, shown when the merge is refused). (Or edit the file and commit it without the markers.)'
+}
+
+export const SEAM_INPUTS = {
+  seam_quilts: { new: z.string().max(63).optional().describe('Make a quilt with this slug') },
+  seam_open_square: { quilt: QUILT, title: z.string().max(200).describe('What the work is'), line: z.string().max(100).optional(), task_id: z.string().max(64).optional() },
+  seam_squares: { quilt: QUILT, all: z.boolean().optional(), mine: z.boolean().optional() },
+  seam_square_status: { quilt: QUILT, square: SQUARE },
+  seam_log: { quilt: QUILT, rev: REV, paths: PATHS, limit: z.number().int().min(1).max(500).optional() },
+  seam_show: { quilt: QUILT, rev: REV, format: z.enum(['unified', 'stat', 'names']).optional(), paths: PATHS },
+  seam_diff: { quilt: QUILT, from: REV, to: REV, format: z.enum(['unified', 'stat', 'names']).optional(), paths: PATHS },
+  seam_blame: { quilt: QUILT, path: z.string().max(1000), rev: REV },
+  seam_cat: { quilt: QUILT, path: z.string().max(1000), rev: REV, format: z.enum(['diff', 'snapshot', 'git']).optional().describe('How a conflicted file is written (default diff)') },
+  seam_ls: { quilt: QUILT, rev: REV, paths: PATHS },
+  seam_commit: {
+    quilt: QUILT, square: SQUARE, message: z.string().max(65536).describe('Why'),
+    files: z.array(z.object({ path: z.string().max(1000), content: z.string(), base64: z.boolean().optional(), mode: z.enum(['file', 'exec']).optional() })).max(2000).optional(),
+    delete: z.array(z.string().max(1000)).max(2000).optional(),
+    paths: PATHS
+  },
+  seam_square_handoff: { quilt: QUILT, square: SQUARE, to: z.string().max(200).describe('The member to hand it to'), note: z.string().max(2000).optional() },
+  seam_abandon: { quilt: QUILT, square: SQUARE },
+  seam_reopen: { quilt: QUILT, square: SQUARE },
+  seam_events: { quilt: QUILT, after: z.number().int().min(0).optional(), kinds: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff'])).optional() },
+  seam_events_webhook: { quilt: QUILT, url: z.string().max(2000), events: z.array(z.enum(['patch.merged', 'conflict.added', 'square.handoff'])).optional(), secret: z.string().min(16).max(200).optional() },
+  seam_fold: { quilt: QUILT, square: SQUARE, into: z.string().max(100).describe('The square (sq:…) that takes the work'), message: z.string().max(65536).optional() },
+  seam_split: { quilt: QUILT, square: SQUARE, groups: z.array(z.array(z.string().max(1000)).min(1).max(2000)).min(1).max(20).describe('Paths (files or directories) per new square'), titles: z.array(z.string().max(200)).max(20).optional() },
+  seam_merge: { quilt: QUILT, square: SQUARE, from: z.string().max(200).optional().describe('Merge this square (sq:…) or revision into your square instead of merging your square into a line'), into: z.string().max(100).optional().describe('The line, default main'), message: z.string().max(65536).optional(), dry_run: z.boolean().optional(), on_conflict: z.enum(['rebase', 'leave']).optional() },
+  seam_rebase: { quilt: QUILT, square: SQUARE, onto: REV },
+  seam_revert: { quilt: QUILT, rev: z.string().max(200).describe('patch:12, a commit id, …'), line: z.string().max(100).optional() },
+  seam_cherry_pick: { quilt: QUILT, square: SQUARE, from: z.string().max(200) },
+  seam_resolve: { quilt: QUILT, square: SQUARE, entries: z.array(z.object({ path: z.string().max(1000), choose: z.union([z.enum(['ours', 'theirs', 'base', 'suggestion', 'delete', 'keep_edit', 'keep_delete']), z.number().int().min(0).max(8)]) })).min(1).max(500) }
+}
+
+/**
+ * Runs one tool. `client` is a quilt client (client.js) acting as the agent; `found` is the
+ * block folder the local MCP runs in ({ dir, block }) or null. Returns the text to answer.
+ */
+export async function runSeamTool (name, args, { client, found = null }) {
+  const block = found?.block || null
+  const quilt = args.quilt || block?.quilt
+  const square = args.square || block?.square
+  const needQuilt = () => { if (!quilt) throw new Error('Name the quilt (quilt: its slug or id); seam_quilts lists yours.'); return quilt }
+  const needSquare = () => { if (!square) throw new Error('Name the square (square: sq:…); seam_open_square opens one, seam_squares lists them.'); return square }
+  const inFolder = found && block && square === block.square && quilt === block.quilt
+  const sync = async (head, sq) => { if (inFolder && head && head !== block.head) { const s = await syncTo(client, found.dir, block, head, { square: sq }); return `\nThe folder now holds the square's files (${s.written} updated).` } return '' }
+  try {
+    switch (name) {
+      case 'seam_quilts': {
+        if (args.new) { const q = await client.createQuilt({ slug: args.new }); return `Made quilt ${q.slug} (${q.id}).` }
+        const list = await client.quilts()
+        return list.length ? list.map((q) => `${q.slug} (${q.id}), ${q.level}`).join('\n') : 'No quilts yet.'
+      }
+      case 'seam_open_square': {
+        const sq = await client.openSquare(needQuilt(), { title: args.title, line: args.line, task_id: args.task_id })
+        return `Opened ${describeSquare(sq)}.\nCommit in it with seam_commit (square: "${sq.short}") and merge it with seam_merge.`
+      }
+      case 'seam_squares': {
+        const list = await client.squares(needQuilt(), { state: args.all ? undefined : 'open', mine: !!args.mine })
+        return list.length ? list.map(describeSquare).join('\n') : 'No open squares.'
+      }
+      case 'seam_square_status': {
+        if (inFolder) return describeStatus(await blockStatus(client, found.dir, block))
+        return describeSquareStatus(await client.square(needQuilt(), needSquare()))
+      }
+      case 'seam_log': return describeLog(await client.log(needQuilt(), { rev: args.rev || (block?.square ? block.square_short : 'main'), paths: args.paths, limit: args.limit }), { oneline: true })
+      case 'seam_show': return describeShow(await client.show(needQuilt(), args.rev || 'main', { format: args.format || 'unified', paths: args.paths }), { format: args.format || 'unified' })
+      case 'seam_diff': return describeDiff(await client.diff(needQuilt(), { from: args.from, to: args.to, paths: args.paths, format: args.format || 'unified' }), { format: args.format || 'unified' })
+      case 'seam_blame': return describeBlame(await client.blame(needQuilt(), args.rev || 'main', args.path))
+      case 'seam_cat': { const r = await client.cat(needQuilt(), args.rev || 'main', args.path, { format: args.format || 'diff' }); return Buffer.from(r.content, 'base64').toString('utf8') }
+      case 'seam_ls': { const r = await client.tree(needQuilt(), args.rev || 'main', args.paths); return r.entries.map((e) => `${e.mode}\t${e.path}`).join('\n') || 'No files.' }
+      case 'seam_commit': {
+        if (inFolder && !args.files && !args.delete) {
+          const r = await commitFolder(client, found.dir, block, { message: args.message, paths: (args.paths || []).map((p) => `${found.dir}/${p}`) })
+          return r.nothing ? 'Nothing to commit: no file in this folder changed since the last commit.' : describeWrite(r, 'Committed')
+        }
+        const changes = [
+          ...(args.files || []).map((f) => ({ path: f.path, op: 'put', content: f.base64 ? f.content : Buffer.from(f.content, 'utf8').toString('base64'), ...(f.mode ? { mode: f.mode } : {}) })),
+          ...(args.delete || []).map((p) => ({ path: p, op: 'delete' }))
+        ]
+        if (!changes.length) return 'Nothing to commit: give files (and delete), or run in a block folder.'
+        const sq = await client.square(needQuilt(), needSquare())
+        return describeWrite(await client.commit(quilt, sq.id, { expect_head: sq.head, message: args.message, changes }), 'Committed')
+      }
+      case 'seam_square_handoff': { const sq = await client.handoff(needQuilt(), needSquare(), { to: args.to, note: args.note }); return `Handed ${sq.short} to ${sq.holder}.` }
+      case 'seam_abandon': { const sq = await client.abandon(needQuilt(), needSquare(), inFolder ? { expect_head: block.head } : {}); return `Abandoned ${sq.short}; seam_reopen brings it back.` }
+      case 'seam_reopen': { const sq = await client.reopen(needQuilt(), needSquare()); return `Reopened ${describeSquare(sq)}.` }
+      case 'seam_events': return describeEvents(await client.events(needQuilt(), { after: args.after, kinds: args.kinds }))
+      case 'seam_events_webhook': {
+        if (args.url === 'off') { await client.subscribe(needQuilt(), { url: null }); return 'Webhook removed.' }
+        const r = await client.subscribe(needQuilt(), { url: args.url, events: args.events, secret: args.secret })
+        return `Events (${r.events.join(', ')}) now POST to ${r.url}.${r.secret ? ` Signing secret (shown once): ${r.secret}` : ''}`
+      }
+      case 'seam_fold': {
+        const r = await client.fold(needQuilt(), needSquare(), { into: args.into, message: args.message, ...(inFolder ? { expect_head: block.head } : {}) })
+        return describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`)
+      }
+      case 'seam_split': {
+        const r = await client.split(needQuilt(), needSquare(), { by: 'paths', groups: args.groups, titles: args.titles, ...(inFolder ? { expect_head: block.head } : {}) })
+        return [`Kept in ${r.square.short}: ${r.kept.join(', ') || '(nothing)'}`, ...r.squares.map((q) => `New ${describeSquare(q)}: ${q.paths.join(', ')}`)].join('\n') + await sync(r.square.head, r.square)
+      }
+      case 'seam_merge': {
+        if (args.from) {
+          const r = await client.mergeSquare(needQuilt(), needSquare(), { from: args.from, message: args.message, ...(inFolder ? { expect_head: block.head } : {}) })
+          return r.noop ? `Already up to date: ${args.from} is in this square.` : describeWrite(r, `Merged ${args.from} in:`) + await sync(r.square.head, r.square)
+        }
+        const r = await client.merge(needQuilt(), args.into || block?.line || 'main', { square: needSquare(), ...(inFolder ? { expect_head: block.head } : {}), message: args.message, dry_run: !!args.dry_run, on_conflict: args.on_conflict })
+        return describeMerge(r) + (!r.ok && r.head ? await sync(r.head, r.square) : '')
+      }
+      case 'seam_rebase': {
+        const r = await client.rebase(needQuilt(), needSquare(), { ...(inFolder ? { expect_head: block.head } : {}), onto: args.onto })
+        return (r.noop ? 'Already on the tip.' : describeWrite(r, 'Rebased')) + (r.square ? await sync(r.square.head || r.square.base, r.square) : '')
+      }
+      case 'seam_revert': {
+        const r = await client.revert(needQuilt(), { rev: args.rev, line: args.line })
+        return describeWrite(r, 'Reverted in a new square') + `\nMerge it with seam_merge (square: "${r.square.short}").`
+      }
+      case 'seam_cherry_pick': {
+        const r = await client.cherryPick(needQuilt(), needSquare(), { from: args.from, ...(inFolder ? { expect_head: block.head } : {}) })
+        return describeWrite(r, 'Picked') + await sync(r.square.head, r.square)
+      }
+      case 'seam_resolve': {
+        const r = await client.resolve(needQuilt(), needSquare(), { ...(inFolder ? { expect_head: block.head } : {}), entries: args.entries })
+        return describeWrite(r, 'Resolved') + await sync(r.square.head, r.square)
+      }
+    }
+    return `Unknown tool ${name}.`
+  } catch (e) {
+    if (e.code === 'head_moved') return `${e.message}: the square's head is now ${String(e.head || '').slice(0, 12)}. Look again (seam_square_status) and retry.`
+    throw e
+  }
+}
+
+/** Whether this process offers the source-control tools (QUILT_SOURCE, as the API's routes). */
+export const quiltToolsOn = (env = process.env) => /^(1|true|yes)$/i.test(env.QUILT_SOURCE || '')
+
+/**
+ * Registers every tool on an MCP server. `client()` makes the quilt client for a call (it may
+ * throw when the caller is not signed in); `found()` the block folder, or null.
+ */
+export function registerSeamTools (server, { client, found = () => null, extraInput = {} }) {
+  for (const name of SEAM_TOOLS) {
+    server.registerTool(name, { description: SEAM_DESCRIPTIONS[name], inputSchema: { ...SEAM_INPUTS[name], ...extraInput } }, async (args = {}) => {
+      try {
+        const { session, ...rest } = args
+        void session
+        return { content: [{ type: 'text', text: await runSeamTool(name, rest, { client: client(), found: found() }) }] }
+      } catch (e) {
+        return { content: [{ type: 'text', text: e.message }], isError: true }
+      }
+    })
+  }
+}

package/lib/quilts/xdiff.js

@@ -0,0 +1,435 @@
+// A port of git's xdiff line diff (Myers with xdiff's heuristics, record cleanup, and change
+// compaction with the indent heuristic), so `blame` and `diff` choose the same lines git does.
+//
+// Ported from git's xdiff/xprepare.c, xdiff/xdiffi.c and xdiff-interface.c (trim_common_tail).
+// LibXDiff by Davide Libenzi, Copyright (C) 2003, LGPL-2.1-or-later; git's changes are under the
+// same terms. Structure and names follow the C so the two can be compared line by line.
+
+const XDL_KPDIS_RUN = 4
+const XDL_MAX_EQLIMIT = 1024
+const XDL_SIMSCAN_WINDOW = 100
+const XDL_MAX_COST_MIN = 256
+const XDL_HEUR_MIN_COST = 256
+const XDL_LINE_MAX = Number.MAX_SAFE_INTEGER
+const XDL_SNAKE_CNT = 20
+const XDL_K_HEUR = 4
+const DISCARD = 0; const KEEP = 1; const INVESTIGATE = 2
+
+function bogosqrt (n) { let i = 1; for (; n > 0; n = Math.floor(n / 4)) i *= 2; return i }
+
+/** git's trim_common_tail: the byte length to drop from both ends' tails (blame only). */
+function commonTail (a, b) {
+  const blk = 1024
+  let trimmed = 0; let recovered = 0
+  const smaller = Math.min(a.length, b.length)
+  while (blk + trimmed <= smaller &&
+    a.compare(b, b.length - trimmed - blk, b.length - trimmed, a.length - trimmed - blk, a.length - trimmed) === 0) trimmed += blk
+  const ap = a.length - trimmed
+  while (recovered < trimmed) if (a[ap + recovered++] === 10) break
+  return trimmed - recovered
+}
+
+/** Records of a buffer: [start, end) per line, each with its \n. */
+function records (buf, size) {
+  const starts = []
+  let s = 0
+  while (s < size) {
+    let e = buf.indexOf(10, s)
+    e = e < 0 || e >= size ? size : e + 1
+    starts.push(s, e)
+    s = e
+  }
+  return starts
+}
+
+function prepare (buf, size, classes, counts, pass) {
+  const r = records(buf, size)
+  const n = r.length / 2
+  const mph = new Int32Array(n)
+  for (let i = 0; i < n; i++) {
+    const key = buf.toString('latin1', r[2 * i], r[2 * i + 1])
+    let id = classes.get(key)
+    if (id === undefined) { id = classes.size; classes.set(key, id); counts.push(0, 0) }
+    counts[2 * id + pass]++
+    mph[i] = id
+  }
+  return { buf, r, nrec: n, mph, changed: new Uint8Array(n + 2), ref: null, nreff: 0, dstart: 0, dend: n - 1 }
+}
+
+function cleanMmatch (action, i, len) {
+  let s = 0; let e = len - 1
+  if (i - s > XDL_SIMSCAN_WINDOW) s = i - XDL_SIMSCAN_WINDOW
+  if (e - i > XDL_SIMSCAN_WINDOW) e = i + XDL_SIMSCAN_WINDOW
+  let r; let rdis0 = 0; let rpdis0 = 1; let rdis1 = 0; let rpdis1 = 1
+  for (r = 1; i - r >= s; r++) {
+    const a = action[i - r]
+    if (a === DISCARD) rdis0++
+    else if (a === INVESTIGATE) rpdis0++
+    else break
+  }
+  if (rdis0 === 0) return false
+  for (r = 1; i + r <= e; r++) {
+    const a = action[i + r]
+    if (a === DISCARD) rdis1++
+    else if (a === INVESTIGATE) rpdis1++
+    else break
+  }
+  if (rdis1 === 0) return false
+  rdis1 += rdis0
+  rpdis1 += rpdis0
+  return rpdis1 * XDL_KPDIS_RUN < rpdis1 + rdis1
+}
+
+function trimEnds (x1, x2) {
+  const lim = Math.min(x1.nrec, x2.nrec)
+  let i = 0
+  while (i < lim && x1.mph[i] === x2.mph[i]) i++
+  x1.dstart = x2.dstart = i
+  const lim2 = lim - i
+  let j = 0
+  while (j < lim2 && x1.mph[x1.nrec - 1 - j] === x2.mph[x2.nrec - 1 - j]) j++
+  x1.dend = x1.nrec - j - 1
+  x2.dend = x2.nrec - j - 1
+}
+
+function cleanupRecords (counts, x1, x2) {
+  const off = x1.dstart
+  const len1 = x1.dend - off + 1
+  const len2 = x2.dend - off + 1
+  const one = (x, len, other) => {
+    const action = new Uint8Array(Math.max(len, 0))
+    let mlim = bogosqrt(x.nrec)
+    if (mlim > XDL_MAX_EQLIMIT) mlim = XDL_MAX_EQLIMIT
+    for (let i = 0; i < len; i++) {
+      const nm = counts[2 * x.mph[i + off] + other]
+      action[i] = nm === 0 ? DISCARD : nm < mlim ? KEEP : INVESTIGATE
+    }
+    x.ref = new Int32Array(Math.max(len, 0))
+    x.nreff = 0
+    for (let i = 0; i < len; i++) {
+      let a = action[i]
+      if (a === INVESTIGATE) a = cleanMmatch(action, i, len) ? DISCARD : KEEP
+      if (a === KEEP) x.ref[x.nreff++] = i + off
+      else x.changed[i + off + 1] = 1
+    }
+  }
+  one(x1, len1, 1)
+  one(x2, len2, 0)
+}
+
+function doDiff (x1, x2) {
+  const h1 = new Int32Array(x1.nreff); for (let i = 0; i < x1.nreff; i++) h1[i] = x1.mph[x1.ref[i]]
+  const h2 = new Int32Array(x2.nreff); for (let i = 0; i < x2.nreff; i++) h2[i] = x2.mph[x2.ref[i]]
+  const ndiags = x1.nreff + x2.nreff + 3
+  const kvd = new Float64Array(2 * ndiags + 2)
+  const F = x2.nreff + 1
+  const B = ndiags + x2.nreff + 1
+  let mxcost = bogosqrt(ndiags)
+  if (mxcost < XDL_MAX_COST_MIN) mxcost = XDL_MAX_COST_MIN
+  const snakeCnt = XDL_SNAKE_CNT; const heurMin = XDL_HEUR_MIN_COST
+  const spl = { i1: 0, i2: 0, minLo: 0, minHi: 0 }
+
+  function split (off1, lim1, off2, lim2, needMin) {
+    const dmin = off1 - lim2; const dmax = lim1 - off2
+    const fmid = off1 - off2; const bmid = lim1 - lim2
+    const odd = (fmid - bmid) & 1
+    let fmin = fmid; let fmax = fmid; let bmin = bmid; let bmax = bmid
+    let i1, i2, prev1, best, dd, v, k, d
+    kvd[F + fmid] = off1
+    kvd[B + bmid] = lim1
+    for (let ec = 1; ; ec++) {
+      let gotSnake = false
+      if (fmin > dmin) kvd[F + (--fmin) - 1] = -1; else ++fmin
+      if (fmax < dmax) kvd[F + (++fmax) + 1] = -1; else --fmax
+      for (d = fmax; d >= fmin; d -= 2) {
+        if (kvd[F + d - 1] >= kvd[F + d + 1]) i1 = kvd[F + d - 1] + 1
+        else i1 = kvd[F + d + 1]
+        prev1 = i1
+        i2 = i1 - d
+        while (i1 < lim1 && i2 < lim2 && h1[i1] === h2[i2]) { i1++; i2++ }
+        if (i1 - prev1 > snakeCnt) gotSnake = true
+        kvd[F + d] = i1
+        if (odd && bmin <= d && d <= bmax && kvd[B + d] <= i1) {
+          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
+          return
+        }
+      }
+      if (bmin > dmin) kvd[B + (--bmin) - 1] = XDL_LINE_MAX; else ++bmin
+      if (bmax < dmax) kvd[B + (++bmax) + 1] = XDL_LINE_MAX; else --bmax
+      for (d = bmax; d >= bmin; d -= 2) {
+        if (kvd[B + d - 1] < kvd[B + d + 1]) i1 = kvd[B + d - 1]
+        else i1 = kvd[B + d + 1] - 1
+        prev1 = i1
+        i2 = i1 - d
+        while (i1 > off1 && i2 > off2 && h1[i1 - 1] === h2[i2 - 1]) { i1--; i2-- }
+        if (prev1 - i1 > snakeCnt) gotSnake = true
+        kvd[B + d] = i1
+        if (!odd && fmin <= d && d <= fmax && i1 <= kvd[F + d]) {
+          spl.i1 = i1; spl.i2 = i2; spl.minLo = spl.minHi = 1
+          return
+        }
+      }
+      if (needMin) continue
+      if (gotSnake && ec > heurMin) {
+        for (best = 0, d = fmax; d >= fmin; d -= 2) {
+          dd = d > fmid ? d - fmid : fmid - d
+          i1 = kvd[F + d]
+          i2 = i1 - d
+          v = (i1 - off1) + (i2 - off2) - dd
+          if (v > XDL_K_HEUR * ec && v > best && off1 + snakeCnt <= i1 && i1 < lim1 && off2 + snakeCnt <= i2 && i2 < lim2) {
+            for (k = 1; h1[i1 - k] === h2[i2 - k]; k++) {
+              if (k === snakeCnt) { best = v; spl.i1 = i1; spl.i2 = i2; break }
+            }
+          }
+        }
+        if (best > 0) { spl.minLo = 1; spl.minHi = 0; return }
+        for (best = 0, d = bmax; d >= bmin; d -= 2) {
+          dd = d > bmid ? d - bmid : bmid - d
+          i1 = kvd[B + d]
+          i2 = i1 - d
+          v = (lim1 - i1) + (lim2 - i2) - dd
+          if (v > XDL_K_HEUR * ec && v > best && off1 < i1 && i1 <= lim1 - snakeCnt && off2 < i2 && i2 <= lim2 - snakeCnt) {
+            for (k = 0; h1[i1 + k] === h2[i2 + k]; k++) {
+              if (k === snakeCnt - 1) { best = v; spl.i1 = i1; spl.i2 = i2; break }
+            }
+          }
+        }
+        if (best > 0) { spl.minLo = 0; spl.minHi = 1; return }
+      }
+      if (ec >= mxcost) {
+        let fbest = -1; let fbest1 = -1
+        for (d = fmax; d >= fmin; d -= 2) {
+          i1 = Math.min(kvd[F + d], lim1)
+          i2 = i1 - d
+          if (lim2 < i2) { i1 = lim2 + d; i2 = lim2 }
+          if (fbest < i1 + i2) { fbest = i1 + i2; fbest1 = i1 }
+        }
+        let bbest = XDL_LINE_MAX; let bbest1 = XDL_LINE_MAX
+        for (d = bmax; d >= bmin; d -= 2) {
+          i1 = Math.max(off1, kvd[B + d])
+          i2 = i1 - d
+          if (i2 < off2) { i1 = off2 + d; i2 = off2 }
+          if (i1 + i2 < bbest) { bbest = i1 + i2; bbest1 = i1 }
+        }
+        if ((lim1 + lim2) - bbest < fbest - (off1 + off2)) {
+          spl.i1 = fbest1; spl.i2 = fbest - fbest1; spl.minLo = 1; spl.minHi = 0
+        } else {
+          spl.i1 = bbest1; spl.i2 = bbest - bbest1; spl.minLo = 0; spl.minHi = 1
+        }
+        return
+      }
+    }
+  }
+
+  // xdl_recs_cmp, with its recursion on an explicit stack (depth can reach thousands).
+  const stack = [[0, x1.nreff, 0, x2.nreff, 0]]
+  while (stack.length) {
+    let [off1, lim1, off2, lim2, needMin] = stack.pop()
+    while (off1 < lim1 && off2 < lim2 && h1[off1] === h2[off2]) { off1++; off2++ }
+    while (off1 < lim1 && off2 < lim2 && h1[lim1 - 1] === h2[lim2 - 1]) { lim1--; lim2-- }
+    if (off1 === lim1) {
+      for (; off2 < lim2; off2++) x2.changed[x2.ref[off2] + 1] = 1
+    } else if (off2 === lim2) {
+      for (; off1 < lim1; off1++) x1.changed[x1.ref[off1] + 1] = 1
+    } else {
+      spl.i1 = spl.i2 = 0
+      split(off1, lim1, off2, lim2, needMin)
+      const { i1, i2, minLo, minHi } = spl
+      // Low half first, as the C recursion does (it only marks, so order matters not for the
+      // result, but keep it for fidelity).
+      stack.push([i1, lim1, i2, lim2, minHi])
+      stack.push([off1, i1, off2, i2, minLo])
+    }
+  }
+}
+
+// --- change compaction (xdl_change_compact) with the indent heuristic ---
+
+const MAX_INDENT = 200
+const MAX_BLANKS = 20
+const START_OF_FILE_PENALTY = 1
+const END_OF_FILE_PENALTY = 21
+const TOTAL_BLANK_WEIGHT = -30
+const POST_BLANK_WEIGHT = 6
+const RELATIVE_INDENT_PENALTY = -4
+const RELATIVE_INDENT_WITH_BLANK_PENALTY = 10
+const RELATIVE_OUTDENT_PENALTY = 24
+const RELATIVE_OUTDENT_WITH_BLANK_PENALTY = 17
+const RELATIVE_DEDENT_PENALTY = 23
+const RELATIVE_DEDENT_WITH_BLANK_PENALTY = 17
+const INDENT_WEIGHT = 60
+const INDENT_HEURISTIC_MAX_SLIDING = 100
+
+function getIndent (x, i) {
+  let ret = 0
+  const buf = x.buf
+  for (let p = x.r[2 * i], e = x.r[2 * i + 1]; p < e; p++) {
+    const c = buf[p]
+    // isspace: space, \t, \n, \v, \f, \r
+    if (!(c === 32 || (c >= 9 && c <= 13))) return ret
+    else if (c === 32) ret += 1
+    else if (c === 9) ret += 8 - ret % 8
+    if (ret >= MAX_INDENT) return MAX_INDENT
+  }
+  return -1
+}
+
+function measureSplit (x, split) {
+  const m = { eof: 0, indent: -1, preBlank: 0, preIndent: -1, postBlank: 0, postIndent: -1 }
+  if (split >= x.nrec) { m.eof = 1; m.indent = -1 } else m.indent = getIndent(x, split)
+  for (let i = split - 1; i >= 0; i--) {
+    m.preIndent = getIndent(x, i)
+    if (m.preIndent !== -1) break
+    m.preBlank += 1
+    if (m.preBlank === MAX_BLANKS) { m.preIndent = 0; break }
+  }
+  for (let i = split + 1; i < x.nrec; i++) {
+    m.postIndent = getIndent(x, i)
+    if (m.postIndent !== -1) break
+    m.postBlank += 1
+    if (m.postBlank === MAX_BLANKS) { m.postIndent = 0; break }
+  }
+  return m
+}
+
+function scoreAddSplit (m, s) {
+  if (m.preIndent === -1 && m.preBlank === 0) s.penalty += START_OF_FILE_PENALTY
+  if (m.eof) s.penalty += END_OF_FILE_PENALTY
+  const postBlank = m.indent === -1 ? 1 + m.postBlank : 0
+  const totalBlank = m.preBlank + postBlank
+  s.penalty += TOTAL_BLANK_WEIGHT * totalBlank
+  s.penalty += POST_BLANK_WEIGHT * postBlank
+  const indent = m.indent !== -1 ? m.indent : m.postIndent
+  const anyBlanks = totalBlank !== 0
+  s.effectiveIndent += indent
+  if (indent === -1 || m.preIndent === -1) {
+    // no adjustment
+  } else if (indent > m.preIndent) {
+    s.penalty += anyBlanks ? RELATIVE_INDENT_WITH_BLANK_PENALTY : RELATIVE_INDENT_PENALTY
+  } else if (indent === m.preIndent) {
+    // same level
+  } else if (m.postIndent !== -1 && m.postIndent > indent) {
+    s.penalty += anyBlanks ? RELATIVE_OUTDENT_WITH_BLANK_PENALTY : RELATIVE_OUTDENT_PENALTY
+  } else {
+    s.penalty += anyBlanks ? RELATIVE_DEDENT_WITH_BLANK_PENALTY : RELATIVE_DEDENT_PENALTY
+  }
+}
+
+function scoreCmp (s1, s2) {
+  const c = (s1.effectiveIndent > s2.effectiveIndent) - (s1.effectiveIndent < s2.effectiveIndent)
+  return INDENT_WEIGHT * c + (s1.penalty - s2.penalty)
+}
+
+// `changed` is offset by one: changed[i + 1] is record i; changed[0] and changed[nrec + 1] are 0.
+function changeCompact (x, xo) {
+  const ch = x.changed; const cho = xo.changed
+  const C = (i) => ch[i + 1]
+  const CO = (i) => cho[i + 1]
+  const g = { start: 0, end: 0 }; const go = { start: 0, end: 0 }
+  while (C(g.end)) g.end++
+  while (CO(go.end)) go.end++
+  const next = (xx, c, gg) => {
+    if (gg.end === xx.nrec) return -1
+    gg.start = gg.end + 1
+    for (gg.end = gg.start; c(gg.end); gg.end++);
+    return 0
+  }
+  const previous = (c, gg) => {
+    if (gg.start === 0) return -1
+    gg.end = gg.start - 1
+    for (gg.start = gg.end; c(gg.start - 1); gg.start--);
+    return 0
+  }
+  const slideDown = () => {
+    if (g.end < x.nrec && x.mph[g.start] === x.mph[g.end]) {
+      ch[g.start++ + 1] = 0
+      ch[g.end++ + 1] = 1
+      while (C(g.end)) g.end++
+      return 0
+    }
+    return -1
+  }
+  const slideUp = () => {
+    if (g.start > 0 && x.mph[g.start - 1] === x.mph[g.end - 1]) {
+      ch[--g.start + 1] = 1
+      ch[--g.end + 1] = 0
+      while (C(g.start - 1)) g.start--
+      return 0
+    }
+    return -1
+  }
+  const bug = (s) => { throw new Error('xdiff: ' + s) }
+  for (;;) {
+    if (g.end !== g.start) {
+      let groupsize, earliestEnd, endMatchingOther
+      do {
+        groupsize = g.end - g.start
+        endMatchingOther = -1
+        while (!slideUp()) if (previous(CO, go)) bug('group sync broken sliding up')
+        earliestEnd = g.end
+        if (go.end > go.start) endMatchingOther = g.end
+        for (;;) {
+          if (slideDown()) break
+          if (next(xo, CO, go)) bug('group sync broken sliding down')
+          if (go.end > go.start) endMatchingOther = g.end
+        }
+      } while (groupsize !== g.end - g.start)
+      if (g.end === earliestEnd) {
+        // no shifting possible
+      } else if (endMatchingOther !== -1) {
+        while (go.end === go.start) {
+          if (slideUp()) bug('match disappeared')
+          if (previous(CO, go)) bug('group sync broken sliding to match')
+        }
+      } else {
+        let shift = earliestEnd
+        let bestShift = -1; let bestScore = null
+        if (g.end - groupsize - 1 > shift) shift = g.end - groupsize - 1
+        if (g.end - INDENT_HEURISTIC_MAX_SLIDING > shift) shift = g.end - INDENT_HEURISTIC_MAX_SLIDING
+        for (; shift <= g.end; shift++) {
+          const score = { effectiveIndent: 0, penalty: 0 }
+          scoreAddSplit(measureSplit(x, shift), score)
+          scoreAddSplit(measureSplit(x, shift - groupsize), score)
+          if (bestShift === -1 || scoreCmp(score, bestScore) <= 0) { bestScore = score; bestShift = shift }
+        }
+        while (g.end > bestShift) {
+          if (slideUp()) bug('best shift unreached')
+          if (previous(CO, go)) bug('group sync broken sliding to blank line')
+        }
+      }
+    }
+    if (next(x, C, g)) break
+    if (next(xo, CO, go)) bug('group sync broken moving to next group')
+  }
+}
+
+/**
+ * git's diff of two byte buffers: hunks [{ a: [start, len], b: [start, len] }] over their lines
+ * (a final line without \n counts as different from the same line with one). `trimTail`
+ * reproduces what git does for a zero-context diff (blame): drop the common tail in 1 KiB blocks.
+ */
+export function xdiff (a, b, { trimTail = false } = {}) {
+  let sa = a.length; let sb = b.length
+  if (trimTail) { const t = commonTail(a, b); sa -= t; sb -= t }
+  const classes = new Map(); const counts = []
+  const x1 = prepare(a, sa, classes, counts, 0)
+  const x2 = prepare(b, sb, classes, counts, 1)
+  trimEnds(x1, x2)
+  cleanupRecords(counts, x1, x2)
+  doDiff(x1, x2)
+  changeCompact(x1, x2)
+  changeCompact(x2, x1)
+  // xdl_build_script, forwards.
+  const out = []
+  const c1 = x1.changed; const c2 = x2.changed
+  let i1 = 0; let i2 = 0
+  while (i1 < x1.nrec || i2 < x2.nrec) {
+    if (c1[i1 + 1] || c2[i2 + 1]) {
+      const s1 = i1; const s2 = i2
+      while (c1[i1 + 1]) i1++
+      while (c2[i2 + 1]) i2++
+      out.push({ a: [s1, i1 - s1], b: [s2, i2 - s2] })
+    } else { i1++; i2++ }
+  }
+  return out
+}