//! SMH-SPEC-SPEC0001: same-ledger complete payloads, bounded reads, ownership, recovery.
use super::*;
use crate::frame::{NestedPayloadChunk, NestedPayloadPhase};
use crate::metadata::{
self, NestedEffectCompletion, NestedEffectIntent, NestedPayload, NestedPayloadRef,
};
use crate::session::EntryContent;
use smith::error::MutationState;
fn frames(input: &str, output: &str) -> (PathBuf, OpenSession, Vec, Frame) {
let (path, opened, mut outer) = super::commit_tests::setup(MutationState::Applied);
let Frame::Commit {
checkpoint,
entries,
} = &mut outer
else {
unreachable!()
};
let payload = |text: &str| {
NestedPayload::Chunks(NestedPayloadRef {
payload_bytes: text.len().try_into().unwrap(),
})
};
let intent = EntryFrame::new(
entries[0].parent,
&EntryContent::Meta {
kind: metadata::NESTED_INTENT_KIND.into(),
detail: metadata::encode(&NestedEffectIntent {
submission_id: checkpoint.submission_id,
call_id: checkpoint.call_id,
index: 0,
operation: "http",
component: None,
input: payload(input),
})
.unwrap(),
},
)
.unwrap();
let completion = EntryFrame::new(
Some(intent.id),
&EntryContent::Meta {
kind: metadata::NESTED_COMPLETION_KIND.into(),
detail: metadata::encode(&NestedEffectCompletion {
submission_id: checkpoint.submission_id,
call_id: checkpoint.call_id,
index: 0,
ok: true,
mutation_state: MutationState::Applied,
output: payload(output),
})
.unwrap(),
},
)
.unwrap();
let mut frames = Vec::new();
for (text, phase) in [
(input, NestedPayloadPhase::Input),
(output, NestedPayloadPhase::Output),
] {
for (ordinal, bytes) in text
.as_bytes()
.chunks(metadata::NESTED_CHUNK_BYTES_MAX)
.enumerate()
{
frames.push(Frame::NestedPayload {
chunk: Box::new(NestedPayloadChunk {
submission_id: checkpoint.submission_id,
call_id: checkpoint.call_id,
effect_id: intent.id,
index: 0,
phase,
ordinal: ordinal.try_into().unwrap(),
bytes: bytes.to_vec(),
}),
});
}
frames.push(if phase == NestedPayloadPhase::Input {
Frame::Known {
entry: intent.clone(),
}
} else {
Frame::NestedCommit {
entry: completion.clone(),
}
});
}
entries[0].parent = Some(completion.id);
(path, opened, frames, outer)
}
#[test]
fn full_payloads_reconstruct_exactly_without_resident_history_payloads() {
// Deliberately split UTF-8 scalars across physical boundaries.
let input = "a🦀".repeat(14000);
let output = "bλ".repeat(350000);
let (path, mut opened, frames, outer) = frames(&input, &output);
let input_id = frames.iter().flat_map(Frame::entries).next().unwrap().id;
let output_id = frames.iter().flat_map(Frame::entries).last().unwrap().id;
for frame in &frames {
if let Frame::NestedCommit { entry } = frame {
let intent_id = entry.parent.unwrap();
let (_, intent_offset) = SessionReader::open(&path)
.unwrap()
.find_entry(intent_id, Config::default_valid().frame_bytes_max)
.unwrap()
.unwrap();
opened
.writer
.append_frame(&Frame::Checkpoint {
id: intent_id,
offset: intent_offset,
})
.unwrap();
}
opened.writer.append_frame(frame).unwrap();
}
opened.writer.append_frame(&outer).unwrap();
opened.writer.select_entry(output_id).unwrap();
drop(opened);
let limit = Config::default_valid().frame_bytes_max;
let reader = SessionReader::open(&path).unwrap();
assert_eq!(reader.nested_payload(input_id, limit).unwrap(), input);
assert_eq!(reader.nested_payload(output_id, limit).unwrap(), output);
let session = reader.selected_session(limit).unwrap();
assert!(
session
.active_branch()
.entries()
.iter()
.map(|entry| session.bytes(entry).len())
.sum::()
< 16 * 1024,
"resident history contains references, not large canonical payloads"
);
reader.verify_full(limit).unwrap();
drop(reader);
repair_session(&path, limit).unwrap();
let reader = SessionReader::open(&path).unwrap();
reader.verify_full(limit).unwrap();
assert_eq!(reader.selected_tip(limit).unwrap(), Some(output_id));
assert_eq!(reader.nested_payload(output_id, limit).unwrap(), output);
drop(reader);
super::commit_tests::clear(&path);
}
#[test]
fn origin_boundaries_are_bounded_matched_and_never_appended_by_live_writers() {
assert_eq!(std::mem::size_of::(), 40);
let config = Config::default_valid();
for mode in ["unclosed", "unopened", "mismatch", "depth", "transition"] {
let (path, mut opened, _) = super::commit_tests::setup(MutationState::Applied);
let source = SessionId::new();
let begin = Frame::Origin {
source,
begin: true,
};
assert!(opened.writer.append_frame(&begin).is_err());
let frames = match mode {
"unclosed" => vec![begin],
"unopened" => vec![Frame::Origin {
source,
begin: false,
}],
"mismatch" => vec![
begin,
Frame::Origin {
source: SessionId::new(),
begin: false,
},
],
"depth" => vec![begin; ORIGIN_DEPTH_MAX + 1],
_ => vec![
begin,
Frame::Claim {
submission_id: EntryId::new(),
},
Frame::Origin {
source,
begin: false,
},
],
};
let mut file = OpenOptions::new().append(true).open(&path).unwrap();
for frame in &frames {
write_frame(&mut file, frame, config.frame_bytes_max).unwrap();
}
drop(file);
assert!(
SessionReader::open(&path)
.unwrap()
.validate_work(config.frame_bytes_max)
.is_err(),
"{mode}"
);
let mut complete = Vec::new();
SessionReader::open(&path)
.unwrap()
.scan(config.frame_bytes_max, |frame| {
complete.push(frame);
Ok(())
})
.unwrap();
assert!(Session::from_frames(&complete).is_err(), "{mode}");
drop(opened);
super::commit_tests::clear(&path);
}
}
#[test]
fn fork_keeps_chunk_backed_effects_and_unknown_intents_as_source_facts() {
let input = "i🦀".repeat(14000);
let output = "oλ".repeat(24000);
for completed in [false, true] {
let (path, mut opened, frames, outer) = frames(&input, &output);
let input_id = frames.iter().flat_map(Frame::entries).next().unwrap().id;
let output_id = frames.iter().flat_map(Frame::entries).last().unwrap().id;
let Frame::Commit { checkpoint, .. } = &outer else {
unreachable!()
};
for frame in &frames {
if !completed
&& matches!(frame, Frame::NestedPayload { chunk } if chunk.phase == NestedPayloadPhase::Output)
{
break;
}
opened.writer.append_frame(frame).unwrap();
}
if completed {
opened.writer.append_frame(&outer).unwrap();
}
let selected = if completed { output_id } else { input_id };
let fork = path.with_extension("fork.smh");
let second = path.with_extension("second.smh");
let config = Config::default_valid();
let limit = config.frame_bytes_max;
let source_before = std::fs::read(&path).unwrap();
let mut forked = SessionReader::open(&path)
.unwrap()
.fork_at(selected, &fork, config.clone())
.unwrap();
assert!(forked.writer.claim(checkpoint.submission_id).is_err());
let reader = SessionReader::open(&fork).unwrap();
reader.verify_full(limit).unwrap();
reader.reject_pending_admissions(limit).unwrap();
assert_eq!(
reader.work_status(checkpoint.submission_id, limit).unwrap(),
None
);
assert_eq!(reader.nested_payload(input_id, limit).unwrap(), input);
if completed {
assert_eq!(reader.nested_payload(output_id, limit).unwrap(), output);
} else {
assert!(reader.find_entry(output_id, limit).unwrap().is_none());
}
assert_eq!(reader.selected_tip(limit).unwrap(), Some(selected));
let own = forked
.writer
.admit(
&smith::message::Message::with_text(smith::message::Role::User, "new work"),
None,
None,
)
.unwrap();
forked.writer.claim(own.submission_id).unwrap();
forked
.writer
.settle(
own.submission_id,
Some(smith::stream::StopReason::EndTurn),
None,
)
.unwrap();
// A second fork of inherited history closes partial outer scopes without adopting either root.
drop(reader.fork_at(selected, &second, config).unwrap());
let twice = SessionReader::open(&second).unwrap();
twice.verify_full(limit).unwrap();
twice.reject_pending_admissions(limit).unwrap();
assert_eq!(twice.nested_payload(input_id, limit).unwrap(), input);
assert_eq!(twice.work_status(own.submission_id, limit).unwrap(), None);
assert_eq!(std::fs::read(&path).unwrap(), source_before);
if !completed {
let output_start = frames.iter().position(|frame| matches!(frame, Frame::NestedPayload { chunk } if chunk.phase == NestedPayloadPhase::Output)).unwrap();
for frame in &frames[output_start..] {
opened.writer.append_frame(frame).unwrap();
}
opened.writer.append_frame(&outer).unwrap();
assert!(
SessionReader::open(&path)
.unwrap()
.find_entry(output_id, limit)
.unwrap()
.is_some()
);
assert!(
SessionReader::open(&fork)
.unwrap()
.find_entry(output_id, limit)
.unwrap()
.is_none()
);
}
drop((twice, reader, forked, opened));
super::commit_tests::clear(&second);
super::commit_tests::clear(&fork);
super::commit_tests::clear(&path);
}
}
#[test]
fn chunk_damage_owner_sequence_or_missing_bytes_never_publish_completion() {
for mode in [
"missing",
"duplicate",
"reorder",
"root",
"call",
"effect",
"index",
"phase",
"length",
"utf8",
"crc",
"torn",
] {
let text = "x".repeat(metadata::NESTED_CHUNK_BYTES_MAX + 7);
let (path, mut opened, mut frames, outer) = frames(&text, &text);
// First finish the input. Corrupt only the output phase.
for frame in frames.drain(..3) {
opened.writer.append_frame(&frame).unwrap();
}
let completion_id = frames.last().unwrap().entries()[0].id;
match mode {
"missing" => {
frames.remove(0);
}
"duplicate" => {
frames.insert(1, frames[0].clone());
}
"reorder" => frames.swap(0, 1),
"root" | "call" | "effect" | "index" | "phase" | "length" | "utf8" => {
let Frame::NestedPayload { chunk } = &mut frames[0] else {
unreachable!()
};
match mode {
"root" => chunk.submission_id = EntryId::new(),
"call" => chunk.call_id = smith::id::ToolCallId::new(),
"effect" => chunk.effect_id = EntryId::new(),
"index" => chunk.index = 1,
"phase" => chunk.phase = NestedPayloadPhase::Input,
"length" => {
chunk.bytes.pop();
}
_ => chunk.bytes[0] = 255,
}
}
_ => {}
}
let limit = Config::default_valid().frame_bytes_max;
// Writer rejects checksum-valid malformed links before durable acknowledgement.
if !matches!(mode, "crc" | "torn") {
let mut rejected = false;
for frame in &frames {
if opened.writer.append_frame(frame).is_err() {
rejected = true;
break;
}
}
assert!(rejected, "{mode}");
assert!(opened.writer.append_frame(&outer).is_err(), "{mode}");
} else {
let mut bytes = frames[0].encode(limit).unwrap();
if mode == "crc" {
bytes[crate::frame::HEADER_LEN + 4 + 53] ^= 1;
} else {
bytes.pop();
}
OpenOptions::new()
.append(true)
.open(&path)
.unwrap()
.write_all(&bytes)
.unwrap();
}
drop(opened);
let reader = SessionReader::open(&path).unwrap();
assert!(
reader.nested_payload(completion_id, limit).is_err(),
"{mode}"
);
let Frame::Commit { checkpoint, .. } = outer else {
unreachable!()
};
let status = reader.work_status(checkpoint.submission_id, limit);
if mode != "crc" {
assert_eq!(status.unwrap(), Some(WorkStatus::Running), "{mode}");
}
drop(reader);
if let Ok(mut reopened) = open_session(&path, Config::default_valid()) {
assert!(
reopened.writer.claim(checkpoint.submission_id).is_err(),
"{mode}"
);
assert!(
reopened
.writer
.settle(checkpoint.submission_id, None, None)
.is_err(),
"{mode}"
);
}
super::commit_tests::clear(&path);
}
}
#[test]
fn persisted_checksum_valid_bad_chunk_links_cannot_be_reopened_as_complete_output() {
for mode in [
"missing",
"duplicate",
"reorder",
"root",
"call",
"effect",
"index",
"phase",
"length",
"utf8",
] {
let text = "x".repeat(metadata::NESTED_CHUNK_BYTES_MAX + 7);
let (path, opened, mut records, outer) = frames(&text, &text);
let completion = records.last().unwrap().entries()[0].id;
match mode {
"missing" => {
records.remove(3);
}
"duplicate" => {
records.insert(4, records[3].clone());
}
"reorder" => records.swap(3, 4),
_ => {
let Frame::NestedPayload { chunk } = &mut records[3] else {
unreachable!()
};
match mode {
"root" => chunk.submission_id = EntryId::new(),
"call" => chunk.call_id = smith::id::ToolCallId::new(),
"effect" => chunk.effect_id = EntryId::new(),
"index" => chunk.index = 1,
"phase" => chunk.phase = NestedPayloadPhase::Input,
"length" => {
chunk.bytes.pop();
}
_ => chunk.bytes[0] = 255,
}
}
}
let limit = Config::default_valid().frame_bytes_max;
let mut raw = OpenOptions::new().append(true).open(&path).unwrap();
for record in records.iter().chain(std::iter::once(&outer)) {
raw.write_all(&record.encode(limit).unwrap()).unwrap();
}
raw.sync_all().unwrap();
drop(raw);
drop(opened);
let reader = SessionReader::open(&path).unwrap();
assert!(reader.nested_payload(completion, limit).is_err(), "{mode}");
assert!(reader.selected_session(limit).is_err(), "{mode}");
drop(reader);
assert!(
open_session(&path, Config::default_valid()).is_err(),
"{mode}"
);
super::commit_tests::clear(&path);
}
}
#[test]
fn completed_payload_cannot_be_republished_by_a_flattened_marker_after_settlement() {
let text = "x".repeat(metadata::NESTED_CHUNK_BYTES_MAX + 1);
let (path, mut opened, records, outer) = frames(&text, &text);
for record in &records {
opened.writer.append_frame(record).unwrap();
}
opened.writer.append_frame(&outer).unwrap();
let Frame::Commit { checkpoint, .. } = &outer else {
unreachable!()
};
opened
.writer
.settle(checkpoint.submission_id, None, None)
.unwrap();
let mut entry = records.last().unwrap().entries()[0].clone();
entry.id = EntryId::new();
let flattened = Frame::Known { entry };
assert!(opened.writer.append_frame(&flattened).is_err());
let limit = Config::default_valid().frame_bytes_max;
OpenOptions::new()
.append(true)
.open(&path)
.unwrap()
.write_all(&flattened.encode(limit).unwrap())
.unwrap();
drop(opened);
assert!(
SessionReader::open(&path)
.unwrap()
.selected_session(limit)
.is_err()
);
super::commit_tests::clear(&path);
}
#[test]
fn payload_progress_has_fixed_layout_and_exact_total_and_count_bounds() {
let root = EntryId::new();
let call = smith::id::ToolCallId::new();
let effect = EntryId::new();
let mut ledger = WorkLedger {
live: vec![(root, WorkStatus::Running)],
tool: Some(call),
..WorkLedger::default()
};
let mut chunk = NestedPayloadChunk {
submission_id: root,
call_id: call,
effect_id: effect,
index: 0,
phase: NestedPayloadPhase::Input,
ordinal: 0,
bytes: vec![b'x'; metadata::NESTED_CHUNK_BYTES_MAX],
};
for ordinal in 0..metadata::NESTED_CHUNKS_MAX {
chunk.ordinal = ordinal.try_into().unwrap();
ledger.observe_payload(&chunk).unwrap();
}
let progress = ledger.payload.as_ref().unwrap();
assert_eq!(progress.bytes, metadata::NESTED_PAYLOAD_BYTES_MAX);
assert_eq!(
progress.bytes.div_ceil(metadata::NESTED_CHUNK_BYTES_MAX),
metadata::NESTED_CHUNKS_MAX
);
#[cfg(target_arch = "x86_64")]
assert_eq!(std::mem::size_of::(), 64);
chunk.ordinal += 1;
assert!(ledger.observe_payload(&chunk).is_err());
}
#[test]
fn complete_chunks_without_their_publishing_marker_remain_unknown_after_reopen() {
let text = "x".repeat(metadata::NESTED_CHUNK_BYTES_MAX + 1);
for prefix in [2, 5] {
let (path, mut opened, records, outer) = frames(&text, &text);
for record in &records[..prefix] {
opened.writer.append_frame(record).unwrap();
}
let missing = records[prefix].entries()[0].id;
let Frame::Commit { checkpoint, .. } = &outer else {
unreachable!()
};
assert!(opened.writer.append_frame(&outer).is_err());
drop(opened);
let limit = Config::default_valid().frame_bytes_max;
let reader = SessionReader::open(&path).unwrap();
assert_eq!(
reader.work_status(checkpoint.submission_id, limit).unwrap(),
Some(WorkStatus::Running)
);
assert_eq!(
reader
.selected_session(limit)
.unwrap()
.mutation_state(checkpoint.call_id)
.unwrap(),
MutationState::Unknown
);
assert!(reader.nested_payload(missing, limit).is_err());
drop(reader);
let mut reopened = open_session(&path, Config::default_valid()).unwrap();
assert!(reopened.writer.claim(checkpoint.submission_id).is_err());
assert!(
reopened
.writer
.settle(checkpoint.submission_id, None, None)
.is_err()
);
drop(reopened);
super::commit_tests::clear(&path);
}
}
#[test]
fn orphan_input_chunks_cannot_settle_or_acknowledge_an_effect_intent() {
let text = "x".repeat(metadata::NESTED_CHUNK_BYTES_MAX + 1);
let (path, mut opened, frames, outer) = frames(&text, &text);
opened.writer.append_frame(&frames[0]).unwrap();
let Frame::Commit { checkpoint, .. } = &outer else {
unreachable!()
};
assert!(opened.writer.append_frame(&outer).is_err());
assert!(
opened
.writer
.settle(checkpoint.submission_id, None, None)
.is_err()
);
assert!(opened.writer.append_frame(&frames[2]).is_err());
drop(opened);
super::commit_tests::clear(&path);
}