heyquilt 0.3.121 → 0.3.138

package/src/quilts/events.js

@@ -1,160 +0,0 @@
-// Events (plans/quilt-source-control/12): never written in the commit or merge transaction. The
-// events job reads the quilt's log after its cursor, derives each event and its recipients, and
-// writes them with the cursor moved in one transaction (store.addEvents); then it POSTs each one
-// to the recipients' webhooks, signed and retried by seam's own webhook.js. Members read theirs
-// over HTTP (GET /v1/quilts/:q/events?after=), the CLI (`seam events`) and the MCP tool seam_events, so an agent in any tool is woken the same way.
-import { QuiltError, squareShort } from './service.js'
-import { makeSubscription, deliverWebhook, RETRY_DELAYS_MS } from './webhook.js'
-
-export const QUILT_EVENT_KINDS = ['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff']
-const MAX_DIFF_PATHS = 200
-
-export function eventOps (svc, sq, { allowLocalWebhooks = false, fetch, delays = RETRY_DELAYS_MS, log = () => {} } = {}) {
-  const { store, now, quiltFor, getCommit, getTerm, conflictsAt, snapshot, reader } = svc.internals
-  const running = new Map() // quilt → the job in flight, so one process runs one job per quilt at a time
-  const sending = new Map() // quilt + member → delivery chain, so a member's POSTs keep their order
-
-  const by = (c) => ({ member_id: c.author.member_id, kind: c.author.kind, name: c.author.name, ...(c.author.tool ? { tool: c.author.tool } : {}) })
-
-  async function changedPaths (qid, s) {
-    if (!s.head) return []
-    return (await reader(qid).diff(await snapshot(qid, s.base), await snapshot(qid, s.head))).map((e) => e.path)
-  }
-
-  /** The events one log row causes. */
-  async function derive (qid, row) {
-    const out = []
-    if (row.kind === 'merge' && row.payload?.reverts) {
-      // patch.reverted: the reverted patch's holder (and whom they acted for) learns it is gone (07 step 4).
-      const c = await getCommit(qid, row.commit)
-      const gone = await store.patch(qid, row.line, Number(row.payload.reverts))
-      const orig = gone && gone.square ? await store.getSquare(gone.square) : null
-      const oc = gone ? await getCommit(qid, gone.commit).catch(() => null) : null
-      const to = [orig && !orig.import ? orig.holder : null, oc && oc.on_behalf_of].filter(Boolean)
-      if (to.length) {
-        out.push({
-          kind: 'patch.reverted', at: row.at, cause_seq: row.seq, square: orig.id, line: row.line, patch_no: Number(row.payload.reverts), by: by(c), paths: c.changes.map((ch) => ch.path).slice(0, MAX_DIFF_PATHS),
-          payload: { patch_no: Number(row.payload.reverts), revert_patch_no: row.patch_no, commit: c.id, message: c.message },
-          recipients: [...new Set(to)]
-        })
-      }
-    }
-    if (row.kind === 'merge') {
-      // patch.merged: to the holder and writers of every other open square on the line that changed a path the patch changed.
-      const c = await getCommit(qid, row.commit)
-      const touched = new Set(c.changes.map((ch) => ch.path))
-      for (const s of await store.squares(qid, { state: 'open' })) {
-        if (s.id === row.square || s.line !== row.line) continue
-        const overlap = (await changedPaths(qid, s)).filter((p) => touched.has(p))
-        if (!overlap.length) continue
-        const st = await sq.statusOf(qid, s)
-        const wc = (st.would_conflict || []).map((w) => w.path)
-        out.push({
-          kind: 'patch.merged', at: row.at, cause_seq: row.seq, square: s.id, line: row.line, patch_no: row.patch_no, by: by(c), paths: overlap,
-          ...(c.task_id ? { task: { id: c.task_id } } : {}),
-          payload: { patch_no: row.patch_no, commit: c.id, message: c.message, author: c.author.member_id, ...(c.task_id ? { task: c.task_id } : {}), stat: c.changes.slice(0, MAX_DIFF_PATHS).map((ch) => ({ path: ch.path, op: ch.op })), would_conflict: wc.length > 0, would_conflict_paths: wc },
-          recipients: [s.holder, ...(s.writers || [])]
-        })
-      }
-    } else if (row.kind === 'commit') {
-      // conflict.added: a term at a path that did not hold that term before this commit.
-      const c = await getCommit(qid, row.commit)
-      const terms = c.changes.filter((ch) => ch.op === 'conflict')
-      if (!terms.length) return out
-      const prev = c.predecessor || c.parents[0]
-      const before = new Map(prev ? (await conflictsAt(qid, prev)).map((e) => [e.path, e.term]) : [])
-      const s = await store.getSquare(row.square)
-      const cause = row.payload?.rebased_onto ? { commit: row.payload.rebased_onto, ...((await getCommit(qid, row.payload.rebased_onto).catch(() => null))?.patch || {}) } : row.payload?.merged_from ? { commit: row.payload.merged_from } : row.payload?.folded_from ? { square: row.payload.folded_from } : null
-      for (const ch of terms) {
-        if (before.get(ch.path) === ch.term) continue
-        const t = await getTerm(qid, ch.term)
-        out.push({
-          kind: 'conflict.added', at: row.at, cause_seq: row.seq, square: row.square, line: s && s.line, by: by(c), paths: [ch.path],
-          payload: { path: ch.path, kind: t.kind, term: ch.term, commit: c.id, sides: t.adds.map((a) => ({ by: a.by || null, commit: a.from_commit || null, ...(a.from_square ? { square: squareShort(a.from_square) } : {}) })), ...(cause ? { caused_by: cause } : {}), resolver: s ? s.holder : null },
-          recipients: s ? [s.holder] : []
-        })
-      }
-    } else if (row.kind === 'square' && row.payload?.op === 'handoff') {
-      out.push({
-        kind: 'square.handoff', at: row.at, cause_seq: row.seq, square: row.square, by: { member_id: row.actor },
-        payload: { from: row.payload.from, to: row.payload.to, ...(row.payload.context ? { note: row.payload.context } : {}) },
-        recipients: [row.payload.from, row.payload.to]
-      })
-    }
-    return out
-  }
-
-  /** Runs the events job for a quilt until it has read the whole log; returns the new events. */
-  function pump (qid) {
-    const prev = running.get(qid) || Promise.resolve()
-    const job = prev.catch(() => {}).then(async () => {
-      const made = []
-      for (;;) {
-        const cursor = await store.eventCursor(qid)
-        const rows = await store.logRows(qid, { after: cursor, limit: 200 })
-        if (!rows.length) return made
-        const events = []
-        for (const r of rows) events.push(...await derive(qid, r))
-        try {
-          made.push(...await store.addEvents({ quilt_id: qid, events, expect_cursor: cursor, cursor: rows.at(-1).seq }))
-        } catch (err) { if (err.code !== 'cursor_moved') throw err }
-      }
-    })
-    running.set(qid, job)
-    job.finally(() => { if (running.get(qid) === job) running.delete(qid) }).catch(() => {})
-    // Deliveries run beside the job (a dead webhook's retries never hold up reading events).
-    return job.then((made) => { const d = deliver(qid, made); inflight.add(d); d.finally(() => inflight.delete(d)); return made })
-  }
-  const inflight = new Set()
-  /** Waits for every webhook POST in flight (tests, and a clean shutdown). */
-  const eventsSettled = async () => { while (inflight.size) await Promise.all([...inflight]) }
-
-  /** The event as a member sees it (12's shape; recipients are not shown). */
-  const view = (e) => {
-    const { recipients, quilt_id: q, ...rest } = e
-    void recipients
-    return { ...rest, quilt: q, ...(e.square ? { square_short: squareShort(e.square) } : {}) }
-  }
-
-  /** POSTs new events to every recipient that subscribed (one chain per member, in order). */
-  async function deliver (qid, events) {
-    const waits = []
-    for (const e of events) {
-      for (const m of new Set(e.recipients || [])) {
-        const sub = await store.webhook(qid, m)
-        if (!sub || !sub.events.includes(e.kind)) continue
-        const key = `${qid}\u0000${m}`
-        const payload = { event: e.kind, id: `${qid}:${e.event_seq}`, to: m, ts: e.at || now(), ...view(e) }
-        const next = (sending.get(key) || Promise.resolve()).then(() => deliverWebhook(sub, payload, { delays, log, ...(fetch ? { fetch } : {}) })).catch(() => {})
-        sending.set(key, next)
-        waits.push(next)
-      }
-    }
-    await Promise.all(waits)
-  }
-
-  /** GET /events: the caller's events after `after` (the job runs first, so none is missing). */
-  async function events (me, ref, { after = 0, kinds, limit = 100 } = {}) {
-    const q = await quiltFor(me, ref)
-    await pump(q.id)
-    const list = await store.eventsFor(q.id, me.member_id, { after: Number(after) || 0, kinds: kinds && kinds.length ? kinds : undefined, limit: Math.min(Number(limit) || 100, 1000) })
-    return { events: list.map(view), after: list.length ? list.at(-1).event_seq : Number(after) || 0 }
-  }
-
-  /** POST /webhook: { url, secret?, events?, bearer? } subscribes the caller; { url: null } removes it. */
-  async function subscribe (me, ref, body = {}) {
-    const q = await quiltFor(me, ref)
-    if (body.url === null || body.off) { await store.setWebhook({ quilt_id: q.id, member_id: me.member_id, sub: null }); return { ok: true, removed: true } }
-    const kinds = body.events == null ? QUILT_EVENT_KINDS.slice() : body.events
-    if (!Array.isArray(kinds) || !kinds.length || kinds.some((k) => !QUILT_EVENT_KINDS.includes(k))) throw new QuiltError(400, 'bad_request', `events: give some of ${QUILT_EVENT_KINDS.join(', ')}`)
-    let sub
-    try { sub = makeSubscription({ url: body.url, secret: body.secret, bearer: body.bearer }, { allowLocal: allowLocalWebhooks }) } catch (err) { throw new QuiltError(400, 'bad_request', err.message) }
-    const row = { url: sub.url, secret: sub.secret, events: [...new Set(kinds)], since: sub.since, ...(sub.bearer ? { bearer: sub.bearer } : {}) }
-    // Events already in the table are not news to a new subscription: the job runs first.
-    await pump(q.id)
-    await store.setWebhook({ quilt_id: q.id, member_id: me.member_id, sub: row })
-    return { ok: true, url: row.url, events: row.events, ...(sub.made ? { secret: row.secret } : {}) }
-  }
-
-  return { events, subscribe, pumpEvents: pump, eventsSettled }
-}

package/src/quilts/export-git.js

@@ -1,130 +0,0 @@
-// The local driver of the one-way git export (plans/quilt-source-control/14, Export): reads a
-// line's patches from the server (GET /quilts/:q/export/git) and writes each as one commit on a
-// branch of a plain git repository with `git fast-import`, so CI and deploys that expect git
-// keep working. The commit fields come from the server whole, so the same patch always gives
-// the same commit id, on any machine, in any number of runs. A run picks up after the last
-// patch it exported (state in the repository's `quilt-export.json`), and refuses a branch that
-// moved under it: the export is one way, never a merge.
-import { spawn, execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-
-const MODES = { file: '100644', exec: '100755', symlink: '120000', gitlink: '160000' }
-const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_CONFIG_NOSYSTEM: '1' }
-
-const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { env: GIT_ENV, maxBuffer: 256 * 1024 * 1024 }).toString().trim()
-const tryGit = (dir, args) => { try { return git(dir, args) } catch { return null } }
-
-/** A path as fast-import reads it: C-quoted when it would otherwise be misread. */
-const fiPath = (p) => (/^"|[\n"\\]/.test(p) ? '"' + p.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"' : p)
-const ident = (who) => `${who.name} <${who.email}> ${who.at} +0000`
-
-/** The repository at `dir`, made bare when it does not exist yet: its git dir. */
-function openRepo (dir) {
-  if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); git(dir, ['init', '-q', '--bare']) }
-  const gd = tryGit(dir, ['rev-parse', '--absolute-git-dir'])
-  if (!gd) throw new Error(`${dir} is not a git repository`)
-  return gd
-}
-
-/** fast-import as a writable stream with backpressure; done() → its exit. */
-function fastImport (dir, marks) {
-  const p = spawn('git', ['-C', dir, 'fast-import', '--quiet', '--date-format=raw', `--export-marks=${marks}`], { env: GIT_ENV, stdio: ['pipe', 'ignore', 'pipe'] })
-  let err = ''
-  p.stderr.on('data', (d) => { err += d })
-  const exit = new Promise((resolve, reject) => p.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`git fast-import failed: ${err.trim()}`)))))
-  exit.catch(() => {})
-  return {
-    write (chunk) { return p.stdin.write(chunk) ? null : new Promise((resolve) => p.stdin.once('drain', resolve)) },
-    async done () { p.stdin.end(); await exit }
-  }
-}
-
-/** Every blob in `ids`, as Buffers, in as many requests as the server's size cap needs. */
-async function fetchBlobs (client, q, ids) {
-  const out = new Map()
-  let todo = [...new Set(ids)]
-  while (todo.length) {
-    const r = await client.blobs(q, todo.slice(0, 2000))
-    const got = Object.entries(r.blobs || {})
-    if (!got.length) throw new Error(`the server returned none of ${todo.length} blobs`)
-    for (const [id, b64] of got) out.set(id, Buffer.from(b64, 'base64'))
-    todo = todo.filter((id) => !out.has(id))
-  }
-  return out
-}
-
-/**
- * Exports `line` of quilt `q` to `branch` of the repository at `dir` (created bare when
- * missing). Returns { exported, patch_no, sha, branch }.
- */
-export async function exportGit (client, { q, dir, line = 'main', branch, page = 200, log = () => {} }) {
-  branch = branch || line
-  const gitDir = openRepo(dir)
-  const stateFile = path.join(gitDir, 'quilt-export.json')
-  const shaFile = path.join(gitDir, 'quilt-export-shas')
-  const all = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : {}
-  const key = `${line}→${branch}`
-  const state = all[key] || null
-  const tip = tryGit(dir, ['rev-parse', '--verify', '-q', `refs/heads/${branch}`])
-  if (state && state.quilt !== undefined && state.quilt !== null) {
-    const info = await client.quilt(q)
-    if (info.id !== state.quilt) throw new Error(`${dir} holds the export of another quilt (${state.quilt})`)
-  }
-  if (state ? tip !== state.sha : tip) throw new Error(`branch ${branch} in ${dir} moved since the last export (${tip || 'gone'}, expected ${state ? state.sha : 'no branch'}): the export never merges or forces; point it at a new branch or repository`)
-
-  let after = state ? state.patch_no : -1
-  let sha = state ? state.sha : null
-  let exported = 0
-  let version = state ? state.version : null
-  let quiltId = state ? state.quilt : null
-  for (;;) {
-    const r = await client.exportPatches(q, { line, after, limit: page })
-    if (version !== null && version !== r.version) throw new Error(`export format ${r.version} differs from the ${version} this branch was exported with: export to a new branch`)
-    version = r.version; quiltId = r.quilt
-    if (!r.patches.length) break
-    const blobs = await fetchBlobs(client, q, r.patches.flatMap((p) => p.changes.filter((c) => c.op === 'put').map((c) => c.blob)))
-    const marksFile = path.join(gitDir, 'quilt-export.marks')
-    const fi = fastImport(dir, marksFile)
-    const send = async (s) => { const w = fi.write(s); if (w) await w }
-    let mark = 0
-    const blobMark = new Map()
-    for (const [id, bytes] of blobs) {
-      // A gitlink's content is the submodule commit it pins; git writes no blob for it.
-      if (r.patches.some((p) => p.changes.some((c) => c.blob === id && c.mode === 'gitlink'))) blobMark.set(id, bytes.toString('utf8').trim())
-      if (blobMark.has(id)) continue
-      blobMark.set(id, ++mark)
-      await send(`blob\nmark :${mark}\ndata ${bytes.length}\n`); await send(bytes); await send('\n')
-    }
-    const commitMark = new Map()
-    let first = true
-    for (const p of r.patches) {
-      commitMark.set(p.patch_no, ++mark)
-      const msg = Buffer.from(p.message, 'utf8')
-      let s = `commit refs/heads/${branch}\nmark :${mark}\nauthor ${ident(p.author)}\ncommitter ${ident(p.committer)}\ndata ${msg.length}\n`
-      await send(s); await send(msg); s = '\n'
-      if (first && sha) s += `from ${sha}\n`
-      first = false
-      for (const c of p.changes) {
-        if (c.op === 'delete') s += `D ${fiPath(c.path)}\n`
-        else if (c.mode === 'gitlink') s += `M 160000 ${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
-        else s += `M ${MODES[c.mode || 'file'] || MODES.file} :${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
-      }
-      await send(s + '\n')
-    }
-    await fi.done()
-    const marks = new Map(fs.readFileSync(marksFile, 'utf8').split('\n').filter(Boolean).map((l) => { const [m, h] = l.split(' '); return [Number(m.slice(1)), h] }))
-    fs.rmSync(marksFile, { force: true })
-    const lines = r.patches.map((p) => `${line} ${p.patch_no} ${marks.get(commitMark.get(p.patch_no))}`)
-    fs.appendFileSync(shaFile, lines.join('\n') + '\n')
-    const last = r.patches[r.patches.length - 1]
-    after = last.patch_no
-    sha = marks.get(commitMark.get(last.patch_no))
-    exported += r.patches.length
-    all[key] = { quilt: quiltId, line, branch, patch_no: after, sha, version }
-    fs.writeFileSync(stateFile, JSON.stringify(all, null, 2) + '\n')
-    log(`  ${line}/${after} → ${sha.slice(0, 12)} (${exported} exported)`)
-  }
-  if (sha && !tryGit(dir, ['symbolic-ref', '-q', 'HEAD'])?.endsWith(`/${branch}`) && !tryGit(dir, ['rev-parse', '--verify', '-q', 'HEAD'])) git(dir, ['symbolic-ref', 'HEAD', `refs/heads/${branch}`])
-  return { exported, patch_no: after, sha, branch }
-}

package/src/quilts/export.js

@@ -1,81 +0,0 @@
-// The server half of the one-way git export (plans/quilt-source-control/14, Export): the
-// patches of a line in order, each with everything the exported git commit is made from, so a
-// driver (export-git.js) can write the same git objects from them on any machine. The git
-// fields are worked out here, from the commit record and the merge row only, so the same patch
-// always gives the same commit id: nothing from the clock, the driver or a member's current
-// profile gets in (14, Determinism).
-import { QuiltError } from './service.js'
-
-const EXPORT_VERSION = 1
-const COMMITTER = { name: 'Quilt', email: 'export@heyquilt.com' }
-
-/** A member slug safe for an email local part. */
-const slugOf = (id) => String(id || 'unknown').replace(/^[a-z]+:/, '').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'unknown'
-
-/**
- * The git identity of a commit's author, frozen in the commit record. A stub member from a git
- * import keeps the email git had (it was public there); everyone else gets the noreply address
- * of 14 (`<slug>@people|agents.noreply.heyquilt.com`), since no member has opted in to a
- * public email yet.
- */
-export function exportAuthor (author = {}) {
-  const id = String(author.member_id || '')
-  const kind = author.kind === 'agent' ? 'agent' : 'person'
-  const stub = id.startsWith('stub:') ? id.slice(5) : ''
-  const email = stub.includes('@') ? stub : `${slugOf(id)}@${kind === 'agent' ? 'agents' : 'people'}.noreply.heyquilt.com`
-  const name = String(author.name || stub || slugOf(id)).replace(/[<>\n]/g, '').trim() || slugOf(id)
-  return { name, email, slug: slugOf(id), kind, ...(author.tool ? { tool: author.tool } : {}), ...(author.model ? { model: author.model } : {}) }
-}
-
-/** The commit message with 14's trailers, in their fixed order. */
-export function exportMessage ({ commit, line, patch_no: patchNo, git_sha: gitSha }) {
-  const a = exportAuthor(commit.author)
-  const trailers = [
-    `Quilt-Commit: ${commit.id}`,
-    `Quilt-Square: ${commit.square_id}`,
-    `Quilt-Patch: ${line}/${patchNo}`,
-    `Quilt-Author: ${a.slug} (${[a.kind, a.tool, a.model].filter(Boolean).join(', ')})`,
-    ...(commit.on_behalf_of ? [`Quilt-On-Behalf-Of: ${slugOf(commit.on_behalf_of)}`] : []),
-    ...(commit.task_id ? [`Quilt-Task: ${commit.task_id}`] : []),
-    ...Object.keys(commit.stack || {}).sort().map((k) => `Quilt-Stack-${k}: ${commit.stack[k]}`),
-    ...(gitSha ? [`Quilt-Git-Sha: ${gitSha}`] : [])
-  ]
-  const body = String(commit.message || '').replace(/\s+$/, '')
-  return `${body || '(no message)'}\n\n${trailers.join('\n')}\n`
-}
-
-export function exportOps (svc) {
-  const { quiltFor, getCommit, store } = svc.internals
-
-  /**
-   * GET /quilts/:q/export/git: the patches on `line` after `after`, oldest first, at most
-   * `limit`: { version, line, patch_count, patches: [{ patch_no, commit, parent, author,
-   * committer, message, changes }] }. `changes` are the patch commit's changes against its
-   * first parent (the previous patch), which is what the exported commit changes too.
-   */
-  async function exportPatches (me, ref, { line = 'main', after = -1, limit = 200 } = {}) {
-    const q = await quiltFor(me, ref)
-    const ln = await store.getLine(q.id, line)
-    if (!ln) throw new QuiltError(404, 'not_found', `no line ${line}`)
-    const max = Math.max(1, Math.min(Number(limit) || 200, 1000))
-    const rows = await store.patches(q.id, line, { after: Number(after), limit: max, desc: false })
-    const patches = []
-    for (const row of rows) {
-      const c = await getCommit(q.id, row.commit)
-      const gitSha = store.gitShaOf ? await store.gitShaOf(q.id, c.id) : null
-      const a = exportAuthor(c.author)
-      patches.push({
-        patch_no: row.patch_no,
-        commit: c.id,
-        parent: c.parents[0] || null,
-        author: { name: a.name, email: a.email, at: Math.floor((c.authored_at || 0) / 1000) },
-        committer: { ...COMMITTER, at: Math.floor((row.at || 0) / 1000) },
-        message: exportMessage({ commit: c, line, patch_no: row.patch_no, git_sha: gitSha }),
-        changes: c.changes.map((ch) => (ch.op === 'delete' ? { path: ch.path, op: 'delete' } : { path: ch.path, op: 'put', blob: ch.blob, mode: ch.mode }))
-      })
-    }
-    return { version: EXPORT_VERSION, quilt: q.id, line, patch_count: ln.patch_count, patches }
-  }
-
-  return { exportPatches }
-}

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
-}