heyquilt 0.3.121 → 0.3.138

package/src/source-live/bring-in.js

@@ -0,0 +1,283 @@
+// Quilt's side of seam: live squares in a Quilt session. Seam (src/quilts/) never imports this.
+// Bringing main in. Seam's server never moves an open square's base (Seam's plans/quilt-source-control/
+// 02 step 6, 06 open question 3): a member rebases. In git mode Quilt brought outside commits into
+// everyone's folder by itself, into their uncommitted work, and it does the same in Seam: when main
+// moves past a square's base, a member's app asks the relay (server.js quiltCatchUp, as that member)
+// and the square takes main's new patches. Seam rebases its commits (a conflict is kept as a term in
+// its head, as at any rebase); then the square's live document (live-square.js) moves onto the new
+// head here, in one transaction on the relay, so every folder on it sees one change:
+//
+//   a file the square never changed       nothing to do: its folders take the new head's file
+//   a file the new head has as it is       the live entry leaves (nothing left to commit there)
+//   a file both changed                    combined three ways: the head the live work was made on,
+//                                          the live text as the relay holds it now (with everything
+//                                          typed meanwhile), and the new head's
+//
+// A file whose live work would not combine with main is committed first, as the member, so Seam's
+// rebase keeps it as a conflict in the square, the same as a merge does with live work (session-seam.js
+// seam_merge): members see it marked in their folders and settle it, and nothing typed is lost.
+import { liveMaps, liveHead, entryOf, overlay, seal } from './live-square.js'
+import { mergeSmart, withMarkers } from '../merge3.js'
+import { applyTextDiff } from '../textdiff.js'
+import { blobId } from '@heyquilt/seam/lib/quilts/records.js'
+import { isText } from '@heyquilt/seam/lib/quilts/textdiff.js'
+
+// A writer's app brings main in for the holder's square once the holder's app has not asked for this
+// long (offline, or failing): a little over two of the apps' checks (session-follow.js CATCH_UP_MS).
+export const HOLDER_WAIT_MS = 150 * 1000
+// After a move, an edit a folder made on the old head that reaches the relay late (it had not heard
+// of the move yet) is combined with main's changes too, for this long (lateEdits).
+export const LATE_MS = 10 * 60 * 1000
+const MAX_TEXT = 2 * 1024 * 1024
+const CHUNK = 100
+
+/** The paths changed between two revisions, of `paths` when given (null: all): a Set. */
+async function changedBetween (reader, q, from, to, paths = null) {
+  const out = new Set()
+  if (from === to || (paths && !paths.length)) return out
+  for (let i = 0; i < (paths ? paths.length : 1); i += CHUNK) {
+    const d = await reader.diff(q, { from, to, format: 'names', ...(paths ? { paths: paths.slice(i, i + CHUNK) } : {}) })
+    for (const f of (d && d.files) || []) if (!paths || paths.includes(f.path)) out.add(f.path)
+  }
+  return out
+}
+
+/** Each of `paths` at `rev` as a side ({ id, text, mode }; absent: { id: null, text: '' }), reading text blobs up to 2 MiB. */
+async function sidesAt (reader, q, rev, paths) {
+  const entries = new Map()
+  for (let i = 0; i < paths.length; i += CHUNK) {
+    const t = await reader.tree(q, rev, paths.slice(i, i + CHUNK))
+    for (const e of (t && t.entries) || []) entries.set(e.path, e)
+  }
+  const ids = [...new Set([...entries.values()].filter((e) => e.blob && e.mode !== 'conflict' && e.mode !== 'symlink' && (e.size ?? 0) <= MAX_TEXT).map((e) => e.blob))]
+  const bytes = {}
+  for (let i = 0; i < ids.length; i += CHUNK) Object.assign(bytes, (await reader.blobs(q, ids.slice(i, i + CHUNK))).blobs || {})
+  const out = new Map()
+  for (const p of paths) {
+    const e = entries.get(p)
+    if (!e) { out.set(p, { id: null, text: '' }); continue }
+    if (e.mode === 'conflict') { out.set(p, { id: `term:${e.term}`, text: null, term: true }); continue }
+    const b = bytes[e.blob] ? Buffer.from(bytes[e.blob], 'base64') : null
+    out.set(p, { id: e.blob, mode: e.mode, text: b && isText(b) ? b.toString('utf8') : null })
+  }
+  return out
+}
+
+/** What the live document holds at `p` as a side, or null (nothing). */
+function liveSide (doc, p) {
+  const e = entryOf(doc, p)
+  if (!e) return null
+  if (e.op === 'delete') return { id: null, text: '' }
+  if (e.blob) return { id: e.blob, mode: e.mode, text: null }
+  return { id: blobId(e.bytes), mode: e.mode, text: e.mode !== 'symlink' && isText(e.bytes) ? e.bytes.toString('utf8') : null }
+}
+
+/**
+ * Three sides of one file: `o` the head the work was made on, `l` the work, `n` the new head. { same }
+ * when the work is what the new head has, { text } when they combine (text, both changed), or
+ * { conflict } (the same lines changed differently, or a binary, deletion or term on both sides).
+ */
+export function combine (o, l, n) {
+  if (l.id === n.id) return { same: true }
+  if (o.id === n.id) return { keep: true }
+  if (o.id === l.id) return { same: true, theirs: true }
+  if (o.text === null || l.text === null || n.text === null || l.id === null || n.id === null) return { conflict: true }
+  const m = mergeSmart(o.text, l.text, n.text)
+  return m.conflicts.length ? { conflict: true } : m.text === n.text ? { same: true } : { text: m.text }
+}
+
+/**
+ * Before the rebase: the square's live files that would not combine with main (`sq` Seam's square,
+ * `tip` main's revision now). Its new head will have, for each, main's file where the square's commits
+ * did not change it, else Seam's combination of both; one that does not combine there is a conflict
+ * in the square already, and its live work goes with it.
+ */
+export async function conflictsAhead (reader, q, sq, doc, tip) {
+  const paths = overlay(doc).map((x) => x.path)
+  const changed = [...await changedBetween(reader, q, `c:${sq.base}`, tip, paths)]
+  if (!changed.length) return []
+  const base = await sidesAt(reader, q, `c:${sq.base}`, changed)
+  const head = sq.head ? await sidesAt(reader, q, `c:${sq.head}`, changed) : base
+  const now = await sidesAt(reader, q, tip, changed)
+  const out = []
+  for (const p of changed) {
+    const l = liveSide(doc, p)
+    if (!l) continue
+    const [b, h, t] = [base.get(p), head.get(p), now.get(p)]
+    let theirs = t
+    if (h.id !== b.id) {
+      const c = combine(b, h, t)
+      if (c.conflict) { out.push(p); continue }
+      if (c.text !== undefined) theirs = { id: blobId(Buffer.from(c.text, 'utf8')), text: c.text }
+      else if (!c.theirs) theirs = h
+    }
+    if (combine(h, l, theirs).conflict) out.push(p)
+  }
+  return out
+}
+
+// How many of main's versions of a file staleAhead reads; a path with more is never taken for an older copy by its deletion.
+const HISTORY_LIMIT = 100
+// How many live files a bring-in looks up in main's history (staleAhead), the ones main changed first.
+const STALE_LOOKS = 200
+
+/**
+ * Before the rebase: the square's live files main changed since the square's base whose live side is
+ * only an older copy of main's own file, never anyone's edit (2026-11-01: a folder at main:984 put 16
+ * of main's older files and 27 deletions of files main added since into a square, and the bring-in
+ * committed them as "conflicts" with main). A put is an older copy when its bytes are one of main's
+ * earlier versions of that path (Seam's path history); a deletion, when main added the path only after
+ * the square opened (a folder can't delete a file it never had). A file the square's own commits
+ * changed is the square's, whatever its bytes. `reader` needs pathHistory (else nothing is stale).
+ */
+export async function staleAhead (reader, q, sq, doc, tip) {
+  if (!reader || typeof reader.pathHistory !== 'function') return []
+  const paths = overlay(doc).map((x) => x.path)
+  const changed = [...await changedBetween(reader, q, `c:${sq.base}`, tip, paths)].slice(0, STALE_LOOKS)
+  if (!changed.length) return []
+  const base = await sidesAt(reader, q, `c:${sq.base}`, changed)
+  const head = sq.head ? await sidesAt(reader, q, `c:${sq.head}`, changed) : base
+  const out = []
+  for (const p of changed) {
+    const l = liveSide(doc, p)
+    if (!l || head.get(p).id !== base.get(p).id) continue
+    let h
+    try { h = await reader.pathHistory(q, p, { rev: tip, limit: HISTORY_LIMIT }) } catch { continue }
+    const entries = (h && h.entries) || []
+    if (!entries.length) continue
+    if (l.id === null) {
+      // Main's history of the path, newest first: its first put is when main added it.
+      const first = entries[entries.length - 1]
+      const opened = Number(sq.opened_at) || 0
+      if (entries.length < HISTORY_LIMIT && !(h.cursor || h.next) && first.op === 'put' && opened && Number(first.at) > opened) out.push(p)
+      continue
+    }
+    // Every version main had before its newest: the live bytes are one of them.
+    const older = new Set(entries.slice(1).filter((e) => e.op === 'put' && e.blob).map((e) => e.blob))
+    if (older.has(l.id) && entries[0].blob !== l.id) out.push(p)
+  }
+  return out
+}
+
+/**
+ * The square's head stands for `paths` (staleAhead's): their live entries leave and are marked clean,
+ * so every folder on the square writes the head's file (or loses it), and the move after the rebase
+ * brings main's. Done by the relay (`origin` relay-quilt), in one transaction.
+ */
+export function standHead (doc, paths, head) {
+  const m = liveMaps(doc)
+  doc.transact(() => {
+    for (const p of paths) {
+      for (const k of ['files', 'blobs', 'gone', 'modes', 'writers']) m[k].delete(p)
+      m.clean.set(p, { at: head })
+    }
+  }, 'relay-quilt')
+}
+
+/**
+ * Commits the live work of `paths` in the square as the member (`seam`), and seals it out of the live
+ * document: Seam's rebase then keeps each as a conflict in the square. Returns the square's new head.
+ */
+export async function commitAhead (seam, q, sq, doc, paths, by) {
+  const list = overlay(doc).filter((x) => paths.includes(x.path))
+  if (!list.length) return sq.head || null
+  const uploads = list.filter((x) => x.bytes).map((x) => ({ kind: 'blob', id: blobId(x.bytes), bytes: x.bytes }))
+  if (uploads.length) await seam.upload(q, uploads)
+  const changes = list.map((x) => x.op === 'delete' ? { path: x.path, op: 'delete' } : { path: x.path, op: 'put', blob: x.blob || blobId(x.bytes), mode: x.mode })
+  const names = list.map((x) => x.path)
+  const message = `Work on ${names.slice(0, 5).join(', ')}${names.length > 5 ? ` and ${names.length - 5} more` : ''}, kept as it was when main's newer patches came in (they changed the same lines)`
+  const prev = liveHead(doc)
+  const r = await seam.commit(q, sq.id, { expect_head: sq.head || null, message, changes })
+  seal(doc, { prev, head: r.square.head, sealed: Object.fromEntries(list.map((x) => [x.path, x.blob || blobId(x.bytes)])), by })
+  return r.square.head
+}
+
+/**
+ * Moves the square's live document from `prev` onto `head` (a rebase's new head, or the square's base
+ * when it has no commit: `base`), combining each live file the move changed (see the top of this file).
+ * Reads with `reader` (a Seam client: tree, blobs, diff); the move itself is one transaction, with the
+ * live text as the relay holds it then, so an edit that reached the relay meanwhile is in it. `brought`
+ * is kept in the document for everyone's status. { combined, conflicts, dropped, late } or throws when
+ * the live head is no longer `prev`.
+ */
+export async function moveLive (reader, q, doc, { prev, head, base = false, by = '', brought = null }) {
+  const moved = await changedBetween(reader, q, `c:${prev}`, `c:${head}`)
+  const old = new Map()
+  const now = new Map()
+  // The live files the move changed, read; again for any made while reading (a folder's first edit of one).
+  for (let i = 0; i < 3; i++) {
+    const want = overlay(doc).map((x) => x.path).filter((p) => moved.has(p) && !old.has(p))
+    if (!want.length) break
+    for (const [p, s] of await sidesAt(reader, q, `c:${prev}`, want)) old.set(p, s)
+    for (const [p, s] of await sidesAt(reader, q, `c:${head}`, want)) now.set(p, s)
+  }
+  if (liveHead(doc) !== prev) throw new Error(`the square's live head is ${String(liveHead(doc) || 'not set').slice(0, 12)}, not ${String(prev).slice(0, 12)}: read it again`)
+  const m = liveMaps(doc)
+  const out = { combined: [], conflicts: [], dropped: [] }
+  doc.transact(() => {
+    const drop = {}
+    for (const p of [...old.keys()].sort()) {
+      const l = liveSide(doc, p)
+      if (!l) continue
+      const [o, n] = [old.get(p), now.get(p)]
+      const c = combine(o, l, n)
+      if (c.same) { drop[p] = l.id; out.dropped.push(p); continue }
+      if (c.keep) continue
+      const t = m.files.get(p)
+      if (c.text !== undefined && t) { applyTextDiff(t, c.text); out.combined.push(p); continue }
+      // Not expected (conflictsAhead committed it first): an edit made while the rebase ran. Both sides stay in the file, marked.
+      if (t && l.text !== null && o.text !== null && n.text !== null && !n.term) applyTextDiff(t, withMarkers(o.text, l.text, n.text, { mine: 'this square', theirs: 'main' }))
+      out.conflicts.push(p)
+    }
+    seal(doc, { prev, head, sealed: drop, by })
+    if (base) m.live.set('head', { commit: head, by, ts: Date.now(), base: true })
+    if (brought) m.live.set('brought', { ...brought, at: Date.now(), by, combined: out.combined, conflicts: [...new Set([...(brought.conflicts || []), ...out.conflicts])] })
+  }, 'seal')
+  return out
+}
+
+/**
+ * After a move from `from` to `to`: an edit a folder made on `from` that reaches the relay late (it had
+ * not heard of the move) lacks main's change, and taken as it is would undo it. Each folder's block
+ * says which head every edit was made on (live-block.js scan: `writers` path -> { at }); a file written
+ * on `from` is combined three ways: `from`'s copy (what that folder last had under its work), the
+ * text as the relay holds it, and `to`'s copy. An edit made on `to` (one that takes main's new lines
+ * out on purpose, say) is never touched. `read(rev, paths)` reads sides (sidesAt). For LATE_MS (an app
+ * offline for longer takes the square in again as it opens). Returns a function that stops it.
+ */
+export function lateEdits (doc, { from, to, read }, { ms = LATE_MS, origin = 'relay-quilt' } = {}) {
+  const m = liveMaps(doc)
+  let queue = Promise.resolve()
+  const look = (ev, tr) => {
+    if (tr.origin === 'seal' || tr.origin === origin) return
+    const paths = [...ev.keysChanged].filter((p) => { const w = m.writers.get(p); return w && w.at === from && m.files.has(p) })
+    if (!paths.length) return
+    queue = queue.then(async () => {
+      const [o, n] = [await read(`c:${from}`, paths), await read(`c:${to}`, paths)]
+      if (liveHead(doc) !== to) return
+      doc.transact(() => {
+        for (const p of paths) {
+          const t = m.files.get(p)
+          const w = m.writers.get(p)
+          const [a, b] = [o.get(p), n.get(p)]
+          if (!t || !w || w.at !== from || !a || !b || a.text === null || b.text === null || b.term) continue
+          const cur = t.toString()
+          const r = mergeSmart(a.text, cur, b.text)
+          if (!r.conflicts.length && r.text !== cur) applyTextDiff(t, r.text)
+          // Combined: it is on `to` now, so a later edit of the same file is not combined again.
+          m.writers.set(p, { ...w, at: to })
+        }
+      }, origin)
+    }).catch(() => {})
+  }
+  m.writers.observe(look)
+  const timer = setTimeout(() => m.writers.unobserve(look), ms)
+  timer.unref?.()
+  return () => { clearTimeout(timer); m.writers.unobserve(look) }
+}
+
+/** sidesAt for lateEdits: `read(rev, paths)` with `reader` (a Seam client) in quilt `q`. */
+export const sideReader = (reader, q) => (rev, paths) => sidesAt(reader, q, rev, paths)
+
+/** What the live document says of the last time main came in: { at, by, patches, combined, conflicts }, or null. */
+export const broughtOf = (doc) => (doc && doc.getMap('live').get('brought')) || null