@threadedstack/wmd-web 0.0.0-stage → 0.1.13

package/src/fs/pack-write.js

@@ -0,0 +1,165 @@
+// W62: a writer for wmd's pack format (internal/pack/pack.go Writer), byte-compatible with
+// the Go writer for the entries it takes: no sparse runs (the JS reader has none either), so
+// a file's contents are all at its entry's off.
+//
+// writePack(entries) -> Uint8Array. An entry is {path (byte string, '' the root), whiteout?,
+// opaque?, mode, uid, gid, rdev, atime, mtime, ctime (BigInt ns), size, data? (Uint8Array, or
+// a function (off, len) -> Uint8Array for a regular file's contents), target, link, xattrs
+// (Map name -> Uint8Array)}. Entries with the same non-zero link share the first one's
+// contents (pass data on the first only). The index is sorted by path as Go sorts it (byte
+// order), and a path added twice is an error, as Go's Close says.
+
+import { MAGIC, S_IFMT, S_IFREG, bytesOf } from './pack.js'
+
+const FLAG_WHITEOUT = 1
+const FLAG_OPAQUE = 2
+const READ_CHUNK = 1 << 20
+
+class Bytes {
+  constructor(n = 1 << 16) {
+    this.b = new Uint8Array(n)
+    this.n = 0
+  }
+
+  room(k) {
+    if (this.n + k <= this.b.length) return
+    let len = this.b.length * 2
+    while (len < this.n + k) len *= 2
+    const g = new Uint8Array(len)
+    g.set(this.b.subarray(0, this.n))
+    this.b = g
+  }
+
+  byte(x) {
+    this.room(1)
+    this.b[this.n++] = x
+  }
+
+  raw(u8) {
+    this.room(u8.length)
+    this.b.set(u8, this.n)
+    this.n += u8.length
+  }
+
+  // Go's binary.AppendUvarint (x a Number up to 2^53 or a BigInt up to 2^64)
+  uvarint(x) {
+    if (typeof x === 'number' && x < 2 ** 31) {
+      if (x < 0) throw new RangeError(`uvarint ${x}`)
+      while (x >= 0x80) {
+        this.byte((x & 0x7f) | 0x80)
+        x >>>= 7
+      }
+      this.byte(x)
+      return
+    }
+    let v = BigInt(x)
+    if (v < 0n || v >= 1n << 64n) throw new RangeError(`uvarint ${x}`)
+    while (v >= 0x80n) {
+      this.byte(Number(v & 0x7fn) | 0x80)
+      v >>= 7n
+    }
+    this.byte(Number(v))
+  }
+
+  // Go's binary.AppendVarint: zig-zag
+  varint(x) {
+    const v = BigInt(x)
+    if (v < -(1n << 63n) || v >= 1n << 63n) throw new RangeError(`varint ${x}`)
+    this.uvarint(v < 0n ? (-v << 1n) - 1n : v << 1n)
+  }
+
+  str(s) {
+    const u8 = typeof s === 'string' ? bytesOf(s) : s
+    this.uvarint(u8.length)
+    this.raw(u8)
+  }
+
+  done() {
+    return this.b.subarray(0, this.n)
+  }
+}
+
+// a byte string's order is code unit order (pack.js), the order Go sorts its index in
+const byPath = (a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
+
+/** The pack holding entries, as bytes. */
+export function writePack(entries) {
+  const ents = entries.map(e => ({ ...e, path: cleanPath(e.path) }))
+  const data = new Bytes(1 << 20)
+  data.raw(bytesOf(MAGIC))
+  const linked = new Map() // link -> {off, size}
+  for (const e of ents) {
+    e.off = 0
+    if (e.whiteout || ((e.mode >>> 0) & S_IFMT) !== S_IFREG) continue
+    const had = e.link ? linked.get(e.link) : undefined
+    if (had) {
+      e.off = had.off
+      e.size = had.size
+      continue
+    }
+    const size = e.size || 0
+    e.off = data.n
+    if (size > 0) {
+      if (typeof e.data === 'function') {
+        for (let o = 0; o < size; o += READ_CHUNK) {
+          const want = Math.min(READ_CHUNK, size - o)
+          const got = e.data(o, want)
+          if (got.length !== want) throw new Error(`pack ${JSON.stringify(e.path)}: read ${got.length} of ${want} bytes at ${o}`)
+          data.raw(got)
+        }
+      } else {
+        if (!e.data || e.data.length !== size) throw new Error(`pack ${JSON.stringify(e.path)}: ${e.data ? e.data.length : 0} bytes of data for size ${size}`)
+        data.raw(e.data)
+      }
+    }
+    if (e.link) linked.set(e.link, { off: e.off, size })
+  }
+  ents.sort(byPath)
+  for (let i = 1; i < ents.length; i++) {
+    if (ents[i].path === ents[i - 1].path) throw new Error(`pack: ${JSON.stringify(ents[i].path)} added twice`)
+  }
+  const start = data.n
+  data.uvarint(ents.length)
+  for (const e of ents) entry(data, e)
+  const len = data.n - start
+  const foot = new Uint8Array(16)
+  const dv = new DataView(foot.buffer)
+  dv.setBigUint64(0, BigInt(start), true)
+  dv.setBigUint64(8, BigInt(len), true)
+  data.raw(foot)
+  data.raw(bytesOf(MAGIC))
+  return data.done().slice()
+}
+
+function cleanPath(p) {
+  const parts = []
+  for (const s of p.split('/')) {
+    if (s === '' || s === '.') continue
+    if (s === '..') parts.pop()
+    else parts.push(s)
+  }
+  return parts.join('/')
+}
+
+function entry(w, e) {
+  w.str(e.path)
+  w.byte((e.whiteout ? FLAG_WHITEOUT : 0) | (e.opaque ? FLAG_OPAQUE : 0))
+  if (e.whiteout) return
+  w.uvarint(e.mode >>> 0)
+  w.uvarint((e.uid || 0) >>> 0)
+  w.uvarint((e.gid || 0) >>> 0)
+  w.uvarint(e.rdev || 0)
+  w.varint(e.atime || 0n)
+  w.varint(e.mtime || 0n)
+  w.varint(e.ctime || 0n)
+  w.varint(e.size || 0)
+  w.varint(e.off || 0)
+  w.str(e.target || '')
+  w.uvarint(e.link || 0)
+  const keys = e.xattrs ? [...e.xattrs.keys()].sort() : []
+  w.uvarint(keys.length)
+  for (const k of keys) {
+    w.str(k)
+    w.str(e.xattrs.get(k))
+  }
+}

package/src/fs/pack.js

@@ -0,0 +1,427 @@
+// Reader for wmd's pack format (internal/pack/pack.go), byte-compatible with
+// the Go reader.
+//
+// A pack is one image layer in one file:
+//
+//   magic "WMDPACK1"
+//   data   (each regular file's contents at its entry's off)
+//   index  (uvarint count, then the entries, sorted by path)
+//   footer (index offset u64 LE, index length u64 LE, magic)
+//
+// An entry is: path (uvarint length + bytes), flags (1 byte: 1 whiteout,
+// 2 opaque) and, unless it is a whiteout, mode, uid, gid, rdev (uvarints),
+// atime, mtime, ctime, size, off (zig-zag varints), target (string), link
+// (uvarint) and the xattrs (uvarint count, then name and value strings).
+//
+// Names are kept as "byte strings": one UTF-16 code unit per byte (Latin-1),
+// so any byte sequence a Linux name can hold round-trips exactly and string
+// order is byte order, the order Go sorts the index in. bytesOf/strOf convert.
+
+export const MAGIC = 'WMDPACK1'
+
+// Linux file types (st_mode & S_IFMT).
+export const S_IFMT = 0o170000
+export const S_IFREG = 0o100000
+export const S_IFDIR = 0o040000
+export const S_IFLNK = 0o120000
+export const S_IFIFO = 0o010000
+export const S_IFSOCK = 0o140000
+export const S_IFCHR = 0o020000
+export const S_IFBLK = 0o060000
+
+const FLAG_WHITEOUT = 1
+const FLAG_OPAQUE = 2
+
+export class PackFormatError extends Error {}
+
+/** A byte string (one char per byte) from bytes. */
+export function strOf(u8) {
+  let s = ''
+  for (let i = 0; i < u8.length; i += 8192) {
+    s += String.fromCharCode.apply(null, u8.subarray(i, i + 8192))
+  }
+  return s
+}
+
+/** The bytes of a byte string. Chars above 0xff are not bytes: an error. */
+export function bytesOf(s) {
+  const out = new Uint8Array(s.length)
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i)
+    if (c > 0xff) throw new RangeError('not a byte string')
+    out[i] = c
+  }
+  return out
+}
+
+/** A UTF-8 JavaScript string as a byte string. */
+export function byteStr(utf8) {
+  return strOf(new TextEncoder().encode(utf8))
+}
+
+/** A random access source over bytes held in memory. */
+export function bytesSource(u8) {
+  return {
+    size: u8.length,
+    read(off, len) {
+      return u8.subarray(off, Math.min(off + len, u8.length))
+    },
+  }
+}
+
+/** A source over an OPFS FileSystemSyncAccessHandle (Worker only). */
+export function syncHandleSource(handle) {
+  return {
+    size: handle.getSize(),
+    read(off, len) {
+      const b = new Uint8Array(len)
+      const n = handle.read(b, { at: off })
+      return n === len ? b : b.subarray(0, n)
+    },
+  }
+}
+
+/** Linux's device number for major and minor (new_encode_dev). */
+export function makedev(major, minor) {
+  return (major & 0xfff) * 256 + Math.floor(major / 4096) * 2 ** 44 + (minor & 0xff) + Math.floor(minor / 256) * 2 ** 20
+}
+
+/** A Linux device number's major. */
+export function major(dev) {
+  dev = BigInt(dev)
+  return Number(((dev >> 8n) & 0xfffn) | ((dev >> 32n) & ~0xfffn))
+}
+
+/** A Linux device number's minor. */
+export function minor(dev) {
+  dev = BigInt(dev)
+  return Number((dev & 0xffn) | ((dev >> 12n) & 0xffffff00n))
+}
+
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER)
+
+class Decoder {
+  constructor(b) {
+    this.b = b
+    this.p = 0
+  }
+
+  bad() {
+    throw new PackFormatError('not a pack')
+  }
+
+  // uvarint is a Number when it fits in 53 bits, else a BigInt.
+  uvarint() {
+    const b = this.b
+    let p = this.p
+    let x = 0
+    let mul = 1
+    for (let i = 0; i < 7; i++) {
+      if (p >= b.length) this.bad()
+      const c = b[p++]
+      x += (c & 0x7f) * mul
+      if (c < 0x80) {
+        this.p = p
+        return x
+      }
+      mul *= 128
+    }
+    // Beyond 49 bits: finish in BigInt.
+    let big = BigInt(x)
+    let shift = 49n
+    for (let i = 7; i < 10; i++) {
+      if (p >= b.length) this.bad()
+      const c = b[p++]
+      if (i === 9 && c > 1) this.bad() // overflows 64 bits, as Go's Uvarint says
+      big |= BigInt(c & 0x7f) << shift
+      if (c < 0x80) {
+        this.p = p
+        return big <= MAX_SAFE ? Number(big) : big
+      }
+      shift += 7n
+    }
+    this.bad()
+  }
+
+  // varint is zig-zag: a Number when safe, else a BigInt.
+  varint() {
+    const u = this.uvarint()
+    if (typeof u === 'number') {
+      const h = Math.floor(u / 2)
+      return u % 2 ? -h - 1 : h
+    }
+    let x = u >> 1n
+    if (u & 1n) x = ~x
+    return x >= -MAX_SAFE && x <= MAX_SAFE ? Number(x) : x
+  }
+
+  bytes() {
+    const n = this.uvarint()
+    if (typeof n !== 'number' || n > this.b.length - this.p) this.bad()
+    const s = this.b.subarray(this.p, this.p + n)
+    this.p += n
+    return s
+  }
+
+  str() {
+    return strOf(this.bytes())
+  }
+}
+
+const ROOT = -1 // the parent of a top-level entry
+const NONE = -1 // no child, no sibling
+// Distinct times kept as one BigInt each (images share few mtimes).
+const MAX_INTERNED_TIMES = 1 << 16
+// Names kept as one string each: the first this many distinct, this short.
+const MAX_INTERNED_NAMES = 1 << 16
+const MAX_INTERNED_NAME = 32
+
+/**
+ * An open pack. Its index stays in memory as the pack's bytes (one copy),
+ * with three 32-bit numbers per entry (where it starts, its first child, its
+ * next sibling); an entry is decoded when asked for (entry(i), lookup()),
+ * never kept. Opening still decodes and checks every entry once, so a bad
+ * pack is refused at open, as Go's reader does.
+ *
+ * A decoded entry is {path, name, dir, whiteout, opaque, mode, uid, gid,
+ * rdev, atime, mtime, ctime (BigInt ns), size, off, target, link, xattrs
+ * (Map|null)}, a new object each time.
+ */
+export class Pack {
+  constructor(source, name = 'pack') {
+    this.source = source
+    this.name = name
+    const size = source.size
+    const foot = 16 + MAGIC.length
+    if (size < 2 * MAGIC.length + 16) throw new PackFormatError(`${name}: not a pack`)
+    const f = source.read(size - foot, foot)
+    if (strOf(f.subarray(16)) !== MAGIC) throw new PackFormatError(`${name}: not a pack`)
+    const dv = new DataView(f.buffer, f.byteOffset, f.byteLength)
+    const start = Number(dv.getBigUint64(0, true))
+    const n = Number(dv.getBigUint64(8, true))
+    if (start < MAGIC.length || n < 0 || start + n !== size - foot) {
+      throw new PackFormatError(`${name}: not a pack`)
+    }
+    this.dataEnd = start
+    this.times = new Map()
+    this.lastTimeAt = 0
+    this.lastTimeLen = 0
+    this.lastTime = 0n
+    this.names = new Map()
+    // A copy: the source's bytes may be a view the caller reuses.
+    const d = new Decoder(source.read(start, n).slice())
+    this.idx = d.b
+    const count = d.uvarint()
+    if (typeof count !== 'number' || count > n || count >= 2 ** 31) throw new PackFormatError(`${name}: not a pack`)
+    this.count = count
+    this.pos = n < 2 ** 32 ? new Uint32Array(count) : new Float64Array(count)
+    this.firstChild = new Int32Array(count).fill(NONE)
+    this.nextSibling = new Int32Array(count).fill(NONE)
+    this.rootFirst = NONE
+    this.links = new Map() // hard-link group -> {n, first}
+    const lastChild = new Int32Array(count)
+    let rootLast = NONE
+    const dirs = new Map() // directory path -> index, while opening only
+    let prev = null
+    for (let i = 0; i < count; i++) {
+      this.pos[i] = d.p
+      const e = this.#entry(d)
+      if (prev !== null && prev >= e.path) {
+        throw new PackFormatError(`${name}: index not sorted at ${JSON.stringify(e.path)}`)
+      }
+      prev = e.path
+      if (!e.whiteout && (e.mode & S_IFMT) === S_IFREG && (e.off < 0 || e.size < 0 || e.off + e.size > start)) {
+        throw new PackFormatError(`${name}: ${e.path}: contents outside the data`)
+      }
+      if (e.link) {
+        const g = this.links.get(e.link)
+        if (g) g.n++
+        else this.links.set(e.link, { n: 1, first: i })
+      }
+      if (e.path === '') continue
+      if (!e.whiteout && (e.mode & S_IFMT) === S_IFDIR) dirs.set(e.path, i)
+      // Children are linked in index order, which is name order. An entry
+      // whose directory is not a directory entry of this pack is reachable
+      // by no lookup (as before: only directory entries are listed).
+      const parent = e.dir === '' ? ROOT : dirs.get(e.dir)
+      if (parent === undefined) continue
+      if (parent === ROOT) {
+        if (rootLast === NONE) this.rootFirst = i
+        else this.nextSibling[rootLast] = i
+        rootLast = i
+      } else {
+        if (this.firstChild[parent] === NONE) this.firstChild[parent] = i
+        else this.nextSibling[lastChild[parent]] = i
+        lastChild[parent] = i
+      }
+    }
+  }
+
+  // One string per distinct short name (index.js, package.json, ...).
+  #name(b) {
+    const s = strOf(b)
+    if (b.length > MAX_INTERNED_NAME) return s
+    const had = this.names.get(s)
+    if (had !== undefined) return had
+    if (this.names.size < MAX_INTERNED_NAMES) this.names.set(s, s)
+    return s
+  }
+
+  // A time (zig-zag varint ns) as a BigInt, one per distinct time. The
+  // same bytes as the last time decoded (the common case: an image's files
+  // share an mtime) are that time, without decoding.
+  #time(d) {
+    const b = d.b
+    const s = d.p
+    const ls = this.lastTimeAt
+    const ln = this.lastTimeLen
+    if (ln > 0 && s + ln <= b.length) {
+      let k = 0
+      while (k < ln && b[s + k] === b[ls + k]) k++
+      if (k === ln) {
+        d.p = s + ln
+        return this.lastTime
+      }
+    }
+    const v = d.varint()
+    let t = typeof v === 'bigint' ? v : BigInt(v)
+    const had = this.times.get(t)
+    if (had !== undefined) t = had
+    else if (this.times.size < MAX_INTERNED_TIMES) this.times.set(t, t)
+    if (b === this.idx) {
+      this.lastTimeAt = s
+      this.lastTimeLen = d.p - s
+      this.lastTime = t
+    }
+    return t
+  }
+
+  #entry(d) {
+    const pb = d.bytes()
+    const path = strOf(pb)
+    if (d.p >= d.b.length) d.bad()
+    const fl = d.b[d.p++]
+    const slash = pb.lastIndexOf(0x2f)
+    const e = {
+      path,
+      dir: slash < 0 ? '' : path.slice(0, slash),
+      // Its own string (not a slice that would keep path), shared by equal names.
+      name: this.#name(slash < 0 ? pb : pb.subarray(slash + 1)),
+      whiteout: (fl & FLAG_WHITEOUT) !== 0,
+      opaque: (fl & FLAG_OPAQUE) !== 0,
+      mode: 0, uid: 0, gid: 0, rdev: 0,
+      atime: 0n, mtime: 0n, ctime: 0n,
+      size: 0, off: 0, target: '', link: 0, xattrs: null,
+    }
+    if (e.whiteout) return e
+    e.mode = Number(d.uvarint()) >>> 0
+    e.uid = Number(d.uvarint()) >>> 0
+    e.gid = Number(d.uvarint()) >>> 0
+    e.rdev = d.uvarint()
+    e.atime = this.#time(d)
+    e.mtime = this.#time(d)
+    e.ctime = this.#time(d)
+    e.size = d.varint()
+    e.off = d.varint()
+    if (typeof e.size !== 'number' || typeof e.off !== 'number') d.bad()
+    e.target = d.str()
+    e.link = d.uvarint()
+    let nx = d.uvarint()
+    if (typeof nx !== 'number' || nx > d.b.length - d.p) d.bad()
+    for (; nx > 0; nx--) {
+      const k = d.str()
+      const v = d.bytes().slice()
+      if (!e.xattrs) e.xattrs = new Map()
+      e.xattrs.set(k, v)
+    }
+    return e
+  }
+
+  get length() {
+    return this.count
+  }
+
+  /** Entry i, decoded. */
+  entry(i) {
+    const d = new Decoder(this.idx)
+    d.p = this.pos[i]
+    return this.#entry(d)
+  }
+
+  /** Every entry, decoded (for tests and tools: it holds them all). */
+  get entries() {
+    if (!this.all) {
+      this.all = new Array(this.count)
+      for (let i = 0; i < this.count; i++) this.all[i] = this.entry(i)
+    }
+    return this.all
+  }
+
+  // Compares entry i's path with byte string s: <0, 0, >0.
+  #cmp(i, s) {
+    const b = this.idx
+    let p = this.pos[i]
+    // The path's uvarint length (checked at open).
+    let len = 0
+    let mul = 1
+    for (;;) {
+      const c = b[p++]
+      len += (c & 0x7f) * mul
+      if (c < 0x80) break
+      mul *= 128
+    }
+    const m = Math.min(len, s.length)
+    for (let k = 0; k < m; k++) {
+      const x = b[p + k] - s.charCodeAt(k)
+      if (x !== 0) return x
+    }
+    return len - s.length
+  }
+
+  /** The index of the entry at path (whiteouts included), or -1. */
+  index(path) {
+    let lo = 0
+    let hi = this.count - 1
+    while (lo <= hi) {
+      const mid = (lo + hi) >>> 1
+      const c = this.#cmp(mid, path)
+      if (c === 0) return mid
+      if (c < 0) lo = mid + 1
+      else hi = mid - 1
+    }
+    return -1
+  }
+
+  /** The entry at path (whiteouts included), or undefined. */
+  lookup(path) {
+    const i = this.index(path)
+    return i < 0 ? undefined : this.entry(i)
+  }
+
+  /** Directory path's entries' indexes (whiteouts included), in name order. */
+  children(path) {
+    let i
+    if (path === '') {
+      i = this.rootFirst
+    } else {
+      const d = this.index(path)
+      if (d < 0) return []
+      i = this.firstChild[d]
+    }
+    const out = []
+    for (; i !== NONE; i = this.nextSibling[i]) out.push(i)
+    return out
+  }
+
+  /** Hard-link group link's size and its first entry's index (Go's LinkGroup). */
+  linkGroup(link) {
+    return this.links.get(link) || { n: 0, first: 0 }
+  }
+
+  /** Up to len bytes of regular file entry e's contents at off. */
+  read(e, off, len) {
+    if (off >= e.size || len <= 0) return new Uint8Array(0)
+    const n = Math.min(len, e.size - off)
+    return this.source.read(e.off + off, n)
+  }
+}

package/src/fs/seed.js

@@ -0,0 +1,22 @@
+// What a 9P service's `files` option puts in its tree at boot (bootWmd channels.services[].files).
+
+/**
+ * One entry of a 9P service's files: its bytes or text, or {data, mode?, uid?, gid?} (P-B11: the agent
+ * binary, 0755), or {dir: true, mode?, uid?, gid?} (W65: a directory, such as the image's WORKDIR).
+ * Missing parents are made root's, 0755. An entry that names a path the layers have takes its contents
+ * (a file) and the mode and owner it gives; the rest of the layer's attributes stay.
+ */
+export function seedEntry(fs, path, f) {
+  const o = f && typeof f === 'object' && !ArrayBuffer.isView(f) && !(f instanceof ArrayBuffer) ? f : { data: f }
+  const attrs = { mode: o.mode, uid: o.uid, gid: o.gid }
+  let n
+  const slash = path.replace(/\/+$/, '').lastIndexOf('/')
+  if (slash > 0) fs.mkdirp(path.slice(0, slash))
+  if (o.dir) {
+    n = fs.mkdirp(path, o.mode ?? 0o755)
+  } else {
+    const bytes = typeof o.data === 'string' ? new TextEncoder().encode(o.data) : new Uint8Array(o.data)
+    n = fs.writeFile(path, bytes, { mode: o.mode ?? 0o644, uid: o.uid ?? 0, gid: o.gid ?? 0 })
+  }
+  if (attrs.mode !== undefined || attrs.uid !== undefined || attrs.gid !== undefined) fs.setattr(n, attrs)
+}

package/src/fs/svc-snapshot.js

@@ -0,0 +1,65 @@
+// P-B9: the file server's state as bytes, and back. What a checkpoint needs of the 9P
+// service: the Overlay's tree (its upper, and every lower inode that has been read, with
+// their identity: inode numbers, link counts, who is linked to whom) and the live
+// connection's fid table (the guest kernel's v9fs holds those fids across a restore; a
+// new server with none would answer every request on an open file with EBADF).
+//
+// The lower layers are not written: they are the image's packs, which the restoring page
+// gets the way the first boot did. Inodes and Contents that read from a pack are written
+// with a token for the pack (its index in the overlay's layer list).
+//
+// The tree goes through graph.js as one graph, so an inode shared by a name and a fid stays
+// one inode.
+
+import { Content, DirInode, Inode, Overlay } from './overlay.js'
+import { Fid } from './9p/server.js'
+import { Pack } from './pack.js'
+import { decodeGraph, encodeGraph } from './graph.js'
+
+/** Overlay fields the constructor of the restoring process sets (live objects, config). */
+const OVERLAY_SKIP = ['layers', 'now', 'onFull', 'maxUpperBytes']
+
+function classesFor(target) {
+  return {
+    Overlay: { ctor: Overlay, make: () => target, skip: OVERLAY_SKIP },
+    Inode: { ctor: Inode, make: () => new Inode(0n, 0) },
+    DirInode: { ctor: DirInode, make: () => new DirInode(0n, 0) },
+    // Content has private methods: it must come from its constructor.
+    Content: { ctor: Content, make: () => new Content(null, null, 0) },
+    Fid: { ctor: Fid, make: () => new Fid(null, null, '', 0) },
+  }
+}
+
+/**
+ * The state of overlay (and of the 9P server over it, or null) as graph segments.
+ * @returns {{segments: Uint8Array[], bytes: number, inodes: number, fids: number}}
+ */
+export function dumpService(overlay, server = null) {
+  const special = { pack: v => (v instanceof Pack ? overlay.layers.indexOf(v) : undefined) }
+  const root = { overlay, msize: server ? server.msize : 0, fids: server ? server.fids : new Map() }
+  const out = encodeGraph(root, { classes: classesFor(overlay), special })
+  return { ...out, fids: root.fids.size }
+}
+
+/**
+ * Replaces the state of `overlay` (built from the same layers by the restoring process) with
+ * the dumped one. Returns {msize, fids}: the server state to put on the connection's server.
+ */
+export function loadService(bytes, overlay) {
+  const special = {
+    revive: i => {
+      const p = overlay.layers[i]
+      if (!p) throw new Error(`service snapshot: it refers to layer ${i}, and this boot has ${overlay.layers.length}`)
+      return p
+    },
+  }
+  const root = decodeGraph(bytes, { classes: classesFor(overlay), special })
+  if (root.overlay !== overlay) throw new Error('service snapshot: the overlay is not the first object')
+  return { msize: root.msize, fids: root.fids }
+}
+
+/** Puts a loaded fid table on a NinePServer. */
+export function adoptServer(server, state) {
+  server.msize = state.msize
+  server.fids = state.fids
+}