heyquilt 0.3.119 → 0.3.120

package/src/quilts/import.js

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

package/src/quilts/index.js

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

package/src/quilts/lines.js

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,50 @@
+// 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

@@ -0,0 +1,114 @@
+// 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
+}

package/src/quilts/merge.js

@@ -3,6 +3,7 @@
 // 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'
@@ -82,8 +83,15 @@ export function mergeOps (svc) {
     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 = (p, kind, o, a, b, suggestion = null, clash = null) => {
+    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 })
@@ -95,26 +103,26 @@ export function mergeOps (svc) {
       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) { conflict(p, 'edit_vs_delete', o, a, b); continue }
-      if (a.mode === 'conflict' || b.mode === 'conflict') { conflict(p, 'content', o, a, b); 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 conflict(p, 'mode', o, a, b); continue }
+      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)) { conflict(p, 'content', o, a, b); continue }
+      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 })
-        conflict(p, 'content', o, a, b, { how: 'words', blob: sid })
+        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)) { conflict(p, 'order', o, a, b); continue }
-      if (m.conflicts.length || !AUTO.has(m.how)) { conflict(p, o ? 'content' : 'name', o, a, b); continue }
-      if (!mode) { conflict(p, 'mode', o, a, b); continue }
+      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 })
@@ -125,7 +133,7 @@ export function mergeOps (svc) {
     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') conflict(p, 'name', oursPaths.get(p)?.before || theirsPaths.get(p)?.before || null, oursPaths.get(p)?.after || null, theirsPaths.get(p)?.after || null, null, others)
+      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 }
   }
@@ -185,7 +193,7 @@ export function mergeOps (svc) {
    * 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) {
+  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).
@@ -196,9 +204,13 @@ export function mergeOps (svc) {
       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)
@@ -249,10 +261,11 @@ export function mergeOps (svc) {
           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 } })
+            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(() => {})
-            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, square: await squareView(await store.getSquare(sq.id)) }
+            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++
@@ -286,29 +299,60 @@ export function mergeOps (svc) {
     return n
   }
 
-  /** Rebase a square onto its line's tip (or `onto`): conflicts become terms, never a stop (07). */
+  /** 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 onto = body.onto ? await resolve(q.id, body.onto) : (await store.getLine(q.id, sq.line)).tip
-      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 }, 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) }
+      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.
@@ -385,6 +429,7 @@ export function mergeOps (svc) {
       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)
@@ -414,6 +459,7 @@ export function mergeOps (svc) {
           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)
@@ -422,6 +468,8 @@ export function mergeOps (svc) {
       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) }
     })