heyquilt 0.3.122 → 0.3.140

package/src/quilts/fastmerge.js

@@ -1,41 +0,0 @@
-// A fast front for merge-smart.js's mergeSmart (whose node-diff3 LCS is quadratic: seconds on a
-// 7,000-line file). A clean line merge comes from the Myers hunks in textdiff.js (`nway`, the
-// same N-way merge the conflict format uses); only a clash goes to mergeSmart's ladder, and then
-// with the lines all three versions share at the start and end cut off, so it reads only the
-// region that differs. Same answer, same `how`, as mergeSmart for a clean merge; a clash is
-// mergeSmart's own answer on the middle, put back between the shared lines.
-import { mergeSmart } from './merge-smart.js'
-import { nway } from './conflict-format.js'
-
-export function fastMerge (base, ours, theirs) {
-  const [o, a, b] = [base.split('\n'), ours.split('\n'), theirs.split('\n')]
-  const regions = nway(o, [a, b])
-  if (regions.every((r) => r.ok)) return { text: regions.flatMap((r) => r.ok).join('\n'), conflicts: [], how: 'lines' }
-  // Every clash is two inserts at one place the base had nothing (07's `additive` step): ours
-  // then theirs, shared leading lines once. Shared trailing lines are kept on both sides, not
-  // once as 07 says: two added functions share their closing `}`, and taking it once dropped
-  // one function's closing brace (found by real agents adding functions side by side).
-  if (regions.every((r) => r.ok || (!r.base.length && r.sides.length === 2))) {
-    return { text: regions.flatMap((r) => r.ok || additive(r.sides[0], r.sides[1])).join('\n'), conflicts: [], how: 'additive' }
-  }
-  // Shared lines at both ends, leaving at least one line in each middle.
-  const min = Math.min(o.length, a.length, b.length) - 1
-  let p = 0
-  while (p < min && o[p] === a[p] && o[p] === b[p]) p++
-  let s = 0
-  while (s < min - p && o[o.length - 1 - s] === a[a.length - 1 - s] && o[o.length - 1 - s] === b[b.length - 1 - s]) s++
-  if (!p && !s) return mergeSmart(base, ours, theirs)
-  const mid = (x) => x.slice(p, x.length - s).join('\n')
-  const m = mergeSmart(mid(o), mid(a), mid(b))
-  if (m.text === '') return mergeSmart(base, ours, theirs) // zero lines or one empty line: ambiguous
-  return { ...m, text: [...o.slice(0, p), m.text, ...o.slice(o.length - s)].join('\n') }
-}
-
-/** Two inserts at one place: ours, then what theirs adds after the leading lines both share. */
-function additive (a, b) {
-  let pre = 0
-  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
-  if (pre === b.length) return a
-  if (pre === a.length) return b
-  return [...a, ...b.slice(pre)]
-}

package/src/quilts/hash.js

@@ -1,44 +0,0 @@
-// Ids for Quilt source control (plans/quilt-source-control/03): BLAKE3-256 with a
-// domain-separation context per kind of object, so bytes of one kind can never be presented
-// as another. Ids travel as 64 hex characters.
-import { blake3 } from '@noble/hashes/blake3.js'
-
-const enc = new TextEncoder()
-const contexts = new Map()
-
-/** The context bytes for a kind and format version, e.g. 'commit' → "quilt commit v1". */
-function context (kind) {
-  let c = contexts.get(kind)
-  if (!c) { c = enc.encode(`quilt ${kind} v1`); contexts.set(kind, c) }
-  return c
-}
-
-export const KINDS = ['commit', 'blob', 'tree', 'chunk', 'pack', 'term', 'manifest']
-
-/** The id of `bytes` as an object of `kind`: BLAKE3 derive-key mode, 32 bytes, as hex. */
-// Not object kinds: keys made with their own contexts so they can never equal an object id.
-const KEY_KINDS = ['idempotency', 'resolution']
-
-/** A key (not an object id) in its own context, e.g. 'idempotency' → "quilt idempotency v1". */
-export function keyOf (kind, bytes) {
-  if (!KEY_KINDS.includes(kind)) throw new Error(`unknown key kind ${kind}`)
-  return Buffer.from(blake3(bytes, { context: context(kind) })).toString('hex')
-}
-
-export function idOf (kind, bytes) {
-  if (!KINDS.includes(kind)) throw new Error(`unknown object kind ${kind}`)
-  return Buffer.from(blake3(bytes, { context: context(kind) })).toString('hex')
-}
-
-export const ID = /^[0-9a-f]{64}$/
-
-/** Whether `s` looks like an id (64 lowercase hex). */
-export const isId = (s) => typeof s === 'string' && ID.test(s)
-
-/** An id as its 32 bytes. */
-export const idBytes = (hex) => Buffer.from(hex, 'hex')
-
-/** A quilt's shard (03): blake3 of its id's 16 bytes (plain hash mode), first byte mod 64. */
-export function shardOf (quiltId) {
-  return blake3(Buffer.from(String(quiltId).replace(/-/g, ''), 'hex'))[0] % 64
-}

package/src/quilts/history.js

@@ -1,266 +0,0 @@
-// History tools (plans/quilt-source-control/08 and 12): log --follow (a file's history through its
-// renames), log -S (commits that changed how often a text appears), describe (the nearest tag),
-// merge-base (where two revisions last shared history), grep (lines at a revision) and bisect (the
-// server narrows good..bad; whoever runs the check, the seam CLI or an agent, marks each step).
-import { cleanPath, cleanPrefix, under } from './records.js'
-import { isText, lineStat } from './textdiff.js'
-import { QuiltError } from './service.js'
-
-const MAX_WALK = 100000
-const MAX_GREP_BYTES = 64 * 1024 * 1024
-const MAX_GREP_FILE = 2 * 1024 * 1024
-const MAX_SEARCH_QUILTS = 100
-
-/** A grep pattern as a RegExp, refusing the shapes that can backtrack for ever on one line. */
-export function grepPattern (pattern, { fixed = false, ignoreCase = false } = {}) {
-  const p = String(pattern ?? '')
-  if (!p) throw new QuiltError(400, 'bad_request', 'give a pattern')
-  if (p.length > 500) throw new QuiltError(400, 'bad_request', 'a pattern is up to 500 characters')
-  const src = fixed ? p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : p
-  if (!fixed && (/\((?:[^()\\]|\\.)*[+*}](?:[^()\\]|\\.)*\)\s*[+*{]/.test(p) || /\\[1-9]/.test(p))) {
-    throw new QuiltError(400, 'bad_request', `the pattern ${p} could run for ever (a repeated group that repeats, or a back-reference): simplify it, or pass fixed for plain text`)
-  }
-  try { return new RegExp(src, ignoreCase ? 'i' : '') } catch (err) { throw new QuiltError(400, 'bad_request', `bad pattern: ${err.message}`) }
-}
-
-const count = (text, needle) => { let n = 0; let i = 0; while ((i = text.indexOf(needle, i)) >= 0) { n++; i += needle.length } return n }
-
-export function historyOps (svc, { mergeBase: commonBase }) {
-  const { quiltFor, resolve, rootAt, getCommit, snapshot, reader, readBlob, commitView, store } = svc.internals
-  const baseLog = svc.log
-
-  async function entryAt (q, commitId, p) {
-    if (!commitId) return null
-    return reader(q).lookup(await snapshot(q, commitId), p)
-  }
-
-  async function textOf (q, e, cache) {
-    if (!e || !e.blob) return null
-    if (cache.has(e.blob)) return cache.get(e.blob)
-    const b = await readBlob(q, e.blob)
-    const t = isText(b) ? b.toString('utf8') : null
-    cache.set(e.blob, t)
-    return t
-  }
-
-  /** The path `p` had before commit `c` added it: copy_from, a deleted file with the same content, or the most alike deleted text file. */
-  async function renamedFrom (q, c, ch, texts) {
-    if (ch.copy_from?.path) return ch.copy_from.path
-    const parent = c.parents[0] || null
-    if (!parent || await entryAt(q, parent, ch.path)) return null
-    const gone = c.changes.filter((x) => x.op === 'delete')
-    if (!gone.length) return null
-    const before = await Promise.all(gone.map((x) => entryAt(q, parent, x.path)))
-    const same = gone.find((x, i) => before[i]?.blob === ch.blob)
-    if (same) return same.path
-    const now = await textOf(q, { blob: ch.blob }, texts)
-    if (now == null) return null
-    let best = null; let score = 0.5
-    for (let i = 0; i < gone.length; i++) {
-      const was = await textOf(q, before[i], texts)
-      if (was == null) continue
-      const st = lineStat(was, now)
-      const total = Math.max(was.split('\n').length, now.split('\n').length, 1)
-      const kept = 1 - Math.max(st.add, st.del) / total
-      if (kept >= score) { best = gone[i].path; score = kept }
-    }
-    return best
-  }
-
-  /** Whether commit `c` changed how many times `needle` appears in the changed files (a rename keeps the count). */
-  async function changesCount (q, c, needle, prefixes, texts) {
-    const parent = c.parents[0] || null
-    let before = 0; let after = 0
-    for (const ch of c.changes) {
-      if (prefixes.length && !prefixes.some((p) => under(ch.path, p))) continue
-      const was = await textOf(q, await entryAt(q, parent, ch.path), texts)
-      const now = ch.op === 'put' ? await textOf(q, { blob: ch.blob }, texts) : null
-      if (was) before += count(was, needle)
-      if (now) after += count(now, needle)
-    }
-    return before !== after
-  }
-
-  /**
-   * GET /log with follow (one file, through its renames) or search (-S): a walk over first parents.
-   * Without either, the indexed log (service.js).
-   */
-  async function log (me, ref, opts = {}) {
-    const { rev = 'main', paths = [], limit = 20, follow = false, search } = opts
-    if (!follow && !search) return baseLog(me, ref, opts)
-    const q = await quiltFor(me, ref)
-    if (follow && (paths || []).length !== 1) throw new QuiltError(400, 'bad_request', 'log --follow takes one file')
-    if (search != null && (!String(search).length || String(search).length > 500)) throw new QuiltError(400, 'bad_request', 'log -S takes a text of 1 to 500 characters')
-    let range = String(rev || 'main')
-    let stop = null
-    if (range.includes('..')) {
-      const [a, b] = range.split('..')
-      stop = a ? await resolve(q.id, a) : null
-      range = b || 'main'
-    }
-    let id = await resolve(q.id, range)
-    let cur = follow ? cleanPath(paths[0]) : null
-    const prefixes = follow ? [] : (paths || []).map(cleanPrefix)
-    const max = Math.min(Number(limit) || 20, 1000)
-    const texts = new Map()
-    const out = []
-    let walked = 0
-    while (id && id !== stop && out.length < max && walked++ < MAX_WALK) {
-      const c = await getCommit(q.id, id)
-      if (follow) {
-        const ch = c.changes.find((x) => x.path === cur)
-        if (ch && (search == null || await changesCount(q.id, c, String(search), [cur], texts))) out.push({ ...commitView(c, { changes: false }), path: cur })
-        if (ch && ch.op === 'put') { const from = await renamedFrom(q.id, c, ch, texts); if (from) cur = from }
-      } else {
-        const touched = !prefixes.length || c.changes.some((x) => prefixes.some((p) => under(x.path, p)))
-        if (touched && await changesCount(q.id, c, String(search), prefixes, texts)) out.push(commitView(c, { changes: false }))
-      }
-      id = c.parents[0] || null
-    }
-    return { commits: out, more: !!id && id !== stop && out.length >= max, ...(follow ? { follow: cleanPath(paths[0]) } : {}) }
-  }
-
-  /** Every ancestor of `id` (all parents) with its distance, nearest first, up to MAX_WALK. */
-  async function ancestors (q, id, { until } = {}) {
-    const seen = new Map()
-    if (!id) return seen
-    let frontier = [id]
-    seen.set(id, 0)
-    for (let d = 1; frontier.length && seen.size < MAX_WALK; d++) {
-      const next = []
-      for (const x of frontier) {
-        if (until && until(x)) continue
-        for (const p of (await getCommit(q, x)).parents) if (!seen.has(p)) { seen.set(p, d); next.push(p) }
-      }
-      frontier = next
-    }
-    return seen
-  }
-
-  async function patchOf (q, id) { return id ? ((await store.getCommit(q, id))?.patch || null) : null }
-
-  /** GET /describe?rev=: the nearest tag behind a revision, as <tag>-<commits past it>-<commit>. */
-  async function describe (me, ref, rev = 'main') {
-    const q = await quiltFor(me, ref)
-    const id = await resolve(q.id, rev || 'main')
-    if (!id) throw new QuiltError(404, 'not_found', `${rev || 'main'} has no commits yet`)
-    const byCommit = new Map()
-    for (const t of await store.tags(q.id)) {
-      const had = byCommit.get(t.commit)
-      if (!had || (t.seq || 0) > (had.seq || 0)) byCommit.set(t.commit, t)
-    }
-    const short = id.slice(0, 12)
-    let hit = null
-    if (byCommit.size) {
-      const dist = await ancestors(q.id, id, { until: (x) => byCommit.has(x) })
-      for (const [cid, d] of dist) if (byCommit.has(cid) && (!hit || d < hit.d)) hit = { d, tag: byCommit.get(cid).name }
-    }
-    if (!hit) return { commit: id, short, tag: null, distance: null, describe: short }
-    return { commit: id, short, tag: hit.tag, distance: hit.d, describe: hit.d ? `${hit.tag}-${hit.d}-${short}` : hit.tag }
-  }
-
-  /** GET /merge-base?a=&b=: where two revisions last shared history (null if never). */
-  async function mergeBaseOf (me, ref, a, b) {
-    const q = await quiltFor(me, ref)
-    if (!a || !b) throw new QuiltError(400, 'bad_request', 'merge-base takes two revisions (a and b)')
-    const { base } = await commonBase(q.id, await resolve(q.id, a), await resolve(q.id, b))
-    return { commit: base, short: base ? base.slice(0, 12) : null, patch: await patchOf(q.id, base) }
-  }
-
-  /** GET /grep: the lines matching a pattern in the files at a revision (sq:<id>:live too). */
-  async function grep (me, ref, { pattern, rev = 'main', paths = [], ignore_case: ignoreCase = false, fixed = false, limit = 200 } = {}) {
-    const q = await quiltFor(me, ref)
-    const re = grepPattern(pattern, { fixed, ignoreCase })
-    const { id, root } = await rootAt(q.id, rev || 'main')
-    const prefixes = (paths && paths.length ? paths : ['']).map(cleanPrefix)
-    const max = Math.min(Math.max(Number(limit) || 200, 1), 2000)
-    const matches = []
-    const files = []
-    let bytes = 0; let more = false; let skipped = 0
-    for (const e of await reader(q.id).list(root, prefixes)) {
-      if (!e.blob || e.mode === 'gitlink' || e.mode === 'symlink') continue
-      if ((e.size || 0) > MAX_GREP_FILE || bytes + (e.size || 0) > MAX_GREP_BYTES) { skipped++; continue }
-      const buf = await readBlob(q.id, e.blob)
-      bytes += buf.length
-      if (!isText(buf)) continue
-      const lines = buf.toString('utf8').split('\n')
-      let hit = false
-      for (let i = 0; i < lines.length; i++) {
-        const text = lines[i].length > 4000 ? lines[i].slice(0, 4000) : lines[i]
-        if (!re.test(text)) continue
-        if (matches.length >= max) { more = true; break }
-        hit = true
-        matches.push({ path: e.path, line: i + 1, text: text.replace(/\r$/, '') })
-      }
-      if (hit) files.push(e.path)
-      if (more) break
-    }
-    return { commit: id, matches, files, more, ...(skipped ? { skipped } : {}) }
-  }
-
-  /**
-   * GET /v1/search: grep across every quilt the caller can read (or the ones named), at one
-   * revision (main by default). A quilt without that revision is skipped; limit counts all matches.
-   */
-  async function search (me, { pattern, rev = 'main', quilts = [], paths = [], ignore_case: ignoreCase = false, fixed = false, limit = 200 } = {}) {
-    grepPattern(pattern, { fixed, ignoreCase })
-    const max = Math.min(Math.max(Number(limit) || 200, 1), 2000)
-    const named = (quilts || []).filter(Boolean)
-    const targets = named.length ? await Promise.all(named.map((ref) => quiltFor(me, ref))) : await store.quiltsFor(me.member_id)
-    if (targets.length > MAX_SEARCH_QUILTS) throw new QuiltError(400, 'bad_request', `search reads at most ${MAX_SEARCH_QUILTS} quilts at once: name some with quilts`)
-    const matches = []; const files = []; const searched = []
-    let more = false; let skipped = 0
-    for (const q of targets) {
-      if (matches.length >= max) { more = true; break }
-      let r
-      try { r = await grep(me, q.slug, { pattern, rev, paths, ignore_case: ignoreCase, fixed, limit: max - matches.length }) } catch (e) {
-        if (e instanceof QuiltError && e.status === 404) continue
-        throw e
-      }
-      searched.push(q.slug)
-      for (const m of r.matches) matches.push({ quilt: q.slug, ...m })
-      for (const f of r.files) files.push(`${q.slug}:${f}`)
-      skipped += r.skipped || 0
-      if (r.more) { more = true; break }
-    }
-    return { rev: rev || 'main', searched, matches, files, more, ...(skipped ? { skipped } : {}) }
-  }
-
-  /**
-   * POST /bisect { bad, good, marks }: the first-parent commits after good up to bad, narrowed by
-   * marks ({ <commit>: good | bad | skip }). Answers the next commit to test, or the first bad one.
-   */
-  async function bisect (me, ref, { bad = 'main', good, marks = {} } = {}) {
-    const q = await quiltFor(me, ref)
-    if (!good) throw new QuiltError(400, 'bad_request', 'bisect needs a good revision (one without the problem)')
-    const [b, g] = [await resolve(q.id, bad), await resolve(q.id, good)]
-    if (!b || !g) throw new QuiltError(404, 'not_found', 'bisect needs two revisions with commits')
-    const behindGood = await ancestors(q.id, g)
-    const list = []
-    let id = b
-    while (id && !behindGood.has(id) && list.length < MAX_WALK) { list.push(id); id = (await getCommit(q.id, id)).parents[0] || null }
-    if (!id || !list.length) throw new QuiltError(400, 'bad_request', `${good} is not an ancestor of ${bad}: give a good revision older than the bad one`)
-    list.reverse() // oldest first; the last is bad
-    const mark = new Map()
-    for (const [k, v] of Object.entries(marks || {})) {
-      if (!['good', 'bad', 'skip'].includes(v)) throw new QuiltError(400, 'bad_request', `a mark is good, bad or skip, not ${v}`)
-      const full = list.find((x) => x.startsWith(String(k).replace(/^c:/, '')))
-      if (full) mark.set(full, v)
-    }
-    let hi = list.length - 1
-    for (let i = 0; i < list.length; i++) if (mark.get(list[i]) === 'bad') { hi = i; break }
-    let lo = -1
-    for (let i = hi - 1; i >= 0; i--) if (mark.get(list[i]) === 'good') { lo = i; break }
-    const left = []
-    for (let i = lo + 1; i < hi; i++) if (mark.get(list[i]) !== 'skip') left.push(i)
-    const view = async (cid) => commitView(await getCommit(q.id, cid), { changes: false })
-    if (!left.length) {
-      const skipped = list.slice(lo + 1, hi)
-      return { done: true, first_bad: await view(list[hi]), ...(skipped.length ? { maybe: await Promise.all(skipped.map(view)) } : {}), tested: mark.size }
-    }
-    const next = left[Math.floor((left.length - 1) / 2)]
-    return { done: false, next: await view(list[next]), remaining: left.length, steps: Math.ceil(Math.log2(left.length + 1)) }
-  }
-
-  return { log, describe, mergeBaseOf, grep, search, bisect }
-}

package/src/quilts/ids.js

@@ -1,12 +0,0 @@
-// Ids shared by the quilt server and seam's client (the git import makes its squares' ids).
-import crypto from 'node:crypto'
-
-/** A UUIDv7: 48 bits of milliseconds, then random (README §3.3: time-sortable, never collides). */
-export function uuidv7 (ms = Date.now()) {
-  const b = crypto.randomBytes(16)
-  b.writeUIntBE(ms, 0, 6)
-  b[6] = (b[6] & 0x0f) | 0x70
-  b[8] = (b[8] & 0x3f) | 0x80
-  const h = b.toString('hex')
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`
-}

package/src/quilts/import-follow.js

@@ -1,236 +0,0 @@
-// The remote driver of a git import, and the follow (plans/quilt-source-control/14, "Who runs
-// it and where" and "Importing a live repository"; 16 step 1). POST /v1/imports makes a new
-// quilt and imports a git remote into it from a mirror in scratch, with the same code as the
-// local driver (import-git.js). With follow: true the import then keeps following the remote's
-// main and release/* every `interval` seconds (default 600, at least 60), or at once on a poke
-// (POST /v1/imports/:id/poke, with the import's secret, so a git hook or a cron job can send it
-// without a member's key). While it follows, those lines are frozen with reason import_follow:
-// merges into them are refused with the import's id, because git is the authority. A rewritten
-// ref stops the follow (state failed, error 'ref rewritten'). One import per quilt, never
-// reopened (D19): the import's id is its quilt's id.
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import crypto from 'node:crypto'
-import { execFile } from 'node:child_process'
-import { QuiltError } from './service.js'
-import { buildPack } from './pack.js'
-import { importGit } from './import-git.js'
-
-export const POKE_PREFIX = 'sip_'
-const hash = (s) => crypto.createHash('sha256').update(String(s)).digest('hex')
-const followed = (name) => name === 'main' || name.startsWith('release/')
-const LEASE = ' import' // a line lease no line can hold: one pass at a time across servers
-
-/** Who may read a remote: a URL a server may fetch (never a path on the server unless allowLocal). */
-export function remoteUrl (raw, { allowLocal = false } = {}) {
-  const s = String(raw || '').trim()
-  if (/^(https?|ssh|git):\/\/[^\s]+$/i.test(s) || /^[\w.-]+@[\w.-]+:[^\s]+$/.test(s)) return s
-  if (allowLocal && (path.isAbsolute(s) || /^file:\/\//.test(s))) return s
-  throw new QuiltError(400, 'bad_request', 'url: a git remote (https://, ssh:// or user@host:path)')
-}
-
-export function run (args, { env = {}, cwd } = {}) {
-  return new Promise((resolve, reject) => {
-    execFile('git', args, { cwd, env: { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_TERMINAL_PROMPT: '0', ...env }, maxBuffer: 64 << 20 }, (err, stdout, stderr) => {
-      if (err) return reject(new Error(String(stderr || err.message).trim().split('\n').pop()))
-      resolve(stdout)
-    })
-  })
-}
-
-/** The import's credential as git config: `user:token`, or a bare token as x-access-token's. */
-export function authArgs (secret) {
-  if (!secret) return []
-  const pair = secret.includes(':') ? secret : `x-access-token:${secret}`
-  return ['-c', `http.extraHeader=Authorization: Basic ${Buffer.from(pair).toString('base64')}`]
-}
-
-/** importGit's client, in this process: the same operations the HTTP routes call. */
-export function localClient (api, me) {
-  return {
-    quilt: (q) => api.quiltInfo(me, q),
-    createQuilt: (b) => api.createQuilt(me, b),
-    importKnown: (q, shas) => api.importKnown(me, q, { shas }),
-    lines: async (q) => (await api.lines(me, q)).lines,
-    tags: async (q) => (await api.tags(me, q)).tags,
-    createTag: (q, b) => api.createTag(me, q, b),
-    tree: (q, rev, paths) => api.tree(me, q, rev, { paths: paths || [''] }),
-    exportPatches: (q, o) => api.exportPatches(me, q, o),
-    blobs: (q, ids) => api.blobs(me, q, ids),
-    importCommits: (q, items, lines = []) => api.importBatch(me, q, JSON.parse(JSON.stringify({ items, lines }))),
-    async upload (q, objs) {
-      const missing = new Set()
-      for (let i = 0; i < objs.length; i += 10000) for (const id of (await api.have(me, q, objs.slice(i, i + 10000).map((o) => o.id))).missing) missing.add(id)
-      let batch = []; let size = 0
-      const flush = async () => { if (batch.length) await api.uploadPack(me, q, buildPack(batch).bytes); batch = []; size = 0 }
-      for (const o of objs.filter((x) => missing.has(x.id))) {
-        if (size + o.bytes.length > 48 * 1024 * 1024) await flush()
-        batch.push(o); size += o.bytes.length
-      }
-      await flush()
-    }
-  }
-}
-
-export function importFollowOps (svc, api, { scratch = path.join(os.tmpdir(), 'seam-imports'), allowLocal = false, secret = (name) => process.env[`SEAM_SECRET_${String(name).toUpperCase().replace(/[^A-Z0-9]/g, '_')}`] || null, holder = `follower:${process.pid}:${crypto.randomBytes(4).toString('hex')}`, tickMs = 30_000 } = {}) {
-  const { store, now, quiltFor, fromStore } = svc.internals
-  const running = new Map() // quilt id → the pass in flight
-  const lastPass = new Map() // quilt id → when its last pass started, on this server
-  let timer = null
-
-  const view = (rec) => { const { poke_hash: _, ...rest } = rec; return { ...rest, quilt_id: rec.id } }
-  const save = async (qid, rec, opts = {}) => { try { return await store.setImport({ quilt_id: qid, import: rec, actor: rec.by.member_id, at: now(), ...opts }) } catch (err) { throw fromStore(err) } }
-
-  async function record (qid) {
-    const q = await store.getQuilt(qid)
-    return q?.settings?.import || null
-  }
-
-  /** One follow pass: fetch the remote into the mirror, import what is new, freeze what is followed. */
-  async function pass (qid) {
-    const rec = await record(qid)
-    if (!rec || !['reading', 'following'].includes(rec.state)) return
-    const lease = await store.takeLease({ kind: 'line', quilt_id: qid, line: LEASE, holder, ttl_ms: 30 * 60_000, at: now() })
-    if (!lease.held) return
-    lastPass.set(qid, now())
-    const was = rec.state
-    try {
-      const mirror = path.join(scratch, qid)
-      const auth = authArgs(rec.credential ? await secret(rec.credential, { quilt_id: qid }) : null)
-      const env = { GIT_ALLOW_PROTOCOL: allowLocal ? 'https:http:ssh:git:file' : 'https:http:ssh:git' }
-      if (!fs.existsSync(path.join(mirror, 'HEAD'))) {
-        fs.mkdirSync(scratch, { recursive: true })
-        fs.rmSync(mirror, { recursive: true, force: true })
-        await run([...auth, 'clone', '--quiet', '--mirror', rec.source.url, mirror], { env })
-      } else {
-        await run([...auth, '-C', mirror, 'fetch', '--quiet', '--prune', 'origin'], { env })
-      }
-      const r = await importGit(localClient(api, rec.by), { repo: mirror, slug: qid, follow: true })
-      const lines = []
-      for (const l of await store.lines(qid)) {
-        if (!followed(l.name)) continue
-        lines.push({ line: l.name, patches: l.patch_count, tip_sha: l.tip ? await store.gitShaOf(qid, l.tip) : null })
-      }
-      const next = { ...rec, lines, passes: (rec.passes || 0) + 1, last_pass_at: now(), commits: (rec.commits || 0) + r.commits }
-      delete next.error
-      if (r.rewritten.length) Object.assign(next, { state: 'failed', error: 'ref rewritten', rewritten: r.rewritten, finished_at: now() })
-      else if (!rec.follow) Object.assign(next, { state: 'done', finished_at: now() })
-      else next.state = 'following'
-      // While git leads, every followed line stays frozen (a stopped follow too: nobody merges
-      // over git's history until the owner decides).
-      await save(qid, next, { freeze: rec.follow ? true : null, lines: lines.map((l) => l.line), expect_state: was })
-    } catch (err) {
-      // A first pass that fails ends the import; a later one keeps following and says why.
-      const cur = await record(qid)
-      if (cur && cur.state === was) await save(qid, was === 'reading' ? { ...cur, state: 'failed', error: err.message, finished_at: now() } : { ...cur, error: err.message }, { expect_state: was }).catch(() => {})
-    } finally {
-      await store.giveLease({ kind: 'line', quilt_id: qid, line: LEASE, holder }).catch(() => {})
-    }
-  }
-
-  /** Runs a pass now, or joins the one in flight. */
-  function kick (qid) {
-    if (!running.has(qid)) running.set(qid, pass(qid).catch(() => {}).finally(() => running.delete(qid)))
-    return running.get(qid)
-  }
-
-  /** POST /v1/imports { url, slug, follow?, interval?, credential? } → the import, and its poke secret (shown once). */
-  async function startImport (me, { url, slug, follow = false, interval = 600, credential = null } = {}) {
-    const source = remoteUrl(url, { allowLocal })
-    const s = String(slug || '').toLowerCase()
-    let existing = null
-    try { existing = await quiltFor(me, s) } catch (err) { if (err.status !== 404) throw err }
-    if (existing) throw new QuiltError(409, existing.settings?.import ? 'import_closed' : 'slug_taken', existing.settings?.import ? `${s} already has its import (one import per quilt, never reopened)` : `you already have a quilt called ${s}`)
-    if (credential != null && !/^[A-Za-z0-9_.-]{1,100}$/.test(String(credential))) throw new QuiltError(400, 'bad_request', 'credential: the name of a secret, not the secret')
-    const q = await api.createQuilt(me, { slug: s, name: s, import: true })
-    const poke = POKE_PREFIX + crypto.randomBytes(24).toString('base64url')
-    const rec = { id: q.id, source: { url: source }, ...(credential ? { credential: String(credential) } : {}), follow: !!follow, interval_s: Math.max(60, Math.floor(Number(interval) || 600)), state: 'reading', lines: [], passes: 0, commits: 0, poke_hash: hash(poke), by: { member_id: me.member_id, kind: me.kind || 'person', name: me.name || null }, started_at: now() }
-    // main is frozen before anything is imported, so nothing merges ahead of git.
-    await save(q.id, rec, { freeze: rec.follow ? true : null, lines: ['main'], expect_state: null })
-    kick(q.id)
-    return { ...view(rec), poke_secret: poke }
-  }
-
-  async function importStatus (me, id) {
-    const q = await quiltFor(me, id, 'read')
-    const rec = q.settings?.import
-    if (!rec) throw new QuiltError(404, 'not_found', 'this quilt has no import')
-    return view(rec)
-  }
-
-  /** POST /v1/imports/:id/poke: a member who can write, or anyone with the import's secret. */
-  async function pokeImport (me, id, { secret: given } = {}) {
-    let rec
-    if (given) {
-      const q = /^[0-9a-f-]{36}$/i.test(String(id)) ? await store.getQuilt(String(id)) : null
-      rec = q?.settings?.import
-      if (!rec || !rec.poke_hash || !crypto.timingSafeEqual(Buffer.from(rec.poke_hash), Buffer.from(hash(given)))) throw new QuiltError(401, 'bad_token', 'this poke secret is not the import\'s')
-    } else {
-      const q = await quiltFor(me, id, 'write')
-      rec = q.settings?.import
-      if (!rec) throw new QuiltError(404, 'not_found', 'this quilt has no import')
-    }
-    if (rec.state !== 'following') throw new QuiltError(409, 'not_following', `the import is ${rec.state}, not following`)
-    kick(rec.id)
-    return { ok: true, id: rec.id, queued: true }
-  }
-
-  /**
-   * POST /v1/imports/:id/cutover (admin; 14 step 3, 16 step 3): a last follow pass, the remote's
-   * tips checked against the imported tips, then in one go: the follow ended for good (state
-   * done, closed), the followed lines unfrozen, and the export of main to the source turned on.
-   * Refuses (remote_moved, or conflict when a line moved in Seam) and leaves the follow as it was.
-   */
-  async function cutover (me, id, { credential } = {}) {
-    const q = await quiltFor(me, id, 'admin')
-    if (!q.settings?.import) throw new QuiltError(404, 'not_found', 'this quilt has no import')
-    if (q.settings.import.state !== 'following') throw new QuiltError(409, 'not_following', `the import is ${q.settings.import.state}, not following`)
-    await (running.get(q.id) || Promise.resolve())
-    await kick(q.id)
-    const rec = await record(q.id)
-    if (rec.state !== 'following') throw new QuiltError(409, 'not_following', `the last follow pass ended the import: ${rec.error || rec.state}`)
-    const auth = authArgs(rec.credential ? await secret(rec.credential, { quilt_id: q.id }) : null)
-    const env = { GIT_ALLOW_PROTOCOL: allowLocal ? 'https:http:ssh:git:file' : 'https:http:ssh:git' }
-    const remote = new Map()
-    for (const row of (await run([...auth, 'ls-remote', rec.source.url, 'HEAD', 'refs/heads/release/*'], { env })).split('\n').filter(Boolean)) {
-      const [sha, ref] = row.split('\t')
-      remote.set(ref === 'HEAD' ? 'main' : ref.replace(/^refs\/heads\//, ''), sha)
-    }
-    const have = new Map(rec.lines.map((l) => [l.line, l.tip_sha]))
-    for (const [line, sha] of remote) if (have.get(line) !== sha) throw new QuiltError(409, 'remote_moved', `the remote's ${line} is ${sha.slice(0, 12)}, the import has ${have.has(line) ? String(have.get(line)).slice(0, 12) : 'no such line'}: stop pushes to the remote (branch protection), then cut over again`, { line, sha })
-    const tips = {}
-    for (const l of await store.lines(q.id)) if (followed(l.name)) tips[l.name] = l.tip
-    const done = { ...rec, state: 'done', closed: true, finished_at: now() }
-    delete done.error
-    await save(q.id, done, { freeze: false, lines: Object.keys(tips), expect_state: 'following', expect_tips: tips })
-    let exp
-    try {
-      exp = await api.setExport(me, q.id, { target: rec.source.url, credential: credential || rec.credential || null, lines: ['main'], releases: false })
-    } catch (err) {
-      // The export must be on before anything merges in Seam: put the follow back as it was.
-      await save(q.id, rec, { freeze: true, lines: Object.keys(tips), expect_state: 'done' }).catch(() => {})
-      throw err
-    }
-    return { ok: true, import: view(done), export: exp }
-  }
-
-  const follower = {
-    /** Every tick, a pass for each following import whose interval is up (on this server). */
-    start () {
-      if (timer) return
-      const tick = async () => {
-        let list = []
-        try { list = await store.importsFollowing() } catch { return }
-        for (const { quilt_id: qid, import: rec } of list) if (now() - (lastPass.get(qid) || 0) >= rec.interval_s * 1000) kick(qid)
-        api.exportTick?.().catch(() => {})
-      }
-      timer = setInterval(tick, tickMs)
-      timer.unref?.()
-      tick()
-    },
-    stop () { if (timer) clearInterval(timer); timer = null }
-  }
-
-  return { startImport, importStatus, pokeImport, cutover, importIdle: (id) => running.get(id) || Promise.resolve(), follower, importPass: kick }
-}