Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

49.9 KB
Raw Blame
//! A model as a design file keeps it: every feature's result and the state after it, so a design
//! opens without evaluating its timeline again (docs/design-container.md, "Model cache").
//!
//! The records are JSON; the kernel bodies they hold are a separate list ([`SavedModel::bodies`]),
//! which the file stores in SolidCraft's exact native B-rep encoding. A body that several states
//! hold (one that later features pass through unchanged) is recorded once, as are its face names
//! and the solved sketches the states share. Face names are kept as worked out, not as the
//! history they were worked out from: a model taken from a file names every face as the model
//! that was saved did. A file without room for every state keeps fewer
//! ([`SavedModel::thinned`]); opening evaluates the features whose state it left out again.

use super::*;
use crate::history_names::{FaceInfo, Names};
use serde_json::{Value as Json, json};
use std::collections::HashMap;

/// A model's results and states as records, and the kernel bodies they refer to by index.
pub struct SavedModel {
    pub records: Json,
    pub bodies: Vec<Body>,
}

/// Records refer to these at most.
const MAX_ITEMS: usize = 1_000_000;
/// Bodies, sketches, sheet bodies and sketch keys all the states hold together, at most (a state is
/// a list of clones).
const MAX_HELD: usize = 50_000_000;
/// Longest text a record holds (bytes). A feature's warning can quote every generated name of
/// the edges it picked: 122,701 characters in one design, whose saved model was refused, so it
/// evaluated again on every open (#8541).
const MAX_TEXT: usize = 1 << 24;

/// Whether two tap markings are the same to the bit: then they write the same record. (`==` takes
/// 0.0 and -0.0 for the same number, whose records differ.) Every field is named, so a new one
/// cannot be left out.
fn same_marking(a: &ThreadInfo, b: &ThreadInfo) -> bool {
    let numbers = |t: &ThreadInfo| {
        let ThreadInfo {
            feature: _,
            body: _,
            designation: _,
            major_diameter,
            radius,
            pitch,
            internal: _,
            axis_point,
            axis,
            start,
            end,
            form: _,
            hand: _,
            starts: _,
        } = t;
        [*major_diameter, *radius, *pitch, axis_point.x, axis_point.y, axis_point.z, axis.x, axis.y, axis.z, *start, *end]
    };
    a.feature == b.feature
        && a.body == b.body
        && a.designation == b.designation
        && a.internal == b.internal
        && a.form == b.form
        && a.hand == b.hand
        && a.starts == b.starts
        && numbers(a).iter().zip(numbers(b).iter()).all(|(x, y)| x.to_bits() == y.to_bits())
}

fn hex(v: u64) -> String {
    format!("{v:016x}")
}

fn unhex(v: &Json) -> Result<u64> {
    v.as_str().and_then(|s| u64::from_str_radix(s, 16).ok()).ok_or_else(|| bad("saved model: key"))
}

/// A sketch-key set's list `key` (`set` or `drop`).
fn keys_list<'a>(set: &'a Json, key: &str) -> Result<&'a Vec<Json>> {
    set.get(key).and_then(Json::as_array).filter(|l| l.len() <= MAX_ITEMS).ok_or_else(|| bad("saved model: sketch keys"))
}

fn bad(what: &str) -> DocError {
    DocError::Invalid(what.into())
}

/// A design holding a face or edge name saved before format 14 (marked
/// [`crate::naming::LEGACY_MARK`]): it saves without a model.
fn has_legacy_names(doc: &Document) -> bool {
    let mark = format!("\"{}", crate::naming::LEGACY_MARK);
    doc.features.iter().any(|f| match &f.kind {
        FeatureKind::Import { .. } => f.face_names.iter().any(|n| n.starts_with(crate::naming::LEGACY_MARK)),
        _ => serde_json::to_string(f).is_ok_and(|j| j.contains(&mark)),
    })
}

/// What tells two model bodies apart in a record: a body a feature passes through unchanged is a
/// clone sharing its mesh cell and names, so this finds it without writing its record again.
#[derive(PartialEq, Eq, Hash)]
struct BodyKey {
    mesh: usize,
    names: usize,
    imported: usize,
    key: u64,
    feature: u64,
    component: u64,
    transferred: bool,
    name: String,
    source_name: Option<String>,
    source_transform: [u64; 16],
}

impl BodyKey {
    fn of(b: &ModelBody) -> Self {
        let mut source_transform = [0; 16];
        for (bits, v) in source_transform.iter_mut().zip(b.source_transform.iter().flatten()) {
            *bits = v.to_bits();
        }
        BodyKey {
            mesh: Arc::as_ptr(&b.mesh) as usize,
            names: b.names.id(),
            imported: b.imported.as_ref().map_or(0, |l| Arc::as_ptr(l) as usize),
            key: b.key,
            feature: b.feature,
            component: b.component,
            transferred: b.transferred,
            name: b.name.clone(),
            source_name: b.source_name.clone(),
            source_transform,
        }
    }
}

/// Indices as runs of consecutive ones (`[first, count]`): a state lists mostly the bodies of the
/// state before it, in order.
fn runs(indices: &[usize]) -> Vec<[usize; 2]> {
    let mut out: Vec<[usize; 2]> = Vec::new();
    for &i in indices {
        match out.last_mut() {
            Some([first, count]) if *first + *count == i => *count += 1,
            _ => out.push([i, 1]),
        }
    }
    out
}

#[derive(Default)]
struct Writer {
    bodies: Vec<Body>,
    model_bodies: Vec<Json>,
    model_body_index: HashMap<BodyKey, usize>,
    names: Vec<Json>,
    names_index: HashMap<usize, usize>,
    sketches: Vec<Json>,
    sketch_index: HashMap<usize, usize>,
    /// Sheet bodies by their record: most features leave the sheets as they were, so the states
    /// share them (writing them with every state made a sheet-metal design's model too large to keep).
    sheets: Vec<Json>,
    sheet_index: HashMap<String, usize>,
    /// Tap markings (cosmetic threads) by their record, as the sheets: every state lists the
    /// markings of all the features before it, so writing them with each state grew with the
    /// square of the features (400 marked cylinders: 34 of a 37 MB manifest, past its limit).
    threads: Vec<Json>,
    thread_index: HashMap<String, usize>,
    /// The state written last and the places of its markings: a state mostly keeps the markings
    /// of the one before it, which are found again without writing them as text.
    last_threads: Option<(Arc<ModelState>, Vec<usize>)>,
    states: Vec<Json>,
    state_index: HashMap<usize, usize>,
    /// Each kernel body's place in `bodies`, by its record.
    body_index: HashMap<usize, usize>,
    /// The rounds that made bodies (`Body::rounds`): the body, the body they were made on (both
    /// places in `bodies`), and the edges they rounded there with their radii.
    rounds: Vec<Json>,
    /// The states' sketch keys, each distinct map once, written as the changes from the set
    /// written before it: every state used to repeat the whole map (one entry per solved sketch),
    /// 85 % of a 5,484-feature design's records, which then did not fit the cache's manifest.
    sketch_key_sets: Vec<Json>,
    sketch_key_index: HashMap<BTreeMap<u64, u64>, usize>,
    last_sketch_keys: Option<(BTreeMap<u64, u64>, usize)>,
}

impl Writer {
    /// The place of `keys` among the sketch-key sets, written the first time a state holds them
    /// (as the changes from the set written last: a later state mostly adds a sketch or two).
    fn sketch_key_set(&mut self, keys: &BTreeMap<u64, u64>) -> usize {
        if let Some(i) = self.sketch_key_index.get(keys) {
            return *i;
        }
        let record = match &self.last_sketch_keys {
            Some((base, at)) => {
                let set: Vec<Json> = keys.iter().filter(|(f, k)| base.get(f) != Some(k)).map(|(f, k)| json!([f, hex(*k)])).collect();
                let drop: Vec<u64> = base.keys().filter(|f| !keys.contains_key(f)).copied().collect();
                json!({"base": at, "set": set, "drop": drop})
            }
            None => json!({"set": keys.iter().map(|(f, k)| json!([f, hex(*k)])).collect::<Vec<_>>(), "drop": []}),
        };
        self.sketch_key_sets.push(record);
        let i = self.sketch_key_sets.len() - 1;
        self.sketch_key_index.insert(keys.clone(), i);
        self.last_sketch_keys = Some((keys.clone(), i));
        i
    }

    fn names(&mut self, b: &ModelBody) -> usize {
        let id = b.names.id();
        if let Some(i) = self.names_index.get(&id) {
            return *i;
        }
        let names = crate::naming::names(b);
        let info: Vec<Json> = names.info.iter().map(|i| json!([i.aliases, i.bounds, i.verified, i.synonyms])).collect();
        self.names.push(json!({"faces": *names.faces, "info": info}));
        self.names_index.insert(id, self.names.len() - 1);
        self.names.len() - 1
    }

    fn model_body(&mut self, b: &ModelBody) -> Option<usize> {
        let key = BodyKey::of(b);
        if let Some(i) = self.model_body_index.get(&key) {
            return Some(*i);
        }
        let names = self.names(b);
        let mut r = json!({
            "name": b.name, "feature": b.feature, "component": b.component, "key": hex(b.key), "names": names,
        });
        if let Some(depth) = b.names.depth() {
            r["depth"] = json!(depth);
        }
        if let Some(source) = &b.source_name {
            r["source_name"] = json!(source);
        }
        if b.source_transform != crate::IDENTITY {
            r["source_transform"] = json!(b.source_transform);
        }
        if b.transferred {
            r["transferred"] = json!(true);
        }
        if let Some(look) = &b.imported {
            let faces: Vec<Json> = look.faces.iter().map(|(name, (color, opacity))| json!([name, color, opacity])).collect();
            r["imported"] = json!({"color": look.color, "opacity": look.opacity, "faces": faces});
        }
        r["body"] = json!(self.body(&b.body));
        self.model_bodies.push(r);
        self.model_body_index.insert(key, self.model_bodies.len() - 1);
        Some(self.model_bodies.len() - 1)
    }

    /// The place of a model body's kernel body: its own (a placed copy shares its record with
    /// the part's other copies, but not its display), with the bodies the rounds that made it
    /// were made on, each written once though no state holds it: a later round at a corner where
    /// they meet blends them again, in a model opened from the file as in one evaluated anew.
    fn body(&mut self, body: &Body) -> usize {
        let key = |b: &Body| std::ptr::from_ref(b.record()).addr();
        self.bodies.push(body.clone());
        let first = self.bodies.len() - 1;
        self.body_index.entry(key(body)).or_insert(first);
        let (mut at, mut of) = (body.clone(), first);
        // Down the rounds, until a body made on one already written.
        while let Some((before, edges)) = at.rounds().map(|(b, e)| (b.clone(), e.to_vec())) {
            let (i, new) = match self.body_index.get(&key(&before)) {
                Some(i) => (*i, false),
                None => {
                    self.bodies.push(before.clone());
                    self.body_index.insert(key(&before), self.bodies.len() - 1);
                    (self.bodies.len() - 1, true)
                }
            };
            self.rounds.push(json!({"body": of, "before": i, "edges": edges}));
            if !new {
                break;
            }
            (at, of) = (before, i);
        }
        first
    }

    fn sketch(&mut self, s: &Arc<SolvedSketch>) -> Option<usize> {
        let id = Arc::as_ptr(s) as usize;
        if let Some(i) = self.sketch_index.get(&id) {
            return Some(*i);
        }
        let r = json!({
            "feature": s.feature, "name": s.name, "plane": serde_json::to_value(s.plane).ok()?,
            "sketch": serde_json::to_value(&s.sketch).ok()?, "report": serde_json::to_value(&s.report).ok()?,
        });
        self.sketches.push(r);
        self.sketch_index.insert(id, self.sketches.len() - 1);
        Some(self.sketches.len() - 1)
    }

    fn sheet(&mut self, sheet: &crate::sheet::SheetBody) -> Option<usize> {
        // Keyed by the sheet written as text, straight from the sheet: every state asks for each
        // of its sheets, and building the record (a JSON tree) each time only to find it written
        // already took most of a sheet-metal design's save (906 states, 300 sheets: 0.8 s). Two
        // sheets are the same text exactly when they are the same record.
        let key = serde_json::to_string(sheet).ok()?;
        if let Some(i) = self.sheet_index.get(&key) {
            return Some(*i);
        }
        let record = serde_json::to_value(sheet).ok()?;
        self.sheets.push(record);
        self.sheet_index.insert(key, self.sheets.len() - 1);
        Some(self.sheets.len() - 1)
    }

    /// The places of `st`'s markings among the written ones. A marking at the same place in the
    /// state written last, the same to the bit, is that one (no text built); any other is keyed by
    /// its text, as a sheet is.
    fn threads(&mut self, st: &Arc<ModelState>) -> Option<Vec<usize>> {
        let mut out = Vec::with_capacity(st.threads.len());
        for (i, t) in st.threads.iter().enumerate() {
            let before = self.last_threads.as_ref().and_then(|(s, at)| Some((s.threads.get(i)?, *at.get(i)?)));
            if let Some((_, at)) = before.filter(|(b, _)| same_marking(b, t)) {
                out.push(at);
                continue;
            }
            let key = serde_json::to_string(t).ok()?;
            let at = match self.thread_index.get(&key) {
                Some(at) => *at,
                None => {
                    self.threads.push(serde_json::to_value(t).ok()?);
                    self.thread_index.insert(key, self.threads.len() - 1);
                    self.threads.len() - 1
                }
            };
            out.push(at);
        }
        self.last_threads = Some((st.clone(), out.clone()));
        Some(out)
    }

    fn state(&mut self, st: &Arc<ModelState>) -> Option<usize> {
        let id = Arc::as_ptr(st) as usize;
        if let Some(i) = self.state_index.get(&id) {
            return Some(*i);
        }
        let bodies = st.bodies.iter().map(|b| self.model_body(b)).collect::<Option<Vec<_>>>()?;
        let sketches = st.sketches.iter().map(|s| self.sketch(s)).collect::<Option<Vec<_>>>()?;
        let sheets = st.sheets.iter().map(|s| self.sheet(s)).collect::<Option<Vec<_>>>()?;
        let threads = self.threads(st)?;
        let r = json!({
            "bodies": runs(&bodies), "sketches": runs(&sketches), "body_counter": st.body_counter,
            "reserved_body_names": st.reserved_body_names.iter().collect::<Vec<_>>(),
            "sheets": sheets, "construct": serde_json::to_value(&st.construct).ok()?,
            "threads": runs(&threads),
            "sketch_key_set": self.sketch_key_set(&st.sketch_keys),
            "blend_edges": serde_json::to_value(&st.blend_edges).ok()?, "fitted": serde_json::to_value(&st.fitted).ok()?,
            "tapered": serde_json::to_value(&st.tapered).ok()?,
        });
        self.states.push(r);
        self.state_index.insert(id, self.states.len() - 1);
        Some(self.states.len() - 1)
    }
}

impl Model {
    /// The model as a design file keeps it: `None` unless it is `doc`'s evaluation without an
    /// error and `doc` keeps no names saved before format 14. Works out
    /// the face names not asked for yet (a saved model keeps them as worked out).
    pub fn saved(&self, doc: &Document) -> Option<SavedModel> {
        if self.results.is_empty() || self.results.iter().any(|r| r.error.is_some()) || !self.is_current(doc) || has_legacy_names(doc) {
            return None;
        }
        kernel::guard("save the model", || {
            let mut w = Writer::default();
            let mut features = Vec::with_capacity(self.results.len());
            for r in &self.results {
                let state = w.state(&r.state).ok_or_else(|| kernel::KernelError::Invalid("not kept".into()))?;
                let mut f = json!({"id": r.id, "fingerprint": hex(r.fingerprint), "ms": r.ms, "skipped": r.skipped, "state": state});
                if let Some(w) = &r.warning {
                    f["warning"] = json!(w);
                }
                if let Some(report) = &r.import_report {
                    f["import_report"] = serde_json::to_value(report.as_ref()).map_err(|e| kernel::KernelError::Invalid(e.to_string()))?;
                }
                features.push(f);
            }
            // The check mode the results were evaluated under: they are another mode's results.
            let records = json!({
                "features": features, "states": w.states, "model_bodies": w.model_bodies, "names": w.names, "sketches": w.sketches,
                "sheets": w.sheets, "threads": w.threads, "validation": self.validation().id(), "rounds": w.rounds,
                "sketch_key_sets": w.sketch_key_sets,
            });
            Ok(SavedModel { records, bodies: w.bodies })
        })
        .ok()
    }
}

impl SavedModel {
    /// The states the records hold, every record checked.
    fn states(&self) -> Result<Vec<Arc<ModelState>>> {
        let bodies = &self.bodies_with_rounds()?;
        let records = &self.records;
        let list = |key: &str| records.get(key).and_then(Json::as_array).filter(|l| l.len() <= MAX_ITEMS).ok_or_else(|| bad("saved model: list"));
        let index = |v: Option<&Json>, len: usize| {
            v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len).ok_or_else(|| bad("saved model: index"))
        };
        let text =
            |v: Option<&Json>| v.and_then(Json::as_str).filter(|s| s.len() <= MAX_TEXT).map(str::to_owned).ok_or_else(|| bad("saved model: text"));
        let parse = |v: Option<&Json>| v.cloned().ok_or_else(|| bad("saved model: missing"));
        let mut names = Vec::new();
        for n in list("names")? {
            let faces: Vec<String> = serde_json::from_value(parse(n.get("faces"))?).map_err(|_| bad("saved model: names"))?;
            let info: Vec<(Vec<String>, std::collections::BTreeSet<String>, bool, Vec<String>)> =
                serde_json::from_value(parse(n.get("info"))?).map_err(|_| bad("saved model: names"))?;
            if info.len() != faces.len() {
                return Err(bad("saved model: names"));
            }
            let info = info.into_iter().map(|(aliases, bounds, verified, synonyms)| FaceInfo { aliases, synonyms, bounds, verified }).collect();
            names.push(Arc::new(Names { faces: Arc::new(faces), info }));
        }
        let mut sketches = Vec::new();
        for s in list("sketches")? {
            let sketch: solidcraft_sketch::Sketch = serde_json::from_value(parse(s.get("sketch"))?).map_err(|_| bad("saved model: sketch"))?;
            sketches.push(Arc::new(SolvedSketch {
                feature: s.get("feature").and_then(Json::as_u64).ok_or_else(|| bad("saved model: sketch"))?,
                name: text(s.get("name"))?,
                plane: serde_json::from_value(parse(s.get("plane"))?).map_err(|_| bad("saved model: sketch"))?,
                report: serde_json::from_value(parse(s.get("report"))?).map_err(|_| bad("saved model: sketch"))?,
                profiles: find_profiles(&sketch),
                ends: solidcraft_sketch::loose_ends(&sketch),
                sketch,
            }));
        }
        let mut model_bodies = Vec::new();
        for r in list("model_bodies")? {
            let body = bodies.get(index(r.get("body"), bodies.len())?).cloned().ok_or_else(|| bad("saved model: body"))?;
            let mut b =
                ModelBody::new(text(r.get("name"))?, body, r.get("feature").and_then(Json::as_u64).ok_or_else(|| bad("saved model: feature"))?);
            b.component = r.get("component").and_then(Json::as_u64).ok_or_else(|| bad("saved model: component"))?;
            b.key = unhex(r.get("key").unwrap_or(&Json::Null))?;
            let depth =
                r.get("depth").map(|d| d.as_u64().and_then(|d| usize::try_from(d).ok()).ok_or_else(|| bad("saved model: depth"))).transpose()?;
            b.names = crate::naming::NameCell::saved(
                names.get(index(r.get("names"), names.len())?).cloned().ok_or_else(|| bad("saved model: names"))?,
                depth,
            );
            b.source_name = r.get("source_name").map(|s| text(Some(s))).transpose()?;
            if let Some(m) = r.get("source_transform") {
                let m: crate::Mat = serde_json::from_value(m.clone()).map_err(|_| bad("saved model: transform"))?;
                if m.iter().flatten().any(|x| !x.is_finite()) {
                    return Err(bad("saved model: transform"));
                }
                b.source_transform = m;
            }
            b.transferred = r.get("transferred").and_then(Json::as_bool).unwrap_or(false);
            // Measured once here, so every state holding it adds it up for the cache's budget.
            b.bytes = b.body.retained_bytes();
            if let Some(look) = r.get("imported") {
                let faces: Vec<(String, [f32; 3], f32)> = serde_json::from_value(parse(look.get("faces"))?).map_err(|_| bad("saved model: look"))?;
                b.imported = Some(Arc::new(crate::appearance::ImportedLook {
                    color: serde_json::from_value(parse(look.get("color"))?).map_err(|_| bad("saved model: look"))?,
                    opacity: serde_json::from_value(parse(look.get("opacity"))?).map_err(|_| bad("saved model: look"))?,
                    faces: faces.into_iter().map(|(name, color, opacity)| (name, (color, opacity))).collect(),
                }));
            }
            model_bodies.push(b);
        }
        let mut sheets = Vec::new();
        for s in list("sheets")? {
            sheets.push(serde_json::from_value::<crate::sheet::SheetBody>(s.clone()).map_err(|_| bad("saved model: sheet"))?);
        }
        let mut threads = Vec::new();
        for t in list("threads")? {
            threads.push(serde_json::from_value::<ThreadInfo>(t.clone()).map_err(|_| bad("saved model: tap marking"))?);
        }
        // The sketch-key sets, each the changes from an earlier one (`base`): a short record can
        // stand for a large set, so what they hold counts towards MAX_HELD as they are built.
        let mut key_sets: Vec<BTreeMap<u64, u64>> = Vec::new();
        let mut held = 0usize;
        for k in list("sketch_key_sets")? {
            // A set is the changes from one before it.
            let base = match k.get("base") {
                Some(b) => Some(key_sets.get(index(Some(b), key_sets.len())?).ok_or_else(|| bad("saved model: sketch keys"))?),
                None => None,
            };
            let (drop, set) = (keys_list(k, "drop")?, keys_list(k, "set")?);
            // Counted before the base is copied: at most what the set can hold.
            held = held.saturating_add(base.map_or(0, BTreeMap::len)).saturating_add(set.len());
            if held > MAX_HELD {
                return Err(bad("saved model: sketch keys"));
            }
            let mut keys = base.cloned().unwrap_or_default();
            for f in drop {
                keys.remove(&f.as_u64().ok_or_else(|| bad("saved model: sketch keys"))?);
            }
            for e in set {
                keys.insert(e.get(0).and_then(Json::as_u64).ok_or_else(|| bad("saved model: sketch keys"))?, unhex(e.get(1).unwrap_or(&Json::Null))?);
            }
            key_sets.push(keys);
        }
        // Running totals of what each marking costs to clone (its items and text), by place.
        let mut thread_weight = vec![0usize];
        for t in &threads {
            let w = 1usize.saturating_add((t.body.len().saturating_add(t.designation.len())) / 64);
            thread_weight.push(thread_weight.last().copied().unwrap_or(0).saturating_add(w));
        }
        let records = list("states")?;
        // What every state holds, counted from its runs and its sketch-key set before any is
        // built (a hostile file cannot make the states clone more than MAX_HELD items).
        for s in records {
            for key in ["bodies", "sketches"] {
                for run in s.get(key).and_then(Json::as_array).ok_or_else(|| bad("saved model: state"))? {
                    held = held.saturating_add(run.get(1).and_then(Json::as_u64).and_then(|n| usize::try_from(n).ok()).unwrap_or(usize::MAX));
                }
            }
            // A marking is cloned deeply into every state that lists it, so each counts by its
            // text, not as one item: a run of a large marking repeated cannot exhaust memory.
            for run in s.get("threads").and_then(Json::as_array).ok_or_else(|| bad("saved model: state"))? {
                let first = index(run.get(0), threads.len())?;
                let count = run.get(1).and_then(Json::as_u64).and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad("saved model: run"))?;
                let end = first.checked_add(count).filter(|end| *end <= threads.len()).ok_or_else(|| bad("saved model: run"))?;
                held = held.saturating_add(thread_weight[end].saturating_sub(thread_weight[first]));
            }
            held = held.saturating_add(s.get("sheets").and_then(Json::as_array).map_or(0, Vec::len));
            held = held.saturating_add(key_sets.get(index(s.get("sketch_key_set"), key_sets.len())?).map_or(0, BTreeMap::len));
            if held > MAX_HELD {
                return Err(bad("saved model: states"));
            }
        }
        // Each state is independent of the others once the records they share are read: built
        // on threads (a 5,484-feature design spent 3.5 s building them one after another).
        let built = kernel::map_on_threads(records, 16, |s: &Json| -> Result<ModelState> {
            // Runs of consecutive indices, each within the list it indexes.
            let ids = |key: &str, len: usize| -> Result<Vec<usize>> {
                let mut out = Vec::new();
                for run in s.get(key).and_then(Json::as_array).ok_or_else(|| bad("saved model: state"))? {
                    let first = index(run.get(0), len)?;
                    let count = run.get(1).and_then(Json::as_u64).and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad("saved model: run"))?;
                    if first.checked_add(count).is_none_or(|end| end > len) || out.len().saturating_add(count) > MAX_ITEMS {
                        return Err(bad("saved model: run"));
                    }
                    out.extend(first..first + count);
                }
                Ok(out)
            };
            let field = |key: &str| parse(s.get(key));
            let invalid = |_| bad("saved model: state");
            let sketch_keys = key_sets.get(index(s.get("sketch_key_set"), key_sets.len())?).cloned().ok_or_else(|| bad("saved model: state"))?;
            Ok(ModelState {
                frame_bodies: Default::default(),
                bodies: ids("bodies", model_bodies.len())?.into_iter().filter_map(|i| model_bodies.get(i).cloned()).collect(),
                sketches: ids("sketches", sketches.len())?.into_iter().filter_map(|i| sketches.get(i).cloned()).collect(),
                body_counter: index(s.get("body_counter"), usize::MAX)?,
                reserved_body_names: s
                    .get("reserved_body_names")
                    .and_then(Json::as_array)
                    .map(|a| a.iter().filter_map(|n| n.as_str().map(str::to_string)).collect())
                    .unwrap_or_default(),
                sheets: s
                    .get("sheets")
                    .and_then(Json::as_array)
                    .ok_or_else(|| bad("saved model: state"))?
                    .iter()
                    .map(|i| index(Some(i), sheets.len()).and_then(|i| sheets.get(i).cloned().ok_or_else(|| bad("saved model: sheet"))))
                    .collect::<Result<Vec<_>>>()?,
                construct: serde_json::from_value(field("construct")?).map_err(invalid)?,
                threads: ids("threads", threads.len())?.into_iter().filter_map(|i| threads.get(i).cloned()).collect(),
                sketch_keys,
                blend_edges: serde_json::from_value(field("blend_edges")?).map_err(invalid)?,
                fitted: serde_json::from_value(field("fitted")?).map_err(invalid)?,
                tapered: serde_json::from_value(field("tapered")?).map_err(invalid)?,
                // A join's notice is for the evaluation that made it, not kept with the cache.
                kept_separate: BTreeMap::new(),
                // Not kept either: a saved model's states carry no lineage, so the check of a
                // legacy split's picks (`lineage::legacy_picks_digest`) finds no pieces in them
                // and takes them as the design's evaluation they were saved as.
                legacy_picks: BTreeMap::new(),
            })
        });
        let states = built.into_iter().map(|r| r.unwrap_or_else(|| Err(bad("saved model: state"))).map(Arc::new)).collect::<Result<Vec<_>>>()?;
        Ok(states)
    }

    /// The kernel bodies with the rounds that made them ([`kernel::Body::rounds`]) as the records
    /// list them, each body's before it is taken as another's body before its rounds.
    fn bodies_with_rounds(&self) -> Result<Vec<Body>> {
        let refused = || bad("saved model: rounds");
        let list = self.records.get("rounds").and_then(Json::as_array).filter(|l| l.len() <= self.bodies.len()).ok_or_else(refused)?;
        let place = |v: Option<&Json>| v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < self.bodies.len());
        // Per body, the body its rounds were made on and their edges.
        let mut made: Vec<Option<(usize, Vec<(usize, f64)>)>> = vec![None; self.bodies.len()];
        for r in list {
            let (body, before) = (place(r.get("body")).ok_or_else(refused)?, place(r.get("before")).ok_or_else(refused)?);
            let edges: Vec<(usize, f64)> = serde_json::from_value(r.get("edges").cloned().ok_or_else(refused)?).map_err(|_| refused())?;
            match made.get_mut(body) {
                Some(slot @ None) => *slot = Some((before, edges)),
                _ => return Err(refused()),
            }
        }
        // Each body after the one its rounds were made on, down each chain once (a cycle is refused).
        let mut bodies = self.bodies.clone();
        let (mut done, mut on_chain) = (vec![false; bodies.len()], vec![false; bodies.len()]);
        for start in 0..bodies.len() {
            let mut chain = Vec::new();
            let mut at = start;
            while let Some(seen @ false) = done.get_mut(at) {
                *seen = true;
                chain.push(at);
                if let Some(on) = on_chain.get_mut(at) {
                    *on = true;
                }
                match made.get(at).and_then(Option::as_ref) {
                    Some((before, _)) => at = *before,
                    None => break,
                }
                if on_chain.get(at).copied().unwrap_or(false) {
                    return Err(refused());
                }
            }
            for &k in chain.iter().rev() {
                if let Some(on) = on_chain.get_mut(k) {
                    *on = false;
                }
                let Some(Some((before, edges))) = made.get(k) else { continue };
                let before = bodies.get(*before).cloned().ok_or_else(refused)?;
                let body = bodies.get(k).cloned().ok_or_else(refused)?;
                *bodies.get_mut(k).ok_or_else(refused)? = body.with_rounds_of(&before, edges.clone())?;
            }
        }
        Ok(bodies)
    }

    /// The model's final state (what a picture of it shows), without checking that it is a
    /// document's evaluation.
    pub fn final_state(&self) -> Result<Arc<ModelState>> {
        let states = self.states()?;
        let features = self.records.get("features").and_then(Json::as_array).ok_or_else(|| bad("saved model: features"))?;
        let last = features.iter().rev().find(|f| f.get("skipped").and_then(Json::as_bool) == Some(false));
        match last {
            Some(f) => f
                .get("state")
                .and_then(Json::as_u64)
                .and_then(|i| states.get(usize::try_from(i).ok()?))
                .cloned()
                .ok_or_else(|| bad("saved model: state")),
            None => Ok(Arc::new(ModelState::default())),
        }
    }

    /// This model with fewer states, for a design file without room for all of them (#3220): the
    /// final state (what the design shows, kept whatever it costs), then the others, the slowest
    /// feature's first (the ones opening would take longest to evaluate again; of equal ones the
    /// later first), each while what it adds still fits in `budget` bytes: the bodies no state kept
    /// so far holds, and the records of the state, those bodies, their names and sketches.
    /// `pieces[i]` is what keeping body `i` stores, as ids and bytes: a piece that several bodies
    /// or states need counts once. A feature whose state is left out keeps none, and opening
    /// evaluates it again ([`Model::adopt`]). With the model, the index here of each body it keeps,
    /// and the bytes it counted: over `budget` when the final state alone is. `None` only for
    /// records it cannot read.
    pub fn thinned(&self, pieces: &[Vec<(usize, usize)>], budget: usize) -> Option<(SavedModel, Vec<usize>, usize)> {
        let list = |key: &str| self.records.get(key).and_then(Json::as_array);
        let (features, states, model_bodies) = (list("features")?, list("states")?, list("model_bodies")?);
        let (names, sketches) = (list("names")?, list("sketches")?);
        let at = |v: Option<&Json>, len: usize| v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len);
        // The indices a state's runs list.
        let held = |s: &Json, key: &str, len: usize| -> Option<Vec<usize>> {
            let mut out = Vec::new();
            for run in s.get(key)?.as_array()? {
                let first = at(run.get(0), len)?;
                out.extend(first..first.checked_add(at(run.get(1), len.saturating_add(1))?).filter(|end| *end <= len)?);
            }
            Some(out)
        };
        let state_bodies = states.iter().map(|s| held(s, "bodies", model_bodies.len())).collect::<Option<Vec<_>>>()?;
        let state_sketches = states.iter().map(|s| held(s, "sketches", sketches.len())).collect::<Option<Vec<_>>>()?;
        let body_of = model_bodies.iter().map(|r| at(r.get("body"), self.bodies.len())).collect::<Option<Vec<_>>>()?;
        let names_of = model_bodies.iter().map(|r| at(r.get("names"), names.len())).collect::<Option<Vec<_>>>()?;
        // The body each body's rounds were made on: kept with it, though no kept state holds it.
        let rounds = list("rounds")?;
        let mut before_of = HashMap::new();
        for r in rounds {
            before_of.insert(at(r.get("body"), self.bodies.len())?, at(r.get("before"), self.bodies.len())?);
        }
        // A kernel body and the bodies down its rounds (a cycle, refused on reading, ends it).
        let with_before = |k: usize| -> Vec<usize> {
            let mut out = vec![k];
            while let Some(b) = out.last().and_then(|k| before_of.get(k)).filter(|b| !out.contains(b)) {
                out.push(*b);
            }
            out
        };
        // What each record takes in the file.
        let bytes = |list: &[Json]| list.iter().map(|r| serde_json::to_vec(r).map_or(usize::MAX, |b| b.len().saturating_add(1))).collect::<Vec<_>>();
        let (state_bytes, body_bytes) = (bytes(states.as_slice()), bytes(model_bodies.as_slice()));
        let (name_bytes, sketch_bytes) = (bytes(names.as_slice()), bytes(sketches.as_slice()));
        // What each state's feature took to evaluate, and the final state.
        let mut ms = vec![0.0f64; states.len()];
        let mut last = None;
        for f in features.iter().filter(|f| f.get("skipped").and_then(Json::as_bool) == Some(false)) {
            let s = at(f.get("state"), states.len())?;
            if let Some(t) = ms.get_mut(s) {
                *t += f.get("ms").and_then(Json::as_f64).filter(|t| t.is_finite() && *t > 0.0).unwrap_or(0.0);
            }
            last = Some(s);
        }
        let last = last?;
        let time = |s: &usize| ms.get(*s).copied().unwrap_or(0.0);
        let mut order: Vec<usize> = (0..states.len()).filter(|s| *s != last).collect();
        order.sort_by(|a, b| time(b).total_cmp(&time(a)).then(b.cmp(a)));
        let mut keep = vec![false; states.len()];
        // The records and pieces kept so far, and their bytes.
        let mut kept_bodies = vec![false; model_bodies.len()];
        let (mut names_used, mut sketches_used) = (vec![false; names.len()], vec![false; sketches.len()]);
        let mut stored = std::collections::HashSet::new();
        // The sheet bodies and tap markings, each written once and named by place in the states: all kept.
        let sheets = list("sheets").cloned().unwrap_or_default();
        let threads = list("threads").cloned().unwrap_or_default();
        let key_sets = list("sketch_key_sets").cloned().unwrap_or_default();
        let mut used = [&sheets, &threads, &key_sets].iter().flat_map(|l| bytes(l.as_slice())).fold(0usize, |t, b| t.saturating_add(b));
        for s in std::iter::once(last).chain(order) {
            let (mut adds, mut new_names, mut new_sketches) = (HashMap::new(), std::collections::HashSet::new(), std::collections::HashSet::new());
            let mut records = *state_bytes.get(s)?;
            for &m in state_bodies.get(s)? {
                if kept_bodies.get(m) == Some(&false) {
                    records = records.saturating_add(*body_bytes.get(m)?);
                    let n = *names_of.get(m)?;
                    if names_used.get(n) == Some(&false) && new_names.insert(n) {
                        records = records.saturating_add(*name_bytes.get(n)?);
                    }
                    for k in with_before(*body_of.get(m)?) {
                        for &(piece, bytes) in pieces.get(k)? {
                            if !stored.contains(&piece) {
                                adds.insert(piece, bytes);
                            }
                        }
                    }
                }
            }
            for &k in state_sketches.get(s)? {
                if sketches_used.get(k) == Some(&false) && new_sketches.insert(k) {
                    records = records.saturating_add(*sketch_bytes.get(k)?);
                }
            }
            let total = adds.values().fold(used.saturating_add(records), |t, b| t.saturating_add(*b));
            if total > budget && s != last {
                continue;
            }
            used = total;
            stored.extend(adds.into_keys());
            for &m in state_bodies.get(s)? {
                *kept_bodies.get_mut(m)? = true;
            }
            for n in new_names {
                *names_used.get_mut(n)? = true;
            }
            for k in new_sketches {
                *sketches_used.get_mut(k)? = true;
            }
            *keep.get_mut(s)? = true;
        }
        // What the states kept refer to, numbered again in the order it had.
        let mut kernel_used = vec![false; self.bodies.len()];
        for m in (0..model_bodies.len()).filter(|m| kept_bodies.get(*m) == Some(&true)) {
            for k in with_before(*body_of.get(m)?) {
                *kernel_used.get_mut(k)? = true;
            }
        }
        let renumber = |used: &[bool]| -> Vec<Option<usize>> {
            let mut next = 0;
            used.iter()
                .map(|&u| {
                    u.then(|| {
                        next += 1;
                        next - 1
                    })
                })
                .collect()
        };
        let (new_body, new_kernel, new_names) = (renumber(&kept_bodies), renumber(&kernel_used), renumber(&names_used));
        let (new_sketch, new_state) = (renumber(&sketches_used), renumber(&keep));
        let new = |map: &[Option<usize>], i: usize| map.get(i).copied().flatten();
        let kept_of = |list: &[Json], used: &[bool]| list.iter().zip(used).filter(|(_, u)| **u).map(|(v, _)| v.clone()).collect::<Vec<_>>();
        let mut out_states = Vec::new();
        for (s, st) in states.iter().enumerate().filter(|(s, _)| keep.get(*s) == Some(&true)) {
            let bodies = state_bodies.get(s)?.iter().map(|m| new(&new_body, *m)).collect::<Option<Vec<_>>>()?;
            let sketches = state_sketches.get(s)?.iter().map(|i| new(&new_sketch, *i)).collect::<Option<Vec<_>>>()?;
            let mut st = st.clone();
            let o = st.as_object_mut()?;
            o.insert("bodies".into(), json!(runs(&bodies)));
            o.insert("sketches".into(), json!(runs(&sketches)));
            out_states.push(st);
        }
        let mut out_bodies = Vec::new();
        for (m, r) in model_bodies.iter().enumerate().filter(|(m, _)| kept_bodies.get(*m) == Some(&true)) {
            let (body, named) = (new(&new_kernel, *body_of.get(m)?)?, new(&new_names, at(r.get("names"), names.len())?)?);
            let mut r = r.clone();
            let o = r.as_object_mut()?;
            o.insert("body".into(), json!(body));
            o.insert("names".into(), json!(named));
            out_bodies.push(r);
        }
        let mut out_features = Vec::with_capacity(features.len());
        for f in features {
            let state = new(&new_state, at(f.get("state"), states.len())?);
            let mut f = f.clone();
            let o = f.as_object_mut()?;
            match state {
                Some(s) => o.insert("state".into(), json!(s)),
                None => o.remove("state"),
            };
            out_features.push(f);
        }
        let mut out_rounds = Vec::new();
        for r in rounds {
            let Some(body) = new(&new_kernel, at(r.get("body"), self.bodies.len())?) else { continue };
            let before = new(&new_kernel, at(r.get("before"), self.bodies.len())?)?;
            let mut r = r.clone();
            let o = r.as_object_mut()?;
            o.insert("body".into(), json!(body));
            o.insert("before".into(), json!(before));
            out_rounds.push(r);
        }
        let mut records = json!({
            "features": out_features, "states": out_states, "model_bodies": out_bodies, "names": kept_of(names.as_slice(), &names_used),
            "sketches": kept_of(sketches.as_slice(), &sketches_used), "sheets": sheets, "threads": threads, "rounds": out_rounds,
            "sketch_key_sets": key_sets,
        });
        // The check mode the results were evaluated under, as the model records it (a model
        // that records none stays without one: adopting it is refused either way).
        if let (Some(validation), Some(out)) = (self.records.get("validation"), records.as_object_mut()) {
            out.insert("validation".into(), validation.clone());
        }
        let kept: Vec<usize> = (0..self.bodies.len()).filter(|i| kernel_used.get(*i) == Some(&true)).collect();
        let bodies = kept.iter().filter_map(|i| self.bodies.get(*i).cloned()).collect();
        Some((SavedModel { records, bodies }, kept, used))
    }
}

impl Model {
    /// The model a design file kept for `doc` ([`Model::saved`]), taken as `doc`'s evaluation:
    /// every feature's result as saved, nothing evaluated but the features whose state the file
    /// did not keep ([`SavedModel::thinned`]), under the check mode it was evaluated in
    /// ([`Model::validation`]). Refused (an error) unless every feature's fingerprint is the one
    /// `doc` gives it now, and every record is well formed.
    pub fn adopt(doc: &Document, saved: &SavedModel) -> Result<Model> {
        let mut states = saved.states()?;
        let frame_bodies = Arc::new(std::sync::Mutex::new(FrameBodies::default()));
        for state in &mut states {
            Arc::make_mut(state).frame_bodies = Arc::downgrade(&frame_bodies);
        }
        let records = &saved.records;
        let index = |v: Option<&Json>, len: usize| {
            v.and_then(Json::as_u64).and_then(|i| usize::try_from(i).ok()).filter(|i| *i < len).ok_or_else(|| bad("saved model: index"))
        };
        let text =
            |v: Option<&Json>| v.and_then(Json::as_str).filter(|s| s.len() <= MAX_TEXT).map(str::to_owned).ok_or_else(|| bad("saved model: text"));
        let features = records.get("features").and_then(Json::as_array).ok_or_else(|| bad("saved model: features"))?;
        let validation =
            records.get("validation").and_then(Json::as_str).and_then(kernel::Validation::parse).ok_or_else(|| bad("saved model: validation"))?;
        if features.len() != doc.features.len() {
            return Err(bad("saved model: features"));
        }
        let (vals, param_errors) = evaluation_values(doc);
        let import_digests = ImportDigests::of(doc, &ImportDigests::default());
        let marker = doc.marker.unwrap_or(usize::MAX);
        // As `evaluate` digests the context under the mode, so the next evaluation reuses these.
        let ctx = context_digest(doc, &vals) ^ validation_digest(validation);
        let mut before = Arc::new(ModelState::default());
        // Whether `before` is the state before the feature: one the file left out only stands in.
        let mut exact = true;
        let mut prev = 0;
        let mut results = Vec::with_capacity(features.len());
        let mut construction = HashMap::new();
        let mut prepared_states = std::collections::HashSet::new();
        for (i, (f, r)) in doc.features.iter().zip(features).enumerate() {
            let saved = unhex(r.get("fingerprint").unwrap_or(&Json::Null))?;
            // A fingerprint reads the state before its feature (where the bodies it takes lie).
            // After a state the file left out, the saved one is taken: `evaluate` works that state
            // out, checks the fingerprints after it, and evaluates again from one that differs.
            prev = if exact { chain_fingerprint(doc, &vals, f, prev, i >= marker, &import_digests, Some(&before)) } else { saved };
            if r.get("id").and_then(Json::as_u64) != Some(f.id) || saved != prev {
                return Err(bad("saved model: the document changed"));
            }
            let ms = r.get("ms").and_then(Json::as_f64).filter(|ms| ms.is_finite()).ok_or_else(|| bad("saved model: time"))?;
            // A file without room for every state keeps some features without one (#3220).
            let state = r.get("state").map(|s| index(Some(s), states.len())).transpose()?;
            if let Some(at) = state
                && prepared_states.insert(at)
            {
                let original = matches!(
                    &f.kind,
                    FeatureKind::Box { operation: Operation::NewBody, .. } | FeatureKind::Extrude { operation: Operation::NewBody, .. }
                );
                let current = states.get_mut(at).ok_or_else(|| bad("saved model: state"))?;
                // Each state is prepared before its first shared clone. Record and NameCell
                // identity prove this is still the original geometry and its exact names.
                for body in &mut Arc::make_mut(current).bodies {
                    let key = (std::ptr::from_ref(body.body.record()).addr(), body.names.id());
                    if original && body.feature == f.id && before.body(&body.name).is_none() {
                        construction.insert(key, f.id);
                    }
                    body.names.cached_construction = construction.get(&key).copied();
                }
            }
            let state = state.map(|at| states.get(at).cloned().ok_or_else(|| bad("saved model: state"))).transpose()?;
            let result = FeatureResult {
                id: f.id,
                name: f.name.clone(),
                error: None,
                internal: false,
                warning: r.get("warning").map(|w| text(Some(w))).transpose()?,
                import_report: r
                    .get("import_report")
                    .map(|v| serde_json::from_value::<kernel::ImportReport>(v.clone()).map(Arc::new).map_err(|_| bad("saved model: import report")))
                    .transpose()?,
                repair: None,
                ms,
                skipped: r.get("skipped").and_then(Json::as_bool).ok_or_else(|| bad("saved model: skipped"))?,
                stale: false,
                fingerprint: prev,
                unkept: state.is_none(),
                state: state.unwrap_or_else(|| before.clone()),
            };
            if !result.skipped {
                exact = !result.unkept;
                before = result.state.clone();
            }
            results.push(result);
        }
        let mut model = Model { results, param_errors, import_digests, context: ctx, frame_bodies, validation, ..Model::default() };
        let unkept = model.results.iter().filter(|r| r.unkept).count();
        if unkept > 0 {
            // The features whose state the file did not keep, each evaluated again from the state
            // before it: nothing else in the model is missing then.
            model.evaluate(doc);
            log::info!(
                "the saved model kept the states of {} of {} features: {} evaluated again",
                model.results.len().saturating_sub(unkept),
                model.results.len(),
                model.last_recomputed
            );
        }
        // Each result where an evaluation would have put it, so an edit undone (or set back)
        // finds it again rather than evaluating the feature anew.
        let mut before = Arc::new(ModelState::default());
        if let Ok(mut cache) = model.cache.lock() {
            for (f, r) in doc.features.iter().zip(&model.results).filter(|(_, r)| !r.skipped && r.error.is_none()) {
                let local = fingerprint(doc, 0, f, &vals, false, &model.import_digests) ^ placement_digest(doc, f, Some(&before));
                cache.put(
                    cache_key(f, r.fingerprint, local, ctx, &before),
                    CachedEval {
                        error: None,
                        warning: r.warning.clone(),
                        import_report: r.import_report.clone(),
                        repair: r.repair.clone(),
                        ms: r.ms,
                        bytes: r.state.retained_bytes(),
                        state: r.state.clone(),
                    },
                );
                before = r.state.clone();
            }
        }
        Ok(model)
    }
}