heyquilt 0.3.121 → 0.3.138

package/src/session-layout3.js

@@ -0,0 +1,466 @@
+// Quilt's side of Seam: the room's switch to layout 3 (Seam's plans/quilt-source-control/16, "How a
+// session becomes a quilt"). After the session became a quilt (session-migrate.js), each branch
+// document is copied into its square's live document on the relay (`quilt/<square id>`,
+// source-live/live-square.js), whose shape is an overlay: only the paths that differ from the
+// square's head. The default branch's difference from `main` goes to an adoption square. The copy
+// is checked against the branch document before `meta.layout = 3` is written; the branch
+// documents themselves stay where they are, read-only, so going back to layout 2 loses nothing.
+// Seam (src/quilts/) never imports this.
+import crypto from 'node:crypto'
+import path from 'node:path'
+import * as Y from 'yjs'
+import { blobId } from '@heyquilt/seam/lib/quilts/records.js'
+import { liveMaps, startHead, entryOf, entryId } from './source-live/live-square.js'
+import { makeIgnore, scopeIgnore, isIgnored, submodulePathsIn, IGNORE_FILES, MAX_TEXT_BYTES, MAX_BINARY_BYTES } from './pathrules.js'
+import { looksBinary, sha1 } from './fsutil.js'
+import { applyTextDiff } from './textdiff.js'
+import { sameEditClient, asClient } from './same-edit.js'
+import { removePath } from './branch-view.js'
+import { mergeAuto } from './merge3.js'
+
+export const LAYOUT_QUILT = 3
+
+// A branch file as the switch holds it: its text, or { blob, size?, bytes? } (branchFiles).
+const idOf = (v) => v && typeof v === 'object' ? v.blob : blobId(Buffer.from(String(v), 'utf8'))
+const has = (o, p) => Object.prototype.hasOwnProperty.call(o || {}, p)
+
+/** A Seam tree answer ({ entries: [{ path, blob, mode }] }) as path -> blob id (conflict terms by term id). */
+export function treeIds (tree) {
+  const out = {}
+  for (const e of (tree && tree.entries) || []) out[e.path] = e.blob || e.term || null
+  return out
+}
+
+/** The executable files and links of a Seam tree answer: path -> 'exec' | 'symlink'. */
+export function treeModes (tree) {
+  const out = {}
+  for (const e of (tree && tree.entries) || []) if (e.mode === 'exec' || e.mode === 'symlink') out[e.path] = e.mode
+  return out
+}
+
+/** What the session never syncs (fsutil.js loadIgnore), as the ignore files among `files` (path -> text) say. */
+export function docIgnore (files) {
+  const ig = makeIgnore()
+  // A submodule's folder is its own git's (fsutil.js loadIgnore).
+  if (typeof (files || {})['.gitmodules'] === 'string') for (const p of submodulePathsIn(files['.gitmodules'])) ig.add(`/${p}`)
+  for (const [p, t] of Object.entries(files || {})) {
+    if (typeof t !== 'string' || !IGNORE_FILES.includes(path.posix.basename(p))) continue
+    const dir = path.posix.dirname(p)
+    ig.add(scopeIgnore(t, dir === '.' ? '' : dir))
+  }
+  return (p) => isIgnored(ig, p)
+}
+
+/**
+ * A branch document's files as the switch compares them with a square's head (`tree`, Seam's
+ * answer): path -> text, or { blob, size, bytes } for a small binary the document holds, or
+ * { blob } (the head's) for a path the document leaves as the head has it. Those are what the
+ * session never syncs (links, submodules, ignored files, files too large for it), a large file in
+ * the session's storage (the relay can't read its bytes), and in a diff document every file it
+ * has no entry for (it follows git). Any other head path the document lacks is a deletion, but
+ * with `unheld` (a square that starts at main's tip for want of the branch's own commit) only one
+ * it held and let go of: main's work after the branch left it is not the branch's to delete.
+ */
+export function branchFiles (doc, tree, { diff = false, unheld = false } = {}) {
+  const head = treeIds(tree)
+  const entries = new Map(((tree && tree.entries) || []).map((e) => [e.path, e]))
+  const out = {}
+  const blobs = doc.getMap('blobs')
+  for (const [p, t] of doc.getMap('files')) out[p] = t.toString()
+  for (const [p, b] of blobs) {
+    if (has(out, p) || !b) continue
+    if (typeof b.data === 'string') { const bytes = Buffer.from(b.data, 'base64'); out[p] = { blob: blobId(bytes), size: bytes.length, bytes } } else if (head[p]) out[p] = { blob: head[p] }
+  }
+  const ignored = docIgnore(out)
+  // An untracked file the branch's ignore rules or Quilt's built-ins leave out (an agent's scratch
+  // folder, logs, supabase/.temp, .claude/settings.local.json) is local to the folder that has it, never
+  // a square's (Seam's 05: ignore rules gate untracked paths; 2026-11-01: 31 of them went into one).
+  for (const p of Object.keys(out)) if (!head[p] && ignored(p)) delete out[p]
+  // Nothing inside a submodule (a gitlink of the head, or a folder .gitmodules names): a document
+  // that took its files before they were left out (fsutil.js loadIgnore) never puts them in a square.
+  const subs = [...[...entries.values()].filter((e) => e.mode === 'gitlink').map((e) => e.path), ...(typeof out['.gitmodules'] === 'string' ? submodulePathsIn(out['.gitmodules']) : [])]
+  for (const p of Object.keys(out)) if (subs.some((d) => p.startsWith(`${d}/`))) delete out[p]
+  const gone = doc.getMap('gone')
+  const unsynced = (p) => {
+    const e = entries.get(p) || {}
+    return e.mode === 'symlink' || e.mode === 'gitlink' || (Number(e.size) || 0) > MAX_TEXT_BYTES || ignored(p)
+  }
+  const held = (p) => doc.getMap('files')._map.has(p) || blobs._map.has(p)
+  for (const p of Object.keys(head)) if (!has(out, p) && head[p] && (diff ? !gone.has(p) : unsynced(p) || (unheld && !held(p)))) out[p] = { blob: head[p] }
+  return out
+}
+
+/**
+ * The session's people (`members`: [{ key, role }]) become writers of a square its holder (or an
+ * admin) acts on through `client`, so their AIs, working for them, write there too: every person
+ * but the holder and viewers. What Seam refused: [{ member, why }] (one not in the quilt, a full square).
+ */
+export async function shareWithPeople (client, quilt, square, members) {
+  const s = await client.square(quilt, square)
+  const me = s && s.holder
+  const refused = []
+  for (const m of members) {
+    const id = m && m.key
+    if (!id || !String(id).startsWith('person:') || id === me || (s.writers || []).includes(id) || m.role === 'viewer') continue
+    await client.share(quilt, square, { member: id }).catch((err) => refused.push({ member: id, why: String(err.message || err).slice(0, 200) }))
+  }
+  return refused
+}
+
+/** git's id of a file's bytes (what `git hash-object` says), for finding them in git's history. */
+export const gitBlobId = (buf) => crypto.createHash('sha1').update(`blob ${buf.length}\0`).update(buf).digest('hex')
+
+/** The paths of `files` (branchFiles) that differ from `head`, with git's id of the branch's bytes: Map path -> git blob id. */
+export function changedGitIds (files, head) {
+  const out = new Map()
+  for (const [p, v] of Object.entries(files || {})) {
+    if (head[p] && head[p] === idOf(v)) continue
+    const buf = typeof v === 'string' ? Buffer.from(v, 'utf8') : v && v.bytes ? v.bytes : null
+    if (buf) out.set(p, gitBlobId(buf))
+  }
+  return out
+}
+
+/**
+ * `files` without the branch's older copies of main's files: a path whose bytes the branch holds are
+ * one of main's own earlier versions of it (`history`: path -> the git blob ids main's history gave
+ * it), main's tip having moved on, is the head's (gone, when the head has no such file). For a square
+ * that starts at main's tip for want of the branch's commit, where a full document names every
+ * file. A branch that put a file back as main once had it on purpose loses that: the head's stands.
+ */
+export function dropOldCopies (files, head, history) {
+  const out = { ...files }
+  for (const [p, id] of changedGitIds(files, head)) {
+    if (!(history.get(p) || new Set()).has(id)) continue
+    if (head[p]) out[p] = { blob: head[p] }; else delete out[p]
+  }
+  return out
+}
+
+/** The small binaries in `files` that differ from `head`: what Seam must hold before a live document names them. */
+export function binariesToUpload (files, head = {}) {
+  const out = []
+  for (const [p, v] of Object.entries(files || {})) if (v && typeof v === 'object' && v.bytes && head[p] !== v.blob) out.push({ kind: 'blob', id: v.blob, bytes: v.bytes })
+  return out
+}
+
+/** What turns `head` (path -> id) into `files` (path -> text): { puts: { path: text }, gone: [path] }. */
+export function overlayFor (files, head) {
+  const puts = {}
+  for (const [p, t] of Object.entries(files || {})) if (head[p] !== idOf(t)) puts[p] = t
+  const gone = Object.keys(head || {}).filter((p) => !has(files, p)).sort()
+  return { puts, gone }
+}
+
+/** Writes an overlay into an empty live document, with `head` as its first head. */
+export function writeOverlay (doc, { puts, gone }, head, by = '') {
+  const m = liveMaps(doc)
+  doc.transact(() => {
+    for (const [p, t] of Object.entries(puts)) {
+      if (t && typeof t === 'object') { m.blobs.set(p, { blob: t.blob, size: t.size || 0, mode: 'file' }); continue }
+      const y = new Y.Text(); y.insert(0, t); m.files.set(p, y)
+    }
+    for (const p of gone) m.gone.set(p, { by, ts: Date.now() })
+  }, 'relay-quilt')
+  if (head) startHead(doc, head, by)
+}
+
+/**
+ * The post-copy check (16, "Dry run and check"): the live document over its head holds exactly
+ * the branch document's files, by id. Returns null, or the first difference in words.
+ */
+export function checkOverlay (doc, files, head) {
+  const want = {}
+  for (const [p, t] of Object.entries(files || {})) want[p] = idOf(t)
+  const have = { ...head }
+  const m = liveMaps(doc)
+  for (const p of new Set([...m.files.keys(), ...m.blobs.keys(), ...m.gone.keys()])) {
+    const e = entryOf(doc, p)
+    if (!e) continue
+    if (e.op === 'delete') delete have[p]; else have[p] = entryId(e)
+  }
+  for (const p of new Set([...Object.keys(want), ...Object.keys(have)])) {
+    if (want[p] !== have[p]) return want[p] == null ? `${p} is in the square but not in the branch document` : have[p] == null ? `${p} is in the branch document but not in the square` : `${p} differs between the branch document and the square`
+  }
+  return null
+}
+
+// Branch-document maps that are bookkeeping for two authorities (16's table, "Dropped"): emptied
+// in a square's live copy. The kept branch documents still have them for a rollback.
+export const DROPPED_DOC_MAPS = ['changes', 'fromGithub', 'published']
+
+/**
+ * The live document as a copy of the branch document (16: "The Y.Doc is copied ..., so edit
+ * history inside it survives"), then made an overlay over `head` (path -> blob id): every text
+ * equal to head's is marked clean (the first commit drops it), a head path the branch lacks is
+ * marked gone, the branch's large-file entries and git bookkeeping leave, and `skip` paths (held
+ * by conflict terms in Seam) are taken out so head's term shows. `files` is the branch's files
+ * (branchFiles), as the check reads them; `modes` the head's (treeModes), so a changed executable
+ * stays one.
+ */
+export function copyIntoLive (doc, branchDoc, { files, head = {}, modes = {}, commit = null, by = '', skip = new Set() }) {
+  Y.applyUpdate(doc, Y.encodeStateAsUpdate(branchDoc), 'relay-quilt')
+  const m = liveMaps(doc)
+  doc.transact(() => {
+    // The branch's own binary entries leave (its large files, and small ones as base64); so does a
+    // binary this set before that the branch no longer changes (copied again), set again just below.
+    const changedBinary = (p) => { const v = files[p]; return !!(v && typeof v === 'object' && v.bytes && !skip.has(p) && head[p] !== v.blob) }
+    for (const p of [...m.blobs.keys()]) { const b = m.blobs.get(p); if (!b || !b.blob || !changedBinary(p)) m.blobs.delete(p) }
+    for (const name of DROPPED_DOC_MAPS) { const x = doc.getMap(name); for (const k of [...x.keys()]) x.delete(k) }
+    // A small binary the branch changed (its bytes are in Seam already: binariesToUpload).
+    for (const [p, v] of Object.entries(files)) if (changedBinary(p) && (m.blobs.get(p) || {}).blob !== v.blob) m.blobs.set(p, { blob: v.blob, size: v.size, mode: modes[p] === 'exec' ? 'exec' : 'file' })
+    // The session marks an executable file 'x'; a square says 'exec', and a text the branch changed keeps the head's mode.
+    for (const [p, v] of [...m.modes.entries()]) { if (v === 'x') m.modes.set(p, 'exec'); else if (v !== 'exec' && v !== 'symlink') m.modes.delete(p) }
+    for (const p of [...m.files.keys()]) {
+      if (skip.has(p)) { m.files.delete(p); continue }
+      // Not in the switch's files nor the head: a text the switch left out (dropOldCopies: main deleted it since), not work.
+      if (!has(files, p)) { if (!head[p]) m.files.delete(p); continue }
+      if (head[p] === idOf(files[p])) m.clean.set(p, { at: commit }); else {
+        if (m.clean.has(p)) m.clean.delete(p)
+        if (!m.modes.has(p) && modes[p] === 'exec') m.modes.set(p, 'exec')
+      }
+    }
+    for (const p of Object.keys(head)) if (!skip.has(p) && !has(files, p)) m.gone.set(p, { by, ts: Date.now() })
+    // Copied again (edits that came while the move waited): a path the branch has again is no longer gone;
+    // nor is one the head does not have (main deleted it already: as carryLive drops it after a merge).
+    for (const p of [...m.gone.keys()]) if ((has(files, p) && !skip.has(p)) || !head[p]) m.gone.delete(p)
+  }, 'relay-quilt')
+  if (commit) startHead(doc, commit, by)
+  // The head the copy is an overlay of: a write that still reaches the branch document is forwarded
+  // into the square only while the square is on it (server.js forwardToSquare, copiedHead).
+  if (commit) doc.transact(() => liveMaps(doc).live.set('copied', { commit, ts: Date.now() }), 'relay-quilt')
+}
+
+/**
+ * The head a square's live document was copied over from its branch document (copyIntoLive), or null.
+ * While the square is still on it, the branch document and the square agree on every file the folder
+ * did not change, so a write to the branch document is the folder's own change on the square's head too.
+ */
+export const copiedHead = (doc) => (doc.getMap('live').get('copied') || {}).commit || null
+
+/**
+ * After a branch's square merged (a merged square never changes again), its next square's live
+ * document carries on from the merged one: a copy of it (edit history kept) made an overlay over
+ * `head` (path -> blob id, the merged commit's tree, `commit` its id). What the merge already
+ * has leaves, as `seal` drops it, and so do clean marks (equal to the old head, not the new one,
+ * so keeping them would undo whatever else merged); work typed after the last commit stays.
+ */
+export function carryLive (doc, fromDoc, { head = {}, commit, by = '' }) {
+  Y.applyUpdate(doc, Y.encodeStateAsUpdate(fromDoc), 'relay-quilt')
+  const m = liveMaps(doc)
+  doc.transact(() => {
+    const drop = (p) => { for (const k of ['files', 'blobs', 'gone', 'modes', 'clean']) m[k].delete(p) }
+    for (const p of [...m.clean.keys()]) drop(p)
+    for (const p of new Set([...m.files.keys(), ...m.blobs.keys(), ...m.gone.keys()])) {
+      const e = entryOf(doc, p)
+      if (!e || (e.op === 'delete' ? !head[p] : head[p] === entryId(e))) drop(p)
+    }
+    m.live.set('head', { commit, by, ts: Date.now() })
+  }, 'relay-quilt')
+}
+
+// Room meta that is bookkeeping for git as an authority (16's table, "Dropped"). At layout 3 it
+// moves into meta.quilt.kept, and back on a rollback, so git-mode sync resumes as it was.
+export const GIT_META = ['sync', 'upstreams', 'remoteBranches', 'viewBranches', 'ciPending', 'pullTold', 'githubToken', 'githubSync', 'largeToRelay', 'recreateDeleted']
+const isGitMeta = (k) => GIT_META.includes(k) || k.startsWith('agentCommits')
+
+/** Takes git's bookkeeping out of `meta`: what was there, to put back with restoreGitMeta. */
+export function takeGitMeta (meta) {
+  const kept = {}
+  for (const k of Object.keys(meta)) if (isGitMeta(k)) { kept[k] = meta[k]; delete meta[k] }
+  return kept
+}
+
+export function restoreGitMeta (meta, kept) {
+  for (const [k, v] of Object.entries(kept || {})) if (isGitMeta(k)) meta[k] = v
+}
+
+/**
+ * Where a branch document's square starts in a quilt imported from the session's git remote: the
+ * imported commit of the ref's tip (`git:<sha>`, Seam resolves it through its translation table),
+ * a detached document's own commit (`@<sha>`), or main's tip when nothing names one (null).
+ */
+export function squareBase (key, meta) {
+  const at = /^@([0-9a-f]{7,64})$/.exec(String(key))
+  if (at) return `git:${at[1]}`
+  const up = meta && meta.upstreams && meta.upstreams[key]
+  if (up && /^[0-9a-f]{40,64}$/.test(String(up.sha || ''))) return `git:${up.sha}`
+  const b = meta && meta.branches && meta.branches[key]
+  if (b && /^[0-9a-f]{40,64}$/.test(String(b.base || ''))) return `git:${b.base}`
+  return null
+}
+
+/**
+ * Applies a member's Yjs update to a square's live document as the relay (`origin`), where the
+ * guard (server.js checkChange) never looks: `may(path)` says whether they may change a path, and an
+ * update that touches one they may not is undone whole (its structs stay, deleted, so the member's
+ * later updates still fit the document). { touched: [path], refused: [path] }.
+ */
+export function applyChecked (doc, update, may = () => true, origin = 'relay-forward') {
+  const m = liveMaps(doc)
+  const touched = new Set()
+  const seen = (tr) => {
+    if (tr.origin !== origin) return
+    for (const [type, keys] of tr.changed) {
+      if (type === m.files || type === m.blobs || type === m.gone || type === m.modes) { for (const k of keys) if (k != null) touched.add(k) } else if (type instanceof Y.Text && type.parent === m.files && type._item) touched.add(type._item.parentSub)
+    }
+  }
+  const um = new Y.UndoManager([m.files, m.blobs, m.gone, m.modes, m.clean], { trackedOrigins: new Set([origin]), captureTimeout: 0 })
+  doc.on('afterTransaction', seen)
+  try { Y.applyUpdate(doc, update, origin) } finally { doc.off('afterTransaction', seen) }
+  const refused = [...touched].filter((p) => !may(p))
+  if (refused.length) um.undo()
+  um.destroy()
+  return { touched: [...touched], refused }
+}
+
+/**
+ * A write that reached a branch's kept document at layout 3 from an app not yet following the
+ * branch's square (the moment between the switch and the app hearing it): applied to the square's
+ * live document instead, which is a copy of the branch document, so the update fits it, as far as
+ * its member may change those files (`may`, applyChecked). Each path it put loses a clean or gone
+ * mark (it is the member's edit now). Returns the paths it deleted (gone only when the square's head
+ * has them: the caller looks), binaries it can't keep (the branch document's bytes are not in Seam;
+ * the folder's block takes them in when it follows), and the paths it refused.
+ */
+export function forwardIntoLive (doc, update, { may, origin = 'relay-forward' } = {}) {
+  const m = liveMaps(doc)
+  const { touched, refused } = applyChecked(doc, update, may, origin)
+  if (refused.length) return { deleted: [], binaries: [], refused }
+  const deleted = []; const binaries = []
+  doc.transact(() => {
+    for (const p of touched) {
+      const b = m.blobs.get(p)
+      if (b && !b.blob) { m.blobs.delete(p); binaries.push(p); continue }
+      if (m.modes.get(p) === 'x') m.modes.set(p, 'exec') // the session marks an executable 'x'; a square says 'exec' (copyIntoLive)
+      if (m.files.has(p) || b) { m.clean.delete(p); m.gone.delete(p) } else deleted.push(p)
+    }
+  }, 'relay-quilt')
+  return { deleted, binaries, refused: [] }
+}
+
+/**
+ * Whether a Yjs update would change `doc`: content it lacks, or a deletion of what it still has.
+ * A read-only branch document's member is told only about a write that was really refused (the
+ * empty answer every app sends when it joins is no write).
+ */
+export function bringsNew (doc, update) {
+  const sv = Y.decodeStateVector(Y.encodeStateVector(doc))
+  const { structs, ds } = Y.decodeUpdate(update)
+  // Each struct by its own clock: Yjs's encodeStateVectorFromUpdate leaves out a client whose structs
+  // do not start at clock 0, which is every member typing on into a file the relay already has.
+  for (const s of structs) if (!(s instanceof Y.Skip) && s.id.clock + s.length > (sv.get(s.id.client) || 0)) return true
+  if (!ds || !ds.clients.size) return false
+  const have = Y.createDeleteSetFromStructStore(doc.store)
+  for (const [client, items] of ds.clients) {
+    for (const it of items) {
+      if (it.clock >= (sv.get(client) || 0)) continue
+      for (const c of [it.clock, Math.min(it.clock + it.len, sv.get(client) || 0) - 1]) if (!Y.isDeleted(have, Y.createID(client, c))) return true
+    }
+  }
+  return false
+}
+
+/**
+ * Going back (quiltUnswitch) with a square no folder follows any more: what its branch document
+ * lacks of it. `square` is the square's files (path -> { blob, mode }), `cur` the branch's
+ * (branchFiles over the same tree, so what the session never syncs reads as the square has it).
+ * { put: [{ path, blob, mode }], gone: [path], skip: [{ path, why }] }: links and submodules are
+ * never synced, nor what the branch's ignore files leave out.
+ */
+export function foldBack (square, cur) {
+  const ignored = docIgnore(cur)
+  const out = { put: [], gone: [], skip: [] }
+  for (const p of [...new Set([...Object.keys(square), ...Object.keys(cur)])].sort()) {
+    const want = square[p]
+    const have = has(cur, p) ? idOf(cur[p]) : null
+    if ((want ? want.blob : null) === have) continue
+    if (want && want.term) { out.skip.push({ path: p, why: 'a conflict the square had not settled' }); continue }
+    if (want && (want.mode === 'symlink' || want.mode === 'gitlink')) { out.skip.push({ path: p, why: `a ${want.mode === 'symlink' ? 'link' : 'submodule'}, which the session never syncs` }); continue }
+    if (ignored(p)) continue
+    if (want) out.put.push({ path: p, blob: want.blob, mode: want.mode || 'file' }); else out.gone.push(p)
+  }
+  return out
+}
+
+/**
+ * Writes what foldBack found into branch entry `e` (branchdocs.js), with `bytes` (blob id -> Buffer).
+ * A text is written as the folders write the square's work when they leave it (Session.leaveSquare,
+ * same-edit.js): under an id taken from the path, before and after, so a folder that brings the same
+ * work back later makes the very same edit and the text lands once. Returns the paths written and
+ * the ones it could not take ({ path, why }).
+ */
+export function writeFold (e, fold, bytes, by = '') {
+  const done = []; const left = []
+  e.doc.transact(() => {
+    for (const x of fold.put) {
+      const buf = bytes[x.blob]
+      if (!buf) { left.push({ path: x.path, why: 'Seam did not give its bytes' }); continue }
+      if (looksBinary(buf)) {
+        if (buf.length > MAX_BINARY_BYTES) { left.push({ path: x.path, why: `${Math.round(buf.length / 1048576)} MB, larger than the session keeps in a branch` }); continue }
+        e.files.delete(x.path)
+        e.blobs.set(x.path, { hash: sha1(buf), data: buf.toString('base64') })
+      } else {
+        if (buf.length > MAX_TEXT_BYTES) { left.push({ path: x.path, why: `${Math.round(buf.length / 1048576)} MB of text, larger than the session syncs` }); continue }
+        const text = buf.toString('utf8')
+        const before = e.files.has(x.path) ? e.files.get(x.path).toString() : null
+        e.blobs.delete(x.path)
+        asClient(e.doc, sameEditClient('square', x.path, before, text), () => {
+          let y = e.files.get(x.path)
+          if (!y) { y = new Y.Text(); e.files.set(x.path, y) }
+          applyTextDiff(y, text)
+        })
+      }
+      if (x.mode === 'exec') { if (e.modes.get(x.path) !== 'x') e.modes.set(x.path, 'x') } else if (e.modes.has(x.path)) e.modes.delete(x.path)
+      done.push(x.path)
+    }
+    for (const p of fold.gone) { removePath(e, p, { by }); done.push(p) }
+  }, 'relay-quilt')
+  return { done, left }
+}
+
+/** How far apart two texts are, line by line (lines one has that the other lacks, counted with repeats). */
+export function lineDistance (a, b) {
+  const count = new Map()
+  for (const l of String(a).split('\n')) count.set(l, (count.get(l) || 0) + 1)
+  let n = 0
+  for (const l of String(b).split('\n')) { const c = count.get(l) || 0; if (c) count.set(l, c - 1); else n++ }
+  for (const c of count.values()) n += c
+  return n
+}
+
+/**
+ * A boxed file at the move (a member's unfinished work the session held while every other folder kept
+ * git's copy): the branch document holds the box holder's whole file, on the main they had when they
+ * began, which may be far behind the square's head. Carried as it is, it would undo main's newer
+ * changes to the file in the square, and in every folder that follows it. `versions` are main's
+ * earlier versions of the file (from the head's history): the nearest to the box's copy is what it
+ * started from, and only the box's change from there goes onto `head` (the head's text). Returns the
+ * text for the square, or null when the box's copy already is the head plus its change (or nothing
+ * in the history is near enough to tell: then the copy stands, as before).
+ */
+export function boxOntoHead (box, head, versions) {
+  let base = null; let best = Infinity
+  for (const v of versions) { if (typeof v !== 'string') continue; const d = lineDistance(box, v); if (d < best) { best = d; base = v } }
+  if (base === null || base === head) return null
+  // Not the box's starting point unless the box's copy is nearer to it than to the head.
+  if (best >= lineDistance(box, head)) return null
+  return mergeAuto(base, box, head, { oursNewer: true }).text
+}
+
+/**
+ * Puts `texts` (path -> the square's text, boxOntoHead) into a square's live document after the
+ * move's copy (copyIntoLive): a path whose text is the head's is clean, any other is the square's work.
+ */
+export function writeIntoLive (doc, texts, head = {}, commit = null) {
+  const m = liveMaps(doc)
+  doc.transact(() => {
+    for (const [p, t] of Object.entries(texts)) {
+      m.gone.delete(p); m.blobs.delete(p)
+      let y = m.files.get(p)
+      if (!y) { y = new Y.Text(); m.files.set(p, y) }
+      applyTextDiff(y, t)
+      if (head[p] === idOf(t)) m.clean.set(p, { at: commit }); else m.clean.delete(p)
+    }
+  }, 'relay-quilt')
+}

package/src/session-migrate.js

@@ -0,0 +1,123 @@
+// Quilt's side of Seam: a session with no git remote becomes a quilt
+// (Seam's plans/quilt-source-control/16, "How a session becomes a quilt", "Without history").
+// It calls Seam through a client with the quiltClient shape (src/quilts/client.js), acting as
+// the session's owner, who becomes the quilt's admin. Seam (src/quilts/) never imports this.
+//
+//   1. a quilt named after the room (slug from the room, `-2`.. when taken);
+//   2. patch 1 on main: the default branch document's files, sealed in a square of the owner's
+//      and merged, message "Session <room> as of <date>";
+//   3. one square per other branch document, based at patch 1, whose live changes are its
+//      difference from patch 1 (so it shows as uncommitted work).
+//
+//   4. each open merge record (state open or editing) as a conflict term in its square's first
+//      commit (16's merges row): `ours` the opener's text, on the migrated square; `theirs` the
+//      session's text, naming patch 1's square and commit; the record's base as the remove. A
+//      default branch's open merges get a square of their own ('(default)'), as main is patch 1.
+//      Binary records, and records whose text stayed on the opener's disk, have nothing to put
+//      in a term: they are listed in `merges_left`.
+//
+// Small binaries (kept in the branch document as base64) go in with the texts: patch 1 carries
+// the default branch's, a branch's square its own. Files kept in storage (large files) have no
+// bytes on the relay; they are listed in `left_out` and stay in the session's storage.
+
+export const slugFor = (room) => String(room || '').toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 56) || 'session'
+
+const b64 = (text) => Buffer.from(String(text)).toString('base64')
+const put = (path, text) => ({ path, op: 'put', content: b64(text) })
+
+/** The changes that turn `base` ({ path: text }) into `files`; `bins` and `baseBins` ({ path: base64 }) are the small binaries of each. */
+export function changesFrom (base, files, bins = {}, baseBins = {}) {
+  const out = []
+  for (const [p, t] of Object.entries(files || {})) if (!base || base[p] !== t) out.push(put(p, t))
+  for (const [p, d] of Object.entries(bins || {})) if (!(p in (files || {})) && (!base || (baseBins || {})[p] !== d)) out.push({ path: p, op: 'put', content: String(d) })
+  const now = (p) => p in (files || {}) || p in (bins || {})
+  for (const p of new Set([...Object.keys(base || {}), ...(base ? Object.keys(baseBins || {}) : [])])) if (!now(p)) out.push({ path: p, op: 'delete' })
+  return out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
+}
+
+const taken = (e) => e && (e.status === 409 || e.code === 'conflict' || e.code === 'slug_taken' || /taken|exists|duplicate/i.test(String(e.message)))
+
+/**
+ * Makes the quilt. `defaultFiles`: { path: text } of the default branch document, `defaultBinaries`
+ * its small binaries ({ path: base64 }), `defaultModes` its executables ({ path: 'x' }); `branches`: [{ key, files: { path: text }, binaries? }] for the others; `leftOut`: paths with no text. Returns
+ * { quilt_id, slug, patch, squares: [{ from, id }], left_out }. A failure after the quilt was
+ * made throws with `quilt_id` on the error, so the caller can name it.
+ */
+export const DEFAULT_MERGES = '(default)'
+const OPEN = new Set(['open', 'editing'])
+
+/** The open merges of one branch → { terms: conflict changes, left: records with no text to carry }. */
+export function termsFor (merges, files, { square, patchSquare, patch }) {
+  const terms = []; const left = []; const seen = new Set()
+  for (const m of merges || []) {
+    if (!m || !OPEN.has(m.state) || seen.has(m.path)) continue
+    if (m.binary || m.local || (m.ours == null && !m.oursDeleted)) { left.push(m); continue }
+    seen.add(m.path)
+    const now = files && Object.prototype.hasOwnProperty.call(files, m.path) ? files[m.path] : null
+    if (now == null && m.oursDeleted) { left.push(m); continue } // both sides gone: nothing conflicts
+    terms.push({
+      path: m.path,
+      op: 'conflict',
+      reason: 'import',
+      base: m.base != null ? { content: b64(m.base) } : null,
+      ours: m.oursDeleted ? null : { content: b64(m.ours), from_square: square, ...(m.by ? { by: String(m.by) } : {}) },
+      theirs: now == null ? null : { content: b64(now), ...(patchSquare ? { from_square: patchSquare } : {}), ...(patch ? { from_commit: patch.commit } : {}) }
+    })
+  }
+  return { terms, left }
+}
+
+export async function makeQuiltWithoutHistory ({ seam, room, defaultFiles = {}, defaultBinaries = {}, defaultModes = {}, defaultMerges = [], branches = [], leftOut = [], date = new Date() }) {
+  const base = slugFor(room)
+  let q = null
+  for (let n = 1; !q && n <= 20; n++) {
+    const slug = n === 1 ? base : `${base}-${n}`
+    try { q = await seam.createQuilt({ slug, name: room }) } catch (e) { if (!taken(e) || n === 20) throw e }
+  }
+  try {
+    let patch = null
+    let patchSquare = null
+    // Executables keep their mode in patch 1 (the document marks them 'x').
+    const first = changesFrom(null, defaultFiles, defaultBinaries).map((c) => c.op === 'put' && defaultModes[c.path] === 'x' ? { ...c, mode: 'exec' } : c)
+    if (first.length) {
+      const day = new Date(date).toISOString().slice(0, 10)
+      const s = await seam.openSquare(q.id, { title: `Session ${room}` })
+      patchSquare = s.id
+      await seam.commit(q.id, s.id, { expect_head: null, message: `Session ${room} as of ${day}`, changes: first })
+      const m = await seam.merge(q.id, 'main', { square: s.id })
+      if (!m || !m.ok || !m.merged) throw Object.assign(new Error(`Seam did not merge patch 1: ${(m && ((m.refused && m.refused.detail) || m.error || m.code)) || "no answer"}`), { code: m && m.code })
+      patch = { no: m.merged.patch_no, commit: m.merged.commit }
+    }
+    const squares = []
+    const terms = []
+    const mergesLeft = []
+    // Open merges as terms in the square's first commit; the rest of its work stays live.
+    const carry = async (from, sq, merges, files) => {
+      const t = termsFor(merges, files, { square: sq, patchSquare, patch })
+      for (const m of t.left) mergesLeft.push({ from, path: m.path, id: m.id })
+      if (!t.terms.length) return new Set()
+      await seam.commit(q.id, sq, { expect_head: null, message: `Open merges from session ${room}: ${t.terms.map((x) => x.path).join(', ')}`.slice(0, 2000), changes: t.terms })
+      for (const x of t.terms) terms.push({ from, path: x.path, square: sq })
+      return new Set(t.terms.map((x) => x.path))
+    }
+    const defaultLeft = termsFor(defaultMerges, defaultFiles, {})
+    if (!defaultLeft.terms.length) for (const m of defaultLeft.left) mergesLeft.push({ from: DEFAULT_MERGES, path: m.path, id: m.id })
+    else {
+      const s = await seam.openSquare(q.id, { title: `Open merges from session ${room}` })
+      const held = await carry(DEFAULT_MERGES, s.id, defaultMerges, defaultFiles)
+      if (held.size) squares.push({ from: DEFAULT_MERGES, id: s.id })
+    }
+    for (const b of branches) {
+      const s = await seam.openSquare(q.id, { title: String(b.key).slice(0, 200) })
+      const held = await carry(b.key, s.id, b.merges, b.files)
+      const changes = changesFrom(defaultFiles, b.files, b.binaries, defaultBinaries).filter((c) => !held.has(c.path))
+      if (changes.length) await seam.setLive(q.id, s.id, { changes })
+      squares.push({ from: b.key, id: s.id })
+    }
+    return { quilt_id: q.id, slug: q.slug, patch, squares, terms, merges_left: mergesLeft, left_out: [...leftOut].sort() }
+  } catch (e) {
+    e.quilt_id = q.id
+    e.message = `${e.message} (quilt ${q.slug} was made but the session was not moved into it)`
+    throw e
+  }
+}