heyquilt 0.3.122 → 0.3.140

package/src/quilts/setup.js

@@ -1,41 +0,0 @@
-// Which store and object store Quilt source control runs on, from the environment.
-//   QUILT_SOURCE=1            turns it on (off: the API has no /v1/quilts routes)
-//   QUILT_SOURCE_DATA=<dir>   local: the memory store's journal and the packs on disk (default ./quilt-source-data)
-//   QUILT_SOURCE_STORE=supabase   rows and packs in their own Supabase project ("Quilt Source"), apart
-//                             from the accounts project: QUILT_SOURCE_SUPABASE_URL and
-//                             QUILT_SOURCE_SUPABASE_KEY (its service role key); the rows from the
-//                             *_quilts.sql migration, the packs in its bucket QUILT_SOURCE_BUCKET
-//                             (default quilt-packs)
-//   SEAM_IMPORT_SCRATCH=<dir>   where imports from a git remote keep their mirrors (default the temp folder)
-//   SEAM_SECRET_<NAME>        a credential an import names (`--credential name`): user:token or a token
-import path from 'node:path'
-import os from 'node:os'
-import { createQuilts } from './index.js'
-import { createMemoryQuiltStore } from './store-memory.js'
-import { BlobstoreObjects, diskObjects } from './objects.js'
-
-export async function quiltsFromEnv (env, { memory = false, log = () => {} } = {}) {
-  if (!/^(1|true|yes)$/i.test(env.QUILT_SOURCE || '')) return null
-  if (env.QUILT_SOURCE_STORE === 'supabase') {
-    const { createSupabaseQuiltStore } = await import('./store-supabase.js')
-    const { SupabaseBucket } = await import('./bucket.js')
-    // Never the accounts project: its load and its mistakes stay away from people's accounts.
-    for (const k of ['QUILT_SOURCE_SUPABASE_URL', 'QUILT_SOURCE_SUPABASE_KEY']) if (!env[k]) throw new Error(`QUILT_SOURCE_STORE=supabase needs ${k}`)
-    const url = env.QUILT_SOURCE_SUPABASE_URL
-    const key = env.QUILT_SOURCE_SUPABASE_KEY
-    if (env.SUPABASE_URL && url.replace(/\/+$/, '') === env.SUPABASE_URL.replace(/\/+$/, '')) throw new Error('QUILT_SOURCE_SUPABASE_URL must be its own project, not the accounts project')
-    const store = createSupabaseQuiltStore({ url, serviceKey: key })
-    const objects = new BlobstoreObjects(new SupabaseBucket({ url, key, bucket: env.QUILT_SOURCE_BUCKET || 'quilt-packs' }))
-    log(`quilt source control: rows and packs in ${new URL(url).host}`)
-    const quilts = createQuilts({ store, objects, events: { log }, siteUrl: env.SEAM_SITE_URL || undefined, importFollow: { scratch: env.SEAM_IMPORT_SCRATCH || path.join(os.tmpdir(), 'seam-imports') } })
-    quilts.follower.start()
-    return quilts
-  }
-  const dir = path.resolve(env.QUILT_SOURCE_DATA || './quilt-source-data')
-  const store = createMemoryQuiltStore({ file: path.join(dir, 'journal.jsonl') })
-  log(`quilt source control: local store in ${dir}${memory ? '' : ' (QUILT_SOURCE_DATA)'}`)
-  // The local prototype may POST events to webhooks on this machine; the hosted one may not.
-  const quilts = createQuilts({ store, objects: diskObjects(path.join(dir, 'packs')), events: { allowLocalWebhooks: true, log }, siteUrl: env.SEAM_SITE_URL || undefined, importFollow: { scratch: env.SEAM_IMPORT_SCRATCH || path.join(dir, 'imports'), allowLocal: true } })
-  quilts.follower.start()
-  return quilts
-}

package/src/quilts/signing.js

@@ -1,149 +0,0 @@
-// Signed commits: a person or an agent adds an Ed25519 public key to their account, signs a commit
-// with the private key (which never leaves their computer), and anyone reading the log can check
-// the signature (seam log --show-signature). A commit's id is the hash of its whole record (tree,
-// parents, author, message, quilt), so signing the id signs all of it.
-//
-// What is signed is the text `seam-commit <id>\n`. Only the commit's author, or the person it was
-// made for (on_behalf_of), may sign it, with one of their own keys. A key is removed, never
-// deleted: signatures made with it then read as "removed_key", so a stolen key stops vouching.
-import crypto from 'node:crypto'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { QuiltError } from './errors.js'
-
-export const MAX_KEYS = 20
-const SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex') // Ed25519 SubjectPublicKeyInfo header
-
-/** The bytes a signature covers. */
-export const signedText = (commitId) => `seam-commit ${commitId}\n`
-
-/** A public key (SPKI PEM, or base64 of the 32 raw bytes) as base64 of its raw bytes, or null. */
-export function rawPublicKey (input) {
-  const s = String(input || '').trim()
-  if (!s) return null
-  try {
-    if (s.includes('BEGIN')) {
-      const k = crypto.createPublicKey(s)
-      if (k.asymmetricKeyType !== 'ed25519') return null
-      return k.export({ format: 'der', type: 'spki' }).subarray(SPKI_PREFIX.length).toString('base64')
-    }
-    const b = Buffer.from(s, 'base64')
-    return b.length === 32 ? b.toString('base64') : null
-  } catch { return null }
-}
-
-const keyObject = (raw) => crypto.createPublicKey({ key: Buffer.concat([SPKI_PREFIX, Buffer.from(raw, 'base64')]), format: 'der', type: 'spki' })
-
-/** A key's id: `ed25519:` and the first 16 hex of the sha256 of its raw bytes. */
-export const keyId = (raw) => 'ed25519:' + crypto.createHash('sha256').update(Buffer.from(raw, 'base64')).digest('hex').slice(0, 16)
-
-export function verifySignature (raw, commitId, signature) {
-  try { return crypto.verify(null, Buffer.from(signedText(commitId)), keyObject(raw), Buffer.from(String(signature), 'base64')) } catch { return false }
-}
-
-// ---- the client side: the private key on this computer ----
-
-/** Where this computer's signing key lives: SEAM_SIGNING_KEY, else ~/.seam/signing-key.pem. */
-export const signingKeyFile = () => process.env.SEAM_SIGNING_KEY || path.join(process.env.SEAM_HOME || path.join(os.homedir(), '.seam'), 'signing-key.pem')
-
-/** Makes a new key pair on this computer (refused when one is there). Returns the public half. */
-export function makeLocalKey (file = signingKeyFile()) {
-  if (fs.existsSync(file)) throw new Error(`There is already a signing key at ${file}.`)
-  const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519')
-  fs.mkdirSync(path.dirname(file), { recursive: true })
-  fs.writeFileSync(file, privateKey.export({ format: 'pem', type: 'pkcs8' }), { mode: 0o600 })
-  return publicKey.export({ format: 'pem', type: 'spki' })
-}
-
-/** This computer's key: { sign(commitId), public_key, key } or null when there is none. */
-export function localKey (file = signingKeyFile()) {
-  if (!fs.existsSync(file)) return null
-  const priv = crypto.createPrivateKey(fs.readFileSync(file))
-  const pub = crypto.createPublicKey(priv).export({ format: 'pem', type: 'spki' })
-  const raw = rawPublicKey(pub)
-  return { public_key: pub, key: keyId(raw), sign: (commitId) => crypto.sign(null, Buffer.from(signedText(commitId)), priv).toString('base64') }
-}
-
-/** Signs a commit with this computer's key and sends the signature. */
-export async function signWithLocalKey (client, quilt, rev) {
-  const k = localKey()
-  if (!k) throw new Error('No signing key on this computer: run seam key add first.')
-  const id = (await client.describe(quilt, rev || 'main')).commit
-  if (!id) throw new Error(`No commit at ${rev || 'main'}.`)
-  return client.sign(quilt, id, { key: k.key, signature: k.sign(id) })
-}
-
-// ---- the server side ----
-
-export function signingOps (svc) {
-  const { store, now, quiltFor, resolve, getCommit, fromStore } = svc.internals
-
-  const keyView = (r) => ({ key: r.id, name: r.name || '', public_key: r.public_key, added_at: r.added_at, ...(r.removed_at ? { removed_at: r.removed_at } : {}) })
-
-  /** POST /signing-keys { public_key, name? }: adds one of your keys. */
-  async function addKey (me, _ref, { public_key: pk, name = '' } = {}) {
-    const raw = rawPublicKey(pk)
-    if (!raw) throw new QuiltError(400, 'bad_request', 'public_key: an Ed25519 public key (PEM, or base64 of its 32 bytes)')
-    if (String(name).length > 100) throw new QuiltError(400, 'bad_request', 'a key name is up to 100 characters')
-    const mine = await store.signingKeys(me.member_id)
-    if (mine.filter((k) => !k.removed_at).length >= MAX_KEYS) throw new QuiltError(409, 'too_many_keys', `up to ${MAX_KEYS} keys each`)
-    try {
-      return keyView(await store.addSigningKey({ id: keyId(raw), member: me.member_id, public_key: raw, name: String(name), added_at: now() }))
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /** GET /signing-keys: your keys (or a member's, with ?member=). */
-  async function keys (me, _ref, { member } = {}) {
-    return { member: member || me.member_id, keys: (await store.signingKeys(member || me.member_id)).map(keyView) }
-  }
-
-  /** DELETE /signing-keys/:key: removes one of your keys; its signatures stop counting. */
-  async function removeKey (me, _ref, key) {
-    const row = await store.signingKey(String(key))
-    if (!row || row.member !== me.member_id) throw new QuiltError(404, 'not_found', `you have no key ${key}`)
-    if (row.removed_at) return keyView(row)
-    try { return keyView(await store.removeSigningKey({ id: row.id, member: me.member_id, at: now() })) } catch (err) { throw fromStore(err) }
-  }
-
-  /** POST /commits/:rev/signatures { key, signature }: signs a commit you made (or that was made for you). */
-  async function sign (me, ref, rev, { key, signature } = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const id = await resolve(q.id, String(rev || ''))
-    if (!id) throw new QuiltError(404, 'not_found', `no commit at ${rev}`)
-    const c = await getCommit(q.id, id)
-    const by = c.author?.member_id
-    if (me.member_id !== by && me.member_id !== c.on_behalf_of) throw new QuiltError(403, 'not_author', 'only the commit\'s author, or whom it was made for, signs it')
-    const row = key ? await store.signingKey(String(key)) : null
-    if (!row || row.member !== me.member_id || row.removed_at) throw new QuiltError(400, 'bad_key', `${key || 'key'} is not one of your keys (seam key add)`)
-    if (!verifySignature(row.public_key, id, signature)) throw new QuiltError(422, 'bad_signature', `the signature does not match ${id.slice(0, 12)} and ${row.id}`)
-    try {
-      await store.addSignature({ quilt_id: q.id, commit: id, key: row.id, signer: me.member_id, signature: String(signature), at: now() })
-    } catch (err) { throw fromStore(err) }
-    return { commit: id, short: id.slice(0, 12), signature: { status: 'good', key: row.id, signer: me.member_id } }
-  }
-
-  /** Each commit's signature, checked now: good, bad, removed_key, or none. */
-  async function signaturesFor (q, commits) {
-    const rows = await store.signaturesOf(q, commits.map((c) => c.id))
-    const keyRows = new Map()
-    const out = new Map()
-    for (const r of rows) {
-      if (!keyRows.has(r.key)) keyRows.set(r.key, await store.signingKey(r.key))
-      const k = keyRows.get(r.key)
-      const status = !k || !verifySignature(k.public_key, r.commit, r.signature) ? 'bad' : k.removed_at ? 'removed_key' : 'good'
-      const prev = out.get(r.commit)
-      if (!prev || (status === 'good' && prev.status !== 'good')) out.set(r.commit, { status, key: r.key, signer: r.signer, at: r.at })
-    }
-    return out
-  }
-
-  /** Adds `signature` to each commit of a log answer. */
-  async function withSignatures (me, ref, answer) {
-    const q = await quiltFor(me, ref, 'read')
-    const sigs = await signaturesFor(q.id, answer.commits || [])
-    return { ...answer, commits: (answer.commits || []).map((c) => ({ ...c, signature: sigs.get(c.id) || { status: 'none' } })) }
-  }
-
-  return { addKey, signingKeys: keys, removeKey, sign, withSignatures }
-}

package/src/quilts/squares.js

@@ -1,239 +0,0 @@
-// The rest of a square's lifecycle (plans/quilt-source-control/06): handoff, abandon, reopen,
-// fold, split, merging one square into another (07), and status's merged_under_you and
-// would_conflict (06). Each state move is one square log row and a compare-and-swap on the
-// square row (store.setSquare expect).
-import { QuiltError, uuidv7, squareShort } from './service.js'
-import { under, cleanPrefix } from './records.js'
-
-const MAX_HANDOFF_TEXT = 2000
-
-export function squareOps (svc, m = {}) {
-  const { store, now, quiltFor, squareByRef, squareView, fromStore, resolve, getCommit, snapshot, reader, seal, writable, once, commitView, pathPatches } = svc.internals
-  const move = async (args) => { try { return await store.setSquare(args) } catch (e) { throw fromStore(e) } }
-
-  /** handoff: { to, expect_head?, note? } — the holder (or an admin) gives the square to another member. */
-  async function handoff (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await squareByRef(q.id, sqRef)
-    if (sq.holder !== me.member_id && q.level !== 'admin') throw new QuiltError(403, 'not_holder', `this square is held by ${sq.holder}`, { holder: sq.holder })
-    if (sq.state !== 'open') throw new QuiltError(409, 'square_state', `the square is ${sq.state}`)
-    const to = String(body.to || '')
-    if (!to) throw new QuiltError(400, 'bad_request', 'give `to`: the member to hand the square to')
-    const level = await store.memberLevel(q.id, to)
-    if (level !== 'write' && level !== 'admin') throw new QuiltError(403, 'forbidden', `${to} cannot write to this quilt`)
-    const note = String(body.note || body.context || '')
-    if (note.length > MAX_HANDOFF_TEXT) throw new QuiltError(400, 'bad_request', `the note is at most ${MAX_HANDOFF_TEXT} characters`)
-    const expect = { holder: sq.holder, state: 'open', ...(body.expect_head !== undefined ? { head: body.expect_head } : {}) }
-    const row = await move({ square_id: sq.id, op: 'handoff', expect, actor: me.member_id, at: now(), patch: { holder: to, writers: (sq.writers || []).filter((w) => w !== to) }, log: { from: sq.holder, to, ...(note ? { context: note } : {}) } })
-    return squareView(row)
-  }
-
-  /** abandon: { expect_head? } — the work is not wanted; the id stays, and it can be reopened. */
-  async function abandon (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await squareByRef(q.id, sqRef)
-    if (sq.holder !== me.member_id && q.level !== 'admin') throw new QuiltError(403, 'not_holder', `this square is held by ${sq.holder}`, { holder: sq.holder })
-    if (sq.state !== 'open') throw new QuiltError(409, 'square_state', `the square is ${sq.state}`)
-    const expect = { state: 'open', ...(body.expect_head !== undefined ? { head: body.expect_head } : {}) }
-    return squareView(await move({ square_id: sq.id, op: 'abandon', expect, actor: me.member_id, at: now(), patch: { state: 'abandoned' }, log: { snapshot_commit: sq.head || null } }))
-  }
-
-  /** reopen: abandoned → open; the reopener becomes the holder. */
-  async function reopen (me, ref, sqRef) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await squareByRef(q.id, sqRef)
-    if (sq.state !== 'abandoned') throw new QuiltError(409, 'square_state', `only an abandoned square reopens; this one is ${sq.state}`)
-    return squareView(await move({ square_id: sq.id, op: 'reopen', expect: { state: 'abandoned' }, actor: me.member_id, at: now(), patch: { state: 'open', holder: me.member_id, writers: (sq.writers || []).filter((w) => w !== me.member_id) } }))
-  }
-
-  const authorOf = (me) => ({ member_id: me.member_id, kind: me.kind, name: me.name, ...(me.tool ? { tool: me.tool } : {}) })
-  const toChange = (p, e) => !e ? { path: p, op: 'delete' } : e.mode === 'conflict' ? { path: p, op: 'conflict', term: e.term } : { path: p, op: 'put', blob: e.blob, mode: e.mode, size: e.size }
-
-  /** Seals a made commit and writes it on its square (compare-and-swap on the head). */
-  async function writeMade (q, made, expectHead, me, objects, payload, squarePatch) {
-    await seal(q, [...objects, made.object], { by: me.member_id })
-    await store.stageFiles({ quilt_id: q, commit_id: made.id, files: made.record.changes })
-    try {
-      return await store.commit({ commit: { ...made.record, id: made.id, at: now() }, expect_head: expectHead || null, actor: me.member_id, at: now(), payload, ...(squarePatch ? { square_patch: squarePatch } : {}) })
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /**
-   * The merge base of two commits (07, 08): the common ancestor with the highest seq. Walks both
-   * histories newest first (a parent's seq is always below its child's), so it reads only the
-   * commits since the two sides parted. Returns { base, bases } (bases: candidates seen).
-   */
-  async function mergeBase (q, a, b) {
-    if (!a || !b) return { base: null, bases: 0 }
-    const flags = new Map(); const info = new Map(); const done = new Set(); const queue = []
-    const mark = async (id, f) => {
-      const cur = flags.get(id) || 0
-      if ((cur | f) === cur) return
-      flags.set(id, cur | f)
-      if (!info.has(id)) { const c = await getCommit(q, id); info.set(id, { seq: c.seq, parents: c.parents }) }
-      if (!done.has(id) && !queue.includes(id)) queue.push(id)
-    }
-    await mark(a, 1); await mark(b, 2)
-    while (queue.length) {
-      let at = 0
-      for (let i = 1; i < queue.length; i++) if (info.get(queue[i]).seq > info.get(queue[at]).seq) at = i
-      const id = queue.splice(at, 1)[0]
-      done.add(id)
-      const f = flags.get(id)
-      if (f === 3) return { base: id, bases: 1 + queue.filter((x) => flags.get(x) === 3).length }
-      for (const p of info.get(id).parents) await mark(p, f)
-    }
-    return { base: null, bases: 0 }
-  }
-
-  /**
-   * merge into a square (07): { from: sq:… | revision, expect_head?, message? } writes a commit
-   * in the square with parents [head, from] after a three-way merge against their merge base.
-   * Conflicts are kept as terms in the result; `from` stays open (fold closes it).
-   */
-  async function mergeSquare (me, ref, intoRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const into = await writable(me, q, intoRef)
-    const expect = body.expect_head === undefined ? into.head : body.expect_head
-    if (!body.from) throw new QuiltError(400, 'bad_request', 'give `from`: the square (sq:…) or revision to merge in')
-    const fromSq = /^sq:/.test(String(body.from)) || /^[0-9a-f-]{36}$/.test(String(body.from)) ? await squareByRef(q.id, body.from).catch(() => null) : null
-    const theirs = fromSq ? (fromSq.head || fromSq.base) : await resolve(q.id, body.from)
-    if (!theirs) throw new QuiltError(404, 'not_found', `${body.from} names no commit`)
-    if (fromSq && fromSq.id === into.id) throw new QuiltError(400, 'bad_request', 'a square cannot merge itself')
-    return once('merge-square', into.id, expect, { from: theirs, message: body.message || null }, async () => {
-      if (into.state !== 'open') throw new QuiltError(409, into.state === 'merging' ? 'square_merging' : 'square_closed', `the square is ${into.state}`)
-      if ((into.head || null) !== (expect || null)) throw new QuiltError(409, 'head_moved', 'the square moved on since you looked', { head: into.head })
-      const ours = into.head || into.base
-      const { base, bases } = await mergeBase(q.id, ours, theirs)
-      if (base === theirs) return { ok: true, noop: true, detail: 'already merged: that work is in this square', square: await squareView(into) }
-      const sides = { ours: { commit: ours, square: into.id, by: me.member_id }, theirs: { commit: theirs, ...(fromSq ? { square: fromSq.id, by: fromSq.holder } : { by: (await getCommit(q.id, theirs)).author.member_id }) }, base: { commit: base } }
-      const comb = await m.combine(q.id, base, ours, theirs, sides, { reason: 'merge', against: theirs })
-      const onto = await m.entryMap(q.id, ours, comb.finals.keys())
-      const changes = m.changesOnto(onto, comb.finals)
-      const label = fromSq ? `square ${squareShort(fromSq.id)} "${fromSq.title}"` : `${String(body.from)}`
-      const made = m.makeCommit(q.id, into, { parents: [ours, theirs].filter(Boolean), author: authorOf(me), onBehalfOf: me.on_behalf_of, message: body.message || `Merge ${label} into ${squareShort(into.id)}`, changes })
-      const row = await writeMade(q.id, made, into.head, me, [...comb.blobs, ...comb.terms], { merged_from: theirs, ...(fromSq ? { from_square: fromSq.id } : {}), base, bases })
-      return { ok: true, seq: row.seq, result: commitView({ ...row, changes }), base, bases, combined: comb.combined, conflicted: comb.conflicts.length, terms: comb.conflicts, square: await squareView(await store.getSquare(into.id)) }
-    })
-  }
-
-  /**
-   * fold (06): { into, expect_head? } ends this square and keeps its work: one commit on `into`
-   * whose change is this square's head against its base (predecessor = the head; overlaps become
-   * conflict terms, D10), then this square is `folded` with `folded_into`.
-   */
-  async function fold (me, ref, fromRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const from = await squareByRef(q.id, fromRef)
-    if (!body.into) throw new QuiltError(400, 'bad_request', 'give `into`: the square to fold this one into')
-    const into = await squareByRef(q.id, body.into)
-    if (from.id === into.id) throw new QuiltError(400, 'bad_request', 'a square cannot fold into itself')
-    if (q.level !== 'admin' && (from.holder !== me.member_id || into.holder !== me.member_id)) throw new QuiltError(403, 'not_holder', 'fold needs you to hold both squares (hand the other one to yourself first)', { holders: [from.holder, into.holder] })
-    for (const s of [from, into]) if (s.state !== 'open') throw new QuiltError(409, 'square_state', `${squareShort(s.id)} is ${s.state}; open a new square from the patch instead`)
-    const expect = body.expect_head === undefined ? from.head : body.expect_head
-    if ((from.head || null) !== (expect || null)) throw new QuiltError(409, 'head_moved', 'the square moved on since you looked', { head: from.head })
-    return once('fold', from.id, expect, { into: into.id }, async () => {
-      let commit = null; let terms = []
-      if (from.head) {
-        const ours = into.head || into.base
-        const sides = { ours: { commit: ours, square: into.id, by: into.holder }, theirs: { commit: from.head, square: from.id, by: from.holder }, base: { commit: from.base } }
-        const comb = await m.combine(q.id, from.base, ours, from.head, sides, { reason: 'merge', against: from.head })
-        const finals = new Map([...comb.finals].filter(([p]) => comb.theirsPaths.has(p)))
-        const changes = m.changesOnto(await m.entryMap(q.id, ours, finals.keys()), finals)
-        if (changes.length) {
-          const made = m.makeCommit(q.id, into, { parents: [ours].filter(Boolean), predecessor: from.head, author: authorOf(me), onBehalfOf: me.on_behalf_of, message: body.message || `Fold ${squareShort(from.id)}: ${from.title}`, changes })
-          const row = await writeMade(q.id, made, into.head, me, [...comb.blobs, ...comb.terms], { folded_from: from.id, from_head: from.head })
-          commit = commitView({ ...row, changes })
-          terms = comb.conflicts.filter((c) => finals.has(c.path))
-        }
-      }
-      const row = await move({ square_id: from.id, op: 'fold', expect: { state: 'open', head: from.head || null }, actor: me.member_id, at: now(), patch: { state: 'folded', folded_into: into.id }, log: { into: into.id, commit: commit ? commit.id : null } })
-      return { ok: true, folded: await squareView(row), result: commit, conflicted: terms.length, terms, square: await squareView(await store.getSquare(into.id)) }
-    })
-  }
-
-  /**
-   * split (06): { by: 'paths', groups: [[path or dir, ...], ...], titles?, expect_head? }. Each
-   * group of the square's changed paths moves to a new sibling square (same base and line) as one
-   * commit with predecessor = the head; the largest group and the paths no group covers stay,
-   * and the square's head is rewritten to that remainder.
-   */
-  async function split (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    if ((body.by || 'paths') !== 'paths') throw new QuiltError(400, 'bad_request', 'this prototype splits by paths only (claims and tasks are not on the quilt server yet)')
-    if (sq.state !== 'open') throw new QuiltError(409, 'square_state', `the square is ${sq.state}`)
-    const expect = body.expect_head === undefined ? sq.head : body.expect_head
-    if ((sq.head || null) !== (expect || null)) throw new QuiltError(409, 'head_moved', 'the square moved on since you looked', { head: sq.head })
-    if (!sq.head) throw new QuiltError(400, 'bad_request', 'the square has no commits to split')
-    const groups = (body.groups || []).map((g) => (Array.isArray(g) ? g : [g]).map(cleanPrefix))
-    if (groups.length < 1 || groups.some((g) => !g.length)) throw new QuiltError(400, 'bad_request', 'give groups: [[paths], ...], one per new square')
-    return once('split', sq.id, expect, { groups, titles: body.titles || null }, async () => {
-      const d = await reader(q.id).diff(await snapshot(q.id, sq.base), await snapshot(q.id, sq.head))
-      const sets = groups.map(() => [])
-      const rest = []
-      for (const e of d) { const i = groups.findIndex((g) => g.some((p) => under(e.path, p))); (i < 0 ? rest : sets[i]).push(e) }
-      const empty = sets.findIndex((s) => !s.length)
-      if (empty >= 0) throw new QuiltError(400, 'bad_request', `group ${empty + 1} (${groups[empty].join(', ')}) covers no path the square changed`)
-      // The keeper: the paths no group covers, or the largest group when every path is covered.
-      let keep = -1
-      if (!rest.length) { keep = 0; for (let i = 1; i < sets.length; i++) if (sets[i].length > sets[keep].length) keep = i }
-      const kept = keep < 0 ? rest : [...sets[keep], ...rest]
-      const opened = []
-      for (let i = 0; i < sets.length; i++) {
-        if (i === keep) continue
-        const title = String((body.titles && body.titles[i]) || `${sq.title} (${groups[i].join(', ')})`).slice(0, 200)
-        const ns = await store.openSquare({ square: { id: uuidv7(now()), quilt_id: q.id, title, line: sq.line, base: sq.base, holder: sq.holder, opened_by: me.member_id, writers: [], ...(sq.task_id ? { task_id: sq.task_id } : {}) }, at: now() })
-        const changes = sets[i].map((e) => toChange(e.path, e.after || null))
-        const made = m.makeCommit(q.id, ns, { parents: [sq.base].filter(Boolean), predecessor: sq.head, author: authorOf(me), onBehalfOf: me.on_behalf_of, message: `${title}\n\n(split from ${squareShort(sq.id)})`, changes })
-        await writeMade(q.id, made, null, me, [], { split_from: sq.id, reason: 'split' })
-        opened.push(Object.assign(ns, { group: i }))
-      }
-      try {
-        const head = await getCommit(q.id, sq.head)
-        const made = m.makeCommit(q.id, sq, { parents: [sq.base].filter(Boolean), predecessor: sq.head, author: authorOf(me), onBehalfOf: me.on_behalf_of, message: head.message, changes: kept.map((e) => toChange(e.path, e.after || null)) })
-        await writeMade(q.id, made, sq.head, me, [], { split_into: opened.map((s) => s.id) })
-        await move({ square_id: sq.id, op: 'split', actor: me.member_id, at: now(), patch: {}, log: { into: opened.map((s) => s.id), kept_paths: kept.length, blocks_moved: 0 } })
-      } catch (err) {
-        // The square moved under the split: the new squares go away again (abandoned), nothing else changed.
-        for (const s of opened) await move({ square_id: s.id, op: 'abandon', actor: me.member_id, at: now(), patch: { state: 'abandoned' }, log: { reason: 'split_failed' } }).catch(() => {})
-        throw err
-      }
-      return { ok: true, kept: kept.map((e) => e.path), square: await squareView(await store.getSquare(sq.id)), squares: await Promise.all(opened.map(async (s) => ({ ...(await squareView(await store.getSquare(s.id))), paths: sets[s.group].map((e) => e.path) }))) }
-    })
-  }
-
-  /**
-   * One square with 06's derived status: merged_under_you (patches since the base that changed a
-   * path the square changed, newest first, at most 50 plus `more`) and would_conflict (07's merge
-   * as a dry run against the tip: the paths that would carry a term, and the patch each meets).
-   */
-  async function square (me, ref, sqRef) {
-    const q = await quiltFor(me, ref)
-    return statusOf(q.id, await squareByRef(q.id, sqRef))
-  }
-
-  async function statusOf (qid, sq) {
-    const q = { id: qid }
-    const view = await squareView(sq)
-    if (sq.state !== 'open' || !view.behind_by) return { ...view, merged_under_you: [], would_conflict: [] }
-    const ln = await store.getLine(q.id, sq.line)
-    const changed = sq.head ? (await reader(q.id).diff(await snapshot(q.id, sq.base), await snapshot(q.id, sq.head))).map((e) => e.path) : []
-    if (!changed.length) return { ...view, merged_under_you: [], would_conflict: [] }
-    const hit = await pathPatches(q.id, sq.line, changed.slice(0, 2000), ln.patch_count, sq.base, 50)
-    const merged = []
-    for (const id of hit.ids) {
-      const c = await getCommit(q.id, id)
-      const touched = c.changes.filter((ch) => changed.includes(ch.path)).map((ch) => ch.path)
-      merged.push({ patch_no: c.patch?.patch_no, commit: id, author: c.author.member_id, ...(c.task_id ? { task_id: c.task_id } : {}), message: String(c.message || '').split('\n')[0], paths: touched })
-    }
-    const dry = await m.rebaseCommit(q.id, sq, sq.head, ln.tip, {})
-    const wouldConflict = dry.conflicts.map((t) => {
-      const by = merged.find((p) => p.paths.includes(t.path))
-      return { path: t.path, kind: t.kind, ...(by ? { patch_no: by.patch_no, author: by.author } : {}) }
-    })
-    return { ...view, merged_under_you: merged, ...(hit.more ? { merged_under_you_more: true } : {}), would_conflict: wouldConflict }
-  }
-
-  return { handoff, abandon, reopen, mergeSquare, fold, split, square, mergeBase, statusOf }
-}