heyquilt 0.3.121 → 0.3.138

package/src/quilts/block.js

@@ -1,347 +0,0 @@
-// Blocks on disk (plans/quilt-source-control/05): a folder holding part of one square, the
-// subtrees named by `paths`, as of commit `at`. The folder is a projection of a known commit
-// plus the edits made in it since; it is rebuilt from the server, never repaired. Its record is
-// .seam/block.json: the quilt, the square, the paths, `at`, the head it last saw, and a
-// manifest of what was written (blob, mode, size, mtime) so status needs no server call.
-import fs from 'node:fs'
-import path from 'node:path'
-import ignore from 'ignore'
-import { blobId, cleanPrefix, under, cmpPath, cleanCommit, commitBytes, commitId } from './records.js'
-import { unified, isText } from './textdiff.js'
-
-/** A block folder's own folder (seam's, not the Quilt app's .quilt). */
-export const BLOCK_DIR = '.seam'
-export const BLOCK_FILE = path.join(BLOCK_DIR, 'block.json')
-const ALWAYS_IGNORED = ['.git', BLOCK_DIR, 'node_modules']
-
-/** The block a folder (or one of its parents) holds, as { dir, block }, or null. */
-export function findBlock (start = process.cwd()) {
-  let dir = path.resolve(start)
-  for (;;) {
-    const f = path.join(dir, BLOCK_FILE)
-    if (fs.existsSync(f)) return { dir, block: JSON.parse(fs.readFileSync(f, 'utf8')) }
-    const up = path.dirname(dir)
-    if (up === dir) return null
-    dir = up
-  }
-}
-
-export function saveBlock (dir, block) {
-  fs.mkdirSync(path.join(dir, BLOCK_DIR), { recursive: true })
-  const f = path.join(dir, BLOCK_FILE)
-  fs.writeFileSync(f + '.tmp', JSON.stringify(block, null, 1))
-  fs.renameSync(f + '.tmp', f)
-}
-
-const inBlock = (block, p) => block.paths.some((x) => under(p, x))
-
-/** The folders that hold committed files: they are walked even when a .gitignore names them. */
-function trackedDirs (block) {
-  const out = new Set()
-  for (const p of Object.keys(block.files)) for (let i = p.indexOf('/'); i > 0; i = p.indexOf('/', i + 1)) out.add(p.slice(0, i))
-  return out
-}
-
-/** Reads `rel`/.gitignore into the stack of rules in force there (deepest last). */
-function rulesIn (dir, rel, stack) {
-  try { return [...stack, { base: rel, ig: ignore().add(fs.readFileSync(path.join(dir, rel, '.gitignore'), 'utf8')) }] } catch { return stack }
-}
-
-/** As git decides: the deepest .gitignore with a rule for the path wins (a `!` rule re-includes). */
-function ignoredBy (stack, r, isDir) {
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const { base, ig } = stack[i]
-    const rel = base ? r.slice(base.length + 1) : r
-    const res = ig.test(isDir ? rel + '/' : rel)
-    if (res.ignored) return true
-    if (res.unignored) return false
-  }
-  return false
-}
-
-const ALWAYS = ignore().add(ALWAYS_IGNORED)
-
-/**
- * Every file under the block's paths on disk: Map path → { abs, stat }. Every .gitignore on the
- * way down is read, as git does; a committed file is never ignored.
- */
-function scan (dir, block) {
-  const out = new Map()
-  const dirs = trackedDirs(block)
-  const walk = (rel, stack) => {
-    let names
-    try { names = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }) } catch { return }
-    for (const d of names) {
-      const r = rel ? `${rel}/${d.name}` : d.name
-      const n = r.normalize('NFC')
-      const isDir = d.isDirectory()
-      if (ALWAYS.ignores(isDir ? r + '/' : r)) continue
-      if (!(isDir ? dirs.has(n) : block.files[n]) && ignoredBy(stack, r, isDir)) continue
-      // A submodule's folder stands for its gitlink entry: what is inside belongs to the submodule.
-      if (isDir && block.files[n]?.mode === 'gitlink') { out.set(n, { abs: path.join(dir, r), gitlink: true }); continue }
-      if (isDir) { if (block.paths.some((x) => under(r, x) || under(x, r))) walk(r, rulesIn(dir, r, stack)); continue }
-      if (!(d.isFile() || d.isSymbolicLink()) || !inBlock(block, r)) continue
-      const abs = path.join(dir, r)
-      out.set(n, { abs, stat: fs.lstatSync(abs) })
-    }
-  }
-  walk('', rulesIn(dir, '', []))
-  return out
-}
-
-function readFileEntry (abs, stat) {
-  if (stat.isSymbolicLink()) return { bytes: Buffer.from(fs.readlinkSync(abs)), mode: 'symlink' }
-  return { bytes: fs.readFileSync(abs), mode: (stat.mode & 0o111) && process.platform !== 'win32' ? 'exec' : 'file' }
-}
-
-/**
- * What changed in the folder since `at`: [{ path, status: 'added' | 'modified' | 'deleted',
- * blob?, mode?, bytes? }]. A conflicted file still carrying its term's marker is unchanged.
- */
-export function localChanges (dir, block, { paths = [] } = {}) {
-  const only = paths.map((p) => cleanPrefix(path.relative(dir, path.resolve(p)).split(path.sep).join('/')))
-  const wanted = (p) => !only.length || only.some((x) => under(p, x))
-  const files = scan(dir, block)
-  const out = []
-  for (const [p, { abs, stat, gitlink }] of files) {
-    if (!wanted(p) || gitlink) continue
-    const known = block.files[p]
-    if (known && known.size === stat.size && known.mtimeMs === stat.mtimeMs) continue
-    const { bytes, mode } = readFileEntry(abs, stat)
-    const id = blobId(bytes)
-    if (known && known.blob === id && known.mode === mode) continue
-    if (known && known.term && bytes.includes(Buffer.from(`quilt-conflict ${known.term.slice(0, 12)}`))) continue
-    out.push({ path: p, status: known ? 'modified' : 'added', blob: id, mode, size: bytes.length, bytes })
-  }
-  for (const p of Object.keys(block.files)) if (!files.has(p) && wanted(p)) out.push({ path: p, status: 'deleted' })
-  return out.sort((a, b) => cmpPath(a.path, b.path))
-}
-
-/** Writes one tree entry to the folder and returns its manifest record. */
-async function writeEntry (dir, e, content) {
-  const abs = path.join(dir, ...e.path.split('/'))
-  fs.mkdirSync(path.dirname(abs), { recursive: true })
-  try { fs.rmSync(abs, { force: true }) } catch {}
-  // A git submodule is an empty folder, as git leaves one it has not cloned.
-  if (e.mode === 'gitlink') { fs.mkdirSync(abs, { recursive: true }); return { blob: e.blob, mode: 'gitlink', size: e.size, mtimeMs: 0 } }
-  if (e.mode === 'symlink') fs.symlinkSync(content.toString('utf8'), abs)
-  else fs.writeFileSync(abs, content, { mode: e.mode === 'exec' ? 0o755 : 0o644 })
-  const st = fs.lstatSync(abs)
-  return { blob: e.mode === 'conflict' ? null : e.blob, mode: e.mode, size: st.size, mtimeMs: st.mtimeMs, ...(e.term ? { term: e.term } : {}) }
-}
-
-/** Fetches blobs by id in batches (want-only, decision 31). */
-async function fetchBlobs (client, quilt, ids) {
-  const out = new Map()
-  const list = [...new Set(ids)]
-  for (let i = 0; i < list.length; i += 200) {
-    const { blobs } = await client.blobs(quilt, list.slice(i, i + 200))
-    for (const [id, b64] of Object.entries(blobs)) out.set(id, Buffer.from(b64, 'base64'))
-  }
-  return out
-}
-
-async function contentsFor (client, quilt, rev, entries) {
-  const blobs = await fetchBlobs(client, quilt, entries.filter((e) => e.blob).map((e) => e.blob))
-  const get = async (e) => {
-    if (e.mode !== 'conflict') return blobs.get(e.blob)
-    const r = await client.cat(quilt, rev, e.path, { format: 'diff' })
-    return Buffer.from(r.content, 'base64')
-  }
-  return get
-}
-
-/**
- * Checks out `rev` (a square's head, or any revision) under `paths` into `dir` as a new block.
- * Refuses a folder that already holds files, unless it is this block's own folder.
- */
-export async function checkout (client, { quilt, square = null, rev, paths = [''], dir, api }) {
-  const prefixes = (paths.length ? paths : ['']).map(cleanPrefix)
-  fs.mkdirSync(dir, { recursive: true })
-  const existing = fs.readdirSync(dir).filter((n) => n !== BLOCK_DIR)
-  if (existing.length) throw new Error(`${dir} is not empty; check out into an empty folder (or switch an existing block with quilt checkout inside it)`)
-  const sq = square ? await client.square(quilt, square) : null
-  const at = sq ? (sq.head || sq.base) : rev || 'main'
-  const t = await client.tree(quilt, at || 'main', prefixes)
-  const get = await contentsFor(client, quilt, at || 'main', t.entries)
-  const files = {}
-  for (const e of t.entries) files[e.path] = await writeEntry(dir, e, await get(e))
-  const block = { api, quilt, square: sq ? sq.id : null, square_short: sq ? sq.short : null, line: sq ? sq.line : (rev || 'main'), paths: prefixes, at: t.commit, head: sq ? sq.head : null, files }
-  saveBlock(dir, block)
-  return { block, files: t.entries.length }
-}
-
-/**
- * Moves the folder from `block.at` to commit `to`, file by file: paths changed on the server
- * are rewritten; a path changed both here and there is left as it is here and reported.
- */
-export async function syncTo (client, dir, block, to, { square } = {}) {
-  const local = new Map(localChanges(dir, block).map((c) => [c.path, c]))
-  const d = await client.diff(block.quilt, { from: block.at ? `c:${block.at}` : undefined, to: to ? `c:${to}` : 'main', paths: block.paths, format: 'names' })
-  const t = d.files.length ? await client.tree(block.quilt, to ? `c:${to}` : 'main', block.paths) : { entries: [] }
-  const byPath = new Map(t.entries.map((e) => [e.path, e]))
-  const get = await contentsFor(client, block.quilt, to ? `c:${to}` : 'main', d.files.map((f) => byPath.get(f.path)).filter(Boolean))
-  const kept = []
-  let written = 0
-  for (const f of d.files) {
-    if (local.has(f.path)) { kept.push(f.path); continue }
-    const e = byPath.get(f.path)
-    if (!e) {
-      const abs = path.join(dir, ...f.path.split('/'))
-      if (block.files[f.path]?.mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true })
-      delete block.files[f.path]; written++; continue
-    }
-    block.files[f.path] = await writeEntry(dir, e, await get(e))
-    written++
-  }
-  block.at = to
-  if (square) { block.square = square.id; block.square_short = square.short; block.head = square.head; block.line = square.line }
-  saveBlock(dir, block)
-  return { written, kept }
-}
-
-/** status: the folder's changes, and the square as the server sees it. */
-export async function status (client, dir, block) {
-  const changes = localChanges(dir, block).map(({ bytes, ...c }) => c)
-  const square = block.square ? await client.square(block.quilt, block.square) : null
-  const conflicted = Object.entries(block.files).filter(([, f]) => f.term).map(([p]) => p)
-  return { dir, quilt: block.quilt, square, paths: block.paths, at: block.at, changes, conflicted, stale: !!(square && square.head !== block.head) }
-}
-
-/** commit: uploads the changed files' blobs (have?, then a pack) and seals them as a commit. */
-export async function commitFolder (client, dir, block, { message, paths = [] }) {
-  if (!block.square) throw new Error('This folder is a read-only checkout of a line; open a square (quilt square open) to commit.')
-  const changes = localChanges(dir, block, { paths })
-  if (!changes.length) return { nothing: true }
-  const blobs = changes.filter((c) => c.bytes).map((c) => ({ kind: 'blob', id: c.blob, bytes: c.bytes }))
-  const list = changes.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', blob: c.blob, mode: c.mode })
-  // 03: the commit record is built here and travels in the pack with its blobs, so the commit
-  // request names it by id. The server refuses a record that is not exactly what it would write
-  // (a file that still carries a conflict's markers, say); then the changes go as a list.
-  let r
-  try {
-    if (!block.author || !block.quilt_id) { const info = await client.quilt(block.quilt); block.author = info.you; block.quilt_id = info.id }
-    const sq = await client.square(block.quilt, block.square)
-    const { on_behalf_of: onBehalf, ...author } = block.author
-    const record = cleanCommit({
-      quilt_id: block.quilt_id, square_id: sq.id, parents: [block.head || sq.base].filter(Boolean), author,
-      ...(onBehalf ? { on_behalf_of: onBehalf } : {}), ...(sq.task_id ? { task_id: sq.task_id } : {}),
-      message: message || '', authored_at: Date.now(),
-      changes: list.map((c) => c.op === 'delete' ? c : { ...c, mode: c.mode || 'file', size: changes.find((x) => x.path === c.path).bytes.length })
-    })
-    const id = commitId(record)
-    await client.upload(block.quilt, [...blobs, { kind: 'commit', id, bytes: commitBytes(record) }])
-    r = await client.commit(block.quilt, block.square, { expect_head: block.head, commit: id })
-  } catch (err) {
-    if (err.code !== 'record_mismatch') throw err
-    r = await client.commit(block.quilt, block.square, { expect_head: block.head, message, changes: list })
-  }
-  for (const c of changes) {
-    if (c.status === 'deleted') { delete block.files[c.path]; continue }
-    const st = fs.lstatSync(path.join(dir, ...c.path.split('/')))
-    block.files[c.path] = { blob: c.blob, mode: c.mode, size: st.size, mtimeMs: st.mtimeMs }
-  }
-  block.at = r.square.head
-  block.head = r.square.head
-  saveBlock(dir, block)
-  return r
-}
-
-/** Amends the square's last commit with the folder's changes (paths: only these) and, if given, a new message. */
-export async function amendFolder (client, dir, block, { message, paths = [] }) {
-  if (!block.square) throw new Error('This folder is a read-only checkout of a line; there is no commit of yours to amend.')
-  const changes = localChanges(dir, block, { paths })
-  const blobs = changes.filter((c) => c.bytes).map((c) => ({ kind: 'blob', id: c.blob, bytes: c.bytes }))
-  if (blobs.length) await client.upload(block.quilt, blobs)
-  const list = changes.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', blob: c.blob, mode: c.mode || 'file' })
-  const r = await client.amend(block.quilt, block.square, { expect_head: block.head, ...(message ? { message } : {}), changes: list })
-  for (const c of changes) {
-    if (c.status === 'deleted') { delete block.files[c.path]; continue }
-    const st = fs.lstatSync(path.join(dir, ...c.path.split('/')))
-    block.files[c.path] = { blob: c.blob, mode: c.mode, size: st.size, mtimeMs: st.mtimeMs }
-  }
-  block.at = r.square.head
-  block.head = r.square.head
-  saveBlock(dir, block)
-  return r
-}
-
-/** The folder's changes as a unified diff against `at` (diff with no revision, in a block). */
-export async function localDiff (client, dir, block, { paths = [] } = {}) {
-  const changes = localChanges(dir, block, { paths })
-  const olds = await fetchBlobs(client, block.quilt, changes.map((c) => block.files[c.path]?.blob).filter(Boolean))
-  const out = []
-  for (const c of changes) {
-    const before = block.files[c.path]?.blob ? olds.get(block.files[c.path].blob) : null
-    const after = c.bytes || null
-    if (!isText(before) || !isText(after)) { out.push(`Binary file ${c.path} ${c.status}\n`); continue }
-    out.push(unified(c.path, before ? before.toString('utf8') : null, after ? after.toString('utf8') : null))
-  }
-  return { changes: changes.map(({ bytes, ...c }) => c), text: out.join('') }
-}
-
-const absOf = (dir, p) => path.join(dir, ...p.split('/'))
-const removeEntry = (dir, p, mode) => { const abs = absOf(dir, p); if (mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true }) }
-
-/** Takes away the folders a removed file leaves empty, up to the block folder. */
-function pruneEmpty (dir, p) {
-  for (let d = path.dirname(absOf(dir, p)); d.startsWith(dir + path.sep); d = path.dirname(d)) {
-    try { if (fs.readdirSync(d).length) return; fs.rmdirSync(d) } catch { return }
-  }
-}
-
-/**
- * restore: puts the named paths back as they were at the folder's last commit (`at`), throwing
- * away their uncommitted edits and deletions. Files nobody committed are left (clean removes them).
- */
-export async function restore (client, dir, block, { paths }) {
-  if (!paths?.length) throw new Error('Which files? seam restore <paths> (. for everything here)')
-  const changes = localChanges(dir, block, { paths }).filter((c) => c.status !== 'added')
-  const entries = changes.map((c) => ({ path: c.path, ...block.files[c.path] }))
-  const get = await contentsFor(client, block.quilt, `c:${block.at}`, entries)
-  for (const e of entries) block.files[e.path] = { ...await writeEntry(dir, e, await get(e)), ...(e.term ? { term: e.term } : {}) }
-  saveBlock(dir, block)
-  return { restored: entries.map((e) => e.path) }
-}
-
-/**
- * reset: makes the folder's files those of `rev` (default: the folder's last commit, throwing
- * away every uncommitted edit). The folder stays on its square or line: what differs from there
- * shows as uncommitted changes, so a commit makes the square match `rev`. Files nobody committed
- * stay unless `rev` has them.
- */
-export async function reset (client, dir, block, { rev } = {}) {
-  if (!rev) {
-    const r = await restore(client, dir, block, { paths: [dir] })
-    return { rev: block.at, written: r.restored.length, removed: 0, changes: 0 }
-  }
-  const t = await client.tree(block.quilt, rev, block.paths)
-  const local = new Map(localChanges(dir, block).map((c) => [c.path, c]))
-  const want = new Map(t.entries.map((e) => [e.path, e]))
-  const toWrite = t.entries.filter((e) => {
-    const known = block.files[e.path]
-    return local.has(e.path) || !known || known.blob !== e.blob || known.mode !== e.mode || (e.term || null) !== (known.term || null)
-  })
-  const get = await contentsFor(client, block.quilt, rev, toWrite)
-  let removed = 0
-  for (const e of toWrite) {
-    const rec = await writeEntry(dir, e, await get(e))
-    const known = block.files[e.path]
-    // Same as the folder's commit: clean again. Otherwise the manifest keeps the commit's record,
-    // so the file shows as changed.
-    if (known && known.blob === e.blob && known.mode === e.mode) block.files[e.path] = rec
-  }
-  for (const [p, f] of Object.entries(block.files)) {
-    if (want.has(p) || !fs.existsSync(absOf(dir, p))) continue
-    removeEntry(dir, p, f.mode); pruneEmpty(dir, p); removed++
-  }
-  saveBlock(dir, block)
-  return { rev: t.commit, written: toWrite.length, removed, changes: localChanges(dir, block).length }
-}
-
-/** clean: removes the files under `paths` that nobody committed and no .gitignore names. */
-export function clean (dir, block, { paths = [], dryRun = false } = {}) {
-  const added = localChanges(dir, block, { paths }).filter((c) => c.status === 'added').map((c) => c.path)
-  if (!dryRun) for (const p of added) { removeEntry(dir, p, 'file'); pruneEmpty(dir, p) }
-  return { removed: added, dry_run: dryRun }
-}

package/src/quilts/bucket.js

@@ -1,25 +0,0 @@
-// A private Supabase Storage bucket for a quilt's packs: write-once signed uploads, short-lived
-// signed downloads, listing. Ids come from the content, so an upload never replaces what is there.
-import { createClient } from '@supabase/supabase-js'
-
-const LINK_S = 10 * 60
-
-export class SupabaseBucket {
-  constructor ({ url, key, bucket }) {
-    this.bucket = createClient(url, key, { auth: { persistSession: false, autoRefreshToken: false } }).storage.from(bucket)
-  }
-
-  // Supabase signed uploads can't bound size: the bucket's file_size_limit caps each object.
-  async uploadTarget (room, name) {
-    const { data, error } = await this.bucket.createSignedUploadUrl(`${room}/${name}`, { upsert: false })
-    if (error && (String(error.statusCode) === '409' || /exists|duplicate/i.test(String(error.message)))) return { exists: true }
-    if (error) throw new Error(`storage: ${error.message}`)
-    return { method: 'PUT', url: data.signedUrl }
-  }
-
-  async downloadTarget (room, name) {
-    const { data, error } = await this.bucket.createSignedUrl(`${room}/${name}`, LINK_S)
-    if (error) throw new Error(`storage: ${error.message}`)
-    return { url: data.signedUrl }
-  }
-}

package/src/quilts/cbor.js

@@ -1,92 +0,0 @@
-// Deterministic CBOR (RFC 8949 §4.2.1, "core deterministic encoding") for Quilt records: every
-// id is a hash of these bytes, so every client and server must write exactly the same ones.
-// Supported: unsigned and negative integers (safe range), byte strings (Uint8Array/Buffer),
-// text, arrays, maps (plain objects; keys sorted bytewise on their encoded form), true, false,
-// null. No floats, no indefinite lengths. Undefined fields are left out, never encoded.
-
-function head (major, n) {
-  if (!Number.isSafeInteger(n) || n < 0) throw new Error(`cbor: bad length or integer ${n}`)
-  if (n < 24) return Buffer.from([(major << 5) | n])
-  if (n < 0x100) return Buffer.from([(major << 5) | 24, n])
-  if (n < 0x10000) { const b = Buffer.alloc(3); b[0] = (major << 5) | 25; b.writeUInt16BE(n, 1); return b }
-  if (n < 0x100000000) { const b = Buffer.alloc(5); b[0] = (major << 5) | 26; b.writeUInt32BE(n, 1); return b }
-  const b = Buffer.alloc(9); b[0] = (major << 5) | 27; b.writeBigUInt64BE(BigInt(n), 1); return b
-}
-
-function encodeInto (v, out) {
-  if (v === null) return out.push(Buffer.from([0xf6]))
-  if (v === true) return out.push(Buffer.from([0xf5]))
-  if (v === false) return out.push(Buffer.from([0xf4]))
-  if (typeof v === 'number') {
-    if (!Number.isSafeInteger(v)) throw new Error(`cbor: no floats (${v})`)
-    return out.push(v >= 0 ? head(0, v) : head(1, -1 - v))
-  }
-  if (typeof v === 'string') {
-    const b = Buffer.from(v, 'utf8')
-    out.push(head(3, b.length)); return out.push(b)
-  }
-  if (v instanceof Uint8Array) { out.push(head(2, v.length)); return out.push(Buffer.from(v)) }
-  if (Array.isArray(v)) {
-    out.push(head(4, v.length))
-    for (const x of v) {
-      if (x === undefined) throw new Error('cbor: undefined in an array')
-      encodeInto(x, out)
-    }
-    return
-  }
-  if (typeof v === 'object') {
-    const entries = Object.entries(v).filter(([, x]) => x !== undefined)
-      .map(([k, x]) => [encode(k), x])
-      .sort(([a], [b]) => Buffer.compare(a, b))
-    out.push(head(5, entries.length))
-    for (const [k, x] of entries) { out.push(k); encodeInto(x, out) }
-    return
-  }
-  throw new Error(`cbor: cannot encode ${typeof v}`)
-}
-
-/** The deterministic CBOR bytes of `v`. */
-export function encode (v) {
-  const out = []
-  encodeInto(v, out)
-  return Buffer.concat(out)
-}
-
-/** Decodes one CBOR item (as written by encode); byte strings come back as Buffers. */
-export function decode (buf) {
-  const b = Buffer.from(buf.buffer ? buf : Buffer.from(buf))
-  let pos = 0
-  const arg = (info) => {
-    if (info < 24) return info
-    if (info === 24) return b[pos++]
-    if (info === 25) { const n = b.readUInt16BE(pos); pos += 2; return n }
-    if (info === 26) { const n = b.readUInt32BE(pos); pos += 4; return n }
-    if (info === 27) { const n = Number(b.readBigUInt64BE(pos)); pos += 8; return n }
-    throw new Error('cbor: indefinite or reserved length')
-  }
-  const item = () => {
-    if (pos >= b.length) throw new Error('cbor: truncated')
-    const ib = b[pos++]
-    const major = ib >> 5
-    const info = ib & 31
-    if (major === 7) {
-      if (info === 20) return false
-      if (info === 21) return true
-      if (info === 22) return null
-      throw new Error('cbor: unsupported simple value or float')
-    }
-    const n = arg(info)
-    switch (major) {
-      case 0: return n
-      case 1: return -1 - n
-      case 2: { const v = b.subarray(pos, pos + n); pos += n; if (v.length !== n) throw new Error('cbor: truncated'); return Buffer.from(v) }
-      case 3: { const v = b.toString('utf8', pos, pos + n); pos += n; if (pos > b.length) throw new Error('cbor: truncated'); return v }
-      case 4: { const a = []; for (let i = 0; i < n; i++) a.push(item()); return a }
-      case 5: { const o = {}; for (let i = 0; i < n; i++) { const k = item(); o[k] = item() } return o }
-      default: throw new Error(`cbor: unsupported major type ${major}`)
-    }
-  }
-  const v = item()
-  if (pos !== b.length) throw new Error('cbor: trailing bytes')
-  return v
-}

package/src/quilts/claims.js

@@ -1,144 +0,0 @@
-// Claims on a square's files (plans/quilt-source-control/06, "Claims on squares"): a claim says
-// "this square is working on these paths" so nobody else spends work on them. A write under a
-// claimed pattern from another open square on the same line is refused (412 claim_refused) and the
-// writer is told who holds it and why. A claim lasts while its square is open: merging, abandoning
-// or archiving the square lets go of it. Merges never check claims; overlapping work that was
-// written before a claim existed still meets at the merge (07).
-import { QuiltError, squareShort } from './errors.js'
-import { uuidv7 } from './ids.js'
-
-export const MAX_PATTERN = 500
-export const MAX_NOTE = 300
-export const MAX_CLAIMS = 200 // per square
-
-/** A path, folder or simple glob (*, **, ?) as a matcher over file paths. */
-export function globMatcher (pattern) {
-  const p = String(pattern).trim().replace(/^\.\//, '')
-  if (!/[*?]/.test(p)) {
-    const base = p.replace(/\/+$/, '')
-    return (rel) => rel === base || rel.startsWith(base + '/')
-  }
-  let re = ''
-  for (let i = 0; i < p.length; i++) {
-    const c = p[i]
-    if (c === '*' && p[i + 1] === '*') {
-      re += '.*'
-      i++
-      if (p[i + 1] === '/') i++
-    } else if (c === '*') re += '[^/]*'
-    else if (c === '?') re += '[^/]'
-    else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&')
-  }
-  const rx = new RegExp(`^${re}$`)
-  return (rel) => rx.test(rel)
-}
-
-/** Whether two patterns can cover the same file (paths: files that exist now). */
-export function patternsOverlap (a, b, paths = []) {
-  if (a === b) return true
-  const ma = globMatcher(a)
-  const mb = globMatcher(b)
-  if (ma(b) || mb(a) || paths.some((p) => ma(p) && mb(p))) return true
-  // A glob reaches every file under the text before its first wildcard: when one pattern's stem
-  // is inside the other's, they may meet on a file that does not exist yet.
-  const stem = (p) => p.split(/[*?]/)[0]
-  const [sa, sb] = [stem(a), stem(b)]
-  if (sa === a && sb === b) return false
-  const [short, long] = sa.length <= sb.length ? [sa, sb] : [sb, sa]
-  return short !== '' && (long.startsWith(short.endsWith('/') ? short : short + '/') || long === short)
-}
-
-/** A claim pattern: a relative path, folder or glob, no `..`. */
-export function claimPattern (raw) {
-  const p = String(raw || '').trim().replace(/^\.\//, '')
-  if (!p || p.length > MAX_PATTERN || p.startsWith('/') || p.split('/').includes('..') || p.includes('\0') || p.includes('\\')) {
-    throw new QuiltError(400, 'bad_request', `a claim is a relative path, folder or glob (*, **, ?), up to ${MAX_PATTERN} characters`)
-  }
-  return p
-}
-
-const ACTIVE = new Set(['open', 'merging'])
-
-/** The claims that still hold: those of open squares. */
-export async function liveClaims (store, q) {
-  const rows = await store.claims(q)
-  if (!rows.length) return []
-  const squares = new Map()
-  const out = []
-  for (const c of rows) {
-    if (!squares.has(c.square_id)) squares.set(c.square_id, await store.getSquare(c.square_id))
-    const sq = squares.get(c.square_id)
-    if (sq && ACTIVE.has(sq.state)) out.push({ ...c, line: sq.line })
-  }
-  return out
-}
-
-/** Refuses a write to `paths` from square `sq` when another open square on its line claims one. */
-export async function guardClaims (store, q, sq, paths) {
-  if (!paths.length) return
-  // A stacked square writes under its parents' claims (06): it builds on their work.
-  const mine = new Set([sq.id])
-  for (let p = sq; p.parent_square && mine.size <= 10;) { mine.add(p.parent_square); p = await store.getSquare(p.parent_square); if (!p) break }
-  const others = (await liveClaims(store, q)).filter((c) => !mine.has(c.square_id) && c.line === sq.line)
-  for (const c of others) {
-    const m = globMatcher(c.pattern)
-    const hit = paths.find((p) => m(p))
-    if (hit) {
-      throw new QuiltError(412, 'claim_refused', `${hit} is claimed by ${c.holder} in ${squareShort(c.square_id)}${c.note ? ` (${c.note})` : ''}: wait for it, ask them to hand it over, or work on other files`,
-        { path: hit, claim: view(c) })
-    }
-  }
-}
-
-const view = (c) => ({ id: c.id, pattern: c.pattern, square: squareShort(c.square_id), square_id: c.square_id, line: c.line, holder: c.holder, note: c.note || '', at: c.at })
-
-export function claimOps (svc) {
-  const { store, now, quiltFor, squareByRef, writable, entriesOf, snapshot, fromStore } = svc.internals
-
-  /** GET /claims[?square=]: the claims that hold now, oldest first. */
-  async function claims (me, ref, { square } = {}) {
-    const q = await quiltFor(me, ref, 'read')
-    let rows = await liveClaims(store, q.id)
-    if (square) { const sq = await squareByRef(q.id, square); rows = rows.filter((c) => c.square_id === sq.id) }
-    return { claims: rows.sort((a, b) => a.at - b.at).map(view) }
-  }
-
-  /** POST /squares/:id/claims { pattern, note? }: claims paths for the square. */
-  async function claim (me, ref, sqRef, body = {}) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    if (sq.state !== 'open') throw new QuiltError(409, 'square_closed', `the square is ${sq.state}`)
-    const pattern = claimPattern(body.pattern)
-    const note = String(body.note || '')
-    if (note.length > MAX_NOTE) throw new QuiltError(400, 'bad_request', `a claim's note is up to ${MAX_NOTE} characters`)
-    const all = await liveClaims(store, q.id)
-    const mine = all.filter((c) => c.square_id === sq.id)
-    const same = mine.find((c) => c.pattern === pattern)
-    if (same) return view(same)
-    if (mine.length >= MAX_CLAIMS) throw new QuiltError(400, 'bad_request', `a square holds up to ${MAX_CLAIMS} claims`)
-    const others = all.filter((c) => c.square_id !== sq.id && c.line === sq.line)
-    if (others.length) {
-      const tip = (await store.getLine(q.id, sq.line))?.tip || sq.base
-      const paths = tip ? (await entriesOf(q.id, await snapshot(q.id, tip))).map((e) => e.path) : []
-      const taken = others.find((c) => patternsOverlap(c.pattern, pattern, paths))
-      if (taken) throw new QuiltError(409, 'claim_taken', `${taken.pattern} is already claimed by ${taken.holder} in ${squareShort(taken.square_id)}${taken.note ? ` (${taken.note})` : ''}`, { claim: view(taken) })
-    }
-    try {
-      const row = await store.createClaim({ quilt_id: q.id, id: uuidv7(now()), square_id: sq.id, pattern, holder: me.member_id, note, at: now() })
-      return view({ ...row, line: sq.line })
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /** DELETE /squares/:id/claims/:claim (its id or its pattern): lets go of a claim. */
-  async function unclaim (me, ref, sqRef, which) {
-    const q = await quiltFor(me, ref, 'write')
-    const sq = await writable(me, q, sqRef)
-    const key = String(which || '').trim().replace(/^\.\//, '')
-    const c = (await store.claims(q.id)).find((x) => x.square_id === sq.id && (x.id === key || x.pattern === key))
-    if (!c) throw new QuiltError(404, 'not_found', `${squareShort(sq.id)} has no claim ${key}`)
-    try { await store.deleteClaim({ quilt_id: q.id, id: c.id }) } catch (err) { throw fromStore(err) }
-    return { ok: true, released: view({ ...c, line: sq.line }) }
-  }
-
-  return { claims, claim, unclaim }
-}