heyquilt 0.3.121 → 0.3.138

package/src/quilts/merge.js

@@ -1,486 +0,0 @@
-// Merge, rebase, cherry-pick, revert and resolve on the server (plans/quilt-source-control/07).
-// A merge into a line rebases the square's head onto the tip as one commit and moves the line
-// by compare-and-swap; a lost race is retried here, never by the client. A textual conflict
-// never reaches a line: the merge is refused and, by default, the conflicted rebase becomes the
-// square's head with the conflicts kept as data (conflict terms), so the square carries on.
-import { recall, remember } from './resolutions.js'
-import { fastMerge as mergeSmart } from './fastmerge.js' // mergeSmart (src/merge3.js) behind a fast clean path
-import { cleanCommit, commitBytes, commitId, blobId, termBytes, termId, cleanPath } from './records.js'
-import { sameEntry } from './tree.js'
-import { isText } from './textdiff.js'
-import { QuiltError, uuidv7, squareShort } from './service.js'
-
-const MAX_ATTEMPTS = 5
-// The highest ladder step that merges by itself (07: auto_combine, default 'whitespace'); words never do.
-const AUTO = new Set(['lines', 'additive', 'whitespace', 'union'])
-const MAX_SIDES = 8
-
-// The line's merge lease (07 step 8): a merge that lost three races queues for the line's lease
-// and makes its next attempts holding it, one holder at a time in arrival order; every merge
-// that holds no lease waits while it is held before reading the tip. So a holder can lose only
-// to attempts already running, and every merge lands. Two layers: an in-process queue keeps
-// arrival order on one API machine, and the store's line lease (quilt_line_leases) is the lock
-// across machines. A non-holder peeks at the table lease with ttl 0 (takes it only if free, and
-// then it is already expired). A crashed holder's lease lapses after LEASE_TTL_MS.
-const LEASE_TTL_MS = 10_000
-const leases = new Map() // quilt + line → { held: boolean, queue: [resolve] }
-
-function leaseOf (key) { let l = leases.get(key); if (!l) { l = { held: false, queue: [], idle: [] }; leases.set(key, l) } return l }
-function takeLease (key) {
-  const l = leaseOf(key)
-  if (!l.held) { l.held = true; return Promise.resolve() }
-  return new Promise((resolve) => l.queue.push(resolve))
-}
-function giveLease (key) {
-  const l = leaseOf(key)
-  const next = l.queue.shift()
-  if (next) return next()
-  l.held = false
-  for (const wake of l.idle.splice(0)) wake()
-}
-async function waitLease (key) {
-  const l = leaseOf(key)
-  while (l.held) await new Promise((resolve) => l.idle.push(resolve))
-}
-
-const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-
-export function mergeOps (svc) {
-  const { store, now, conflictsAt, quiltFor, squareByRef, resolve, getCommit, snapshot, entriesOf, treeGrower, reader, seal, readBlob, squareView, commitView, writable, once, getTerm, fromStore } = svc.internals
-
-  /** The entries of `paths` in a commit's tree (only the nodes on their way are read). */
-  const entryMap = async (q, id, paths) => {
-    const root = await snapshot(q, id)
-    const m = new Map()
-    for (const p of paths) { const e = await reader(q).lookup(root, p); if (e) m.set(p, e) }
-    return m
-  }
-
-  /**
-   * Three-way combination of trees: for every path either side changed from `base`, the final
-   * entry (taken, merged by content, or a conflict term). Returns { finals: Map path → entry|null,
-   * blobs (new merged blobs), terms (term objects), combined, conflicts: [{ path, kind, term }] }.
-   * `sides` names who and what each side is, for the terms: { ours: {commit, square, by}, theirs }.
-   */
-  async function combine (q, baseId, oursId, theirsId, sides, origin) {
-    const [B, O, T] = [await snapshot(q, baseId), await snapshot(q, oursId), await snapshot(q, theirsId)]
-    const r = reader(q)
-    const [dO, dT] = [await r.diff(B, O), await r.diff(B, T)]
-    const oursPaths = new Map(dO.map((d) => [d.path, d]))
-    const theirsPaths = new Map(dT.map((d) => [d.path, d]))
-    const finals = new Map()
-    const blobs = []; const terms = []; const combined = []; const conflicts = []
-    const overlap = []
-    for (const [p, d] of oursPaths) if (!theirsPaths.has(p)) finals.set(p, d.after || null)
-    for (const [p, d] of theirsPaths) if (!oursPaths.has(p)) finals.set(p, d.after || null)
-    for (const [p] of oursPaths) if (theirsPaths.has(p)) overlap.push(p)
-    // A path one side changed that is a directory of a path the other side changed (07 step 2).
-    const dirClash = []
-    // And two different paths that fold to one name on a case-insensitive disk (07 step 2).
-    const folded = new Map()
-    for (const t of theirsPaths.keys()) { const f = t.toLowerCase(); folded.set(f, [...(folded.get(f) || []), t]) }
-    for (const p of oursPaths.keys()) for (const t of folded.get(p.toLowerCase()) || []) if (p !== t && theirsPaths.get(t).after && oursPaths.get(p).after) dirClash.push([p, t])
-    for (const p of oursPaths.keys()) for (const t of theirsPaths.keys()) if (p !== t && (t.startsWith(p + '/') || p.startsWith(t + '/'))) dirClash.push([p, t])
-
-    const side = (e, s) => ({ ...(e && e.blob ? { blob: e.blob, mode: e.mode } : {}), from_commit: s.commit, ...(s.square ? { from_square: s.square } : {}), ...(s.by ? { by: s.by } : {}) })
-    const conflict = async (p, kind, o, a, b, suggestion = null, clash = null) => {
-      const term = { kind, adds: [side(a, sides.ours), side(b, sides.theirs)], removes: [side(o, sides.base || {})], origin, ...(suggestion ? { suggestion } : {}), ...(clash ? { clash } : {}) }
-      // The same conflict settled before (07, D12): apply the remembered answer and say so.
-      const known = !(a && a.mode === 'conflict') && !(b && b.mode === 'conflict') ? await recall(store, q, p, term) : null
-      if (known) {
-        finals.set(p, known.blob ? { path: p, mode: known.mode || 'file', blob: known.blob, size: known.size } : null)
-        combined.push({ path: p, how: 'reuse', by: known.by })
-        return
-      }
-      const id = termId(term)
-      terms.push({ kind: 'term', id, bytes: termBytes(term) })
-      finals.set(p, { path: p, mode: 'conflict', term: id })
-      conflicts.push({ path: p, kind, term: id, ...(suggestion ? { suggestion } : {}) })
-    }
-
-    for (const p of overlap) {
-      const o = oursPaths.get(p).before || null
-      const a = oursPaths.get(p).after || null
-      const b = theirsPaths.get(p).after || null
-      if (sameOrBoth(a, b)) { finals.set(p, a); continue }
-      if (!a || !b) { await conflict(p, 'edit_vs_delete', o, a, b); continue }
-      if (a.mode === 'conflict' || b.mode === 'conflict') { await conflict(p, 'content', o, a, b); continue }
-      // Modes: the side that changed it wins; both changed it differently is a mode term.
-      const mode = a.mode === b.mode ? a.mode : (o && a.mode === o.mode) ? b.mode : (o && b.mode === o.mode) ? a.mode : null
-      if (a.blob === b.blob) { if (mode) finals.set(p, { ...a, mode }); else await conflict(p, 'mode', o, a, b); continue }
-      const [ob, ab, bb] = [o && o.blob ? await readBlob(q, o.blob) : Buffer.alloc(0), await readBlob(q, a.blob), await readBlob(q, b.blob)]
-      if (!isText(ob) || !isText(ab) || !isText(bb)) { await conflict(p, 'content', o, a, b); continue }
-      const m = mergeSmart(ob.toString('utf8'), ab.toString('utf8'), bb.toString('utf8'))
-      if (!m.conflicts.length && m.how === 'words') {
-        // 07: a word merge is a suggestion only; the term carries the text it made.
-        const sb = Buffer.from(m.text, 'utf8')
-        const sid = blobId(sb)
-        blobs.push({ kind: 'blob', id: sid, bytes: sb })
-        await conflict(p, 'content', o, a, b, { how: 'words', blob: sid })
-        continue
-      }
-      // Both sides inserted at one place the base had nothing and no step settles it: `order`.
-      if (m.conflicts.length && o && m.conflicts.every((c) => c.base.length === 0)) { await conflict(p, 'order', o, a, b); continue }
-      if (m.conflicts.length || !AUTO.has(m.how)) { await conflict(p, o ? 'content' : 'name', o, a, b); continue }
-      if (!mode) { await conflict(p, 'mode', o, a, b); continue }
-      const bytes = Buffer.from(m.text, 'utf8')
-      const id = blobId(bytes)
-      blobs.push({ kind: 'blob', id, bytes })
-      finals.set(p, { path: p, mode, blob: id, size: bytes.length })
-      combined.push({ path: p, how: m.how })
-    }
-    const clashes = new Map()
-    for (const [p, t] of dirClash) clashes.set(p, [...(clashes.get(p) || []), t])
-    for (const [p, others] of clashes) {
-      const e = finals.get(p)
-      if (e && e.mode !== 'conflict') await conflict(p, 'name', oursPaths.get(p)?.before || theirsPaths.get(p)?.before || null, oursPaths.get(p)?.after || null, theirsPaths.get(p)?.after || null, null, others)
-    }
-    return { finals, blobs, terms, combined, conflicts, oursPaths, theirsPaths, overlap }
-  }
-
-  /** FileChanges that turn the tree `onto` (a Map) into it with `finals` applied. */
-  function changesOnto (onto, finals) {
-    const out = []
-    for (const [p, e] of finals) {
-      const cur = onto.get(p) || null
-      if (!e && !cur) continue
-      if (e && cur && sameEntry(e, cur)) continue
-      if (!e) out.push({ path: p, op: 'delete' })
-      else if (e.mode === 'conflict') out.push({ path: p, op: 'conflict', term: e.term })
-      else out.push({ path: p, op: 'put', blob: e.blob, mode: e.mode, size: e.size })
-    }
-    return out
-  }
-
-  const sameOrBoth = (a, b) => (!a && !b) || (a && b && sameEntry(a, b))
-
-  /** A new commit record from parts; returns { record, id, objects } ready to seal. */
-  function makeCommit (q, sq, { parents, predecessor, author, onBehalfOf, message, changes, stack }) {
-    const c = cleanCommit({ quilt_id: q, square_id: sq.id, parents, ...(predecessor ? { predecessor } : {}), author, ...(onBehalfOf ? { on_behalf_of: onBehalfOf } : {}), ...(sq.task_id ? { task_id: sq.task_id } : {}), message, authored_at: now(), changes, stack })
-    const id = commitId(c)
-    return { record: c, id, object: { kind: 'commit', id, bytes: commitBytes(c) } }
-  }
-
-  /**
-   * Rebases a square's head onto `ontoId` as one commit: returns { commit, root, objects,
-   * combined, conflicts, fast } without writing anything but objects. The fast path (no path
-   * changed on both sides) re-parents the square's changes and reads no file (07 step 2).
-   */
-  async function rebaseCommit (q, sq, head, ontoId, { message, reason = 'rebase' } = {}) {
-    const headCommit = await getCommit(q, head)
-    const sides = {
-      ours: { commit: head, square: sq.id, by: headCommit.author.member_id },
-      theirs: { commit: ontoId, by: 'line' },
-      base: { commit: sq.base }
-    }
-    const comb = await combine(q, sq.base, head, ontoId, sides, { reason, against: ontoId })
-    const ontoRoot = await snapshot(q, ontoId)
-    const onto = await entryMap(q, ontoId, comb.finals.keys())
-    const changes = changesOnto(onto, comb.finals)
-    const made = makeCommit(q, sq, { parents: [ontoId].filter(Boolean), predecessor: head, author: headCommit.author, onBehalfOf: headCommit.on_behalf_of, message: message ?? headCommit.message, changes, stack: headCommit.stack })
-    const tree = await treeGrower(q)(ontoRoot, changes)
-    return { made, root: tree.root, objects: [...comb.blobs, ...comb.terms, ...tree.objects, made.object], combined: comb.combined, conflicts: comb.conflicts, fast: !comb.overlap.length }
-  }
-
-  /** The patch message by default: the square's title and its commit messages (07). */
-  async function defaultMessage (q, sq) {
-    const commits = (await store.squareCommits(q, sq.id)).filter((c) => !c.hidden_seq)
-    const msgs = [...new Set(commits.map((c) => String(c.message || '').split('\n')[0]).filter(Boolean))]
-    return msgs.length === 1 && msgs[0] === sq.title ? sq.title : [sq.title, '', ...msgs.map((m) => `- ${m}`)].join('\n').trim()
-  }
-
-  /**
-   * Merge a square into a line (07's MergeRequest): { square, expect_head, message?,
-   * on_conflict: 'rebase' | 'leave', dry_run, expect_tip? }.
-   */
-  async function mergeIntoLine (me, ref, lineName, body, { reverts } = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    let sq = await writable(me, q, body.square || body.square_id)
-    // A square left 'merging' by a server that died mid-merge goes back to 'open' once its lease lapsed (07).
-    if (sq.state === 'merging' && await sweepOne(sq)) sq = await store.getSquare(sq.id)
-    const line = lineName || sq.line
-    const expect = body.expect_head === undefined ? sq.head : body.expect_head
-    const run = async () => {
-      const ln = await store.getLine(q.id, line)
-      if (!ln) throw new QuiltError(404, 'not_found', `no line ${line}`)
-      if (ln.frozen) throw new QuiltError(423, 'line_frozen', `${line} is frozen`)
-      const parent = await openParent(sq)
-      if (parent) throw new QuiltError(409, 'parent_open', `this square is stacked on ${squareShort(parent.id)}, which has not merged: merge it first, or fold this square into it`, { parent: squareShort(parent.id) })
-      if (sq.state !== 'open') throw new QuiltError(409, sq.state === 'merging' ? 'square_merging' : 'square_closed', `the square is ${sq.state}`)
-      if ((sq.head || null) !== (expect || null)) throw new QuiltError(409, 'head_moved', 'the square moved on since you looked', { head: sq.head })
-      if (!sq.head) throw new QuiltError(400, 'bad_request', 'the square has no commits to merge')
-      // The line's review rule (13); an automatic revert of a red patch does not wait for approvals.
-      if (!reverts && svc.internals.guardReview) await svc.internals.guardReview(q.id, sq, line)
-      const held = await conflictsAt(q.id, sq.head)
-      if (held.length) throw new QuiltError(422, 'conflict', `the square holds ${held.length} conflicted path${held.length === 1 ? '' : 's'} (${held.map((e) => e.path).join(', ')}); resolve them first`, { head: sq.head, paths: held.map((e) => e.path) })
-      const message = body.message || await defaultMessage(q.id, sq)
-      const warnings = []
-      if (body.expect_tip && body.expect_tip !== ln.tip) warnings.push({ kind: 'behind_by', detail: 'patches merged since you looked' })
-
-      if (body.dry_run) {
-        const r = await rebaseCommit(q.id, sq, sq.head, ln.tip, { message })
-        return r.conflicts.length
-          ? { ok: false, dry_run: true, refused: { code: 'conflict', detail: `would conflict in ${r.conflicts.map((c) => c.path).join(', ')}` }, terms: r.conflicts, warnings }
-          : { ok: true, dry_run: true, would_merge: { line, patch_no: ln.patch_count + 1, fast: r.fast }, combined: r.combined, warnings }
-      }
-
-      if (svc.internals.mergeWindow) await svc.internals.mergeWindow(q, line) // 429 merge_window above the line's window (07)
-      try { await store.beginMerge({ square_id: sq.id, expect_head: sq.head, actor: me.member_id, at: now() }) } catch (err) { throw fromStore(err) }
-      let retries = 0
-      const leaseKey = `${q.id}\u0000${line}`
-      const holder = `merge:${sq.id}:${uuidv7()}`
-      const tableLease = (ttl) => store.takeLease({ kind: 'line', quilt_id: q.id, line, holder, ttl_ms: ttl, at: now() })
-      let release = null
-      try {
-        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-          if (attempt === 4) {
-            await takeLease(leaseKey)
-            release = async () => { giveLease(leaseKey); await store.giveLease({ kind: 'line', quilt_id: q.id, line, holder }).catch(() => {}) }
-            while (!(await tableLease(LEASE_TTL_MS)).held) await pause(10 + Math.random() * 15)
-          }
-          if (!release) {
-            await waitLease(leaseKey)
-            const until = Date.now() + LEASE_TTL_MS
-            while (!(await tableLease(0)).held && Date.now() < until) await pause(10 + Math.random() * 15)
-          }
-          const tip = (await store.getLine(q.id, line)).tip
-          const r = await rebaseCommit(q.id, sq, sq.head, tip, { message })
-          if (r.conflicts.length) {
-            // Refused (D10). With on_conflict 'rebase' the conflicted rebase is the new head.
-            let newHead = sq.head
-            await seal(q.id, r.objects, { by: me.member_id })
-            if ((body.on_conflict || 'rebase') === 'rebase') {
-              await store.stageFiles({ quilt_id: q.id, commit_id: r.made.id, files: r.made.record.changes })
-              await store.commit({ commit: { ...r.made.record, id: r.made.id, at: now() }, expect_head: sq.head, state: 'merging', actor: me.member_id, at: now(), payload: { rebased_onto: tip, reason: 'merge_conflict' }, square_patch: { base: tip } })
-              newHead = r.made.id
-            }
-            await store.endMerge({ square_id: sq.id, why: 'conflict', actor: me.member_id, at: now() })
-            const terms = await Promise.all(r.conflicts.map(async (c) => ({ ...c, sides: (await getTerm(q.id, c.term)).adds.map((s) => ({ by: s.by, commit: s.from_commit, square: s.from_square && squareShort(s.from_square) })) })))
-            return { ok: false, refused: { code: 'conflict', detail: `conflict in ${r.conflicts.map((c) => c.path).join(', ')}` }, head: newHead, terms, warnings, square: await squareView(await store.getSquare(sq.id)) }
-          }
-          await seal(q.id, r.objects, { by: me.member_id })
-          await store.stageFiles({ quilt_id: q.id, commit_id: r.made.id, files: r.made.record.changes })
-          try {
-            const m = await store.merge({ commit: { ...r.made.record, id: r.made.id, at: now() }, line, expected_tip: tip, expect_head: sq.head, snapshot_root: r.root, actor: me.member_id, at: now(), payload: { combined: r.combined, ...(reverts ? { reverts } : {}) } })
-            // 03's second short transaction; if it fails, readers still see the patch as pending.
-            await store.fillLinePaths({ quilt_id: q.id }).catch(() => {})
-            const restacked = await restackChildren(q, sq, r.made.id, me)
-            return { ok: true, seq: m.seq, merged: { line, patch_no: m.patch_no, commit: r.made.id, seq: m.seq }, retries, combined: r.combined, fast: r.fast, warnings, ...(restacked.length ? { restacked } : {}), square: await squareView(await store.getSquare(sq.id)) }
-          } catch (err) {
-            if (err.code !== 'tip_moved') throw err
-            retries++
-            await new Promise((resolve) => setTimeout(resolve, Math.random() * 20 * attempt))
-          }
-        }
-        await store.endMerge({ square_id: sq.id, why: 'tip_moved', actor: me.member_id, at: now() })
-        throw new QuiltError(409, 'tip_moved', `${line} kept moving; ${MAX_ATTEMPTS} attempts lost the race. Call again.`, { attempts: MAX_ATTEMPTS })
-      } catch (err) {
-        await store.endMerge({ square_id: sq.id, why: err.code || 'error', actor: me.member_id, at: now() }).catch(() => {})
-        throw fromStore(err)
-      } finally {
-        if (release) await release()
-      }
-    }
-    if (body.dry_run) return run()
-    return once('merge', sq.id, expect, { line, square: sq.id, message: body.message || null, on_conflict: body.on_conflict || 'rebase' }, run)
-  }
-
-  // ---- the merging sweeper (07): a merge whose server died leaves its square 'merging' ----
-
-  const lapsed = (sq) => sq.state === 'merging' && now() - (typeof sq.updated_at === 'number' ? sq.updated_at : Date.parse(sq.updated_at)) > LEASE_TTL_MS
-  async function sweepOne (sq) {
-    if (!lapsed(sq)) return false
-    return !!(await store.endMerge({ square_id: sq.id, why: 'lease_lapsed', actor: 'system', at: now() }))
-  }
-  /** Returns every lapsed 'merging' square of a quilt to 'open' with a merge_refused row (why: 'lease_lapsed'). */
-  async function sweepMerges (qid) {
-    let n = 0
-    for (const sq of await store.squares(qid, { state: 'merging' })) if (await sweepOne(sq)) n++
-    return n
-  }
-
-  /** Rebase a square onto its line's tip, its open parent square's head when stacked, or `onto`: conflicts become terms, never a stop (07). */
-  async function rebase (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    const expect = body.expect_head === undefined ? sq.head : body.expect_head
-    return once('rebase', sq.id, expect, body, async () => {
-      if (sq.state !== 'open') throw new QuiltError(409, sq.state === 'merging' ? 'square_merging' : 'square_closed', `the square is ${sq.state}`)
-      const parent = await openParent(sq)
-      const onto = body.onto ? await resolve(q.id, body.onto) : parent ? (parent.head || parent.base) : (await store.getLine(q.id, sq.line)).tip
-      return rebaseSquare(q, sq, onto, me, expect, {})
-    })
-  }
-
-  /** A stacked square's parent while it is still open or merging (06), else null. */
-  async function openParent (sq) {
-    if (!sq.parent_square) return null
-    const p = await store.getSquare(sq.parent_square)
-    return p && (p.state === 'open' || p.state === 'merging') ? p : null
-  }
-
-  async function rebaseSquare (q, sq, onto, me, expect, payload) {
-    if (onto === sq.base) return { ok: true, noop: true, square: await squareView(sq) }
-    if (!sq.head) {
-      const s = await store.setSquare({ square_id: sq.id, patch: { base: onto }, op: 'rebase', actor: me.member_id, at: now() })
-      return { ok: true, square: await squareView(s), conflicted: 0 }
-    }
-    const r = await rebaseCommit(q.id, sq, sq.head, onto, {})
-    await seal(q.id, r.objects, { by: me.member_id })
-    await store.stageFiles({ quilt_id: q.id, commit_id: r.made.id, files: r.made.record.changes })
-    try {
-      const row = await store.commit({ commit: { ...r.made.record, id: r.made.id, at: now() }, expect_head: expect, actor: me.member_id, at: now(), payload: { rebased_onto: onto, ...payload }, square_patch: { base: onto } })
-      return { ok: true, seq: row.seq, result: commitView({ ...row, changes: r.made.record.changes }), conflicted: r.conflicts.length, terms: r.conflicts, combined: r.combined, square: await squareView(await store.getSquare(sq.id)) }
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /**
-   * Restack (06, D14): when a square merges, the open squares stacked on it are rebased onto the
-   * line's new tip, conflicts kept as terms in their heads. A child whose head moved meanwhile is
-   * left for its holder to rebase; the answer lists what happened to each.
-   */
-  async function restackChildren (q, parent, tip, me) {
-    const kids = (await store.squares(q.id, { state: 'open' })).filter((s) => s.parent_square === parent.id)
-    const out = []
-    for (const k of kids) {
-      try {
-        const r = await rebaseSquare(q, k, tip, me, k.head, { restacked: { parent_square: parent.id } })
-        out.push({ square: squareShort(k.id), holder: k.holder, conflicted: r.conflicted || 0, ...(r.terms && r.terms.length ? { terms: r.terms } : {}) })
-      } catch (err) {
-        out.push({ square: squareShort(k.id), holder: k.holder, error: err.code || 'failed' })
-      }
-    }
-    return out
-  }
-
-  /**
-   * Applies one commit's change to a square as a single-parent commit (07): three-way with the
-   * picked commit's first parent as base. `invert` is revert: base and theirs swap.
-   */
-  async function applyOne (q, sq, me, pickId, { invert = false, message, payload, open = false }) {
-    const x = await getCommit(q, pickId)
-    const parent = x.parents[0] || null
-    const [base, theirs] = invert ? [pickId, parent] : [parent, pickId]
-    const ours = sq.head || sq.base
-    const sides = { ours: { commit: ours, square: sq.id, by: me.member_id }, theirs: { commit: pickId, square: x.square_id, by: x.author.member_id }, base: { commit: base } }
-    const comb = await combine(q, base, ours, theirs, sides, { reason: 'merge', against: pickId })
-    // Only what the picked commit changed moves; paths only ours changed stay as they are.
-    const finals = new Map([...comb.finals].filter(([p]) => comb.theirsPaths.has(p)))
-    const onto = await entryMap(q, ours, finals.keys())
-    const changes = changesOnto(onto, finals)
-    if (!changes.length) throw new QuiltError(400, 'bad_request', invert ? 'reverting that changes nothing here' : 'that change is already here')
-    const made = makeCommit(q, sq, { parents: [ours].filter(Boolean), author: { member_id: me.member_id, kind: me.kind, name: me.name, ...(me.tool ? { tool: me.tool } : {}) }, onBehalfOf: me.on_behalf_of, message, changes })
-    await seal(q, [...comb.blobs, ...comb.terms, made.object], { by: me.member_id })
-    await store.stageFiles({ quilt_id: q, commit_id: made.id, files: made.record.changes })
-    // A revert's new square is opened in the same transaction as its commit (04).
-    const row = open
-      ? await store.openAndCommit({ square: sq, at: now(), commit: { ...made.record, id: made.id, at: now() }, expect_head: null, actor: me.member_id, payload })
-      : await store.commit({ commit: { ...made.record, id: made.id, at: now() }, expect_head: sq.head || null, actor: me.member_id, at: now(), payload })
-    const conflicts = comb.conflicts.filter((c) => finals.has(c.path))
-    return { ok: true, seq: row.seq, result: commitView({ ...row, changes: made.record.changes }), conflicted: conflicts.length, terms: conflicts, square: await squareView(await store.getSquare(sq.id)) }
-  }
-
-  async function cherryPick (me, ref, sqRef, body) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    const expect = body.expect_head === undefined ? sq.head : body.expect_head
-    return once('cherry-pick', sq.id, expect, body, async () => {
-      if ((sq.head || null) !== (expect || null)) throw new QuiltError(409, 'head_moved', 'the square moved on since you looked', { head: sq.head })
-      if (sq.state !== 'open') throw new QuiltError(409, 'square_closed', `the square is ${sq.state}`)
-      const pick = await resolve(q.id, body.from)
-      if (!pick) throw new QuiltError(404, 'not_found', `${body.from} names no commit`)
-      const x = await getCommit(q.id, pick)
-      try {
-        return await applyOne(q.id, sq, me, pick, { message: body.message || `${x.message}\n\n(cherry picked from commit ${pick.slice(0, 12)})`, payload: { picked_from: pick } })
-      } catch (err) { throw fromStore(err) }
-    })
-  }
-
-  /**
-   * Revert a patch (or any commit): a new square from the line tip whose one commit inverts it
-   * (06, 07). It merges like any square.
-   */
-  async function revert (me, ref, body) {
-    const q = await quiltFor(me, ref, 'write')
-    const target = await resolve(q.id, body.rev)
-    if (!target) throw new QuiltError(404, 'not_found', `${body.rev} names no commit`)
-    const x = await getCommit(q.id, target)
-    const line = body.line || 'main'
-    const ln = await store.getLine(q.id, line)
-    const label = x.patch ? `patch ${x.patch.line}:${x.patch.patch_no}` : `commit ${target.slice(0, 12)}`
-    const title = `Revert ${label}: ${String(x.message).split('\n')[0]}`.slice(0, 200)
-    const square = { id: uuidv7(now()), quilt_id: q.id, title, line, base: ln.tip, holder: me.member_id, opened_by: me.member_id, writers: [] }
-    const sq = { ...square, head: null, state: 'open' }
-    try {
-      return await applyOne(q.id, sq, me, target, { open: true, invert: true, message: body.message || `${title}\n\nThis reverts ${label}.`, payload: { reverts: target, ...(x.patch ? { reverts_patch: x.patch } : {}) } })
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /**
-   * Resolve conflict terms by choice (07's ResolveRequest): { expect_head, entries: [{ path,
-   * choose: 'ours' | 'theirs' | 'base' | 'suggestion' | n | 'delete' | 'keep_edit' | 'keep_delete' | { blob } }] }.
-   */
-  async function resolveTerms (me, ref, sqRef, body) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    const expect = body.expect_head === undefined ? sq.head : body.expect_head
-    return once('resolve', sq.id, expect, body, async () => {
-      if (!sq.head) throw new QuiltError(400, 'bad_request', 'nothing to resolve')
-      const cur = await entryMap(q.id, sq.head, (body.entries || []).map((e) => cleanPath(e.path)))
-      const changes = []
-      const resolved = []
-      const picks = []
-      for (const e of body.entries || []) {
-        const p = cleanPath(e.path)
-        const at = cur.get(p)
-        if (!at || at.mode !== 'conflict') throw new QuiltError(400, 'bad_request', `${p} is not conflicted`)
-        const t = await getTerm(q.id, at.term)
-        let pick
-        const c = e.choose
-        if (c === 'suggestion') {
-          if (!t.suggestion) throw new QuiltError(400, 'bad_request', `${p}: this conflict has no suggestion`)
-          const row = await store.getBlob(q.id, t.suggestion.blob)
-          pick = { blob: t.suggestion.blob, mode: t.adds[0].mode || 'file', size: row.size }
-        } else if (c && typeof c === 'object' && c.blob) {
-          const row = await store.getBlob(q.id, c.blob)
-          if (!row) throw new QuiltError(422, 'pack_unsealed', `blob ${c.blob.slice(0, 12)} is not uploaded`)
-          pick = { blob: c.blob, mode: t.adds[0].mode || 'file', size: row.size }
-        } else {
-          const s = c === 'ours' || c === 'keep_edit' ? (t.adds[0].blob ? t.adds[0] : t.adds[1]) : c === 'theirs' ? t.adds[1] : c === 'base' ? t.removes[0] : Number.isInteger(c) ? t.adds[c] : null
-          if (c === 'delete' || c === 'keep_delete' || (s && !s.blob)) pick = null
-          else if (!s) throw new QuiltError(400, 'bad_request', `${p}: choose ours, theirs, base, suggestion, a side number, delete, keep_edit, keep_delete or { blob }`)
-          else { const row = await store.getBlob(q.id, s.blob); pick = { blob: s.blob, mode: s.mode || 'file', size: row.size } }
-        }
-        changes.push(pick ? { path: p, op: 'put', ...pick } : { path: p, op: 'delete' })
-        // A name term kept on this side wins the name: the paths it clashed with go, and the answer says so.
-        const dropped = []
-        if (t.kind === 'name' && pick && t.clash) {
-          const root = await snapshot(q.id, sq.head)
-          for (const other of t.clash) if (await reader(q.id).lookup(root, other) && !changes.some((x) => x.path === other)) { changes.push({ path: other, op: 'delete' }); dropped.push(other) }
-        }
-        resolved.push({ path: p, term: at.term, how: typeof c === 'object' ? 'blob' : String(c), ...(dropped.length ? { dropped } : {}) })
-        picks.push({ path: p, term: at.term, pick, how: typeof c === 'object' ? 'blob' : String(c) })
-      }
-      if (!changes.length) throw new QuiltError(400, 'bad_request', 'name the paths to resolve')
-      const head = await getCommit(q.id, sq.head)
-      const made = makeCommit(q.id, sq, { parents: head.parents, predecessor: sq.head, author: { member_id: me.member_id, kind: me.kind, name: me.name }, onBehalfOf: me.on_behalf_of, message: head.message, changes: mergeChanges(head.changes, changes), stack: head.stack })
-      await seal(q.id, [made.object], { by: me.member_id })
-      await store.stageFiles({ quilt_id: q.id, commit_id: made.id, files: made.record.changes })
-      try {
-        const row = await store.commit({ commit: { ...made.record, id: made.id, at: now() }, expect_head: expect, actor: me.member_id, at: now(), payload: { resolved } })
-        // Settled once, settled for good (07, D12), unless the resolver says remember: false.
-        if (body.remember !== false) await remember(store, getTerm, q.id, picks, me, now())
-        return { ok: true, seq: row.seq, result: commitView({ ...row, changes: made.record.changes }), conflicted: (await conflictsAt(q.id, made.id)).length, square: await squareView(await store.getSquare(sq.id)) }
-      } catch (err) { throw fromStore(err) }
-    })
-  }
-
-  return { mergeIntoLine, sweepMerges, rebase, cherryPick, revert, resolve: resolveTerms, combine, mergeInternals: { combine, changesOnto, entryMap, makeCommit, rebaseCommit } }
-}
-
-/** A commit's changes with some paths replaced (a resolution rewrites the head, D13). */
-function mergeChanges (old, repl) {
-  const m = new Map(old.map((c) => [c.path, c]))
-  for (const c of repl) m.set(c.path, c)
-  return [...m.values()]
-}

package/src/quilts/objects.js

@@ -1,144 +0,0 @@
-// Object storage for quilts (plans/quilt-source-control/03, "Object storage layout"): written
-// once, never overwritten, read by range. Packs live at q/<quilt_id>/p/<pack_id>, in a folder on
-// disk (diskBlobs) or a private Supabase Storage bucket (bucket.js). A second write of the same
-// key keeps the first bytes.
-import fs from 'node:fs'
-import path from 'node:path'
-
-/** Files under `dir` on this machine: <dir>/<room>/<name>. */
-export class DiskBlobs {
-  constructor (dir) { this.dir = dir }
-  file (room, name) { return path.join(this.dir, room, name) }
-}
-
-const packRoom = (quiltId) => `q/${quiltId}/p`
-
-/** Packs over DiskBlobs, or a bucket with uploadTarget, downloadTarget and bucket.list (bucket.js). */
-export class BlobstoreObjects {
-  constructor (store, { fetch: fetchImpl = globalThis.fetch } = {}) {
-    this.store = store
-    this.fetch = fetchImpl
-  }
-
-  /** Writes a pack once; a pack already there is left as it is (same id, same bytes). */
-  async putPack (quiltId, packId, bytes) {
-    const room = packRoom(quiltId)
-    if (this.store instanceof DiskBlobs) {
-      const file = this.store.file(room, packId)
-      fs.mkdirSync(path.dirname(file), { recursive: true })
-      try { fs.writeFileSync(file, bytes, { flag: 'wx' }) } catch (err) { if (err.code !== 'EEXIST') throw err }
-      return
-    }
-    const target = await this.store.uploadTarget(room, packId, bytes.length)
-    if (target.exists) return
-    const res = await this.fetch(target.url, { method: target.method || 'PUT', headers: { 'content-type': 'application/octet-stream', 'x-upsert': 'false' }, body: bytes })
-    if (res.ok) { await res.body?.cancel().catch(() => {}); return }
-    // The pack is there already (Supabase says 409, or 400 "Duplicate"), which for
-    // content-addressed bytes is success.
-    const text = await res.text().catch(() => '')
-    if (res.status === 409 || /duplicate|already exists/i.test(text)) return
-    throw new Error(`storage: pack upload answered ${res.status}`)
-  }
-
-  /** `len` bytes of a pack from `offset` (the whole pack when no range is given). */
-  async readPack (quiltId, packId, offset, len) {
-    const room = packRoom(quiltId)
-    if (this.store instanceof DiskBlobs) {
-      const file = this.store.file(room, packId)
-      if (offset == null) return fs.readFileSync(file)
-      const fd = fs.openSync(file, 'r')
-      try {
-        const buf = Buffer.alloc(len)
-        const n = fs.readSync(fd, buf, 0, len, offset)
-        if (n !== len) throw new Error(`storage: pack ${packId} is shorter than its index says`)
-        return buf
-      } finally { fs.closeSync(fd) }
-    }
-    const { url } = await this.store.downloadTarget(room, packId)
-    const headers = offset == null ? {} : { range: `bytes=${offset}-${offset + len - 1}` }
-    const res = await this.fetch(url, { headers })
-    if (!res.ok) throw new Error(`storage: pack read answered ${res.status}`)
-    const buf = Buffer.from(await res.arrayBuffer())
-    // A store that ignores Range sends the whole pack.
-    return offset != null && res.status === 200 && buf.length !== len ? buf.subarray(offset, offset + len) : buf
-  }
-
-  // Other written-once objects of a quilt (03's layout: `w` WAL segments, `j` journal groups):
-  // q/<quilt_id>/<kind>/<name>. Same write-once rule as packs.
-  async putFile (quiltId, kind, name, bytes) {
-    const room = `q/${quiltId}/${kind}`
-    if (this.store instanceof DiskBlobs) {
-      const file = this.store.file(room, name)
-      fs.mkdirSync(path.dirname(file), { recursive: true })
-      try { fs.writeFileSync(file, bytes, { flag: 'wx' }) } catch (err) { if (err.code !== 'EEXIST') throw err }
-      return
-    }
-    const target = await this.store.uploadTarget(room, name, bytes.length)
-    if (target.exists) return
-    const res = await this.fetch(target.url, { method: target.method || 'PUT', headers: { 'content-type': 'application/octet-stream', 'x-upsert': 'false' }, body: bytes })
-    if (res.ok) { await res.body?.cancel().catch(() => {}); return }
-    const text = await res.text().catch(() => '')
-    if (res.status === 409 || /duplicate|already exists/i.test(text)) return
-    throw new Error(`storage: ${kind}/${name} upload answered ${res.status}`)
-  }
-
-  async readFile (quiltId, kind, name) {
-    const room = `q/${quiltId}/${kind}`
-    if (this.store instanceof DiskBlobs) return fs.readFileSync(this.store.file(room, name))
-    const { url } = await this.store.downloadTarget(room, name)
-    const res = await this.fetch(url)
-    if (!res.ok) throw new Error(`storage: ${kind}/${name} read answered ${res.status}`)
-    return Buffer.from(await res.arrayBuffer())
-  }
-
-  /** The names under q/<quilt_id>/<kind>, sorted. */
-  async listFiles (quiltId, kind) {
-    const room = `q/${quiltId}/${kind}`
-    if (this.store instanceof DiskBlobs) {
-      try { return fs.readdirSync(path.join(this.store.dir, room)).sort() } catch (err) { if (err.code === 'ENOENT') return []; throw err }
-    }
-    const names = []
-    for (let offset = 0; ; offset += 1000) {
-      const { data, error } = await this.store.bucket.list(room, { limit: 1000, offset, sortBy: { column: 'name', order: 'asc' } })
-      if (error) throw new Error(`storage: ${error.message}`)
-      names.push(...data.map((f) => f.name))
-      if (data.length < 1000) return names.sort()
-    }
-  }
-}
-
-/** Packs in memory, for tests. */
-export class MemoryObjects {
-  constructor () { this.packs = new Map(); this.puts = 0 }
-  async putPack (quiltId, packId, bytes) {
-    const key = `${quiltId}/${packId}`
-    this.puts++
-    if (!this.packs.has(key)) this.packs.set(key, Buffer.from(bytes))
-  }
-
-  async readPack (quiltId, packId, offset, len) {
-    const b = this.packs.get(`${quiltId}/${packId}`)
-    if (!b) throw new Error(`storage: no pack ${packId}`)
-    return offset == null ? Buffer.from(b) : Buffer.from(b.subarray(offset, offset + len))
-  }
-
-  async putFile (quiltId, kind, name, bytes) {
-    const key = `${quiltId}/${kind}/${name}`
-    this.puts++
-    if (!this.packs.has(key)) this.packs.set(key, Buffer.from(bytes))
-  }
-
-  async readFile (quiltId, kind, name) {
-    const b = this.packs.get(`${quiltId}/${kind}/${name}`)
-    if (!b) throw new Error(`storage: no ${kind}/${name}`)
-    return Buffer.from(b)
-  }
-
-  async listFiles (quiltId, kind) {
-    const pre = `${quiltId}/${kind}/`
-    return [...this.packs.keys()].filter((key) => key.startsWith(pre)).map((key) => key.slice(pre.length)).sort()
-  }
-}
-
-/** A disk-backed object store in `dir`. */
-export const diskObjects = (dir) => new BlobstoreObjects(new DiskBlobs(dir))