summaryrefslogtreecommitdiff
path: root/src/dump.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-05 14:42:45 -0300
committerGabriel Schneider <[email protected]>2026-11-05 19:16:37 -0300
commit15a1b94eaa73747afaa299262a2d6e4fd6af42fd (patch)
tree46bff4f35b642521eead62bc3b5657902e5fee0b /src/dump.zig
parent4e096f6dc6db043caa630514fa75bd18438cb15b (diff)
downloadpardes-15a1b94eaa73747afaa299262a2d6e4fd6af42fd.tar.gz
pardes-15a1b94eaa73747afaa299262a2d6e4fd6af42fd.zip
dumps: a Dump is a labelled entry of the state file (src/Db.zig, architecture §14.3), one fsynced transaction: `dumps/<label>` holds the session as a database of its own, which the walk writes by field name into xitdb's maps (walk.Put: a struct a map keyed by its fields' names, a union a map of its one field, records a list, plain numbers one bytes value tagged with their kind and width, an enum its name, a number a uint or an int, an optional an absent key, a type with dumpWrite its bytes, a .blob text of 4 KiB and up its BLAKE3 hash) and another build reads by name (walk.Get: defaults, notes, a pane it cannot read left out, as the byte loader did), with the hashes of the texts it keeps once under `blobs/`, so an unchanged text is written once across dumps; labels are `pardes-<date>-<time>` (`-2` and on in one second), `last` names the newest, the newest 32 are kept and the texts no kept one names are dropped in the same transaction, and at a session's end the file is compacted into `pardes.xitdb.new` and renamed over once it is past twice what it holds plus 64 MiB (another session notices the new file by its inode); a dump travels as an image, a database in memory holding it alone, deterministic (std.Io.failing's zero ids, so the replay's fixpoint holds): what Dump hands its host, what `Dump export <path>` and $PARDES_DUMP write whole (the snapshot goldens' `Restore <path>` unchanged), what a Restore of a label is read into, what a handover carries (`handover-<seq>`), and what `-l` and `Restore <path>` read; Restore takes a label or a path (bare: this session's last dump, else the newest), a label the file keeps none of refused in words (`Restore: no dump labelled X`, asked of the authority as the closed panes are); `/dumps` lists them, `<label> <date> <size> <panes>`, the newest first; Upgrade commits `upgrade-<pid>` before the exec, its record naming the state file and the label (a record without one, an older build's, names its `.dump` file, read as before), and the label stays; the byte dump stays for the join, the closed panes and the old `.dump` files (dump.byteDump), and dump.outPath, uniqueIn and upgradePath go for dump.label; measured (Debug, a session with a 3.2 MB file and three scratch panes, 20 dumps): the image on the loop 64-66 ms (59 ms of it BLAKE3 of the file, 0.65 ms in ReleaseFast) where the byte dump was 0.7 ms, the commit 9-16 ms with its fsyncs where the file was written in 2, a Restore 1.8 ms to read and 11.4 to load, and the file 3.55 MB after the first dump and 379 KB a dump after it with the big text unchanged (3.58 MB a dump with it edited each time, as twenty `.dump` files would be); tests: dump.zig's 'two dumps in one second get names of their own' and 'a dump makes every directory missing on the way to its DumpDir' become Db.zig's 'two dumps with one label get labels of their own' and 'a Dump makes every directory missing on the way to its DumpDir, and the file there', 'a session read by name, field by field as another build reads it, is the same session' becomes 'a session's byte dump read by name...' beside the new 'a session's image, read by name as every load reads it, is the same session, and dumps to the same bytes again', two replica tests compare the join's stream with dump.byteDump, the Handover tests read the carried image, upgrade's record test carries a label, the root listing tests and the monkey list `dumps`, the behaviour suite gains five root-ctl tests (a Dump and Restore round trip through 9P with `/dumps` and the tag's word, a label kept none of refused in words, the 33rd dump dropping the first, an unchanged text written once across two dumps by the file's size, a killed Dump leaving the one before it whole), the test host performs a Dump's write and a Restore as a host does, the monkey lets go of its log follower at a Restore, and daemon.py's upgrade case finds the kept dump in `/dumps`
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/dump.zig')
-rw-r--r--src/dump.zig275
1 files changed, 199 insertions, 76 deletions
diff --git a/src/dump.zig b/src/dump.zig
index 3ded45ca..8847152d 100644
--- a/src/dump.zig
+++ b/src/dump.zig
@@ -20,64 +20,29 @@ const Options = pardes.Options;
const Pardes = pardes.Pardes;
const views = pardes.views;
-/// Where the next dump goes. $PARDES_DUMP wins verbatim (the snapshot harness
-/// pins it for deterministic goldens); else $XDG_DATA_HOME|~/.local/share
-/// /pardes/pardes-<utc>.dump — timestamped so dumps never overwrite each other.
-/// Creates the directory and any parent missing (a fresh HOME has no
-/// ~/.local/share); a failure surfaces at open.
-pub fn outPath(buf: *[1024:0]u8, dir_setting: []const u8) ?[:0]const u8 {
- if (std.c.getenv("PARDES_DUMP")) |p|
- return std.fmt.bufPrintSentinel(buf, "{s}", .{std.mem.span(p)}, 0) catch null;
- var dir_buf: [900]u8 = undefined;
- const dir = directory(&dir_buf, dir_setting) orelse return null;
- _ = std.Io.Dir.cwd().createDirPathStatus(std.Io.Threaded.global_single_threaded.io(), dir, .fromMode(0o755)) catch {};
+/// A Dump's label in the state file (Db.zig): `pardes-<date>-<time>`, UTC
+/// (another in the same second is `-2` and on there), in `buf`.
+pub fn label(buf: []u8) []const u8 {
var ts: std.c.timespec = undefined;
_ = std.c.clock_gettime(.REALTIME, &ts);
const es: std.time.epoch.EpochSeconds = .{ .secs = @intCast(@max(0, ts.sec)) };
const yd = es.getEpochDay().calculateYearDay();
const md = yd.calculateMonthDay();
const ds = es.getDaySeconds();
- var stamp: [32]u8 = undefined;
- const base = std.fmt.bufPrint(&stamp, "pardes-{d:0>4}{d:0>2}{d:0>2}-{d:0>2}{d:0>2}{d:0>2}", .{
+ return std.fmt.bufPrint(buf, "pardes-{d:0>4}{d:0>2}{d:0>2}-{d:0>2}{d:0>2}{d:0>2}", .{
yd.year, md.month.numeric(), @as(u8, md.day_index) + 1,
ds.getHoursIntoDay(), ds.getMinutesIntoHour(), ds.getSecondsIntoMinute(),
- }) catch return null;
- return uniqueIn(buf, dir, base);
+ }) catch "pardes-dump";
}
-/// `<dir>/<base>.dump`, or `<base>-2.dump` and on when two dumps land in one
-/// second: a dump never overwrites another.
-fn uniqueIn(buf: *[1024:0]u8, dir: []const u8, base: []const u8) ?[:0]const u8 {
- var n: usize = 1;
- while (n < 1000) : (n += 1) {
- const path = (if (n == 1)
- std.fmt.bufPrintSentinel(buf, "{s}/{s}.dump", .{ dir, base }, 0)
- else
- std.fmt.bufPrintSentinel(buf, "{s}/{s}-{d}.dump", .{ dir, base, n }, 0)) catch return null;
- if (std.c.access(path.ptr, std.c.F_OK) != 0) return path;
- }
- return null;
-}
-
-test "two dumps in one second get names of their own" {
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- var dir_buf: [900]u8 = undefined;
- const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
- var buf: [1024:0]u8 = undefined;
- const first = try std.testing.allocator.dupe(u8, uniqueIn(&buf, dir, "pardes-x").?);
- defer std.testing.allocator.free(first);
- try std.testing.expect(std.mem.endsWith(u8, first, "/pardes-x.dump"));
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "pardes-x.dump", .data = "" });
- try std.testing.expect(std.mem.endsWith(u8, uniqueIn(&buf, dir, "pardes-x").?, "/pardes-x-2.dump"));
-}
/// The host's environment.
fn hostEnv(name: [*:0]const u8) ?[*:0]u8 {
return std.c.getenv(name);
}
-/// Where dumps go and relative Restore names are looked up: the `DumpDir`
-/// setting when set (a leading `~/` is the home directory), else the default.
+/// Where the state file is (Db.zig) and relative Restore names are looked
+/// up: the `DumpDir` setting when set (a leading `~/` is the home
+/// directory), else the default.
pub fn directory(buf: []u8, dir_setting: []const u8) ?[]const u8 {
if (dir_setting.len == 0) return defaultDirectory(buf);
var joined: [4096]u8 = undefined;
@@ -92,21 +57,6 @@ pub fn directory(buf: []u8, dir_setting: []const u8) ?[]const u8 {
return std.fmt.bufPrint(buf, "{s}", .{resolved}) catch null;
}
-test "a dump makes every directory missing on the way to its DumpDir" {
- if (std.c.getenv("PARDES_DUMP") != null) return error.SkipZigTest;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- var at: [4096]u8 = undefined;
- const base = at[0..try tmp.dir.realPath(std.testing.io, &at)];
- var setting: [4200]u8 = undefined;
- const dir = try std.fmt.bufPrint(&setting, "{s}/fresh/.local/share/pardes", .{base});
- var out: [1024:0]u8 = undefined;
- const path = outPath(&out, dir).?;
- try std.testing.expect(std.mem.startsWith(u8, path, dir));
- var made = try tmp.dir.openDir(std.testing.io, "fresh/.local/share/pardes", .{});
- made.close(std.testing.io);
-}
-
test "a DumpDir reads back absolute, however it was written" {
var buf: [4096]u8 = undefined;
try std.testing.expectEqualStrings("/tmp/dumps", directory(&buf, "/tmp/dumps/").?);
@@ -130,11 +80,15 @@ pub var terminal_gpa: ?std.mem.Allocator = null;
// ---- a whole session to and from a dump (acme keeps this in rows.c) ----
//
-// A dump (src/walk.zig) is everything the session is but what is the
-// host's, the frame's or worked out again: its panes with their text and
-// undo, terminals with their screens, history and kitty images (ghostty's
-// snapshot), registers, places, tags, layout and settings. It crosses
-// builds: its fields are matched by name.
+// A dump is everything the session is but what is the host's, the frame's
+// or worked out again: its panes with their text and undo, terminals with
+// their screens, history and kitty images (ghostty's snapshot), registers,
+// places, tags, layout and settings. It crosses builds: its fields are
+// matched by name. It is an image (Db.zig): a database in memory the walk
+// writes by name (walk.Put), which the state file keeps under a label,
+// `Dump export` and a handover write as a file, and `-l` and Restore read.
+// The byte dump before it (walk.Dump) is still a replica's join, a closed
+// pane's, and for one release (0.24) what an old `.dump` file is read as.
//
// Loading is two halves. `load` makes the core the dump was and nothing
// else (a replica joining a session takes that, phase 5); `revivePane` and
@@ -166,11 +120,92 @@ pub fn dumpState(p: *Pardes) !void {
p.emit(.write_dump);
}
-/// The session as a dump, gpa-owned.
+/// A Dump: into the state file, or (`Dump export`) a file of its own at
+/// `to` (`~` the home directory).
+pub fn dumpTo(p: *Pardes, to: ?[]const u8) !void {
+ if (p.dump_export) |old| p.gpa.free(old);
+ p.dump_export = null;
+ if (to) |path| {
+ var home_buf: [4096]u8 = undefined;
+ p.dump_export = try p.gpa.dupe(u8, filesystem.expandHome(path, &home_buf));
+ }
+ try dumpState(p);
+}
+
+/// The file a Restore of `name` reads, its whole path in `out`: one named
+/// with a `/` or `~/` (as it resolves, else as typed: the read says why),
+/// or a bare word that names a file in the DumpDir or the directory pardes
+/// runs in; null for one that names none: a label of the state file's.
+pub fn restoreFile(name: []const u8, dir_setting: []const u8, out: *[4096]u8) ?[]const u8 {
+ const path = filesystem.restorePath(name, dir_setting, out);
+ if (std.mem.indexOfScalar(u8, name, '/') != null or std.mem.startsWith(u8, name, "~")) return path;
+ return if (std.fs.path.isAbsolute(path)) path else null;
+}
+
+/// What a Restore of `name` reads, `gpa`'s: the file it names (an image,
+/// or an old byte dump), else the state file's dump of that label.
+pub fn restoreBytes(p: *Pardes, gpa: std.mem.Allocator, name: []const u8) ![]u8 {
+ var buf: [4096]u8 = undefined;
+ if (restoreFile(name, p.settings.dump_dir.get(), &buf)) |path| return filesystem.readFile(gpa, path);
+ const got = p.db.getDump(p, gpa, name) catch |err| return if (err == error.OutOfMemory) error.OutOfMemory else error.BadDump;
+ return got orelse error.FileNotFound;
+}
+
+/// The session as a dump's image, gpa-owned (the host puts it in the state
+/// file under a label of its own).
pub fn dumpBytes(p: *Pardes) ![]u8 {
+ return image(p, "dump");
+}
+
+/// The session as a byte dump (walk.Dump), gpa-owned: what a replica's join
+/// streams, its blobs in place.
+pub fn byteDump(p: *Pardes) ![]u8 {
return dumpWith(p, null);
}
+/// The session as the image of one dump labelled `name` (Db.zig), its
+/// roots by name: the core, its 9P mounts, which of its panes' files were
+/// on disk, its theme's name and the views not live (see `Session`).
+pub fn image(p: *Pardes, name: []const u8) ![]u8 {
+ const gpa = p.gpa;
+ var buf: std.Io.Writer.Allocating = .init(gpa);
+ defer buf.deinit();
+ var db = try walk.Mem.init(std.Io.failing, .{ .buffer = &buf, .file_id = 0 });
+ var w: walk.Put = .{ .gpa = gpa };
+ defer w.deinit();
+ const mounts: []const filesystem.Mount = p.fs.mounts.items;
+ var on_disk: OnDisk = @splat(false);
+ var panes: u64 = 0;
+ for (p.panes, &on_disk) |slot, *on| if (slot) |pane| {
+ on.* = onDisk(pane);
+ panes += 1;
+ };
+ const theme: []const u8 = colors.themes[@min(p.settings.theme, colors.themes.len - 1)].name;
+ const others = try views.dumped(p, gpa);
+ defer {
+ for (others) |o| gpa.free(o.panes);
+ gpa.free(others);
+ }
+ const kept: []const views.Dumped = others;
+ try db.runContext(struct {
+ w: *walk.Put,
+ p: *Pardes,
+ mounts: *const []const filesystem.Mount,
+ on_disk: *const OnDisk,
+ theme: *const []const u8,
+ others: *const []const views.Dumped,
+ pub fn run(ctx: @This(), cursor: *walk.Mem.Cursor(.read_write)) !void {
+ const root = try walk.Mem.HashMap(.read_write).init(cursor.*);
+ try ctx.w.member(root, "core", Pardes, ctx.p);
+ try ctx.w.member(root, "mounts", []const filesystem.Mount, ctx.mounts);
+ try ctx.w.member(root, "on_disk", OnDisk, ctx.on_disk);
+ try ctx.w.member(root, "theme", []const u8, ctx.theme);
+ try ctx.w.member(root, "views", []const views.Dumped, ctx.others);
+ }
+ }{ .w = &w, .p = p, .mounts = &mounts, .on_disk = &on_disk, .theme = &theme, .others = &kept });
+ return pardes.Db.image(gpa, name, buf.written(), w.blobs.items, panes);
+}
+
/// A dump for a screen-state replica's join (src/replica.zig): its blobs'
/// bytes left out and noted in `deferred` (they are the session's, alive
/// while pinned: memory.zig `pin`), its terminals' emulators left out (the
@@ -213,6 +248,19 @@ fn dumpWith(p: *Pardes, deferred: ?*std.ArrayListUnmanaged(walk.Deferred)) ![]u8
/// Restore asks before it warns about unsaved text or replaces anything.
/// Why not is left in `why`, ended by a 0.
pub fn check(gpa: std.mem.Allocator, bytes: []const u8, why: []u8) !void {
+ if (pardes.Db.isImage(bytes)) {
+ const r = pardes.Db.Read.open(gpa, bytes, null) catch |err| {
+ const said = std.fmt.bufPrint(why[0 .. why.len - 1], "{s}", .{switch (err) {
+ error.NoDump => "it holds no dump",
+ error.OutOfMemory => "out of memory",
+ else => "it is no dump of pardes's",
+ }}) catch "";
+ why[said.len] = 0;
+ return err;
+ };
+ r.close();
+ return;
+ }
var l = SessionLoad.init(gpa, bytes) catch |err| {
const said = std.fmt.bufPrint(why[0 .. why.len - 1], "{s}", .{switch (err) {
error.BadDump => "it does not begin as one",
@@ -235,6 +283,7 @@ pub fn load(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes: ?*s
/// `load`, with which panes' files were on disk when it was dumped.
fn loadKnowing(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes: ?*std.ArrayList(u8), on_disk: ?*OnDisk) !*Pardes {
+ if (pardes.Db.isImage(bytes)) return loadImage(gpa, opts, bytes, notes, on_disk);
const p = try Pardes.create(gpa, opts);
var l = SessionLoad.init(gpa, bytes) catch |err| {
p.deinit();
@@ -304,6 +353,70 @@ fn loadKnowing(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes:
return p;
}
+/// `loadKnowing` of an image (Db.zig): its roots read by name (walk.Get),
+/// as the byte dump's are read in order.
+fn loadImage(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes: ?*std.ArrayList(u8), on_disk: ?*OnDisk) !*Pardes {
+ const r = pardes.Db.Read.open(gpa, bytes, null) catch |err| return if (err == error.OutOfMemory) err else error.BadDump;
+ defer r.close();
+ const root = r.root();
+ const core_at = (try walk.Get.member(root, "core")) orelse return error.BadDump;
+ const p = try Pardes.create(gpa, opts);
+ var l: walk.Get = .init(gpa);
+ defer l.deinit();
+ l.blobs = r.blobs() catch null;
+ // A load that fails leaves nothing: what it read is freed, and the
+ // core with it, its fields never torn down one by one.
+ errdefer {
+ l.rollback();
+ p.fs.deinit(gpa);
+ gpa.destroy(p);
+ }
+ l.allocs = .{ .image = p.image_gpa, .pdf = p.pdf_gpa, .terminal = terminal_gpa };
+ try l.into(Pardes, core_at, p);
+ const read = l.made.items.len;
+ const mounts: []const filesystem.Mount = if (try walk.Get.member(root, "mounts")) |c| try l.get([]const filesystem.Mount, c) else &.{};
+ defer {
+ for (mounts) |m| {
+ gpa.free(m.name);
+ gpa.free(m.dial);
+ }
+ gpa.free(mounts);
+ // Freed here: no rollback of them.
+ l.made.shrinkRetainingCapacity(read);
+ }
+ const was: OnDisk = if (try walk.Get.member(root, "on_disk")) |c| try l.get(OnDisk, c) else @splat(false);
+ if (on_disk) |out| out.* = was;
+ const theme: []const u8 = if (try walk.Get.member(root, "theme")) |c| try l.get([]const u8, c) else "";
+ defer gpa.free(theme);
+ p.settings.theme = for (colors.themes, 0..) |t, i| {
+ if (std.mem.eql(u8, t.name, theme)) break i;
+ } else if (p.settings.theme < colors.themes.len) p.settings.theme else 0;
+ for (mounts) |m| {
+ const existing = for (p.fs.mounts.items) |e| {
+ if (std.mem.eql(u8, e.name, m.name)) break e;
+ } else null;
+ if (existing) |e| {
+ if (!std.mem.eql(u8, e.dial, m.dial)) return error.MountConflict;
+ continue;
+ }
+ p.fs.mount(gpa, m.name, m.dial) catch |err| l.note("mount {s}: {t}", .{ m.name, err });
+ }
+ if (l.notes.items.len > 0) {
+ dropMissing(p);
+ for (p.panes) |slot| if (slot) |pane| try ensureKind(p, pane);
+ if (notes) |n| try n.appendSlice(gpa, l.notes.items);
+ }
+ // The views not live, last: what it moves into the core is never
+ // rolled back from under it, nothing after it failing.
+ const at = l.made.items.len;
+ const others: []const views.Dumped = if (try walk.Get.member(root, "views")) |c| try l.get([]const views.Dumped, c) else &.{};
+ try views.undumped(p, others);
+ for (others) |o| gpa.free(o.panes);
+ gpa.free(others);
+ l.made.shrinkRetainingCapacity(at);
+ return p;
+}
+
/// A pane that is none of its kinds (a terminal kept slim, or one another
/// build's dump could not give): a terminal, a new emulator for its shell.
fn ensureKind(p: *Pardes, pane: *pardes.panes.Pane) !void {
@@ -349,7 +462,7 @@ pub fn restore(p: *Pardes, bytes: []const u8, from: []const u8) !*Pardes {
pub fn initFromDump(gpa: std.mem.Allocator, opts: Options, bytes: []const u8) !*Pardes {
pardes.tape.startFromEnv();
const taped = pardes.tape.enter(null, .{ .init_from_dump = .{ .opts = opts, .bytes = bytes } });
- const p = (if (std.mem.startsWith(u8, bytes, Handover.carried_magic)) carriedWindow(gpa, opts, bytes) else loadAndRevive(gpa, opts, bytes, null, null)) catch |err| {
+ const p = (if (Handover.carries(bytes)) carriedWindow(gpa, opts, bytes) else loadAndRevive(gpa, opts, bytes, null, null)) catch |err| {
pardes.tape.leave(null, taped);
return err;
};
@@ -375,16 +488,6 @@ pub fn resumeFromDump(gpa: std.mem.Allocator, opts: Options, bytes: []const u8,
return loadAndRevive(gpa, opts, bytes, null, kept);
}
-/// Where an upgrade leaves its dump: the DumpDir (a relative Restore finds
-/// it there by name), as `pardes-upgrade-<pid>.dump`; never $PARDES_DUMP,
-/// which is a Dump's.
-pub fn upgradePath(buf: *[1024:0]u8, dir_setting: []const u8) ?[:0]const u8 {
- var dir_buf: [900]u8 = undefined;
- const dir = directory(&dir_buf, dir_setting) orelse return null;
- _ = std.Io.Dir.cwd().createDirPathStatus(std.Io.Threaded.global_single_threaded.io(), dir, .fromMode(0o755)) catch {};
- return std.fmt.bufPrintSentinel(buf, "{s}/pardes-upgrade-{d}.dump", .{ dir, std.c.getpid() }, 0) catch null;
-}
-
fn loadAndRevive(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, previous: ?*Pardes, kept: ?*const [MAX_PANES]bool) !*Pardes {
var notes: std.ArrayList(u8) = .empty;
defer notes.deinit(gpa);
@@ -711,7 +814,7 @@ test "an upgraded session's dump keeps its views and its running terminal as the
try std.testing.expect(r.panes[0].?.terminal.?.vt.screens.active_key == .primary);
}
-test "a session read by name, field by field as another build reads it, is the same session" {
+test "a session's image, read by name as every load reads it, is the same session, and dumps to the same bytes again" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
defer p.deinit();
@@ -720,6 +823,26 @@ test "a session read by name, field by field as another build reads it, is the s
try std.testing.expect(p.executeBuiltinLine(p.active, "Zerox"));
const bytes = try dumpBytes(p);
defer gpa.free(bytes);
+ var notes: std.ArrayList(u8) = .empty;
+ defer notes.deinit(gpa);
+ const q = try load(gpa, p.opts, bytes, &notes);
+ defer q.deinit();
+ try std.testing.expectEqualStrings("", notes.items);
+ try std.testing.expectEqual(walk.digest(Pardes, p), walk.digest(Pardes, q));
+ const again = try dumpBytes(q);
+ defer gpa.free(again);
+ try std.testing.expectEqualSlices(u8, bytes, again);
+}
+
+test "a session's byte dump read by name, field by field as another build reads it, is the same session" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ const pane = try p.setTestFile("one\ntwo\n");
+ _ = ctlfs.pane.spliceBody(p, pane, 0, 0, "unsaved ").?;
+ try std.testing.expect(p.executeBuiltinLine(p.active, "Zerox"));
+ const bytes = try byteDump(p);
+ defer gpa.free(bytes);
const q = try Pardes.create(gpa, p.opts);
defer q.deinit();
var l = try SessionLoad.init(gpa, bytes);