@heyquilt/seam 0.27.0 → 0.131.0

package/lib/quilts/client.js

@@ -1,6 +1,9 @@
 // The quilt API from a client (the CLI, the local MCP, the importer): one function per route.
 // A refusal throws an Error with the server's `code`, `status` and fields (head, terms, ...).
-import { buildPack } from './pack.js'
+import { buildPack, MAX_PACK } from './pack.js'
+import { chunkStream, manifestBuilder, CDC_THRESHOLD } from './fastcdc.js'
+import { idOf, idHasher } from './hash.js'
+import { decodeObjects } from './want.js'
 
 const enc = encodeURIComponent
 const qs = (o) => {
@@ -9,12 +12,42 @@ const qs = (o) => {
 }
 const pathPart = (p) => String(p).split('/').map(enc).join('/')
 
-export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch, timeoutMs = 120_000 }) {
+/** Raw bytes in one client pack before the uploader starts another (under pack.js's 64 MiB). */
+export const PACK_BYTES = 48 * 1024 * 1024
+// A pack this small goes inline (one POST /packs) even where the server signs uploads: a signed
+// upload costs three requests (target, PUT, sealed), and a few small files are most commits.
+export const INLINE_PACK_BYTES = 1024 * 1024
+// An upload this small skips POST /have and sends everything: the server keeps what it has.
+export const SKIP_HAVE_BYTES = 256 * 1024
+
+/** A streamed object's bytes whole, for a server that takes no chunks; over 64 MiB it is refused as buildPack refuses it, before any read. */
+async function wholeOf (o) {
+  if (o.bytes) return o.bytes
+  if (o.size > MAX_PACK) throw Object.assign(new Error(`${o.kind} ${String(o.id).slice(0, 12)} is ${o.size} bytes whole, over 64 MiB: store it in chunks (SEAM_CHUNKING=1)`), { code: 'pack_too_large' })
+  const parts = []
+  for await (const p of o.open()) parts.push(Buffer.from(p))
+  return Buffer.concat(parts)
+}
+
+/**
+ * `packBytes`: raw bytes in one uploaded pack (default 48 MiB); a large file is cut and sent as it
+ * is read, so the uploader holds about two packs' worth of it at most (10, streaming the cut).
+ */
+export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch, timeoutMs = 120_000, packBytes = PACK_BYTES, inlineBytes = INLINE_PACK_BYTES, skipHaveBytes = SKIP_HAVE_BYTES }) {
   const base = String(api || '').replace(/\/+$/, '')
-  if (!base) throw new Error('No quilt server: set QUILT_API (or sign in with `quilt login`).')
+  if (!base) throw new Error('No Seam server: set SEAM_API_URL (or sign in with `seam login`).')
   const auth = token ? (token.startsWith('QuiltPass ') ? token : `Bearer ${token}`) : null
 
-  async function call (method, route, body, { raw = false } = {}) {
+  async function call (method, route, body, opts = {}) {
+    // 202 deriving (08): the server is working the answer out; ask again after its Retry-After.
+    for (let tries = 0; ; tries++) {
+      const r = await once(method, route, body, opts)
+      if (!(r && r.code === 'deriving' && r.job) || tries >= 120) return r
+      await new Promise((resolve) => setTimeout(resolve, Math.min(5, Math.max(0.05, Number(r.retry_after) || 1)) * 1000))
+    }
+  }
+
+  async function once (method, route, body, { raw = false } = {}) {
     let res
     try {
       res = await fetchImpl(base + route, {
@@ -34,14 +67,109 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     return data
   }
 
+  // A route that answers bytes (a tarball): { bytes, name, commit }; a refusal is JSON as usual.
+  async function bytes (route, method = 'GET') {
+    let res
+    try {
+      res = await fetchImpl(base + route, { method, headers: auth ? { authorization: auth } : {}, signal: AbortSignal.timeout(timeoutMs) })
+    } catch (err) {
+      throw new Error(`Couldn't reach the quilt server at ${base} (${err?.cause?.code || err?.name || 'no answer'}).`)
+    }
+    if (!res.ok) {
+      const { error, ...extra } = (await res.json().catch(() => null)) || {}
+      throw Object.assign(new Error(error || `The quilt server answered ${res.status}.`), { status: res.status, ...extra })
+    }
+    const name = (/filename="([^"]+)"/.exec(res.headers.get('content-disposition') || '') || [])[1] || null
+    return { bytes: Buffer.from(await res.arrayBuffer()), name, commit: res.headers.get('x-seam-commit') }
+  }
+
   const Q = (q) => `/v1/quilts/${enc(q)}`
+  let chunksRefused = false // this server takes no client chunks (no SEAM_CHUNKING): ask once
+  let wantOff = false // this server answers no want-lists (POST /objects, 04): ask once, then /blobs
+  let signedOff = false // this server takes packs posted to /packs only (no SEAM_SIGNED_UPLOADS): ask once
+
+  /**
+   * A want-list (04): `list` is [{ id, kind? }] (≤ 1,000), answered as the objects' own bytes.
+   * Every object is checked against its id before it is handed on (a sealed quilt's blobs, a
+   * redaction's tombstone and a damaged file's are checked by whoever opens them).
+   */
+  async function want (q, list, rev) {
+    let res
+    try {
+      res = await fetchImpl(base + `${Q(q)}/objects`, { method: 'POST', headers: { ...(auth ? { authorization: auth } : {}), 'content-type': 'application/json' }, body: JSON.stringify({ want: list, ...(rev ? { rev } : {}) }), signal: AbortSignal.timeout(timeoutMs) })
+    } catch (err) {
+      throw new Error(`Couldn't reach the quilt server at ${base} (${err?.cause?.code || err?.name || 'no answer'}).`)
+    }
+    if (!res.ok) {
+      const { error, ...extra } = (await res.json().catch(() => null)) || {}
+      throw Object.assign(new Error(error || `The quilt server answered ${res.status}.`), { status: res.status, ...extra })
+    }
+    const { objects, trailer } = decodeObjects(Buffer.from(await res.arrayBuffer()))
+    const unchecked = new Set([...Object.keys(trailer.redacted || {}), ...(trailer.damaged || [])])
+    const out = new Map()
+    for (const o of objects) {
+      if (!(o.kind === 'blob' && (trailer.sealed || unchecked.has(o.id))) && idOf(o.kind, o.bytes) !== o.id) throw Object.assign(new Error(`the bytes the server sent for ${o.kind} ${o.id.slice(0, 12)} do not match its id`), { code: 'id_mismatch' })
+      out.set(o.id, o)
+    }
+    return { objects: out, missing: trailer.missing || [], later: trailer.later || [], redacted: trailer.redacted || {}, too_large: trailer.too_large || {}, damaged: trailer.damaged || [], sealed: !!trailer.sealed }
+  }
+
+  /** Files by id in /blobs's shape ({ blobs: { id: base64 }, redacted, too_large }), by want-list where the server answers one. */
+  async function wantBlobs (q, ids, rev) {
+    if (!wantOff) {
+      try {
+        const blobs = {}; const redacted = {}; const tooLarge = {}
+        // An id, or { id, path, ticket } (04 rule 7).
+        const asks = new Map(ids.map((x) => typeof x === 'string' ? [x, { id: x }] : [x.id, x]))
+        let left = [...asks.keys()]
+        while (left.length) {
+          const r = await want(q, left.map((id) => asks.get(id)), rev)
+          for (const [id, o] of r.objects) blobs[id] = o.bytes.toString('base64')
+          Object.assign(redacted, r.redacted); Object.assign(tooLarge, r.too_large)
+          if (!r.objects.size || !r.later.length) break
+          left = r.later
+        }
+        return { blobs, ...(Object.keys(redacted).length ? { redacted } : {}), ...(Object.keys(tooLarge).length ? { too_large: tooLarge } : {}) }
+      } catch (err) {
+        if (err.status !== 404 && err.status !== 405) throw err
+        wantOff = true
+      }
+    }
+    return call('POST', `${Q(q)}/blobs`, { ids: ids.map((x) => typeof x === 'string' ? x : x.id), ...(rev ? { rev } : {}) })
+  }
+
+  /**
+   * One pack up: by a signed PUT straight to object storage and then `sealed` (04 "Uploads"),
+   * where the server offers it, else posted to /packs. The Seam token never goes to storage.
+   */
+  async function sendPack (q, pack) {
+    if (!signedOff && pack.bytes.length > inlineBytes) {
+      let t
+      try { t = await call('POST', `${Q(q)}/packs/${enc(pack.id)}/target`, { bytes: pack.bytes.length }) } catch (err) { if (err.status !== 404 && err.status !== 405) throw err; t = { inline: true } }
+      if (t.inline) signedOff = true
+      else {
+        if (t.sealed) return
+        if (t.put_url) {
+          let res
+          try { res = await fetchImpl(t.put_url, { method: t.method || 'PUT', headers: { 'content-type': 'application/octet-stream', 'x-upsert': 'false' }, body: pack.bytes, signal: AbortSignal.timeout(timeoutMs) }) } catch (err) { throw new Error(`Couldn't reach object storage for pack ${pack.id.slice(0, 12)} (${err?.cause?.code || err?.name || 'no answer'}).`) }
+          // 409: the same bytes are there already (the key is their hash).
+          if (!res.ok && res.status !== 409) throw Object.assign(new Error(`Object storage answered ${res.status} to pack ${pack.id.slice(0, 12)}.`), { status: res.status })
+        }
+        await call('POST', `${Q(q)}/packs/${enc(pack.id)}/sealed`)
+        return
+      }
+    }
+    await call('POST', `${Q(q)}/packs`, pack.bytes, { raw: true })
+  }
+  let chunksSent = false // a chunk pack was taken: the probe is done
   return {
+    api: base,
     call,
     quilts: async () => (await call('GET', '/v1/quilts')).quilts,
     createQuilt: (b) => call('POST', '/v1/quilts', b),
     quilt: (q) => call('GET', Q(q)),
     addMember: (q, b) => call('POST', `${Q(q)}/members`, b),
-    squares: async (q, f = {}) => (await call('GET', `${Q(q)}/squares${qs({ state: f.state, mine: f.mine ? 1 : undefined, task: f.task })}`)).squares,
+    squares: async (q, f = {}) => (await call('GET', `${Q(q)}/squares${qs({ state: f.state, mine: f.mine ? 1 : undefined, hidden: f.hidden ? 1 : undefined, archived: f.archived ? 1 : undefined, task: f.task })}`)).squares,
     openSquare: (q, b) => call('POST', `${Q(q)}/squares`, b),
     square: (q, s) => call('GET', `${Q(q)}/squares/${enc(s)}`),
     commit: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/commit`, b),
@@ -50,10 +178,19 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     abandon: (q, s, b = {}) => call('POST', `${Q(q)}/squares/${enc(s)}/abandon`, b),
     squareMerged: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/merged`, b),
     reopen: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/reopen`, {}),
+    archive: (q, s, body = {}) => call('POST', `${Q(q)}/squares/${enc(s)}/archive`, body),
+    unarchive: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/unarchive`, {}),
+    hide: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/hide`, {}),
+    unhide: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/unhide`, {}),
+    editSquare: (q, s, b) => call('PATCH', `${Q(q)}/squares/${enc(s)}`, b),
+    share: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/share`, b),
+    unshare: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/unshare`, b),
     mergeSquare: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/merge`, b),
+    absorb: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/absorb`, b),
     fold: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/fold`, b),
     split: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/split`, b),
     rebase: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/rebase`, b),
+    reparent: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/reparent`, b),
     cherryPick: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/cherry-pick`, b),
     resolve: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/resolve`, b),
     lines: async (q) => (await call('GET', `${Q(q)}/lines`)).lines,
@@ -74,6 +211,10 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     exportPatches: (q, o = {}) => call('GET', `${Q(q)}/export/git${qs(o)}`),
     log: (q, o = {}) => call('GET', `${Q(q)}/log${qs(o)}`),
     sign: (q, rev, b) => call('POST', `${Q(q)}/commits/${enc(rev)}/signatures`, b),
+    blocks: (q, o = {}) => call('GET', `${Q(q)}/blocks${qs(o)}`),
+    openBlock: (q, b) => call('POST', `${Q(q)}/blocks`, b),
+    touchBlock: (q, id, b = {}) => call('POST', `${Q(q)}/blocks/${enc(id)}`, b),
+    closeBlock: (q, id) => call('DELETE', `${Q(q)}/blocks/${enc(id)}`),
     tokens: (q) => call('GET', `${Q(q)}/tokens`),
     createToken: (q, b) => call('POST', `${Q(q)}/tokens`, b),
     revokeToken: (q, id) => call('DELETE', `${Q(q)}/tokens/${enc(id)}`),
@@ -81,59 +222,205 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     addKey: (b) => call('POST', '/v1/signing-keys', b),
     removeKey: (key) => call('DELETE', `/v1/signing-keys/${enc(key)}`),
     describe: (q, rev) => call('GET', `${Q(q)}/describe${qs({ rev })}`),
+    watches: async (q, { all = false } = {}) => (await call('GET', `${Q(q)}/watches${qs({ all: all ? 1 : undefined })}`)).watches,
+    watch: (q, b) => call('POST', `${Q(q)}/watches`, b),
+    unwatch: (q, id) => call('DELETE', `${Q(q)}/watches/${enc(id)}`),
+    pipeline: (q, line, check) => call('GET', `${Q(q)}/lines/${enc(line)}/checks/${enc(check)}/pipeline`),
+    stopPipeline: (q, line, check) => call('POST', `${Q(q)}/lines/${enc(line)}/checks/${enc(check)}/pipeline/stop`, {}),
+    stack: (q, rev) => call('GET', `${Q(q)}/stack/${encodeURIComponent(rev || 'main')}`),
+    stackDiff: (q, from, to) => call('GET', `${Q(q)}/stack-diff${qs({ from, to })}`),
     mergeBase: (q, a, b) => call('GET', `${Q(q)}/merge-base${qs({ a, b })}`),
+    ancestor: (q, a, b) => call('GET', `${Q(q)}/ancestor${qs({ a, b })}`),
+    contains: (q, rev) => call('GET', `${Q(q)}/contains/${enc(rev)}`),
+    derivation: (q, job) => call('GET', `${Q(q)}/derivations/${enc(job)}`),
     grep: (q, o = {}) => call('GET', `${Q(q)}/grep${qs(o)}`),
     search: (o = {}) => call('GET', `/v1/search${qs(o)}`),
+    searchCode: (q, o = {}) => call('GET', `${Q(q)}/search${qs(o)}`),
     bisect: (q, b) => call('POST', `${Q(q)}/bisect`, b),
     linePatches: (q, line = 'main', o = {}) => call('GET', `${Q(q)}/lines/${encodeURIComponent(line)}/patches${qs(o)}`),
     diff: (q, o = {}) => call('GET', `${Q(q)}/diff${qs(o)}`),
-    resolutions: async (q, p) => (await call('GET', `${Q(q)}/resolutions${p ? `?path=${enc(p)}` : ''}`)).resolutions,
+    resolutions: async (q, p, { hunks = false } = {}) => (await call('GET', `${Q(q)}/resolutions${qs({ path: p || undefined, hunks: hunks ? 1 : undefined })}`)).resolutions,
     forgetResolution: (q, key) => call('DELETE', `${Q(q)}/resolutions/${enc(key)}`),
     reviews: (q, sq) => call('GET', `${Q(q)}/squares/${enc(sq)}/reviews`),
+    interdiff: (q, sq, o = {}) => call('GET', `${Q(q)}/squares/${enc(sq)}/interdiff${qs(o)}`),
     review: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/reviews`, b),
+    applySuggestion: (q, sq, r) => call('POST', `${Q(q)}/squares/${enc(sq)}/reviews/${enc(r)}/apply`, {}),
     reportSquareCheck: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/checks`, b),
     rerunCheck: (q, { check, square, line, commit }) => call('POST', square ? `${Q(q)}/squares/${enc(square)}/checks/${enc(check)}/rerun` : `${Q(q)}/lines/${enc(line || 'main')}/checks/${enc(check)}/rerun`, commit ? { commit } : {}),
     checkRuns: (q, o = {}) => call('GET', `${Q(q)}/checks${qs(o)}`),
+    squarePolicy: (q, sq, o = {}) => call('GET', `${Q(q)}/squares/${enc(sq)}/policy${qs(o)}`),
+    linePolicyVersions: (q, line) => call('GET', `${Q(q)}/lines/${enc(line)}/policy/versions`),
+    decideLinePolicy: (q, line, version, decision) => call('POST', `${Q(q)}/lines/${enc(line)}/policy/versions/${enc(version)}/${decision}`, {}),
+    confirmLinePolicy: (q, line, version, b) => call('POST', `${Q(q)}/lines/${enc(line)}/policy/versions/${enc(version)}/confirm`, b),
     linePolicy: (q, line) => call('GET', `${Q(q)}/lines/${enc(line)}/policy`),
     setLinePolicy: (q, line, b) => call('PUT', `${Q(q)}/lines/${enc(line)}/policy`, b),
     claims: async (q, square) => (await call('GET', `${Q(q)}/claims${square ? `?square=${enc(square)}` : ''}`)).claims,
     claim: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/claims`, b),
+    requestClaim: (q, b) => call('POST', `${Q(q)}/claims/requests`, b),
+    withdrawRequest: (q, id) => call('DELETE', `${Q(q)}/claims/requests/${enc(id)}`),
+    handoffClaim: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/claims/handoff`, b),
+    finishClaims: (q, sq, b = {}) => call('POST', `${Q(q)}/squares/${enc(sq)}/claims/finish`, b),
     unclaim: (q, sq, which) => call('DELETE', `${Q(q)}/squares/${enc(sq)}/claims/${enc(which)}`),
     live: (q, sq) => call('GET', `${Q(q)}/squares/${enc(sq)}/live`),
+    liveJoin: (q, sq, member) => call('GET', `${Q(q)}/squares/${enc(sq)}/live/join${member ? `?member=${enc(member)}` : ''}`),
     setLive: (q, sq, body) => call('PUT', `${Q(q)}/squares/${enc(sq)}/live`, body),
-    tree: (q, rev, paths) => call('GET', `${Q(q)}/tree/${enc(rev || 'main')}${qs({ paths })}`),
+    patchLive: (q, sq, body) => call('PATCH', `${Q(q)}/squares/${enc(sq)}/live`, body),
+    exitArchive: (q) => bytes(`${Q(q)}/exit/archive`, 'POST'),
+    tarball: (q, rev, { paths } = {}) => bytes(`${Q(q)}/tarball/${enc(rev || 'main')}${qs({ paths })}`),
+    tree: (q, rev, paths, { nodes = false } = {}) => call('GET', `${Q(q)}/tree/${enc(rev || 'main')}${qs({ paths, ...(nodes ? { nodes: 1, classes: 1 } : {}) })}`),
     cat: (q, rev, path, o = {}) => call('GET', `${Q(q)}/blob/${enc(rev || 'main')}/${pathPart(path)}${qs(o)}`),
-    blame: (q, rev, path) => call('GET', `${Q(q)}/blame/${enc(rev || 'main')}/${pathPart(path)}`),
+    /**
+     * A file's bytes as they stream (cat with raw, 10): { body (async iterable of bytes), size,
+     * blob, stone, sealed }. Nothing is held: the caller reads `body` as it comes. A body that
+     * fails part way throws as it is read. The time limit covers the answer's start, not its bytes.
+     */
+    async catRaw (q, rev, path) {
+      const ctl = new AbortController()
+      const timer = setTimeout(() => ctl.abort(), timeoutMs)
+      let res
+      try {
+        res = await fetchImpl(base + `${Q(q)}/blob/${enc(rev || 'main')}/${pathPart(path)}?raw=1`, { headers: auth ? { authorization: auth } : {}, signal: ctl.signal })
+      } catch (err) {
+        throw new Error(`Couldn't reach the quilt server at ${base} (${err?.cause?.code || err?.name || 'no answer'}).`)
+      } finally { clearTimeout(timer) }
+      const type = res.headers.get('content-type') || ''
+      if (!res.ok || type.startsWith('application/json')) {
+        const data = await res.json().catch(() => null)
+        if (!res.ok) {
+          const { error, ...extra } = data || {}
+          throw Object.assign(new Error(error || `The quilt server answered ${res.status}.`), { status: res.status, ...extra })
+        }
+        // A server from before raw reads answers cat's JSON: its content is the file.
+        const bytes = Buffer.from(data?.content || '', 'base64')
+        return { body: [bytes], size: bytes.length, blob: data?.blob || null, stone: data?.redacted ? 'redacted' : null, sealed: !!data?.sealed }
+      }
+      return { body: res.body || [], size: Number(res.headers.get('content-length')), blob: res.headers.get('x-seam-blob'), stone: res.headers.get('x-seam-stone'), sealed: res.headers.get('x-seam-sealed') === '1' }
+    },
+    blame: (q, rev, path, { range, ignore, moves, reverse } = {}) => call('GET', `${Q(q)}/blame/${enc(rev || 'main')}/${pathPart(path)}${qs({ range: range ? [].concat(range).join(',') : undefined, ignore, moves: moves ? 1 : undefined, reverse })}`),
     have: (q, ids) => call('POST', `${Q(q)}/have`, { ids }),
-    blobs: (q, ids) => call('POST', `${Q(q)}/blobs`, { ids }),
+    blobs: (q, ids, rev) => call('POST', `${Q(q)}/blobs`, { ids, ...(rev ? { rev } : {}) }),
+    want,
+    wantBlobs,
+    protections: (q) => call('GET', `${Q(q)}/protections`),
+    setProtections: (q, rows) => call('PUT', `${Q(q)}/protections`, { rows }),
+    teams: (q) => call('GET', `${Q(q)}/teams`),
+    setTeam: (q, name, members) => call('PUT', `${Q(q)}/teams/${enc(name)}`, { members }),
+    agentTokens: (q) => call('GET', `${Q(q)}/agent-tokens`),
+    agents: () => call('GET', '/v1/agents'),
+    createAgent: (b) => call('POST', '/v1/agents', b),
+    createAgentToken: (q, b) => call('POST', `${Q(q)}/agent-tokens`, b),
+    revokeAgentToken: (q, id) => call('DELETE', `${Q(q)}/agent-tokens/${enc(id)}`),
+    orgs: () => call('GET', '/v1/orgs'),
+    createOrg: (b) => call('POST', '/v1/orgs', b),
+    org: (o) => call('GET', `/v1/orgs/${enc(o)}`),
+    orgLog: (o, { limit, before } = {}) => call('GET', `/v1/orgs/${enc(o)}/log${qs({ limit, before })}`),
+    // A member id, or the email of a person who has signed in to Seam.
+    setOrgTeam: (o, name, members) => call('PUT', `/v1/orgs/${enc(o)}/teams/${enc(name)}`, { members }),
+    setOrgMember: (o, member, role) => String(member).includes('@') ? call('POST', `/v1/orgs/${enc(o)}/members`, { email: member, role }) : call('PUT', `/v1/orgs/${enc(o)}/members/${enc(member)}`, { role }),
+    setQuiltOwner: (q, org) => call('PUT', `${Q(q)}/owner`, { org }),
+    setAgentsMakeLines: (q, allow) => call('PUT', `${Q(q)}/agents-make-lines`, { allow }),
+    setPublic: (q, value) => call('PUT', `${Q(q)}/public`, { public: value }),
+    setSealed: (q, value) => call('PUT', `${Q(q)}/sealed`, { sealed: value }),
+    setMigrationsDir: (q, dir) => call('PUT', `${Q(q)}/migrations-dir`, { dir }),
+    setInfraPaths: (q, paths) => call('PUT', `${Q(q)}/infra-paths`, { paths }),
+    setOwnerIdleHours: (q, hours) => call('PUT', `${Q(q)}/owner-idle-hours`, { hours }),
+    publicReads: (q) => call('GET', `${Q(q)}/public-reads`),
+    setSecretScanning: (q, mode) => call('PUT', `${Q(q)}/secret-scanning`, { mode }),
+    addSealingKey: (publicKey) => call('PUT', '/v1/me/sealing-keys', { public_key: publicKey }),
+    sealingKeys: (member) => call('GET', `/v1/sealing-keys${qs({ member })}`),
+    seal: (q) => call('GET', `${Q(q)}/seal`),
+    grantSeal: (q, wraps) => call('PUT', `${Q(q)}/seal/wraps`, { wraps }),
+    rotateSeal: (q, version, wraps) => call('POST', `${Q(q)}/seal/rotate`, { version, wraps }),
+    redact: (q, b) => call('POST', `${Q(q)}/redact`, b),
+    redactions: (q) => call('GET', `${Q(q)}/redactions`),
+    metrics: (q) => call('GET', `${Q(q)}/metrics`),
+    attestations: (q, o = {}) => call('GET', `${Q(q)}/attestations${qs(o)}`),
+    verify: (q, o = {}) => call('GET', `${Q(q)}/verify${qs(o)}`),
+    attestationKeys: () => call('GET', '/.well-known/seam-keys.json'),
+    access: (q, path = '') => call('GET', `${Q(q)}/access${qs({ path })}`),
+    reportMismatch: (q, id) => call('POST', `${Q(q)}/sealed/mismatch`, { id }),
     uploadPack: (q, bytes) => call('POST', `${Q(q)}/packs`, bytes, { raw: true }),
     importCommits: (q, items, lines = []) => call('POST', `${Q(q)}/import/commits`, { items, ...(lines.length ? { lines } : {}) }),
+    importEmails: (q, emails) => call('POST', `${Q(q)}/import/emails`, { emails }),
     importKnown: (q, shas) => call('POST', `${Q(q)}/import/known`, { shas }),
     setExport: (q, b) => call('PUT', `${Q(q)}/export`, b),
     exportStatus: (q) => call('GET', `${Q(q)}/export`),
     startImport: (b) => call('POST', '/v1/imports', b),
     github: () => call('GET', '/v1/github'),
     importGithub: (b) => call('POST', '/v1/github/import', b),
+    answerImportAuthors: (id, b) => call('POST', `/v1/imports/${enc(id)}/authors`, b),
     importStatus: (id) => call('GET', `/v1/imports/${enc(id)}`),
     cutover: (id, b = {}) => call('POST', `/v1/imports/${enc(id)}/cutover`, b),
     pokeImport: (id) => call('POST', `/v1/imports/${enc(id)}/poke`),
 
     /**
-     * Uploads objects the server does not have yet ([{ kind, id, bytes }]), in packs of at most
-     * ~48 MiB, after asking `have` (04: want-only, one pack per commit for a typical commit).
+     * Uploads objects the server does not have yet, in packs of at most `packBytes` raw, after
+     * asking `have` (04: want-only, one pack per commit for a typical commit). An object is
+     * { kind, id, bytes }, or a file too large to hold, { kind: 'blob', id, size, open }, where
+     * open() gives its bytes as an async iterable of pieces (fs.createReadStream).
      */
     async upload (q, objs) {
-      const missing = new Set()
-      for (let i = 0; i < objs.length; i += 10000) for (const id of (await call('POST', `${Q(q)}/have`, { ids: objs.slice(i, i + 10000).map((o) => o.id) })).missing) missing.add(id)
-      const todo = objs.filter((o) => missing.has(o.id))
-      let batch = []; let size = 0; let packs = 0
-      const flush = async () => { if (!batch.length) return; await call('POST', `${Q(q)}/packs`, buildPack(batch).bytes, { raw: true }); packs++; batch = []; size = 0 }
-      for (const o of todo) {
-        if (size + o.bytes.length > 48 * 1024 * 1024) await flush()
+      const missingIds = async (ids) => {
+        const missing = new Set()
+        for (let i = 0; i < ids.length; i += 10000) for (const id of (await call('POST', `${Q(q)}/have`, { ids: ids.slice(i, i + 10000) })).missing) missing.add(id)
+        return missing
+      }
+      const missingOf = async (list) => { const m = await missingIds(list.map((o) => o.id)); return list.filter((o) => m.has(o.id)) }
+      const small = objs.every((o) => o.bytes) && objs.reduce((n, o) => n + o.bytes.length, 0) <= skipHaveBytes
+      let todo = small ? objs : await missingOf(objs)
+      let batch = []; let size = 0; let packs = 0; let chunked = 0
+      const flush = async () => { if (!batch.length) return; const pack = buildPack(batch); batch = []; size = 0; await sendPack(q, pack); packs++ }
+      const add = async (o) => {
+        if (size + o.bytes.length > packBytes) await flush()
         batch.push(o); size += o.bytes.length
       }
+      // 10: a file over 1 MiB goes as its chunks, only those the quilt lacks, when the server takes
+      // them (SEAM_CHUNKING). It is cut as it is read: chunks wait in `pending` until a pack's worth
+      // is in, `have` says which are missing, and those go in the next pack, so only about two packs
+      // of the file are ever held. The very first chunk travels alone, so a server without the flag
+      // refuses a small pack, and every file then goes whole as before. A sealed file's id is keyed,
+      // so it never matches the cut and goes whole too.
+      const sendChunked = async (o) => {
+        const whole = idHasher('blob')
+        const manifests = manifestBuilder()
+        let pending = []; let held = 0
+        const drain = async () => {
+          const list = pending; pending = []; held = 0
+          const seen = new Set()
+          const missing = await missingIds([...new Set(list.map((e) => e.id))])
+          for (const e of list) {
+            if (seen.has(e.id) || !missing.has(e.id)) continue
+            seen.add(e.id)
+            if (!chunksSent && e.kind === 'chunk') { await flush(); batch = [e]; await flush(); chunksSent = true; continue }
+            await add(e)
+          }
+        }
+        const pieces = async function * () { for await (const p of o.open ? o.open() : [o.bytes]) { whole.update(p); yield p } }
+        for await (const c of chunkStream(pieces())) {
+          pending.push({ kind: 'chunk', id: c.id, bytes: c.bytes }); held += c.size
+          const leaf = manifests.add(c)
+          if (leaf) pending.push({ kind: 'manifest', id: leaf.id, bytes: leaf.bytes })
+          if (held >= packBytes) await drain()
+        }
+        if (whole.digest() !== o.id || (o.size != null && whole.size !== o.size)) throw Object.assign(new Error(`a file (blob ${o.id.slice(0, 12)}) changed while it was being uploaded: commit again`), { code: 'changed_during_upload' })
+        const root = manifests.finish()
+        for (const m of root.manifests) pending.push({ kind: 'manifest', id: m.id, bytes: m.bytes })
+        await drain()
+        await add({ kind: 'chunked', id: o.id, bytes: root.bytes }); await flush()
+      }
+      for (const o of todo.filter((x) => x.kind === 'blob' && (x.bytes ? x.bytes.length : x.size) > CDC_THRESHOLD)) {
+        if (chunksRefused) break
+        if (o.bytes && idOf('blob', o.bytes) !== o.id) continue
+        try { await sendChunked(o) } catch (err) {
+          batch = []; size = 0
+          if (err.code !== 'pack_corrupt') throw err
+          chunksRefused = true; break
+        }
+        todo = todo.filter((x) => x !== o); chunked++
+      }
+      for (const o of todo) await add(o.bytes ? o : { kind: o.kind, id: o.id, bytes: await wholeOf(o) })
       await flush()
-      return { uploaded: todo.length, packs }
+      return { uploaded: todo.length + chunked, packs, ...(chunked ? { chunked } : {}) }
     }
   }
 }