heyquilt 0.3.121 → 0.3.138

package/src/quilts/store-memory.js

@@ -1,683 +0,0 @@
-// The quilt tables (plans/quilt-source-control/03, "The Postgres schema") in memory, for tests
-// and for running everything on one machine. Every write is one call that either applies whole
-// or throws, as one SQL function call does in the Supabase store (supabase/migrations/
-// *_quilts.sql has the same transactions). With `file`, every write is also appended to a
-// journal (one JSON line per transaction) and replayed at start, so a local server keeps its
-// quilts across restarts.
-import fs from 'node:fs'
-import path from 'node:path'
-
-export class StoreError extends Error {
-  constructor (code, message, extra = {}) { super(message || code); this.code = code; Object.assign(this, extra) }
-}
-
-const k = (...parts) => parts.join('\u0000')
-
-export function createMemoryQuiltStore ({ file = null } = {}) {
-  const t = {
-    quilts: new Map(), // id → quilt
-    slugs: new Map(), // owner + slug → quilt id
-    members: new Map(), // quilt + member → { level }
-    lines: new Map(), // quilt + name → line
-    live: new Map(), // square id → its shared uncommitted work { head, changes, actor, at }
-    reviews: new Map(), // quilt → review rows (13), oldest first
-    signingKeys: new Map(), // key id → { id, member, public_key, name, added_at, removed_at }
-    signatures: new Map(), // quilt + commit → signature rows
-    tokens: new Map(), // token id → { id, quilt_id, name, level, hash, created_by, created_at, revoked_at } (tokens.js)
-    lineRules: new Map(), // quilt → Map of line → { line, approvals, checks }
-    squareChecks: new Map(), // square → Map of check name → its latest report
-    claims: new Map(), // quilt → Map of claim id → claim (06: rows, not log entries)
-    resolutions: new Map(), // quilt → Map of key → remembered resolution (07, D12)
-    tags: new Map(), // quilt + name → tag (06: never moved or deleted)
-    squares: new Map(), // id → square
-    commits: new Map(), // quilt + id → commit row
-    bySeq: new Map(), // quilt + seq → commit id
-    files: new Map(), // quilt + commit id → [file rows] (staged before the commit row exists)
-    linePaths: new Map(), // quilt + line + path → [{ patch_no, commit_id, seq, op }] oldest first
-    linePathsPending: new Map(), // quilt → [{ line, patch_no, commit_id, seq }] (03: merged, rows not written yet)
-    blobs: new Map(), // quilt + id → location
-    objects: new Map(), // quilt + id → location
-    packs: new Map(), // quilt + id → pack row
-    log: new Map(), // quilt → [log rows] (index = seq − 1)
-    patches: new Map(), // quilt + line + patch_no → seq of the merge row
-    idem: new Map(), // key → { result, at }
-    gitShas: new Map(), // quilt + sha → commit id
-    stubs: new Map(), // quilt + member id → stub member (14: git import authors)
-    gitOf: new Map(), // quilt + commit id → sha
-    blocks: new Map(), // id → block
-    events: new Map(), // quilt → [event rows] (index = event_seq − 1), each with its recipients
-    eventCursors: new Map(), // quilt → the last log seq the events job read
-    memberEvents: new Map(), // quilt + member → [event_seq] (event_recipients)
-    webhooks: new Map(), // quilt + member → subscription
-    leases: new Map(), // 'line' + quilt + line | 'square' + id → { holder, expires_at }
-    // Indexes, so no read scans every row:
-    byMember: new Map(), // member → Set of quilt ids
-    quiltMembers: new Map(), // quilt → Set of member ids
-    quiltLines: new Map(), // quilt → Set of line names
-    quiltTags: new Map(), // quilt → Set of tag names
-    quiltSquares: new Map(), // quilt → Set of square ids
-    squareCommitIds: new Map(), // square → [commit ids] in seq order
-    squareTail: new Map(), // quilt + last 4 hex digits of the id → Set of square ids
-    idPrefix: new Map() // quilt + first 3 hex chars → [commit ids]
-  }
-  const clone = (v) => v == null ? null : structuredClone(v)
-  const addTo = (m, key, v) => { let x = m.get(key); if (!x) { x = new Set(); m.set(key, x) } x.add(v) }
-  const pushTo = (m, key, v) => { let x = m.get(key); if (!x) { x = []; m.set(key, x) } x.push(v) }
-
-  // ---- writes (each one transaction) ----
-
-  const logOf = (q) => { let l = t.log.get(q); if (!l) { l = []; t.log.set(q, l) } return l }
-  const quiltRow = (q) => {
-    const row = t.quilts.get(q)
-    if (!row) throw new StoreError('not_found', 'no such quilt')
-    return row
-  }
-  // The quilt row lock: in one process every transaction runs to its end before the next starts.
-  function appendLog (q, row) {
-    const quilt = quiltRow(q)
-    const seq = quilt.head_seq + 1
-    const full = { quilt_id: q, seq, ...row }
-    logOf(q).push(full)
-    quilt.head_seq = seq
-    return full
-  }
-
-  const tx = {
-    createQuilt ({ quilt, at }) {
-      const sk = k(quilt.owner, quilt.slug)
-      if (t.slugs.has(sk)) throw new StoreError('slug_taken', `you already have a quilt called ${quilt.slug}`)
-      t.quilts.set(quilt.id, { ...quilt, head_seq: 0, created_at: at })
-      t.slugs.set(sk, quilt.id)
-      t.members.set(k(quilt.id, quilt.owner), { quilt_id: quilt.id, member_id: quilt.owner, level: 'admin' })
-      addTo(t.byMember, quilt.owner, quilt.id); addTo(t.quiltMembers, quilt.id, quilt.owner); addTo(t.quiltLines, quilt.id, 'main')
-      t.lines.set(k(quilt.id, 'main'), { quilt_id: quilt.id, name: 'main', tip: null, tip_seq: 0, patch_count: 0, frozen: false, updated_at: at })
-      appendLog(quilt.id, { kind: 'policy', actor: quilt.owner, at, payload: { op: 'create', slug: quilt.slug } })
-      return quiltRow(quilt.id)
-    },
-
-    setMember ({ quilt_id: q, member_id: m, level, actor, at }) {
-      quiltRow(q)
-      if (level) { t.members.set(k(q, m), { quilt_id: q, member_id: m, level }); addTo(t.byMember, m, q); addTo(t.quiltMembers, q, m) }
-      else t.members.delete(k(q, m))
-      appendLog(q, { kind: 'policy', actor, at, payload: { op: 'member', member: m, level: level || null } })
-      return { member_id: m, level: level || null }
-    },
-
-    /** Packs, blobs and objects rows for a sealed pack (03: committed before any row names them). */
-    sealPack ({ quilt_id: q, pack, blobs = [], objects = [], at }) {
-      quiltRow(q)
-      if (!t.packs.has(k(q, pack.id))) t.packs.set(k(q, pack.id), { ...pack, sealed_at: at })
-      const seq = quiltRow(q).head_seq
-      for (const b of blobs) if (!t.blobs.has(k(q, b.id))) t.blobs.set(k(q, b.id), { ...b, pack_id: pack.id, first_seen_seq: seq + 1 })
-      for (const o of objects) if (!t.objects.has(k(q, o.id))) t.objects.set(k(q, o.id), { ...o, pack_id: pack.id })
-      return { ok: true }
-    },
-
-    /** A commit's file rows, keyed by its content id, written before the lock (03). */
-    stageFiles ({ quilt_id: q, commit_id: id, files }) {
-      if (!t.files.has(k(q, id))) t.files.set(k(q, id), files)
-      return { ok: true }
-    },
-
-    openSquare ({ square, at }) {
-      quiltRow(square.quilt_id)
-      if (t.squares.has(square.id)) throw new StoreError('exists', 'that square exists')
-      if (square.task_id && square.task_primary) {
-        for (const s of [...(t.quiltSquares.get(square.quilt_id) || [])].map((id) => t.squares.get(id))) if (s.quilt_id === square.quilt_id && s.task_id === square.task_id && s.task_primary && s.state === 'open') return { ...s, existed: true }
-      }
-      const row = appendLog(square.quilt_id, { kind: 'square', square: square.id, line: square.line, actor: square.opened_by, at, payload: { op: 'open', title: square.title, base: square.base } })
-      const s = { ...square, state: 'open', head: null, opened_at: at, updated_at: at, last_seq: row.seq }
-      t.squares.set(s.id, s)
-      addTo(t.quiltSquares, s.quilt_id, s.id)
-      addTo(t.squareTail, k(s.quilt_id, s.id.replace(/-/g, '').slice(-4)), s.id)
-      return s
-    },
-
-    /**
-     * The commit transaction (03): compare-and-swap of the square's head, then the commit row
-     * and its log row, the predecessor hidden. `state` is the square state the write expects:
-     * 'open', or 'merging' for a merge's own writes.
-     */
-    commit ({ commit, expect_head, state = 'open', actor, at, payload = {}, square_patch: patch = null }) {
-      const q = commit.quilt_id
-      const s = t.squares.get(commit.square_id)
-      if (!s || s.quilt_id !== q) throw new StoreError('not_found', 'no such square')
-      if (s.state !== state) throw new StoreError(s.state === 'merging' ? 'square_merging' : 'square_closed', `the square is ${s.state}`, { head: s.head })
-      if ((s.head || null) !== (expect_head || null)) throw new StoreError('head_moved', 'the square moved on since you looked', { head: s.head })
-      if (t.commits.has(k(q, commit.id))) throw new StoreError('exists', 'that commit exists')
-      const c = writeCommit(commit, s, actor, at, payload, true)
-      // A rebase moves the square's base in the same transaction (07).
-      if (patch && patch.base !== undefined) s.base = patch.base
-      return c
-    },
-
-    /** Moves a square to 'merging' (07 step 1), by compare-and-swap on state and head. */
-    beginMerge ({ square_id, expect_head, actor, at }) {
-      const s = t.squares.get(square_id)
-      if (!s) throw new StoreError('not_found', 'no such square')
-      if (s.state === 'merging') throw new StoreError('square_merging', 'another merge of this square is running')
-      if (s.state !== 'open') throw new StoreError('square_closed', `the square is ${s.state}`)
-      if ((s.head || null) !== (expect_head || null)) throw new StoreError('head_moved', 'the square moved on since you looked', { head: s.head })
-      appendLog(s.quilt_id, { kind: 'square', square: s.id, actor, at, payload: { op: 'merging' } })
-      s.state = 'merging'; s.updated_at = at
-      return { ...s }
-    },
-
-    /** A refused or abandoned merge: the square goes back to 'open' with a merge_refused row. */
-    endMerge ({ square_id, why, actor, at }) {
-      const s = t.squares.get(square_id)
-      if (!s || s.state !== 'merging') return null
-      appendLog(s.quilt_id, { kind: 'square', square: s.id, actor, at, payload: { op: 'merge_refused', why } })
-      s.state = 'open'; s.updated_at = at
-      return { ...s }
-    },
-
-    /**
-     * The merge transaction (07 step 7): the rebased commit, the merge row, the line's
-     * compare-and-swap and the square's merged row, all or nothing. `tip_moved` means the
-     * caller rebases again.
-     */
-    merge ({ commit, line, expected_tip, expect_head, snapshot_root, actor, at, payload = {}, import: imported = false, root = false }) {
-      const q = commit.quilt_id
-      const ln = t.lines.get(k(q, line))
-      if (!ln) throw new StoreError('not_found', `no line ${line}`)
-      if (ln.frozen && !imported) throw new StoreError('line_frozen', `${line} is frozen`)
-      if ((ln.tip || null) !== (expected_tip || null)) throw new StoreError('tip_moved', `${line} moved on`, { tip: ln.tip })
-      if (commit.conflicted) throw new StoreError('conflict', 'a line never takes a conflicted commit')
-      const s = t.squares.get(commit.square_id)
-      if (!s) throw new StoreError('not_found', 'no such square')
-      if (!imported && (s.state !== 'merging' || (s.head || null) !== (expect_head || null))) throw new StoreError('head_moved', 'the square moved on since you looked', { head: s.head })
-      const c = t.commits.get(k(q, commit.id)) || writeCommit({ ...commit, snapshot_root }, s, actor, at, payload, false)
-      const patchNo = root && !ln.tip ? 0 : ln.patch_count + 1 // the root commit is patch 0 (ruling 2026-10-24)
-      const mrow = appendLog(q, { kind: 'merge', commit: commit.id, square: s.id, line, patch_no: patchNo, from: ln.tip, to: commit.id, actor, at, snapshot_root, payload: { combined: payload.combined || [], ...(payload.reverts ? { reverts: payload.reverts } : {}) } })
-      Object.assign(ln, { tip: commit.id, tip_seq: mrow.seq, patch_count: patchNo, updated_at: at })
-      t.patches.set(k(q, line, patchNo), mrow.seq)
-      if (snapshot_root) c.snapshot_root = snapshot_root
-      c.patch = { line, patch_no: patchNo }
-      const merged = { line, patch_no: patchNo, commit: commit.id, seq: mrow.seq }
-      appendLog(q, { kind: 'square', square: s.id, actor, at, payload: { op: 'merged', ...merged } })
-      Object.assign(s, { state: 'merged', head: commit.id, merged, updated_at: at, closed_at: at })
-      // line_paths: written by the second short transaction (fillLinePaths, 03); until then the
-      // patch is pending and readers take its rows from its file rows.
-      pushTo(t.linePathsPending, q, { line, patch_no: patchNo, commit_id: commit.id, seq: c.seq })
-      return { patch_no: patchNo, seq: mrow.seq, commit: c }
-    },
-
-    /** 03's second short transaction: the line_paths rows of every pending patch of a quilt. */
-    fillLinePaths ({ quilt_id: q }) {
-      const pending = t.linePathsPending.get(q) || []
-      for (const pp of pending) {
-        for (const [path, op] of pathRows(q, pp.commit_id)) {
-          const lk = k(q, pp.line, path)
-          let list = t.linePaths.get(lk)
-          if (!list) { list = []; t.linePaths.set(lk, list) }
-          if (!list.some((r) => r.patch_no === pp.patch_no)) list.push({ patch_no: pp.patch_no, commit_id: pp.commit_id, seq: pp.seq, op })
-        }
-      }
-      t.linePathsPending.delete(q)
-      return { filled: pending.length }
-    },
-
-    /** Writes an imported commit that is not a patch (a side branch's commit) into its square. */
-    importCommit ({ commit, actor, at, payload = {} }) {
-      const s = t.squares.get(commit.square_id)
-      if (!s) throw new StoreError('not_found', 'no such square')
-      if (t.commits.has(k(commit.quilt_id, commit.id))) return t.commits.get(k(commit.quilt_id, commit.id))
-      return writeCommit(commit, s, actor, at, payload, false)
-    },
-
-    setSnapshot ({ quilt_id: q, commit_id: id, root }) {
-      const c = t.commits.get(k(q, id))
-      if (c && !c.snapshot_root) c.snapshot_root = root
-      return { ok: true }
-    },
-
-    setSquare ({ square_id, patch, op, expect, log = {}, actor, at }) {
-      const s = t.squares.get(square_id)
-      if (!s) throw new StoreError('not_found', 'no such square')
-      // Compare-and-swap on the square row (06): head, holder and state as the caller saw them.
-      if (expect && 'head' in expect && (s.head || null) !== (expect.head || null)) throw Object.assign(new StoreError('head_moved', 'the square moved on since you looked'), { head: s.head })
-      if (expect && 'holder' in expect && s.holder !== expect.holder) throw Object.assign(new StoreError('holder_moved', `the square is now held by ${s.holder}`), { holder: s.holder })
-      if (expect && 'state' in expect && s.state !== expect.state) throw Object.assign(new StoreError('square_state', `the square is ${s.state}`), { state: s.state })
-      appendLog(s.quilt_id, { kind: 'square', square: s.id, actor, at, payload: { op, ...patch, ...log } })
-      Object.assign(s, patch, { updated_at: at })
-      return { ...s }
-    },
-
-    /** Stores a square's conflicted paths for one head (07); a head that moved since is left alone. */
-    setConflicted ({ square_id, head, paths }) {
-      const s = t.squares.get(square_id)
-      if (!s || (s.head || null) !== (head || null)) return { ok: false }
-      s.conflicted_paths = [...paths]
-      s.conflicted_at = head
-      return { ok: true }
-    },
-
-    setGitSha ({ quilt_id: q, sha, commit_id: id }) {
-      t.gitShas.set(k(q, sha), id)
-      t.gitOf.set(k(q, id), sha)
-      return { ok: true }
-    },
-
-    /** Stub person/agent members for git import authors (14); a known stub is left as it is. */
-    addStubs ({ quilt_id: q, stubs, at }) {
-      let added = 0
-      for (const st of stubs) {
-        if (t.stubs.has(k(q, st.member_id))) continue
-        t.stubs.set(k(q, st.member_id), { quilt_id: q, member_id: st.member_id, kind: st.kind || 'person', name: st.name || null, email: st.email || null, stub: true, created_at: at })
-        added++
-      }
-      return { added }
-    },
-
-    remember ({ key, result, at }) { t.idem.set(key, { result, at }); return { ok: true } },
-
-    putBlock ({ block }) { t.blocks.set(block.id, { ...block }); return { ...block } },
-
-    /**
-     * The events job's transaction (12): the events derived from log rows up to `cursor`, each
-     * with a dense event_seq and its recipients, and the cursor moved, only if it is still at
-     * `expect_cursor` (so two workers never write one row's events twice).
-     */
-    addEvents ({ quilt_id: q, events, expect_cursor: expect, cursor }) {
-      quiltRow(q)
-      if ((t.eventCursors.get(q) || 0) !== (expect || 0)) throw new StoreError('cursor_moved', 'another events job ran')
-      const list = t.events.get(q) || []
-      t.events.set(q, list)
-      const out = []
-      for (const ev of events) {
-        const row = { ...ev, quilt_id: q, event_seq: list.length + 1 }
-        list.push(row)
-        for (const m of new Set(ev.recipients || [])) pushTo(t.memberEvents, k(q, m), row.event_seq)
-        out.push(row)
-      }
-      t.eventCursors.set(q, cursor)
-      return out.map(clone)
-    },
-
-    /** revert (04): a new square and its one commit in one transaction. */
-    openAndCommit ({ square, at, ...commitArgs }) {
-      const q = commitArgs.commit.quilt_id
-      for (const p of commitArgs.commit.parents) if (!t.commits.has(k(q, p))) throw new StoreError('bad_parent', `parent ${p} is not in this quilt`)
-      tx.openSquare({ square, at })
-      return tx.commit({ ...commitArgs, at, expect_head: null })
-    },
-
-    /** Takes (or renews) a line's or a square's lease (03's line_leases / square_leases). */
-    takeLease ({ kind, quilt_id: q, line, square_id: sq, holder, ttl_ms: ttl, at }) {
-      const key = kind === 'line' ? k('line', q, line) : k('square', sq)
-      const cur = t.leases.get(key)
-      if (!cur || cur.holder === holder || cur.expires_at <= at) t.leases.set(key, { holder, expires_at: at + ttl })
-      const now = t.leases.get(key)
-      return { held: now.holder === holder, holder: now.holder, expires_at: now.expires_at }
-    },
-    giveLease ({ kind, quilt_id: q, line, square_id: sq, holder }) {
-      const key = kind === 'line' ? k('line', q, line) : k('square', sq)
-      if (t.leases.get(key)?.holder === holder) t.leases.delete(key)
-      return { ok: true }
-    },
-
-    /** One webhook subscription per member per quilt (null removes it). */
-    setWebhook ({ quilt_id: q, member_id: m, sub }) {
-      if (sub) t.webhooks.set(k(q, m), { ...sub }); else t.webhooks.delete(k(q, m))
-      return sub ? { ...sub } : null
-    },
-    // A new line (release/<name>) starting at a commit: its next merge is patch 1.
-    createLine ({ quilt_id: q, name, tip, actor, at }) {
-      quiltRow(q)
-      if (t.lines.has(k(q, name))) throw new StoreError('line_exists', `there is already a line ${name}`)
-      if (tip && !t.commits.has(k(q, tip))) throw new StoreError('not_found', 'no such commit')
-      const row = appendLog(q, { kind: 'policy', line: name, actor, at, payload: { op: 'line', tip: tip || null } })
-      t.lines.set(k(q, name), { quilt_id: q, name, tip: tip || null, tip_seq: row.seq, patch_count: 0, frozen: false, updated_at: at })
-      addTo(t.quiltLines, q, name)
-      return clone(t.lines.get(k(q, name)))
-    },
-    // A tag (or a release: a tag with notes) on a commit; a name is taken once, for good.
-    createTag ({ quilt_id: q, name, commit, release = false, notes = null, actor, at }) {
-      quiltRow(q)
-      if (t.tags.has(k(q, name))) throw new StoreError('tag_exists', `there is already a tag ${name}`)
-      if (!t.commits.has(k(q, commit))) throw new StoreError('not_found', 'no such commit')
-      const row = appendLog(q, { kind: 'release', commit, actor, at, payload: { op: release ? 'release' : 'tag', name, ...(release ? { notes } : {}) } })
-      t.tags.set(k(q, name), { quilt_id: q, name, commit, release: !!release, notes: release ? notes : null, actor, at, seq: row.seq })
-      addTo(t.quiltTags, q, name)
-      return clone(t.tags.get(k(q, name)))
-    },
-    // A member's Ed25519 public key (signing.js): removed, never deleted.
-    addSigningKey (r) {
-      const had = t.signingKeys.get(r.id)
-      if (had && !had.removed_at) throw new StoreError('key_exists', had.member === r.member ? 'you already added this key' : 'this key is someone else\'s')
-      if (had && had.member !== r.member) throw new StoreError('key_exists', 'this key is someone else\'s')
-      t.signingKeys.set(r.id, { ...r, removed_at: null })
-      return clone(t.signingKeys.get(r.id))
-    },
-    removeSigningKey ({ id, member, at }) {
-      const row = t.signingKeys.get(id)
-      if (!row || row.member !== member) throw new StoreError('not_found', 'no such key')
-      if (!row.removed_at) row.removed_at = at
-      return clone(row)
-    },
-    // A quilt token (tokens.js): a row and its membership token:<id>, made and ended together.
-    createToken (r) {
-      quiltRow(r.quilt_id)
-      if ([...t.tokens.values()].some((x) => x.hash === r.hash)) throw new StoreError('exists', 'this token exists')
-      t.tokens.set(r.id, { ...r, revoked_at: null })
-      const m = `token:${r.id}`
-      t.members.set(k(r.quilt_id, m), { quilt_id: r.quilt_id, member_id: m, level: r.level }); addTo(t.byMember, m, r.quilt_id); addTo(t.quiltMembers, r.quilt_id, m)
-      appendLog(r.quilt_id, { kind: 'policy', actor: r.created_by, at: r.created_at, payload: { op: 'token', token: r.id, name: r.name, level: r.level } })
-      return clone(t.tokens.get(r.id))
-    },
-    revokeToken ({ quilt_id: q, id, actor, at }) {
-      const row = t.tokens.get(id)
-      if (!row || row.quilt_id !== q) throw new StoreError('not_found', 'no such token')
-      if (!row.revoked_at) {
-        row.revoked_at = at
-        t.members.delete(k(q, `token:${id}`))
-        appendLog(q, { kind: 'policy', actor, at, payload: { op: 'revoke_token', token: id } })
-      }
-      return clone(row)
-    },
-    // A signature on a commit: one per (commit, key), kept for good.
-    addSignature (r) {
-      if (!t.commits.has(k(r.quilt_id, r.commit))) throw new StoreError('not_found', 'no such commit')
-      let a = t.signatures.get(k(r.quilt_id, r.commit)); if (!a) { a = []; t.signatures.set(k(r.quilt_id, r.commit), a) }
-      if (!a.some((x) => x.key === r.key)) a.push({ ...r })
-      return clone(r)
-    },
-    // A review row on a square (13): kept for good, never changed.
-    addReview (r) {
-      const row = t.squares.get(r.square_id)
-      if (!row || row.quilt_id !== r.quilt_id) throw new StoreError('not_found', 'no such square')
-      let a = t.reviews.get(r.quilt_id); if (!a) { a = []; t.reviews.set(r.quilt_id, a) }
-      a.push({ ...r })
-      return clone(r)
-    },
-    // What a line needs to take a merge (13): a number of approvals.
-    setLineRule ({ quilt_id: q, line, approvals, checks = [] }) {
-      if (!t.lines.has(k(q, line))) throw new StoreError('not_found', `no line ${line}`)
-      let m = t.lineRules.get(q); if (!m) { m = new Map(); t.lineRules.set(q, m) }
-      m.set(line, { line, approvals, checks: [...checks] })
-      return clone(m.get(line))
-    },
-    // A check's latest result on a square (13): one row per (square, check), replaced by each report.
-    setSquareCheck ({ quilt_id: q, square_id: sq, name, status, head, by, at }) {
-      const row = t.squares.get(sq)
-      if (!row || row.quilt_id !== q) throw new StoreError('not_found', 'no such square')
-      let m = t.squareChecks.get(sq); if (!m) { m = new Map(); t.squareChecks.set(sq, m) }
-      m.set(name, { name, status, head, by, at })
-      return clone(m.get(name))
-    },
-    // A claim on a square's files (06): a mutable row, not a log entry.
-    createClaim ({ quilt_id: q, id, square_id: sq, pattern, holder, note = '', at }) {
-      const row = t.squares.get(sq)
-      if (!row || row.quilt_id !== q) throw new StoreError('not_found', 'no such square')
-      let m = t.claims.get(q); if (!m) { m = new Map(); t.claims.set(q, m) }
-      m.set(id, { quilt_id: q, id, square_id: sq, pattern, holder, note, at })
-      return clone(m.get(id))
-    },
-    deleteClaim ({ quilt_id: q, id }) {
-      const m = t.claims.get(q)
-      if (!m || !m.has(id)) throw new StoreError('not_found', 'no such claim')
-      m.delete(id)
-      return { ok: true }
-    },
-    // A square's shared uncommitted work, replaced whole; no changes clears it. Not history: no log row.
-    setLive ({ quilt_id: q, square_id: sq, head = null, changes = [], actor, at }) {
-      const row = t.squares.get(sq)
-      if (!row || row.quilt_id !== q) throw new StoreError('not_found', 'no such square')
-      if (!changes.length) { t.live.delete(sq); return null }
-      t.live.set(sq, { quilt_id: q, square_id: sq, head, changes: clone(changes), actor, at })
-      return clone(t.live.get(sq))
-    },
-    // Freezes or unfreezes a line: a frozen line refuses merges (line_frozen).
-    setLineFrozen ({ quilt_id: q, name, frozen, actor, at }) {
-      const ln = t.lines.get(k(q, name))
-      if (!ln) throw new StoreError('not_found', `no line ${name}`)
-      appendLog(q, { kind: 'policy', line: name, actor, at, payload: { op: frozen ? 'freeze' : 'unfreeze' } })
-      Object.assign(ln, { frozen: !!frozen, updated_at: at })
-      return clone(ln)
-    },
-    // The merge window's state on a line (07): current window, maximum, red checks.
-    setLineWindow ({ quilt_id: q, line, merge_window: w, merge_window_max: m, red_checks: red }) {
-      const ln = t.lines.get(k(q, line))
-      if (!ln) throw new StoreError('not_found', `no line ${line}`)
-      Object.assign(ln, { merge_window: w, merge_window_max: m, red_checks: { ...red } })
-      return clone(ln)
-    },
-    // The archiver's step (03): archive_seq moves from `expect_seq` to `to_seq` (a CAS, so two
-    // archivers never both advance it) and last_segment names the newest segment's hash.
-    setArchive ({ quilt_id: q, expect_seq: expect, to_seq: to, segment }) {
-      const row = quiltRow(q)
-      if ((row.archive_seq || 0) !== expect) throw new StoreError('archive_moved', 'another archiver moved archive_seq', { archive_seq: row.archive_seq || 0 })
-      if (to <= expect || to > row.head_seq) throw new StoreError('bad_archive', 'a segment must end after archive_seq and at or before head_seq')
-      row.archive_seq = to
-      row.last_segment = segment
-      return { archive_seq: to, last_segment: segment }
-    }
-  }
-
-  // A patch's line_paths rows: one per file, and one per directory it is in ('dir/'), so
-  // `log -- dir` reads them too.
-  function pathRows (q, commitId) {
-    const rows = new Map()
-    for (const f of t.files.get(k(q, commitId)) || []) {
-      rows.set(f.path, f.op)
-      const parts = f.path.split('/')
-      for (let i = 1; i < parts.length; i++) rows.set(parts.slice(0, i).join('/') + '/', 'dir')
-    }
-    return rows
-  }
-
-  function writeCommit (commit, s, actor, at, payload, moveHead) {
-    const q = commit.quilt_id
-    const parentSeqs = commit.parents.map((p) => {
-      const pc = t.commits.get(k(q, p))
-      if (!pc) throw new StoreError('bad_parent', `parent ${p} is not in this quilt`)
-      return pc.seq
-    })
-    if (commit.predecessor && !t.commits.has(k(q, commit.predecessor))) throw new StoreError('bad_parent', 'predecessor is not in this quilt')
-    for (const f of t.files.get(k(q, commit.id)) || commit.changes || []) if (f.copy_from && !t.commits.has(k(q, f.copy_from.commit))) throw new StoreError('bad_parent', 'copy_from commit is not in this quilt')
-    const row = appendLog(q, { kind: 'commit', commit: commit.id, square: s.id, actor, at, payload })
-    const { changes, ...rest } = commit
-    const c = { ...rest, seq: row.seq, parent_seqs: parentSeqs, hidden_seq: null }
-    t.commits.set(k(q, commit.id), c)
-    pushTo(t.squareCommitIds, c.square_id, c.id)
-    pushTo(t.idPrefix, k(q, c.id.slice(0, 3)), c.id)
-    t.bySeq.set(k(q, row.seq), commit.id)
-    if (!t.files.has(k(q, commit.id))) t.files.set(k(q, commit.id), changes || [])
-    if (commit.predecessor) { const p = t.commits.get(k(q, commit.predecessor)); if (p && p.hidden_seq == null) p.hidden_seq = row.seq }
-    if (moveHead) { s.head = commit.id; s.updated_at = at; s.last_seq = row.seq }
-    return c
-  }
-
-  // ---- the journal ----
-
-  // Compaction: the whole state as one `state` line (Maps and Sets tagged), then new ops after it.
-  // Leases are not journaled: they last seconds, and after a restart every holder is gone.
-  const NOT_JOURNALED = new Set(['remember', 'takeLease', 'giveLease'])
-  const COMPACT_AT = 5000
-  const pack = (_, v) => v instanceof Map ? { $map: [...v] } : v instanceof Set ? { $set: [...v] } : v
-  const unpack = (_, v) => v && typeof v === 'object' && !Array.isArray(v) ? (v.$map ? new Map(v.$map) : v.$set ? new Set(v.$set) : v) : v
-  let journal = null
-  let ops = 0
-  if (file) {
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    if (fs.existsSync(file)) {
-      for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
-        if (!line) continue
-        if (line.startsWith('{"state":')) { const st = JSON.parse(line, unpack).state; for (const key of Object.keys(t)) if (st[key]) t[key] = st[key]; ops = 0; continue }
-        const { op, args } = JSON.parse(line)
-        try { tx[op](args) } catch (err) { throw new Error(`quilt journal ${file}: replaying ${op} failed: ${err.message}`) }
-        ops++
-      }
-    }
-    journal = fs.openSync(file, 'a')
-    if (ops >= COMPACT_AT) compact()
-  }
-
-  /** Rewrites the journal as one state line (written beside it, then renamed over it). */
-  function compact () {
-    if (!file) return
-    const { leases, ...durable } = t
-    const tmp = `${file}.compact`
-    fs.writeFileSync(tmp, JSON.stringify({ state: durable }, pack) + '\n')
-    fs.closeSync(journal)
-    fs.renameSync(tmp, file)
-    journal = fs.openSync(file, 'a')
-    ops = 0
-  }
-
-  const store = { compact: async () => compact() }
-  for (const [name, fn] of Object.entries(tx)) {
-    store[name] = async (args) => {
-      const out = fn(args)
-      if (journal && !NOT_JOURNALED.has(name)) {
-        fs.writeSync(journal, JSON.stringify({ op: name, args }) + '\n')
-        if (++ops >= COMPACT_AT) compact()
-      }
-      return structuredClone(out)
-    }
-  }
-
-  // ---- reads ----
-  Object.assign(store, {
-    async getQuilt (id) { return clone(t.quilts.get(id)) },
-    async quiltBySlug (owner, slug) { const id = t.slugs.get(k(owner, slug)); return clone(id && t.quilts.get(id)) },
-    async quiltsFor (member) {
-      return [...(t.byMember.get(member) || [])].map((q) => t.members.get(k(q, member))).filter(Boolean).map((m) => ({ ...clone(t.quilts.get(m.quilt_id)), level: m.level }))
-    },
-    async memberLevel (q, member) { return t.members.get(k(q, member))?.level || null },
-    async members (q) { return [...(t.quiltMembers.get(q) || [])].map((m) => t.members.get(k(q, m))).filter(Boolean).map(clone) },
-    async getLine (q, name) { return clone(t.lines.get(k(q, name))) },
-    async lines (q) { return [...(t.quiltLines.get(q) || [])].map((n) => t.lines.get(k(q, n))).filter(Boolean).map(clone) },
-    async getLive (q, sq) { const r = t.live.get(sq); return r && r.quilt_id === q ? clone(r) : null },
-    // A remembered resolution (07, D12): one row per conflict key, the latest answer wins.
-    setResolution (r) {
-      let m = t.resolutions.get(r.quilt_id); if (!m) { m = new Map(); t.resolutions.set(r.quilt_id, m) }
-      m.set(r.key, { ...r })
-      return clone(m.get(r.key))
-    },
-    deleteResolution ({ quilt_id: q, key }) {
-      const m = t.resolutions.get(q)
-      if (!m || !m.has(key)) throw new StoreError('not_found', 'no such resolution')
-      m.delete(key)
-      return { ok: true }
-    },
-    async resolution (q, key) { return clone(t.resolutions.get(q)?.get(key) || null) },
-    async resolutions (q) { return [...(t.resolutions.get(q)?.values() || [])].map(clone) },
-    async signingKey (id) { const r = t.signingKeys.get(id); return r ? clone(r) : null },
-    async tokens (q) { return [...t.tokens.values()].filter((r) => r.quilt_id === q).sort((a, b) => a.created_at - b.created_at).map(clone) },
-    async tokenByHash (hash) { const r = [...t.tokens.values()].find((x) => x.hash === hash); return r ? clone(r) : null },
-    async signingKeys (member) { return [...t.signingKeys.values()].filter((r) => r.member === member).sort((a, b) => a.added_at - b.added_at).map(clone) },
-    async signaturesOf (q, commits) { return commits.flatMap((c) => t.signatures.get(k(q, c)) || []).map(clone) },
-    async reviews (q, sq) { return (t.reviews.get(q) || []).filter((r) => r.square_id === sq).map(clone) },
-    async squareChecks (q, sq) { return t.squares.get(sq)?.quilt_id === q ? [...(t.squareChecks.get(sq)?.values() || [])].map(clone) : [] },
-    async lineRules (q) { return [...(t.lineRules.get(q)?.values() || [])].map(clone) },
-    async claims (q) { return [...(t.claims.get(q)?.values() || [])].map(clone) },
-    async getTag (q, name) { return clone(t.tags.get(k(q, name))) },
-    async tags (q) { return [...(t.quiltTags.get(q) || [])].map((n) => t.tags.get(k(q, n))).filter(Boolean).map(clone) },
-    async getSquare (id) { return clone(t.squares.get(id)) },
-    async squares (q, { state, holder, task } = {}) {
-      return [...(t.quiltSquares.get(q) || [])].map((id) => t.squares.get(id)).filter((s) => s.quilt_id === q && (!state || s.state === state) && (!holder || s.holder === holder) && (!task || s.task_id === task)).map(clone)
-    },
-    /** Squares whose id (without dashes) ends in `tail` (4+ hex digits), at most two. */
-    async squaresByTail (q, tail) {
-      return [...(t.squareTail.get(k(q, tail.slice(-4))) || [])].filter((id) => id.replace(/-/g, '').endsWith(tail)).slice(0, 2).map((id) => clone(t.squares.get(id)))
-    },
-    async getCommit (q, id) {
-      const c = t.commits.get(k(q, id))
-      return c ? { ...clone(c), changes: clone(t.files.get(k(q, id)) || []) } : null
-    },
-    async commitAtSeq (q, seq) { const id = t.bySeq.get(k(q, seq)); return id ? store.getCommit(q, id) : null },
-    async resolvePrefix (q, prefix) {
-      const out = []
-      // Prefixes shorter than 3 characters read the buckets they cover (at most 4096, never rows).
-      const buckets = prefix.length >= 3 ? [prefix.slice(0, 3)] : [...Array(16 ** (3 - prefix.length)).keys()].map((n) => prefix + n.toString(16).padStart(3 - prefix.length, '0'))
-      for (const b of buckets) {
-        for (const id of t.idPrefix.get(k(q, b)) || []) if (id.startsWith(prefix)) { out.push(id); if (out.length > 1) return out }
-      }
-      return out
-    },
-    async squareCommits (q, squareId) {
-      return (t.squareCommitIds.get(squareId) || []).map((id) => t.commits.get(k(q, id))).filter(Boolean).sort((a, b) => a.seq - b.seq).map(clone)
-    },
-    /**
-     * A square's commits at or below seq `upTo` that touched `p` (a file, or every file under a
-     * 'dir/' key), newest first: [{ commit_id, seq }]. Reads only that square's file rows.
-     */
-    async squarePathCommits (q, squareId, p, { upTo = Infinity, limit = 1000 } = {}) {
-      const out = []
-      const ids = t.squareCommitIds.get(squareId) || []
-      for (let i = ids.length - 1; i >= 0 && out.length < limit; i--) {
-        const c = t.commits.get(k(q, ids[i]))
-        if (!c || c.seq > upTo) continue
-        const files = t.files.get(k(q, c.id)) || []
-        if (files.some((f) => f.path === p || (p.endsWith('/') && f.path.startsWith(p)))) out.push({ commit_id: c.id, seq: c.seq })
-      }
-      return out
-    },
-    async getBlob (q, id) { return clone(t.blobs.get(k(q, id))) },
-    async hasBlobs (q, ids) { return ids.filter((id) => t.blobs.has(k(q, id))) },
-    async getObject (q, id) { return clone(t.objects.get(k(q, id))) },
-    async patch (q, line, n) { const seq = t.patches.get(k(q, line, n)); return seq ? clone(t.log.get(q)[seq - 1]) : null },
-    async patches (q, line, { after = 0, before = Infinity, limit = 50, desc = true } = {}) {
-      const ln = t.lines.get(k(q, line))
-      if (!ln) return []
-      const out = []
-      // An imported quilt has no patch 0 (it takes git's root commit as patch 1).
-      const add = (n) => { const seq = t.patches.get(k(q, line, n)); if (seq) out.push(clone(t.log.get(q)[seq - 1])) }
-      if (desc) {
-        for (let n = Math.min(ln.patch_count, before - 1); n > after && out.length < limit; n--) add(n)
-      } else {
-        for (let n = after + 1; n <= ln.patch_count && n < before && out.length < limit; n++) add(n)
-      }
-      return out
-    },
-    /** A line's patches, newest first, with their commits' authors and their squares' times (as quilt_line_patches_view). */
-    async linePatchesView (q, line, { before = Infinity, limit = 100 } = {}) {
-      const rows = await store.patches(q, line, { before, limit: Math.min(limit, 1001), desc: true })
-      return rows.map((r) => {
-        const c = t.commits.get(k(q, r.commit))
-        const s = c && t.squares.get(c.square_id)
-        if (!c) return null
-        const out = { patch_no: r.patch_no, commit: c.id, square_id: c.square_id, author: clone(c.author), title: String(c.message || '').split('\n')[0].slice(0, 300), authored_at: c.authored_at, at: c.at, files: (t.files.get(k(q, c.id)) || []).length }
-        if (s) Object.assign(out, { opened_at: s.opened_at }, s.import ? { import: true } : {}, s.closed_at ? { closed_at: s.closed_at } : {})
-        return out
-      }).filter(Boolean)
-    },
-    async eventCursor (q) { return t.eventCursors.get(q) || 0 },
-    /** A member's events after `after`, oldest first (event_recipients, then the rows). */
-    async eventsFor (q, member, { after = 0, kinds, limit = 100 } = {}) {
-      const seqs = t.memberEvents.get(k(q, member)) || []
-      let lo = 0; let hi = seqs.length
-      while (lo < hi) { const mid = (lo + hi) >> 1; if (seqs[mid] <= after) lo = mid + 1; else hi = mid }
-      const out = []
-      for (let i = lo; i < seqs.length && out.length < limit; i++) { const e = t.events.get(q)[seqs[i] - 1]; if (!kinds || kinds.includes(e.kind)) out.push(clone(e)) }
-      return out
-    },
-    async webhook (q, member) { return clone(t.webhooks.get(k(q, member)) || null) },
-    async logRows (q, { after = 0, limit = 100, kinds } = {}) {
-      return (t.log.get(q) || []).slice(after, after + 100000).filter((r) => !kinds || kinds.includes(r.kind)).slice(0, limit).map(clone)
-    },
-    /** A path's patches on a line, newest first, at or below patch `upTo` (03's line_paths). */
-    async linePaths (q, line, p, { upTo = Infinity, limit = 1000 } = {}) {
-      const list = t.linePaths.get(k(q, line, p)) || []
-      const out = []
-      // Pending patches (merged, rows not written yet) are the newest; read their file rows.
-      const pending = (t.linePathsPending.get(q) || []).filter((pp) => pp.line === line && pp.patch_no <= upTo)
-      for (let i = pending.length - 1; i >= 0 && out.length < limit; i--) {
-        const op = pathRows(q, pending[i].commit_id).get(p)
-        if (op && !list.some((r) => r.patch_no === pending[i].patch_no)) out.push({ patch_no: pending[i].patch_no, commit_id: pending[i].commit_id, seq: pending[i].seq, op })
-      }
-      for (let i = list.length - 1; i >= 0 && out.length < limit; i--) if (list[i].patch_no <= upTo) out.push(clone(list[i]))
-      return out
-    },
-    async recall (key, maxAgeMs, now) { const r = t.idem.get(key); return r && now - r.at < maxAgeMs ? clone(r.result) : null },
-    async stubMembers (q) { const out = []; for (const [key, v] of t.stubs) if (v.quilt_id === q) out.push(clone(v)); return out.sort((a, b) => a.member_id.localeCompare(b.member_id)) },
-    async gitSha (q, sha) { return t.gitShas.get(k(q, sha)) || null },
-    async gitShas (q, shas) { const out = {}; for (const sha of shas) { const id = t.gitShas.get(k(q, sha)); if (id) out[sha] = id } return out },
-    async gitShaOf (q, id) { return t.gitOf.get(k(q, id)) || null },
-    async getBlock (id) { return clone(t.blocks.get(id)) },
-    close () { if (journal) { fs.closeSync(journal); journal = null } }
-  })
-  return store
-}