heyquilt 0.3.121 → 0.3.138

package/src/quilts/archiver.js

@@ -1,175 +0,0 @@
-// The log archiver (plans/quilt-source-control/03, "The log order and the archiver"; 15
-// invariant 5): copies a quilt's log rows, with the commit rows they write, into immutable WAL
-// segments in object storage, so the database is rebuildable by replay. A segment is written when
-// 1,000 rows are waiting or the oldest waiting row is 5 minutes old, holds at most 1,000 rows, and
-// names the segment before it by hash, so a quilt's segments are one chain. archive_seq then moves
-// by compare-and-swap (setArchive), so two archivers never both advance one quilt; a loser's
-// segment has the same name and the same bytes as the winner's (rows are immutable and the
-// encoding is deterministic), and object storage keeps the first.
-//
-// Segment bytes: 'QWS1', a flag byte (0 deflate-raw, 1 zstd), the compressed body (one canonical
-// JSON record a line: { t: 'log', row } or { t: 'commit', row }), the trailer JSON
-// { quilt_id, from_seq, to_seq, row_count, prev, blake3 } and its length as a u32. `blake3` is
-// the hash of everything before the trailer; `prev` the previous segment's (64 zeros first).
-import zlib from 'node:zlib'
-import { blake3 } from '@noble/hashes/blake3.js'
-
-export const SEGMENT_ROWS = 1000
-export const SEGMENT_AGE_MS = 5 * 60 * 1000
-const MAGIC = Buffer.from('QWS1')
-const ZERO = '0'.repeat(64)
-const HAS_ZSTD = typeof zlib.zstdCompressSync === 'function'
-
-const pad = (n) => String(n).padStart(12, '0')
-/** 03's key w/<from_seq>-<to_seq>.qws, zero-padded so names sort in seq order. */
-export const segmentName = (from, to) => `${pad(from)}-${pad(to)}.qws`
-const hashOf = (bytes) => Buffer.from(blake3(bytes)).toString('hex')
-
-/** Canonical JSON: keys sorted at every level, so the same rows always give the same bytes. */
-function canonical (v) {
-  if (Array.isArray(v)) return '[' + v.map(canonical).join(',') + ']'
-  if (v && typeof v === 'object') return '{' + Object.keys(v).sort().filter((key) => v[key] !== undefined).map((key) => JSON.stringify(key) + ':' + canonical(v[key])).join(',') + '}'
-  return JSON.stringify(v ?? null)
-}
-
-// Commit-row columns that change after the row is written (03's replay table derives them):
-// hidden_seq from successors' `predecessor`, patch from merge rows, snapshot_root from the merge
-// row or the deriver. A segment keeps only what never changes.
-const LATER = ['hidden_seq', 'patch', 'snapshot_root']
-export const frozenCommit = (c) => { const out = { ...c }; for (const key of LATER) delete out[key]; return out }
-
-export function encodeSegment ({ quilt_id: q, from_seq: from, to_seq: to, prev, records }) {
-  const body = Buffer.from(records.map(canonical).join('\n'), 'utf8')
-  const head = Buffer.concat([MAGIC, Buffer.from([HAS_ZSTD ? 1 : 0]), HAS_ZSTD ? zlib.zstdCompressSync(body) : zlib.deflateRawSync(body, { level: 6 })])
-  const trailer = { quilt_id: q, from_seq: from, to_seq: to, row_count: records.filter((r) => r.t === 'log').length, prev, blake3: hashOf(head) }
-  const tb = Buffer.from(canonical(trailer), 'utf8')
-  const len = Buffer.alloc(4); len.writeUInt32BE(tb.length)
-  return { bytes: Buffer.concat([head, tb, len]), trailer }
-}
-
-export function decodeSegment (bytes) {
-  if (bytes.length < 9 || !bytes.subarray(0, 4).equals(MAGIC)) throw new Error('not a WAL segment')
-  const tl = bytes.readUInt32BE(bytes.length - 4)
-  const head = bytes.subarray(0, bytes.length - 4 - tl)
-  const trailer = JSON.parse(bytes.subarray(head.length, bytes.length - 4).toString('utf8'))
-  if (hashOf(head) !== trailer.blake3) throw new Error(`segment ${trailer.from_seq}-${trailer.to_seq}: its bytes do not match its hash`)
-  const flag = head[4]
-  if (flag === 1 && !HAS_ZSTD) throw new Error('this segment is zstd and this Node cannot read zstd (needs Node 22.15 or later)')
-  const body = (flag === 1 ? zlib.zstdDecompressSync : zlib.inflateRawSync)(head.subarray(5)).toString('utf8')
-  return { trailer, records: body ? body.split('\n').map((l) => JSON.parse(l)) : [] }
-}
-
-/**
- * The archiver over a store and an object store. `archive(q, { force })` writes every segment
- * that is due (with `force`, the rest too, in segments of at most 1,000 rows) and returns
- * { segments, archive_seq }. `maybe(q)` runs it in the background, once at a time per quilt.
- */
-export function createArchiver ({ store, objects, now = Date.now, rows = SEGMENT_ROWS, ageMs = SEGMENT_AGE_MS }) {
-  const running = new Map()
-
-  async function writeOne (q, quilt, to) {
-    const from = (quilt.archive_seq || 0) + 1
-    const records = []
-    for (let after = from - 1; after < to;) {
-      const page = await store.logRows(q, { after, limit: Math.min(1000, to - after) })
-      if (!page.length) throw new Error(`log rows ${after + 1}..${to} are missing: the archiver never writes past a gap`)
-      for (const row of page) {
-        if (row.seq !== after + 1) throw new Error(`log row ${after + 1} is missing (found ${row.seq}): the archiver never writes past a gap`)
-        records.push({ t: 'log', row })
-        after = row.seq
-        // The commit row this log row wrote (a commit, or the rebased commit of a merge).
-        const id = row.kind === 'commit' || row.kind === 'merge' ? row.commit || row.commit_id : null
-        if (id) {
-          const c = await store.getCommit(q, id)
-          if (c && c.seq === row.seq) records.push({ t: 'commit', row: frozenCommit(c) })
-        }
-      }
-    }
-    const prev = quilt.last_segment || ZERO
-    const { bytes, trailer } = encodeSegment({ quilt_id: q, from_seq: from, to_seq: to, prev, records })
-    await objects.putFile(q, 'w', segmentName(from, to), bytes)
-    const r = await store.setArchive({ quilt_id: q, expect_seq: from - 1, to_seq: to, segment: trailer.blake3 })
-    return { ...trailer, archive_seq: r.archive_seq }
-  }
-
-  async function archive (q, { force = false } = {}) {
-    const segments = []
-    for (;;) {
-      const quilt = await store.getQuilt(q)
-      if (!quilt) throw new Error('no such quilt')
-      const done = quilt.archive_seq || 0
-      const waiting = quilt.head_seq - done
-      if (waiting <= 0) return { segments, archive_seq: done }
-      let due = force || waiting >= rows
-      if (!due) {
-        const [oldest] = await store.logRows(q, { after: done, limit: 1 })
-        due = !!oldest && now() - Number(oldest.at) >= ageMs
-      }
-      if (!due) return { segments, archive_seq: done }
-      try {
-        segments.push(await writeOne(q, quilt, done + Math.min(rows, waiting)))
-      } catch (err) {
-        if (err.code === 'archive_moved') continue // another archiver advanced it: read again
-        throw err
-      }
-    }
-  }
-
-  function maybe (q) {
-    if (running.has(q)) return running.get(q)
-    const p = archive(q).catch(() => null).finally(() => running.delete(q))
-    running.set(q, p)
-    return p
-  }
-
-  return { archive, maybe }
-}
-
-/**
- * Replay (03's table, for the rows segments carry): reads a quilt's segments from object storage
- * alone, checks the chain end to end (each segment's hash, `prev`, and seq continuity from 1), and
- * rebuilds the log, the commit rows (with hidden_seq and patch derived again) and every line's tip.
- */
-export async function replaySegments (objects, q) {
-  const names = await objects.listFiles(q, 'w')
-  const log = []
-  const commits = new Map()
-  const lines = new Map()
-  let prev = ZERO
-  let at = 0
-  for (const name of names) {
-    const { trailer, records } = decodeSegment(await objects.readFile(q, 'w', name))
-    if (trailer.quilt_id !== q) throw new Error(`segment ${name} belongs to quilt ${trailer.quilt_id}`)
-    if (trailer.prev !== prev) throw new Error(`segment ${name} does not follow the one before it (chain broken)`)
-    if (trailer.from_seq !== at + 1) throw new Error(`segment ${name} starts at ${trailer.from_seq}, expected ${at + 1} (a gap)`)
-    if (name !== segmentName(trailer.from_seq, trailer.to_seq)) throw new Error(`segment ${name} says it holds ${trailer.from_seq}-${trailer.to_seq}`)
-    for (const r of records) {
-      if (r.t === 'commit') { commits.set(r.row.id, { ...r.row, hidden_seq: null }); continue }
-      const row = r.row
-      if (row.seq !== at + 1) throw new Error(`segment ${name}: row ${row.seq} out of order`)
-      at = row.seq
-      log.push(row)
-    }
-    if (at !== trailer.to_seq || log.length < trailer.row_count) throw new Error(`segment ${name} ends at ${at}, its trailer says ${trailer.to_seq}`)
-    prev = trailer.blake3
-  }
-  for (const c of commits.values()) {
-    const p = c.predecessor && commits.get(c.predecessor)
-    if (p && p.hidden_seq == null) p.hidden_seq = c.seq
-  }
-  for (const row of log) {
-    // A line made from a commit, and a line frozen or unfrozen (policy rows naming the line).
-    if (row.kind === 'policy' && row.line && row.payload) {
-      const op = row.payload.op
-      if (op === 'line') lines.set(row.line, { name: row.line, tip: row.payload.tip || null, tip_seq: row.seq, patch_count: 0, frozen: false })
-      else if ((op === 'freeze' || op === 'unfreeze') && lines.has(row.line)) lines.get(row.line).frozen = op === 'freeze'
-      continue
-    }
-    if (row.kind !== 'merge') continue
-    const id = row.commit || row.to || row.commit_id
-    lines.set(row.line, { ...lines.get(row.line), name: row.line, tip: id, tip_seq: row.seq, patch_count: row.patch_no })
-    const c = commits.get(id)
-    if (c) { c.patch = { line: row.line, patch_no: row.patch_no }; if (row.snapshot_root) c.snapshot_root = row.snapshot_root }
-  }
-  return { archive_seq: at, last_segment: prev === ZERO ? null : prev, log, commits, lines }
-}

package/src/quilts/autorevert.js

@@ -1,49 +0,0 @@
-// The automatic revert (plans/quilt-source-control/07 "The post-merge pipeline", steps 3 and 4).
-// A red post-merge check that names the patch it failed at (`patch`, found by the runner, for
-// example with `seam bisect`) reverts that patch on the line by itself: a revert square is opened
-// and merged as the reporter, and a fix square holding the change again is opened for the
-// patch's holder, so fixing forward is "edit, commit, merge". The patch stays in history. The
-// revert is an ordinary revert and merge, so a frozen line or a full merge window refuses it like
-// any merge and the revert square is left open; a revert that conflicts with later patches is
-// left open too, with its terms.
-import { QuiltError } from './service.js'
-
-export function autoRevertOps (svc, { revert, mergeIntoLine, cherryPick, openSquare, handoff }) {
-  const { store, quiltFor, resolve, getCommit, squareView } = svc.internals
-
-  async function revertCulprit (me, ref, line, check, n) {
-    const q = await quiltFor(me, ref, 'write')
-    const row = await store.patch(q.id, line, n)
-    if (!row || !row.commit) throw new QuiltError(404, 'not_found', `${line} has no patch ${n}`)
-    const culprit = await resolve(q.id, `${line}:${n}`)
-    const x = await getCommit(q.id, culprit)
-    const first = String(x.message || '').split('\n')[0]
-    let r
-    try {
-      r = await revert(me, ref, { rev: `${line}:${n}`, line, message: `Revert patch ${line}:${n}: ${check} failed\n\nThis reverts patch ${line}:${n} (${first}).` })
-    } catch (err) {
-      if (err.code === 'bad_request') return { reverted: false, patch_no: n, refused: { code: 'nothing_to_revert', detail: err.message } }
-      throw err
-    }
-    const out = { reverted: false, patch_no: n, square: r.square }
-    if (r.conflicted) return { ...out, refused: { code: 'conflict', detail: `the revert conflicts with later patches in ${r.terms.map((t) => t.path).join(', ')}; resolve and merge the revert square` } }
-    try {
-      const m = await mergeIntoLine(me, ref, line, { square: r.square.id }, { reverts: n })
-      if (!m.ok) return { ...out, square: m.square || r.square, refused: m.refused }
-      Object.assign(out, { reverted: true, revert_patch_no: m.merged.patch_no, square: m.square })
-    } catch (err) {
-      if (!err.code || !err.status) throw err
-      return { ...out, refused: { code: err.code, detail: err.message } }
-    }
-    // The fix square: the change again over the tip after the revert, held by the patch's holder.
-    const orig = row.square ? await store.getSquare(row.square) : null
-    const holder = orig && !orig.import ? orig.holder : null
-    const fix = await openSquare(me, ref, { title: `Fix ${first || `patch ${line}:${n}`}`.slice(0, 200), line })
-    await cherryPick(me, ref, fix.id, { from: culprit, expect_head: null, message: x.message })
-    if (holder && holder !== me.member_id) await handoff(me, ref, fix.id, { to: holder, context: `Patch ${line}:${n} was reverted: ${check} failed. This square holds the change again: fix it, commit, merge.` })
-    out.fix_square = await squareView(await store.getSquare(fix.id))
-    return out
-  }
-
-  return { revertCulprit }
-}

package/src/quilts/bisect-run.js

@@ -1,31 +0,0 @@
-// The check side of bisect (the server narrows, history.js): each commit the server names is
-// checked out into a fresh folder and the check command runs there. Exit 0 is good, 125 is skip,
-// 1 to 127 is bad, anything else (a signal, 128 and up) stops, as git bisect run does.
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { spawn } from 'node:child_process'
-import { checkout } from './block.js'
-
-const runIn = (cmd, cwd) => new Promise((resolve, reject) => {
-  const child = spawn(cmd, { cwd, shell: true, stdio: 'ignore' })
-  child.on('error', reject)
-  child.on('exit', (code, signal) => resolve(signal ? null : code))
-})
-
-export async function bisectRun (client, { quilt, bad, good, run, marks = {}, paths = [''], api, log = () => {} }) {
-  const m = { ...marks }
-  for (let i = 0; i < 200; i++) {
-    const r = await client.bisect(quilt, { bad, good, marks: m })
-    if (r.done) return { ...r, marks: m }
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'seam-bisect-'))
-    try {
-      await checkout(client, { quilt, rev: r.next.id, paths, dir, api })
-      const code = await runIn(run, dir)
-      if (code == null || code > 127) throw new Error(`The check stopped on ${r.next.short} (exit ${code ?? 'by a signal'}): bisect stopped.`)
-      m[r.next.id] = code === 0 ? 'good' : code === 125 ? 'skip' : 'bad'
-      log(`${r.next.short} ${m[r.next.id]}`)
-    } finally { fs.rmSync(dir, { recursive: true, force: true }) }
-  }
-  throw new Error('bisect took more than 200 steps')
-}

package/src/quilts/blame.js

@@ -1,103 +0,0 @@
-// Blame, computed on request (plans/quilt-source-control/08): each line of a file at a revision
-// is attributed to the commit that last changed it, walking first parents back from the
-// revision. Whole-file renames and the derived, eager-for-main version come later; this walk
-// is what that type computes, without the cache.
-import { cleanPath } from './records.js'
-import { isText, splitLines, lineMap } from './textdiff.js'
-import { QuiltError, squareShort } from './service.js'
-
-const MAX_WALK = 100000
-
-export function blameOps (svc) {
-  const { quiltFor, resolve, getCommit, snapshot, reader, readBlob } = svc.internals
-
-  async function blame (me, ref, rev, path) {
-    const q = await quiltFor(me, ref)
-    const p = cleanPath(path)
-    const start = await resolve(q.id, rev)
-    const at = start ? await reader(q.id).lookup(await snapshot(q.id, start), p) : null
-    if (!at || !at.blob) throw new QuiltError(404, 'not_found', `${p} is not in ${rev || 'main'}`)
-    const bytes = await readBlob(q.id, at.blob)
-    if (!isText(bytes)) throw new QuiltError(400, 'bad_request', `${p} is not text`)
-    const lines = splitLines(bytes.toString('utf8'))
-    const owner = new Array(lines.length).fill(null)
-    // `track[i]` is the index, in the version being looked at, of the result's line i (or -1 once owned).
-    let track = lines.map((_, i) => i)
-    let text = lines
-    let buf = bytes
-    let id = start
-    let blob = at.blob
-    let walked = 0
-    let cur = p
-    const chains = new Map()
-    while (id && walked++ < MAX_WALK && track.some((x) => x >= 0)) {
-      const c = await getCommit(q.id, id)
-      const ch = c.changes.find((x) => x.path === cur)
-      const parent = c.parents[0] || null
-      if (!ch) {
-        // On a line, jump straight to the last patch that touched the file (line_paths).
-        if (c.patch && c.patch.line) {
-          const rows = await svc.internals.store.linePaths(q.id, c.patch.line, cur, { upTo: c.patch.patch_no, limit: 1 })
-          if (rows.length) { id = rows[0].commit_id; continue }
-        } else if (!c.patch) {
-          // Inside a square, jump to its last commit on this chain that touched the file, or out of it.
-          const { chain, exit } = await svc.internals.squareChain(q.id, c, chains)
-          const hit = (await svc.internals.store.squarePathCommits(q.id, c.square_id, cur, { upTo: c.seq, limit: chain.size })).find((r) => chain.has(r.commit_id))
-          id = hit ? hit.commit_id : exit
-          continue
-        }
-        id = parent
-        continue
-      }
-      // This commit changed the file: lines it kept come from its parent's version; the rest are its own.
-      let before = ch.op === 'put' && parent ? await reader(q.id).lookup(await snapshot(q.id, parent), cur) : null
-      if ((!before || !before.blob) && parent) {
-        // Added here: a whole-file rename when a path this commit deleted held at least half its lines.
-        const from = ch.copy_from ? ch.copy_from.path : await renamedFrom(q.id, c, parent, text)
-        if (from) { before = await reader(q.id).lookup(await snapshot(q.id, parent), from); if (before) cur = from }
-      }
-      if (!before || !before.blob) {
-        for (let i = 0; i < track.length; i++) if (track[i] >= 0) { owner[i] = c; track[i] = -1 }
-        break
-      }
-      const prevBuf = before.blob === blob ? buf : await readBlob(q.id, before.blob)
-      const prevText = before.blob === blob ? text : splitLines(prevBuf.toString('utf8'))
-      const map = lineMap(prevBuf, buf)
-      track = track.map((x, i) => {
-        if (x < 0) return x
-        if (map[x] < 0) { owner[i] = c; return -1 }
-        return map[x]
-      })
-      text = prevText
-      buf = prevBuf
-      blob = before.blob
-      id = parent
-    }
-    const out = lines.map((line, i) => {
-      const c = owner[i]
-      return { line: i + 1, text: line, commit: c ? c.id : null, short: c ? c.id.slice(0, 12) : null, author: c ? c.author.name : null, member: c ? c.author.member_id : null, at: c ? (c.authored_at || c.at) : null, square: c ? squareShort(c.square_id) : null, ...(c && c.patch ? { patch: c.patch } : {}) }
-    })
-    return { path: p, rev: rev || 'main', commit: start, lines: out }
-  }
-
-  /** The path a commit deleted whose parent version shares at least half of `text`'s lines, or null. */
-  async function renamedFrom (q, c, parent, text) {
-    const gone = c.changes.filter((x) => x.op === 'delete')
-    if (!gone.length || !text.length) return null
-    const want = new Set(text)
-    let best = null; let score = 0.5
-    const root = await snapshot(q, parent)
-    for (const g of gone.slice(0, 50)) {
-      const e = await reader(q).lookup(root, g.path)
-      if (!e || !e.blob) continue
-      const b = await readBlob(q, e.blob)
-      if (!isText(b)) continue
-      const lines = splitLines(b.toString('utf8'))
-      const shared = lines.filter((l) => want.has(l)).length / Math.max(lines.length, text.length)
-      if (shared >= score) { best = g.path; score = shared }
-    }
-    return best
-  }
-
-  return { blame }
-}