Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-core/tests/context_edits.rs

Raw
//! SMH-SPEC-SPEC0001: Sessions, Context edits and Effective request context.
use smith::config::Config;
use smith::message::{Message, Role};
use smith_core::context::{ContextEdit, ContextReplacement};
use smith_core::session::{EntryContent, Session};
use smith_core::store::{SessionReader, create_session};

#[test]
fn durable_replace_and_omit_preserve_raw_history() {
    let home = std::env::temp_dir().join(format!("smith-context-{}", smith::id::SessionId::new()));
    std::fs::create_dir(&home).unwrap();
    let path = home.join("context.smh");
    let mut session = Session::new();
    let original = Message::with_text(Role::User, "original");
    let target = session
        .append(&EntryContent::Message(original.clone()))
        .unwrap()
        .id;
    let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
    opened
        .writer
        .edit_context(&[ContextEdit {
            target,
            replacement: Some(ContextReplacement::Text("replacement".into())),
        }])
        .unwrap();
    let reader = SessionReader::open(&path).unwrap();
    let projected = reader
        .selected_session(Config::default_valid().frame_bytes_max)
        .unwrap();
    let message = &projected.projected_messages().unwrap()[0];
    assert_eq!(message.id, original.id);
    assert_eq!(message.role, original.role);
    assert_eq!(message.timestamp_ms, original.timestamp_ms);
    assert_eq!(
        message.blocks,
        Message::with_text(Role::User, "replacement").blocks
    );
    assert_eq!(
        projected
            .content(&projected.active_branch().entries()[0])
            .unwrap(),
        EntryContent::Message(original)
    );
    opened
        .writer
        .edit_context(&[ContextEdit {
            target,
            replacement: None,
        }])
        .unwrap();
    let projected = SessionReader::open(&path)
        .unwrap()
        .selected_session(Config::default_valid().frame_bytes_max)
        .unwrap();
    assert!(projected.projected_messages().unwrap().is_empty());
}

#[test]
fn rejected_batches_leave_file_and_projection_unchanged() {
    use smith::id::{EntryId, ToolCallId};
    use smith::message::ContentBlock;
    use smith::structured::ToolArguments;
    let home = std::env::temp_dir().join(format!(
        "sce-invalid-{:x}",
        smith::id::SessionId::new().as_u128()
    ));
    std::fs::create_dir(&home).unwrap();
    let path = home.join("context.smh");
    let mut session = Session::new();
    let root = session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "root",
        )))
        .unwrap()
        .id;
    let call_id = ToolCallId::new();
    let mut call = Message::new(Role::Assistant);
    call.add_block(ContentBlock::tool_use(
        "read",
        ToolArguments::empty_object(),
        call_id,
    ));
    let call = session.append(&EntryContent::Message(call)).unwrap().id;
    let mut result = Message::new(Role::Tool);
    result.add_block(ContentBlock::ToolResult {
        call_id,
        ok: true,
        output: "evidence".into(),
    });
    let result = session.append(&EntryContent::Message(result)).unwrap().id;
    let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
    let baseline = std::fs::read(&path).unwrap();
    let cases = [
        vec![ContextEdit {
            target: call,
            replacement: None,
        }],
        vec![ContextEdit {
            target: result,
            replacement: None,
        }],
        vec![ContextEdit {
            target: call,
            replacement: Some(ContextReplacement::Text("invalid schema".into())),
        }],
        vec![ContextEdit {
            target: EntryId::new(),
            replacement: None,
        }],
        vec![
            ContextEdit {
                target: root,
                replacement: None
            };
            65
        ],
        vec![ContextEdit {
            target: root,
            replacement: Some(ContextReplacement::Text("x".repeat(65536))),
        }],
        vec![
            ContextEdit {
                target: root,
                replacement: None
            };
            2
        ],
        vec![],
    ];
    for batch in cases {
        assert!(opened.writer.edit_context(&batch).is_err());
        assert_eq!(std::fs::read(&path).unwrap(), baseline);
        let projected = SessionReader::open(&path)
            .unwrap()
            .selected_session(Config::default_valid().frame_bytes_max)
            .unwrap();
        assert_eq!(
            projected.projected_messages().unwrap(),
            session.projected_messages().unwrap()
        );
    }
    opened.writer.select_entry(root).unwrap();
    let navigated = std::fs::read(&path).unwrap();
    assert!(
        opened
            .writer
            .edit_context(&[ContextEdit {
                target: result,
                replacement: None
            }])
            .is_err()
    );
    assert_eq!(std::fs::read(&path).unwrap(), navigated);
    opened.writer.select_entry(result).unwrap();
    opened
        .writer
        .edit_context(&[
            ContextEdit {
                target: call,
                replacement: None,
            },
            ContextEdit {
                target: result,
                replacement: None,
            },
        ])
        .unwrap();
    let projected = SessionReader::open(&path)
        .unwrap()
        .selected_session(Config::default_valid().frame_bytes_max)
        .unwrap();
    assert_eq!(projected.projected_messages().unwrap().len(), 1);
    assert!(projected.provider_call_ids().unwrap().is_empty());
}

#[test]
fn generic_append_cannot_bypass_batch_validation() {
    let mut session = Session::new();
    let before = session.clone();
    assert!(
        session
            .append(&EntryContent::ContextEdit(vec![ContextEdit {
                target: smith::id::EntryId::new(),
                replacement: None
            }]))
            .is_err()
    );
    assert_eq!(session, before);
}

#[test]
fn codec_rejects_unknown_required_semantics_and_trailing_bytes() {
    use smith_core::context::ContextBatchView;
    assert!(ContextBatchView::decode(&[1, 1, 0]).is_err());
    let mut bytes = vec![2, 1, 0];
    bytes.extend_from_slice(&1u128.to_le_bytes());
    bytes.push(2);
    assert!(ContextBatchView::decode(&bytes).is_err());
    bytes[19] = 0;
    assert!(ContextBatchView::decode(&bytes).is_ok());
    bytes.push(0);
    assert!(ContextBatchView::decode(&bytes).is_err());
}

#[cfg(unix)]
#[test]
fn readonly_session_cannot_admit_edit() {
    use std::os::unix::fs::PermissionsExt;
    let home = std::env::temp_dir().join(format!(
        "sce-ro-{:x}",
        smith::id::SessionId::new().as_u128()
    ));
    std::fs::create_dir(&home).unwrap();
    let path = home.join("context.smh");
    let opened = create_session(&path, &Session::new(), Config::default_valid()).unwrap();
    drop(opened);
    let before = std::fs::read(&path).unwrap();
    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o400)).unwrap();
    assert!(smith_core::store::SessionWriter::open(&path, Config::default_valid()).is_err());
    assert_eq!(std::fs::read(&path).unwrap(), before);
    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
    std::fs::remove_dir_all(home).unwrap();
}

proptest::proptest! {
    #[test]
    fn rejected_batch_preserves_projection(text in ".{0,128}", replacement in ".{0,128}") {
        let mut session = Session::new();
        let target = session.append(&EntryContent::Message(Message::with_text(Role::User, &text))).unwrap().id;
        let before = session.clone();
        let result = session.edit_context_with(&[ContextEdit {
            target, replacement: None,
        }, ContextEdit {
            target: smith::id::EntryId::new(),
            replacement: Some(ContextReplacement::Text(replacement)),
        }], |_, _| panic!("rejected batch reached persistence"));
        proptest::prop_assert!(result.is_err());
        proptest::prop_assert_eq!(session, before);
    }

    #[test]
    fn typed_edit_codec_roundtrips(text in ".{0,256}", kind in 0u8..4, identity in 1u128..) {
        use smith_core::session::EntryFrame;
        use smith_core::frame::{Frame, visit_frames};
        let content = EntryContent::ContextEdit(vec![ContextEdit {
            target: smith::id::EntryId::from_u128(identity),
            replacement: match kind { 0 => None, 1 => Some(ContextReplacement::Text(text)), 2 => Some(ContextReplacement::AssistantText(text)), _ => Some(ContextReplacement::ToolResultOutput { call_id: smith::id::ToolCallId::from_u128(identity), output: text }) },
        }]);
        let entry = EntryFrame::new(None, &content).unwrap();
        proptest::prop_assert_eq!(EntryContent::decode(&entry.content).unwrap(), content);
        let frame = Frame::Known { entry };
        let encoded = frame.encode(1 << 20).unwrap();
        proptest::prop_assert_eq!(u16::from_le_bytes([encoded[4], encoded[5]]), smith_core::frame::KIND_CONTEXT_EDIT);
        let mut decoded = None;
        visit_frames(&mut encoded.as_slice(), 1 << 20, |frame| { decoded = Some(frame); false }).unwrap();
        proptest::prop_assert_eq!(decoded, Some(frame));
    }
}

#[cfg(target_arch = "x86_64")]
#[test]
fn edit_layout_bounds() {
    assert_eq!(std::mem::size_of::<ContextEdit>(), 56);
    assert_eq!(
        std::mem::size_of::<smith_core::context::ContextBatchView<'_>>(),
        16
    );
}

#[test]
fn worker_ack_failure_preserves_projection_and_readonly_authority_rejects() {
    use smith_core::tools::ToolSession;
    let mut session = Session::new();
    let target = session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "original",
        )))
        .unwrap()
        .id;
    let before = session.clone();
    let mut tools = ToolSession::with_persist(std::env::temp_dir(), session, |_, _| {
        Err(smith::error::SmithError::Cancelled)
    });
    assert!(
        tools
            .edit_context(&[ContextEdit {
                target,
                replacement: None
            }])
            .is_err()
    );
    assert_eq!(tools.session, before);
    assert!(
        tools
            .edit_context(&[ContextEdit {
                target,
                replacement: None
            }])
            .is_err()
    );
    let mut readonly = ToolSession::new(std::env::temp_dir());
    let target = readonly
        .session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "readonly",
        )))
        .unwrap()
        .id;
    assert!(
        readonly
            .edit_context(&[ContextEdit {
                target,
                replacement: None
            }])
            .is_err()
    );
    assert_eq!(readonly.session.projected_messages().unwrap().len(), 1);
}

#[test]
fn exact_wire_bound_and_latest_edit_precedence() {
    let mut session = Session::new();
    let target = session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "original",
        )))
        .unwrap()
        .id;
    // 3-byte header + 16-byte ID + 1-byte tag + 4-byte length.
    let text = "x".repeat(smith_core::context::CONTEXT_EDIT_BYTES_MAX - 24);
    let first = session
        .edit_context_with(
            &[ContextEdit {
                target,
                replacement: Some(ContextReplacement::Text(text.clone())),
            }],
            |_, _| Ok(()),
        )
        .unwrap();
    assert_eq!(
        session.projected_messages().unwrap()[0].blocks,
        vec![smith::message::ContentBlock::Text(text)]
    );
    session
        .edit_context_with(
            &[ContextEdit {
                target,
                replacement: None,
            }],
            |_, _| Ok(()),
        )
        .unwrap();
    assert!(session.projected_messages().unwrap().is_empty());
    let before_edit = session.fork_at(target).unwrap();
    assert_eq!(
        before_edit.projected_messages().unwrap()[0].blocks,
        vec![smith::message::ContentBlock::Text("original".into())]
    );
    let first_edit = session.fork_at(first).unwrap();
    assert_eq!(first_edit.projected_messages().unwrap().len(), 1);
}

#[test]
fn unedited_projection_rejects_invalid_tool_pairing() {
    use smith::id::ToolCallId;
    use smith::message::ContentBlock;
    use smith::structured::ToolArguments;
    let call_id = ToolCallId::new();
    let call = |role| {
        let mut message = Message::new(role);
        message.add_block(ContentBlock::tool_use(
            "read",
            ToolArguments::empty_object(),
            call_id,
        ));
        message
    };
    let result = |role| {
        let mut message = Message::new(role);
        message.add_block(ContentBlock::ToolResult {
            call_id,
            ok: true,
            output: "result".into(),
        });
        message
    };
    for messages in [
        vec![Message::with_text(Role::Tool, "missing result")],
        vec![result(Role::Tool)],
        vec![call(Role::User)],
        vec![result(Role::User)],
        vec![call(Role::Assistant)],
        vec![
            call(Role::Assistant),
            Message::with_text(Role::User, "interruption"),
            result(Role::Tool),
        ],
        vec![
            call(Role::Assistant),
            result(Role::Tool),
            call(Role::Assistant),
            result(Role::Tool),
        ],
    ] {
        let mut session = Session::new();
        for message in messages {
            session.append(&EntryContent::Message(message)).unwrap();
        }
        assert!(matches!(
            session.projected_messages(),
            Err(smith::SmithError::Session {
                code: smith::error::SessionCode::SessionIncompleteContext,
                ..
            })
        ));
    }
}

#[test]
fn resulting_context_rejects_tool_role_without_result_schema() {
    let mut session = Session::new();
    let target = session
        .append(&EntryContent::Message(Message::with_text(
            Role::Tool,
            "not a paired result",
        )))
        .unwrap()
        .id;
    let before = session.clone();
    assert!(
        session
            .edit_context_with(
                &[ContextEdit {
                    target,
                    replacement: Some(ContextReplacement::Text("still not a result".into())),
                }],
                |_, _| Ok(())
            )
            .is_err()
    );
    assert_eq!(session, before);
}

#[test]
fn unknown_required_edit_envelope_fails_both_readers() {
    use smith_core::frame::{Frame, KIND_CONTEXT_EDIT, read_frames, visit_metadata_reporting};
    for version in [0, 1, 3, u16::MAX] {
        let bytes = Frame::Unknown {
            kind: KIND_CONTEXT_EDIT,
            version,
            payload: vec![0; 32],
        }
        .encode(1 << 20)
        .unwrap();
        assert!(read_frames(&mut bytes.as_slice(), 1 << 20).is_err());
        assert!(
            visit_metadata_reporting(&mut bytes.as_slice(), 1 << 20, |_, _| Ok(()), |_| Ok(()))
                .is_err()
        );
    }
}

#[test]
fn forged_edit_metadata_is_rejected_before_writing() {
    use smith_core::frame::Frame;
    use smith_core::session::{EntryFrame, EntryKind};
    let home = std::env::temp_dir().join(format!("sce-forged-{}", smith::id::SessionId::new()));
    std::fs::create_dir(&home).unwrap();
    let path = home.join("context.smh");
    let mut session = Session::new();
    let target = session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "raw",
        )))
        .unwrap()
        .id;
    let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
    let baseline = std::fs::read(&path).unwrap();
    let mut entry = EntryFrame::new(
        Some(target),
        &EntryContent::ContextEdit(vec![ContextEdit {
            target,
            replacement: None,
        }]),
    )
    .unwrap();
    entry.kind = EntryKind::Meta { compaction: true };
    assert!(opened.writer.append_frame(&Frame::Known { entry }).is_err());
    assert_eq!(std::fs::read(&path).unwrap(), baseline);
    std::fs::remove_dir_all(home).unwrap();
}

#[test]
fn checksummed_invalid_edits_fail_selected_restore() {
    use smith_core::frame::Frame;
    use smith_core::session::EntryFrame;
    use std::io::Write;
    for case in ["unknown", "offbranch", "duplicate", "future"] {
        let home =
            std::env::temp_dir().join(format!("sce-restore-{}", smith::id::SessionId::new()));
        std::fs::create_dir(&home).unwrap();
        let path = home.join("context.smh");
        let mut session = Session::new();
        let root = session
            .append(&EntryContent::Message(Message::with_text(
                Role::User,
                "root",
            )))
            .unwrap()
            .id;
        let mut opened = create_session(&path, &session, Config::default_valid()).unwrap();
        let sibling = EntryFrame::new(
            Some(root),
            &EntryContent::Message(Message::with_text(Role::User, "sibling")),
        )
        .unwrap();
        if case == "offbranch" {
            opened
                .writer
                .append_frame(&Frame::Known {
                    entry: sibling.clone(),
                })
                .unwrap();
        }
        drop(opened);
        let future = EntryFrame::new(
            None,
            &EntryContent::Message(Message::with_text(Role::User, "future")),
        )
        .unwrap();
        let target = match case {
            "duplicate" => root,
            "offbranch" => sibling.id,
            "future" => future.id,
            _ => smith::id::EntryId::new(),
        };
        let edit = ContextEdit {
            target,
            replacement: Some(ContextReplacement::Text("edited".into())),
        };
        let entry = EntryFrame::new(
            Some(root),
            &EntryContent::ContextEdit(if case == "duplicate" {
                vec![edit.clone(), edit]
            } else {
                vec![edit]
            }),
        )
        .unwrap();
        let id = entry.id;
        let encoded = Frame::Known { entry }.encode(1 << 20).unwrap();
        // Low-level checksummed fixture deliberately bypasses the typed writer guard.
        let bytes = Frame::Unknown {
            kind: smith_core::frame::KIND_CONTEXT_EDIT,
            version: smith_core::frame::VERSION_CONTEXT_EDIT,
            payload: encoded[16..encoded.len() - 4].to_vec(),
        }
        .encode(1 << 20)
        .unwrap();
        let mut file = std::fs::OpenOptions::new()
            .append(true)
            .open(&path)
            .unwrap();
        file.write_all(&bytes).unwrap();
        if case == "future" {
            let mut future = future;
            future.parent = Some(id);
            file.write_all(&Frame::Known { entry: future }.encode(1 << 20).unwrap())
                .unwrap();
        }
        drop(file);
        let restored =
            SessionReader::open(&path).and_then(|reader| reader.selected_session(1 << 20));
        assert!(restored.is_err(), "accepted {case} edit");
        std::fs::remove_dir_all(home).unwrap();
    }
}

#[test]
fn typed_tool_replacements_preserve_identity_schema_and_raw_evidence() {
    use smith::id::ToolCallId;
    use smith::message::ContentBlock;
    use smith::structured::ToolArguments;
    let mut session = Session::new();
    let call_id = ToolCallId::new();
    let mut call = Message::with_text(Role::Assistant, "raw prose");
    call.add_block(ContentBlock::tool_use(
        "read",
        ToolArguments::empty_object(),
        call_id,
    ));
    let call_target = session
        .append(&EntryContent::Message(call.clone()))
        .unwrap()
        .id;
    let mut result = Message::new(Role::Tool);
    result.add_block(ContentBlock::ToolResult {
        call_id,
        ok: true,
        output: "raw output".into(),
    });
    let result_target = session
        .append(&EntryContent::Message(result.clone()))
        .unwrap()
        .id;
    let prose: ContextReplacement =
        serde_json::from_value(serde_json::json!({"AssistantText": "edited prose"})).unwrap();
    let output: ContextReplacement = serde_json::from_value(
        serde_json::json!({"ToolResultOutput": {"call_id": call_id, "output": "edited output"}}),
    )
    .unwrap();
    session
        .edit_context_with(
            &[
                ContextEdit {
                    target: call_target,
                    replacement: Some(prose),
                },
                ContextEdit {
                    target: result_target,
                    replacement: Some(output),
                },
            ],
            |_, _| Ok(()),
        )
        .unwrap();
    let before = session.clone();
    for (target, replacement) in [
        (
            result_target,
            ContextReplacement::ToolResultOutput {
                call_id: ToolCallId::new(),
                output: "retargeted".into(),
            },
        ),
        (
            call_target,
            ContextReplacement::ToolResultOutput {
                call_id,
                output: "role change".into(),
            },
        ),
        (
            result_target,
            ContextReplacement::AssistantText("role change".into()),
        ),
    ] {
        assert!(
            session
                .edit_context_with(
                    &[ContextEdit {
                        target,
                        replacement: Some(replacement)
                    }],
                    |_, _| panic!("invalid replacement reached persistence")
                )
                .is_err()
        );
        assert_eq!(session, before);
    }
    let projected = session.projected_messages().unwrap();
    assert_eq!(
        (
            projected[0].id,
            projected[0].role,
            projected[0].timestamp_ms
        ),
        (call.id, call.role, call.timestamp_ms)
    );
    assert_eq!(projected[0].blocks[1], call.blocks[1]);
    assert_eq!(
        projected[0].blocks[0],
        ContentBlock::Text("edited prose".into())
    );
    assert_eq!(
        (
            projected[1].id,
            projected[1].role,
            projected[1].timestamp_ms
        ),
        (result.id, result.role, result.timestamp_ms)
    );
    assert_eq!(
        projected[1].blocks[0],
        ContentBlock::ToolResult {
            call_id,
            ok: true,
            output: "edited output".into()
        }
    );
    assert_eq!(
        session
            .content(&session.active_branch().entries()[0])
            .unwrap(),
        EntryContent::Message(call)
    );
    assert_eq!(
        session
            .content(&session.active_branch().entries()[1])
            .unwrap(),
        EntryContent::Message(result)
    );
}

#[test]
fn tool_output_replacement_enforces_exact_encoded_byte_bound() {
    use smith_core::context::CONTEXT_EDIT_BYTES_MAX;
    use smith_core::session::EntryFrame;
    // Header 3 + target 16 + tag 1 + call identity 16 + text length 4.
    let replacement = |length| {
        EntryContent::ContextEdit(vec![ContextEdit {
            target: smith::id::EntryId::from_u128(1),
            replacement: Some(ContextReplacement::ToolResultOutput {
                call_id: smith::id::ToolCallId::from_u128(2),
                output: "x".repeat(length),
            }),
        }])
    };
    let exact = replacement(CONTEXT_EDIT_BYTES_MAX - 40);
    let encoded = EntryFrame::new(None, &exact).unwrap();
    assert_eq!(encoded.content.len(), CONTEXT_EDIT_BYTES_MAX + 1);
    assert_eq!(EntryContent::decode(&encoded.content).unwrap(), exact);
    assert!(EntryFrame::new(None, &replacement(CONTEXT_EDIT_BYTES_MAX - 39)).is_err());
}

#[test]
fn file_backed_live_edits_keep_raw_schema_and_transactional_publication() {
    use smith::message::ContentBlock;
    let home = std::env::temp_dir().join(format!("sce-source-{}", smith::id::SessionId::new()));
    std::fs::create_dir(&home).unwrap();
    let path = home.join("context.smh");
    let config = Config::default_valid();
    let mut initial = Session::new();
    let mut raw = Message::with_text(Role::Assistant, "raw prose");
    raw.add_block(ContentBlock::Thinking("raw thinking".into()));
    let target = initial
        .append(&EntryContent::Message(raw.clone()))
        .unwrap()
        .id;
    let mut opened = create_session(&path, &initial, config.clone()).unwrap();
    opened
        .writer
        .edit_context(&[ContextEdit {
            target,
            replacement: Some(ContextReplacement::Text("first".into())),
        }])
        .unwrap();
    let reader = SessionReader::open(&path).unwrap();
    let mut session = reader.selected_session(config.frame_bytes_max).unwrap();
    let old_edit = *session.active_branch().selected_entry().unwrap();
    let raw_record = session.active_branch().entries()[0];
    assert!(session.bytes(&raw_record).is_empty());
    assert_eq!(
        EntryContent::decode(&session.raw_bytes(&raw_record).unwrap()).unwrap(),
        EntryContent::Message(raw.clone())
    );
    let next = session
        .append_with(
            &EntryContent::Message(Message::with_text(Role::User, "new raw")),
            |entry, bytes| opened.writer.append_entry(entry, bytes),
        )
        .unwrap()
        .id;
    let edits = [
        ContextEdit {
            target,
            replacement: Some(ContextReplacement::AssistantText("latest".into())),
        },
        ContextEdit {
            target: next,
            replacement: Some(ContextReplacement::Text("new effective".into())),
        },
    ];
    let before = session.clone();
    assert!(
        session
            .edit_context_with(&edits, |_, _| Err(smith::error::SmithError::Cancelled))
            .is_err()
    );
    assert_eq!(session, before);
    session
        .edit_context_with(&edits, |entry, bytes| {
            opened.writer.append_entry(entry, bytes)
        })
        .unwrap();
    let projected = session.projected_messages().unwrap();
    assert_eq!(
        projected[0].blocks,
        vec![
            ContentBlock::Text("latest".into()),
            ContentBlock::Thinking("raw thinking".into())
        ]
    );
    assert_eq!(
        projected[1].blocks,
        Message::with_text(Role::User, "new effective").blocks
    );
    assert!(matches!(
        session.content(&old_edit).unwrap(),
        EntryContent::ContextEdit(_)
    ));
    assert_eq!(
        session.content(&raw_record).unwrap(),
        EntryContent::Message(raw)
    );
    assert_eq!(
        SessionReader::open(&path)
            .unwrap()
            .selected_session(config.frame_bytes_max)
            .unwrap()
            .projected_messages()
            .unwrap(),
        projected
    );
    let archived_live_edit = *session.active_branch().selected_entry().unwrap();
    session
        .edit_context_with(&edits, |entry, bytes| {
            opened.writer.append_entry(entry, bytes)
        })
        .unwrap();
    assert!(matches!(
        session.content(&archived_live_edit).unwrap(),
        EntryContent::ContextEdit(_)
    ));
    assert_eq!(
        session
            .fork_at(target)
            .unwrap()
            .projected_messages()
            .unwrap(),
        initial.projected_messages().unwrap()
    );
    assert_eq!(
        session
            .fork_at(archived_live_edit.id)
            .unwrap()
            .projected_messages()
            .unwrap(),
        projected
    );
    drop(before);
    drop(session);
    drop(reader);
    drop(opened);
    std::fs::remove_dir_all(home).unwrap();
}